solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[15];
int p[15];
void shift(int x) {
p[0] += x;
for (int i = 0; i < 15; ++i) {
if (p[i] < i + 1) break;
p[i + 1] += p[i] / (i + 1);
p[i] %= (i + 1);
}
vector<int> vec;
for (int i = 1; i <= 15; ++i) vec.push_back(i);
for (int i = 14; i >= 0; --i) {
a[i] = vec[p[i]];
vec.erase(vec.begin() + p[i]);
}
}
long long get_sum(int ind) {
long long s = (long long)ind * (ind + 1) / 2;
int bios = ((n - 14) > (1) ? (n - 14) : (1));
for (int i = bios; i <= ind; ++i) {
s += a[n - i] - (15 - (n - i));
}
return s;
}
void query(int l, int r) { cout << get_sum(r) - get_sum(l - 1) << endl; }
int main() {
cin.tie(0);
cout.tie(0);
for (int i = 1; i <= 15; ++i) {
a[15 - i] = i;
}
cin >> n >> m;
while (m--) {
int t;
cin >> t;
if (t == 1) {
int l, r;
cin >> l >> r;
query(l, r);
} else {
int x;
cin >> x;
shift(x);
}
}
return 0;
}
| 8 |
#include<bits/stdc++.h>
using namespace std;
long long n,dp[100010];
long long calc(long long x)
{
if(x==n+1||x==0) return 0x3f3f3f3f;
if(dp[x]) return dp[x];
printf("? %lld\n",x);
long long tmp;
fflush(stdout);
scanf("%lld",&tmp);
dp[x]=tmp;
return tmp;
}
long long calc1(long long x)
{
return calc(x-1)<calc(x);
}
void solve(long long x,long long y)
{
if(8>=y-x)
{
for(long long i=x;i<=y;i++)
{
if(calc(i-1)>calc(i)&&calc(i)<calc(i+1))
{
printf("! %lld\n",i);
exit(0);
}
}
}
long long mid=(x+y)>>1;
if(calc1(mid)) solve(x,mid);
else solve(mid-1,y);
}
int main()
{
scanf("%lld",&n);
solve(1,n+1);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void result(bool first) {
if (first)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
int32_t main() {
ios_base::sync_with_stdio();
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
long long n, m;
cin >> n >> m;
if (n == 2 && m == 2 || n == 1 || m == 1) {
cout << "Yes" << endl;
} else {
cout << "NO" << endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long a[305], Lcm;
long long sol(long long x) {
long long cnt = 0;
for (long long i = 2; i * i <= x; i++) {
if (x % i == 0) {
cnt += 2;
if (i * i == x) cnt--;
}
}
return cnt;
}
int main() {
int T;
cin >> T;
while (T--) {
int ok = 1;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%lld", &a[i]);
sort(a, a + n);
if (n == 1)
Lcm = a[0] * a[0];
else
Lcm = a[0] * a[n - 1];
for (int i = 1; i < (n + 1) / 2; i++) {
if (a[i] * a[n - 1 - i] != Lcm) {
ok = 0;
break;
}
}
if (ok && sol(Lcm) == n)
printf("%lld\n", Lcm);
else
puts("-1");
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool startWidth(string s, string t) {
if (s.size() < t.size()) return 0;
return s.substr(0, t.size()) == t;
}
bool endWith(string s, string t) {
if (s.size() < t.size()) return 0;
return s.substr(s.size() - t.size()) == t;
}
char buff[1024];
int main() {
int N;
scanf("%d", &N);
getchar();
for (int i = 0; i < (int)N; i++) {
int type = 0;
string cad;
getline(cin, cad);
if (startWidth(cad, "miao.")) type |= 1 << 0;
if (endWith(cad, "lala.")) type |= 1 << 1;
if (type & (1 << 1) && (type & (1 << 0)) == 0)
puts("Freda's");
else if (type & (1 << 0) && (type & (1 << 1)) == 0)
puts("Rainbow's");
else
puts("OMG>.< I don't know!");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int p[200005], q[200005];
int fa[200005], top[200005], sz[200005], dep[200005];
vector<int> E[200005];
void dfs1(int root);
void dfs2(int root, int toproot);
int lca(int node1, int node2);
int dis(int node1, int node2);
pair<int, int> merge(int node1, int node2, int node3);
pair<int, int> merge(pair<int, int> path1, pair<int, int> path2);
void modify(int index, int lboundary, int rboundary, int position,
pair<int, int> path);
int query(int index, int lboundary, int rboundary, pair<int, int> path);
pair<int, int> tr[4 * 200005];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", p + i), q[p[i]] = i;
for (int i = 2; i <= n; i++) scanf("%d", fa + i);
for (int i = 2; i <= n; i++) {
E[i].push_back(fa[i]);
E[fa[i]].push_back(i);
}
dfs1(1);
dfs2(1, 1);
int k;
scanf("%d", &k);
for (int i = 1; i <= n; i++) {
modify(1, 0, n - 1, p[i], make_pair(q[p[i]], q[p[i]]));
}
while (k--) {
int t, u, v;
scanf("%d", &t);
if (t == 1) {
scanf("%d %d", &u, &v);
swap(p[u], p[v]);
swap(q[p[u]], q[p[v]]);
modify(1, 0, n - 1, p[u], make_pair(q[p[u]], q[p[u]]));
modify(1, 0, n - 1, p[v], make_pair(q[p[v]], q[p[v]]));
} else if (t == 2) {
if (tr[1].first)
cout << n << endl;
else
cout << query(1, 0, n - 1, make_pair(q[0], q[0])) << endl;
}
}
}
void dfs1(int r) {
sz[r] = 1;
for (int u : E[r])
if (u != fa[r]) {
dfs1(u);
sz[r] += sz[u];
}
}
void dfs2(int r, int t) {
top[r] = t;
dep[r] = dep[fa[r]] + 1;
int tid = -1, msz = 0;
for (int u : E[r])
if (u != fa[r] && sz[u] > msz) {
msz = sz[u];
tid = u;
}
if (tid == -1) return;
dfs2(tid, t);
for (int u : E[r])
if (u != fa[r] && u != tid) dfs2(u, u);
}
int lca(int a, int b) {
while (top[a] != top[b]) {
if (dep[top[a]] < dep[top[b]]) swap(a, b);
a = fa[top[a]];
}
return dep[a] < dep[b] ? a : b;
}
int dis(int a, int b) { return dep[a] + dep[b] - 2 * dep[lca(a, b)]; }
pair<int, int> merge(int a, int b, int c) {
int ab = dis(a, b), ac = dis(a, c), bc = dis(b, c);
if (ab == bc + ac)
return make_pair(a, b);
else if (ac == ab + bc)
return make_pair(a, c);
else if (bc == ab + ac)
return make_pair(b, c);
else
return make_pair(0, 0);
}
pair<int, int> merge(pair<int, int> a, pair<int, int> b) {
if (!a.first || !b.first) return make_pair(0, 0);
pair<int, int> tmp = merge(a.first, a.second, b.first);
if (tmp.first) tmp = merge(tmp.first, tmp.second, b.second);
return tmp;
}
void modify(int o, int l, int r, int p, pair<int, int> v) {
if (l == r) {
tr[o] = v;
return;
}
int mid = (l + r) >> 1;
if (p <= mid)
modify((o << 1), l, mid, p, v);
else
modify((o << 1 | 1), mid + 1, r, p, v);
tr[o] = merge(tr[(o << 1)], tr[(o << 1 | 1)]);
}
int query(int o, int l, int r, pair<int, int> p) {
if (l == r) return l;
int mid = (l + r) >> 1;
pair<int, int> q = merge(p, tr[(o << 1)]);
if (!q.first)
return query((o << 1), l, mid, p);
else
return query((o << 1 | 1), mid + 1, r, q);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, y;
cin >> n;
int team[n];
map<int, int> h_color;
map<int, int> g_color;
for (int i = 0; i < n; ++i) {
cin >> x >> y;
team[i] = y;
++h_color[x];
++g_color[y];
}
int temp = 2 * (n - 1);
for (int i = 0; i < n; ++i) {
x = (n - 1) + h_color[team[i]];
cout << x << ' ' << temp - x << '\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 100;
struct SuffixArray {
string s;
int n;
vector<int> SA, RA, tempSA, tempRA, LCP;
int L[N];
void reset(string st) {
s = st;
RA.clear();
s += '$';
n = s.size();
RA.resize(n + 1, 0);
SA = tempSA = tempRA = LCP = RA;
}
void BuildSA() {
for (int i = 0; i < n; ++i) SA[i] = i, RA[i] = s[i];
for (int k = 1; k < n; k <<= 1) {
radix_sort(k);
radix_sort(0);
tempRA[SA[0]] = 0;
for (int i = 1, r = 0; i < n; ++i) {
if (getRA(SA[i - 1]) != getRA(SA[i]) ||
getRA(SA[i - 1] + k) != getRA(SA[i] + k))
++r;
tempRA[SA[i]] = r;
}
for (int i = 0; i < n; ++i) RA[i] = tempRA[i];
if (RA[SA[n - 1]] == n - 1) return;
}
}
void BuildLCP() {
for (int i = 0; i < n; ++i) RA[SA[i]] = i;
int k = 0;
for (int i = 0; i < n; ++i) {
if (RA[i] == n - 1) {
k = 0;
continue;
}
int j = SA[RA[i] + 1];
while (i + k < n && j + k < n && s[i + k] == s[j + k]) ++k;
LCP[RA[i]] = k;
if (k) --k;
}
}
private:
inline int getRA(int i) { return (i < n ? RA[i] : 0); }
void radix_sort(int k) {
memset(L, 0, sizeof L);
for (int i = 0; i < n; ++i) L[getRA(i + k)]++;
int p = 0;
for (int i = 0; i < N; ++i) {
int x = L[i];
L[i] = p;
p += x;
}
for (int i = 0; i < n; ++i) {
int &x = L[getRA(SA[i] + k)];
tempSA[x++] = SA[i];
}
for (int i = 0; i < n; ++i) SA[i] = tempSA[i];
}
} SA;
struct SegmentTreeMax {
int IT[N * 4];
int n;
void reset(int _n) {
n = _n;
for (int i = 1; i < N; ++i) IT[i] = 0;
}
void Up(int u, int v) { Up(1, 1, n, u, v); }
int Query(int u, int v) { return Query(1, 1, n, u, v); }
private:
void Up(int k, int l, int r, int u, int val) {
if (l == r) {
IT[k] = val;
return;
}
int m = (l + r) >> 1;
if (u <= m)
Up(k << 1, l, m, u, val);
else
Up(k << 1 | 1, m + 1, r, u, val);
IT[k] = max(IT[k << 1], IT[k << 1 | 1]);
}
int Query(int k, int l, int r, int u, int v) {
if (v < l || r < u) return 0;
if (u <= l && r <= v) return IT[k];
int m = (l + r) >> 1;
return max(Query(k << 1, l, m, u, v), Query(k << 1 | 1, m + 1, r, u, v));
}
} IT;
struct RMQ {
int rmq[N][20], lg[N];
int n;
void Build(vector<int> &v, int _n) {
n = _n;
for (int i = 1; i <= n; ++i) {
lg[i] = log2(i);
rmq[i][0] = v[i];
}
for (int j = 1; j < 20; ++j) {
for (int i = 1; i <= n; ++i)
if (i + (1 << j) - 1 <= n)
rmq[i][j] = min(rmq[i][j - 1], rmq[i + (1 << (j - 1))][j - 1]);
}
}
int Query(int l, int r) {
int d = lg[r - l + 1];
return min(rmq[l][d], rmq[r - (1 << d) + 1][d]);
}
} LCPRange;
int pos[N], dp[N];
int n;
bool Ok(int u, int length) {
u = pos[u];
if (length == 0) return true;
int l = u;
for (int _l = 1, _r = u - 1; _l <= _r;) {
int _m = (_l + _r) >> 1;
if (LCPRange.Query(_m, u - 1) >= length)
_r = _m - 1, l = _m;
else
_l = _m + 1;
}
int r = u;
for (int _l = u + 1, _r = n; _l <= _r;) {
int _m = (_l + _r) >> 1;
if (LCPRange.Query(u, _m - 1) >= length)
_l = _m + 1, r = _m;
else
_r = _m - 1;
}
return (IT.Query(l, r) >= length);
}
int main() {
string st;
cin >> n >> st;
SA.reset(st);
SA.BuildSA();
SA.BuildLCP();
for (int i = 1; i <= n; ++i) pos[SA.SA[i]] = i;
LCPRange.Build(SA.LCP, n);
IT.reset(n);
for (int i = n - 1; i >= 0; --i) {
dp[i] = dp[i + 1] + 1;
while (!Ok(i, dp[i] - 1) && !Ok(i + 1, dp[i] - 1)) {
int j = i + dp[i] - 1;
IT.Up(pos[j], dp[j]);
--dp[i];
}
}
cout << *max_element(dp, dp + n);
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
long long modRecursion(long long a, long long b);
int main() {
long long cnt = 0;
long long s, n, r, k, t;
cin >> k >> n;
long long c = 0;
for (long long i = k; i <= n; i *= k) {
c++;
if (n == i) {
cout << "YES"
<< "\n"
<< c - 1;
return 0;
}
}
cout << "NO";
}
| 1 |
#include<bits/stdc++.h>
#define st first
#define nd second
#define mp make_pair
#ifndef LOCAL
#define cerr if(0)cerr
#endif
using namespace std;
using ll = long long;
using ld = long double;
using vi = vector<int>;
using pii = pair<int, int>;
int main() {
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
int n, q; cin>>n>>q;
vector<int> a(n);
int zeroes = 0;
for(int i=0; i<n; ++i) {
cin>>a[i];
if(!a[i]) zeroes++;
}
for(int i=0; i<q; ++i) {
int t; cin>>t;
if(t==1) {
int x; cin>>x;
x--;
if(!a[x]) zeroes--;
else zeroes++;
a[x] = !a[x];
}
else {
int k; cin>>k;
int ones = n - zeroes;
if(ones >= k) {
cout<<1<<'\n';
}
else {
cout<<0<<'\n';
}
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void printa(int a[], int n, int begin = 0) {
printf("array : ");
if (begin > 0) n++;
for (int i = begin; i < n; i++) printf("%llu ", a[i]);
printf("\n");
}
int main() {
unsigned long long n, m, k;
unsigned long long ans = 0;
scanf("%llu%llu%llu", &n, &m, &k);
unsigned long long apps[100000];
unsigned long long pos[100000];
for (int i = 1; i <= n; i++) {
scanf("%llu", &apps[i]);
pos[apps[i]] = (i);
}
for (int i = 0; i < m; i++) {
unsigned long long mm;
scanf("%llu", &mm);
ans += ceil(double(pos[mm]) / k);
if (pos[mm] != 1) {
unsigned long long temp = pos[mm];
swap(apps[temp], apps[temp - 1]);
pos[apps[temp]]++;
pos[apps[temp - 1]]--;
}
}
printf("%llu\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int numOfNodes[100005];
vector<vector<int> > adj;
int rootTheTree(int node, int parent) {
numOfNodes[node] = 1;
int sz = adj[node].size();
for (int i = 0; i < sz; ++i) {
int x = adj[node][i];
if (x == parent) continue;
numOfNodes[node] += rootTheTree(x, node);
}
return numOfNodes[node];
}
int main() {
int n;
cin >> n;
adj.resize(n + 1);
int u[100005];
int v[100005];
int c[100005];
for (int i = 1; i < n; ++i) {
cin >> u[i] >> v[i] >> c[i];
adj[u[i]].push_back(v[i]);
adj[v[i]].push_back(u[i]);
}
rootTheTree(1, 1);
long long deno = 1LL * n * (n - 1) * (n - 2) / 6;
double res = 0;
long long e[100005];
for (int i = 1; i < n; ++i) {
int a = min(numOfNodes[u[i]], numOfNodes[v[i]]);
e[i] = 1LL * a * (n - a) * (n - 2);
res += c[i] * 1.0 * e[i] / deno;
}
int q;
cin >> q;
for (int i = 0; i < q; ++i) {
int j, val;
cin >> j >> val;
res += (val - c[j]) * 1.0 * e[j] / deno;
c[j] = val;
cout << setprecision(6) << fixed << res << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cout << 1 << " ";
}
cout << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char a[8];
string q[2];
int main() {
bool is = false;
cin >> a[1] >> a[0] >> a[2] >> a[3] >> a[5] >> a[4] >> a[6] >> a[7];
for (int i = 0; i < 4; i++)
if (a[i] != 'X') q[0] += a[i];
for (int i = 4; i < 8; i++)
if (a[i] != 'X') q[1] += a[i];
for (int i = 0; i < 4; i++) {
int temp = q[0][0];
q[0][0] = q[0][1];
q[0][1] = q[0][2];
q[0][2] = temp;
if (q[0] == q[1]) is = true;
}
if (is)
cout << "YES";
else
cout << "NO";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fll;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int n, a, b, da, db;
cin >> n >> a >> b >> da >> db;
a--, b--;
vector<vector<int>> g(n);
for (int i = 0; i < n - 1; i++) {
int aa, bb;
cin >> aa >> bb;
aa--, bb--;
g[aa].push_back(bb);
g[bb].push_back(aa);
}
bool alicewin = 0;
if (db <= 2 * da) alicewin = 1;
vector<int> d(n, -1);
function<void(int)> dfs = [&](int x) {
for (auto u : g[x])
if (d[u] == -1) {
d[u] = d[x] + 1;
dfs(u);
}
};
d[0] = 0;
dfs(0);
int maxpos = -1, dmax = -1;
for (int i = 0; i < n; i++)
if (d[i] > dmax) {
maxpos = i;
dmax = d[i];
}
for (auto& u : d) u = -1;
d[maxpos] = 0;
dfs(maxpos);
int diameter = *max_element(d.begin(), d.end());
for (auto& u : d) u = -1;
d[a] = 0;
dfs(a);
if (d[b] <= da) alicewin = 1;
if ((diameter + 1) / 2 <= da) alicewin = 1;
cout << (alicewin ? "Alice" : "Bob") << '\n';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1);
bool exist[10004][45];
int main() {
ios_base::sync_with_stdio(false);
int n, m;
scanf("%d%d", &m, &n);
for (int i = 0; i < 10004; i++)
for (int j = 0; j < 45; j++) exist[i][j] = true;
vector<set<int>> ve;
int cur = 0;
while (m--) {
cur++;
int t;
scanf("%d", &t);
vector<int> temp;
while (t--) {
int x;
scanf("%d", &x);
temp.push_back(x);
exist[x][cur] = false;
}
for (int i = 1; i < cur; i++) {
bool b = false;
for (auto x : temp) {
if (!exist[x][i]) {
b = true;
break;
}
}
if (!b) return cout << "impossible\n", 0;
}
}
cout << "possible\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int ed, flow, next;
} edge[2000000];
int head[20010], nEdge;
int d[20010], pre[20010], path[20010], his[20010], cur[20010], vh[20010];
void init() {
memset(head, -1, sizeof(head));
nEdge = 0;
}
void addEdge(const int a, const int b, const int flow) {
edge[nEdge].ed = b;
edge[nEdge].flow = flow;
edge[nEdge].next = head[a];
head[a] = nEdge++;
edge[nEdge].ed = a;
edge[nEdge].flow = 0;
edge[nEdge].next = head[b];
head[b] = nEdge++;
}
int sap(const int v, const int src, const int dst) {
int x, y, i, m, nowFlow = 1000000000, totalFlow = 0;
bool flag;
memset(d, 0, sizeof(d));
memset(vh, 0, sizeof(vh));
memcpy(cur, head, sizeof(cur));
for (vh[0] = v, x = src; d[src] < v;) {
his[x] = nowFlow;
for (flag = false, i = cur[x]; ~i; i = edge[i].next) {
if (edge[i].flow && d[x] == d[y = edge[i].ed] + 1) {
flag = true;
nowFlow = min(nowFlow, edge[i].flow);
pre[y] = x;
path[y] = cur[x] = i;
if ((x = y) == dst) {
for (totalFlow += nowFlow; x != src; x = pre[x]) {
edge[path[x]].flow -= nowFlow;
edge[path[x] ^ 1].flow += nowFlow;
}
nowFlow = 1000000000;
}
break;
}
}
if (!flag) {
for (m = v, i = cur[x] = head[x]; ~i; i = edge[i].next) {
if (edge[i].flow && d[y = edge[i].ed] < m) {
m = d[y];
cur[x] = i;
}
}
if (!(--vh[d[x]])) break;
++vh[d[x] = m + 1];
if (x != src) nowFlow = his[x = pre[x]];
}
}
return totalFlow;
}
int n, m, MA;
int a[100], b[100], c[100];
int l[100], r[100];
int u, v, D;
int node(int i, int x) { return i * 202 + x + 100 + 2; }
int main() {
init();
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d%d%d", &a[i], &b[i], &c[i]);
}
MA = 200000;
for (int i = 0; i < n; i++) {
addEdge(0, node(i, -100), 1000000000);
scanf("%d%d", &l[i], &r[i]);
for (int j = -100; j <= 100; j++) {
if ((l[i] <= j) && (j <= r[i]))
addEdge(node(i, j), node(i, j + 1),
MA - (a[i] * j * j + b[i] * j + c[i]));
else
addEdge(node(i, j), node(i, j + 1), 1000000000);
}
addEdge(node(i, 101), 1, 1000000000);
}
for (int i = 0; i < m; i++) {
scanf("%d%d%d", &u, &v, &D);
for (int j = -100; j <= 100; j++)
if (j - D >= -100) {
addEdge(node(u - 1, j), node(v - 1, j - D), 1000000000);
}
}
printf("%d\n", n * MA - sap(2 + n * 202, 0, 1));
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int dr[]{-1, -1, 0, 1, 1, 1, 0, -1};
const int dc[]{0, 1, 1, 1, 0, -1, -1, -1};
void run() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
int main() {
run();
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
if (n == 1)
cout << -1 << "\n";
else {
string rt(n, '2');
long long sum = 0;
for (int i = 0; i + 1 < n; i++) sum = (sum * 10 + 2) % 3;
if (sum == 0) rt[n - 2] = '3';
rt[n - 1] = '3';
cout << rt << "\n";
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long int lcm(long long int a, long long int b) {
return b * a / gcd(a, b);
}
long long int abs1(long long int a) {
if (a < 0)
return -1 * a;
else
return a;
}
long long int max(long long int a, long long int b) {
if (a > b) return a;
return b;
}
long long int fast_pow(long long base, long long n, long long M) {
if (n == 0) return 1;
if (n == 1) return base;
long long halfn = fast_pow(base, n / 2, M);
if (n % 2 == 0)
return (halfn * halfn) % M;
else
return (((halfn * halfn) % M) * base) % M;
}
long long int findMMI_fermat(long long int n, long long int M) {
return fast_pow(n, M - 2, M);
}
const double PI = 3.14159265358979323846;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m, k;
cin >> n >> m >> k;
int count = 1;
map<int, pair<int, int> > row, column;
while (k--) {
int r, s, t;
cin >> r >> s >> t;
if (r == 1) {
row[s] = make_pair(t, count);
} else {
column[s] = make_pair(t, count);
}
count++;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (row[i].first == 0 && column[j].first == 0) {
cout << "0 ";
continue;
}
int r = row[i].second;
int l = column[j].second;
if (r > l) {
cout << row[i].first << " ";
} else {
cout << column[j].first << " ";
}
}
cout << '\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char *argv[]) {
int raf;
int cup1, cup2, cup3, medal1, medal2, medal3;
cin >> cup1 >> cup2 >> cup3;
cin >> medal1 >> medal2 >> medal3;
cin >> raf;
int medaltop = medal1 + medal2 + medal3;
int cuptop = cup1 + cup2 + cup3;
int bosluk = raf * 5;
if (cuptop > bosluk) {
cout << "NO";
} else {
bosluk = bosluk - cup1 - cup2 - cup3;
if (bosluk < 5) {
if (medaltop != 0)
cout << "NO";
else
cout << "YES";
} else if (bosluk >= 5) {
bosluk = (bosluk - (bosluk % 5)) * 2;
if (medaltop <= bosluk)
cout << "YES";
else
cout << "NO";
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long s, d;
cin >> s >> d;
if (s == 0 || d == 0 || s / d >= 2 || d / s >= 2) {
cout << min(s, d) << endl;
} else {
long long int count = max(s, d) - min(s, d);
if (s > d) {
s = s - 2 * count;
d = d - count;
} else {
d = d - 2 * count;
s = s - count;
}
count = count;
long long ans = 0;
if (s % 3 == 0) {
ans = (s / 3) * 2 + count;
} else {
ans = (s / 3) * 2;
s = s - 3 * (s / 3);
d = s;
if (d > 1 && s >= 1 || d >= 1 && s > 1) {
ans = ans + 1;
}
ans = ans + count;
}
cout << ans << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 7;
int b[MAXN], c[MAXN], a[MAXN], n, cnt[40], B[MAXN], C[MAXN];
int getBit(int v, int p) { return (v >> p) & 1; }
int main() {
if (fopen("tst.inp", "r")) {
freopen("tst.inp", "r", stdin);
freopen("tst.out", "w", stdout);
}
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
long long s = 0;
cin >> n;
for (int i = 1; i <= n; ++i) cin >> b[i], s += b[i];
for (int i = 1; i <= n; ++i) cin >> c[i], s += c[i];
s /= 2LL * n;
for (int i = 1; i <= n; ++i) {
if ((b[i] + c[i] - s) % n != 0 || b[i] + c[i] < s) return cout << -1, 0;
a[i] = (b[i] + c[i] - s) / n;
}
for (int j = 30; j >= 0; --j)
for (int i = 1; i <= n; ++i)
if (getBit(a[i], j)) ++cnt[j];
for (int i = 1; i <= n; ++i)
for (int j = 30; j >= 0; --j)
if (getBit(a[i], j))
B[i] += cnt[j] << j, C[i] += n << j;
else
C[i] += cnt[j] << j;
for (int i = 1; i <= n; ++i)
if (B[i] != b[i] || C[i] != c[i]) return cout << -1, 0;
for (int i = 1; i <= n; ++i) cout << a[i] << ' ';
return 0;
}
| 8 |
#include <bits/stdc++.h>
int a[] = {0, 0, 1, 1, 1, 2, 1, 1, 14, 8, 4, 2, 41, 13, 21, 1, 22,
4, 19, 19, 4, 2, 1, 16, 13, 4, 35, 19, 4, 2, 41, 4, 87, 41,
115, 2, 59, 31, 49, 8, 28, 4, 31, 44, 50, 13, 151, 16, 91, 56, 14},
n;
int main() {
scanf("%d", &n);
for (int i = 0; i < n - 1; i++) printf("%d ", (long long)a[n] >> i & 1);
puts("1");
for (int i = 0; i < n; i++) printf("%d ", 1);
}
| 9 |
#include <bits/stdc++.h>
const int maxn = 4e5 + 5;
using namespace std;
int nex[maxn][26], ans[maxn];
int cnt, n;
int merge(int x, int y) {
if (x == 0 || y == 0) return x | y;
int tmp = ++cnt;
for (int i = 0; i < 26; ++i) nex[tmp][i] = merge(nex[x][i], nex[y][i]);
return tmp;
}
void dfs(int u, int level) {
int now = n + 1;
cnt = now;
for (int i = 0; i < 26; ++i) {
if (nex[u][i]) now = merge(now, nex[u][i]);
}
ans[level] += cnt - n - 1;
for (int i = 0; i < 26; ++i) {
if (nex[u][i]) dfs(nex[u][i], level + 1);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
int u, v;
char c;
scanf("%d %d %c", &u, &v, &c);
nex[u][c - 'a'] = v;
}
dfs(1, 1);
int sz = 0, p;
for (int i = 1; i <= n; ++i) {
if (sz < ans[i]) {
sz = ans[i];
p = i;
}
}
printf("%d\n%d\n", n - sz, p);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1500009;
int t[N], n;
bool ok(int i) {
if (i < 1 || i >= n) return 1;
if ((i & 1) && t[i] >= t[i + 1]) return 0;
if (!(i & 1) && t[i] <= t[i + 1]) return 0;
return 1;
}
vector<int> bd;
bool check(int a, int b) {
bool flag = 1;
swap(t[a], t[b]);
for (int i = 0; i < bd.size(); i++)
if (!ok(bd[i])) flag = 0;
if (!ok(a) || !ok(a - 1) || !ok(b) || !ok(b - 1)) flag = 0;
swap(t[a], t[b]);
return flag;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &t[i]);
for (int i = 1; i < n; i++)
if (!ok(i)) bd.push_back(i);
if (bd.size() > 4) {
printf("0\n");
return 0;
}
int x = bd[0];
int ans = 0;
for (int i = 1; i <= n; i++)
if (check(i, x)) ans++;
for (int i = 1; i <= n; i++)
if (check(i, x + 1)) ans++;
if (check(x, x + 1)) ans--;
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = int(1e5) + 123;
int n, m, q, a[555][555], M;
int b[555];
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m >> q;
for (int i = 1; i <= n; i++) {
int x = -1, y, s = 0;
for (int j = 1; j <= m; j++) {
cin >> a[i][j];
if (a[i][j] == 1) {
if (x == -1) {
x = j;
s++;
} else
s++;
} else {
b[i] = max(s, b[i]);
s = 0;
x = -1;
}
}
b[i] = max(b[i], s);
}
int X, y;
while (q--) {
M = 0;
cin >> X >> y;
a[X][y] = (a[X][y] + 1) % 2;
int x = -1, s = 0;
b[X] = 0;
for (int j = 1; j <= m; j++) {
if (a[X][j] == 1) {
if (x == -1) {
x = j;
s++;
} else
s++;
} else {
b[X] = max(s, b[X]);
s = 0;
x = -1;
}
}
b[X] = max(b[X], s);
for (int i = 1; i <= n; i++) {
M = max(b[i], M);
}
cout << M << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[10005];
int main() {
int t;
cin >> t;
for (int i = 1; i <= t; i++) {
int n;
cin >> n;
for (int j = 1; j <= n; j++) cin >> a[j];
if (a[1] == 1) {
cout << n + 1 << ' ';
for (int i = 1; i <= n; i++) cout << i << ' ';
cout << endl;
continue;
}
if (a[n] == 0) {
for (int i = 1; i <= n + 1; i++) cout << i << ' ';
cout << endl;
continue;
}
for (int j = 1; j <= n; j++) {
if (a[j] != a[j + 1] && j != n) {
for (int k = 1; k <= j; k++) cout << k << ' ';
cout << n + 1 << ' ';
for (int k = j + 1; k <= n; k++) cout << k << ' ';
cout << endl;
break;
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long x, p, q, w;
int main() {
while (~scanf("%I64d", &x)) {
vector<long long> a, b;
long long tot = 0;
for (long long i = 1; i * (i + 1) * (2 * i + 1) <= 6 * x; i++) {
if (6 * x % i == 0) {
p = 6 * x / i;
if (p % (i + 1) == 0) {
p = p / (i + 1);
if (p - 2 * i - 1 >= 0) {
p = p - (2 * i + 1);
if (p % 3 == 0) {
p = p / 3;
a.push_back(i);
b.push_back(i + p);
}
}
}
}
}
tot = a.size();
if (a[tot - 1] == b[tot - 1])
printf("%I64d\n", tot * 2 - 1);
else
printf("%I64d\n", 2 * tot);
for (long long i = 0; i < tot; i++) printf("%I64d %I64d\n", a[i], b[i]);
for (long long i = tot - 1; i >= 0; i--) {
if (a[i] == b[i]) continue;
printf("%I64d %I64d\n", b[i], a[i]);
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long int k, i, j;
cin >> k;
i = k;
j = 1;
cout << "3 3\n";
while (i != 0) {
i /= 2;
j = j * 2;
}
cout << j + k << " " << j + k << " " << j << endl;
cout << j << " " << k << " " << j + k << endl;
cout << j << " " << j << " " << k << endl;
}
| 4 |
#include <bits/stdc++.h>
#include <iostream>
#include <fstream>
#define IOS ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define ll long long
#define pre(a,b) cout<<fixed<<setprecision(a)<<b<<"\n";//a for precision b for answer
#define mp make_pair
#define pb push_back
#define forn(n) for(ll i=0;i<n;i++)
#define ff first
#define ss second
#define MAX 1e18
#define all(x) (x).begin(),(x).end()
#define lb lower_bound
#define ub upper_bound
const double pi = 3.141592653589793238;
const int MOD1 = 1e9 + 7;
const int MOD2 = 998244353;
const int N=3e5+5;
//cout<<"Case #"<<p<<": "<<;
//file input freopen("input.txt","r",stdin);
//file output freopen("output.txt","w",stdout);
using namespace std;
int32_t main()
{
IOS;
ll t=0;
cin>>t;
while(t--)
{
ll a,b;
cin>>a>>b;
if(a%2==0)
{
if(b%a)
cout<<b%a<<"\n";
else
cout<<a<<"\n";
}
else
{
ll d = a/2;//size sequence
ll ans = b/d;
if(!(b%d))
ans--;
if((b+ans)%a)
{
cout<<(b+ans)%a<<"\n";
}
else
cout<<a<<"\n";
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long a[17] = {0ll,
1ll,
11ll,
111ll,
1111ll,
11111ll,
111111ll,
1111111ll,
11111111ll,
111111111ll,
1111111111ll,
11111111111ll,
111111111111ll,
1111111111111ll,
11111111111111ll,
111111111111111ll,
1111111111111111ll};
const long long b[17] = {0ll, 1ll, 2ll, 3ll, 4ll, 5ll, 6ll, 7ll, 8ll,
9ll, 10ll, 11ll, 12ll, 13ll, 14ll, 15ll, 16ll};
long long ans = 1000000000000000ll, n;
void dfs(long long cur, long long tot) {
for (int i = 1; i < 17; i++) {
if (tot + b[i] >= ans) return;
if (cur + a[i] == n) {
ans = tot + b[i];
return;
}
if (cur - a[i] == n) {
ans = tot + b[i];
return;
}
if (cur + a[i] > n && cur + a[i - 1] < n) {
long long temp_cur = cur, temp_tot = tot;
while (temp_cur + a[i - 1] < n) {
temp_cur += a[i - 1];
temp_tot += b[i - 1];
}
dfs(temp_cur, temp_tot);
dfs(cur + a[i], tot + b[i]);
return;
}
if (cur - a[i] < n && cur - a[i - 1] > n) {
long long temp_cur = cur, temp_tot = tot;
while (temp_cur - a[i - 1] > n) {
temp_cur -= a[i - 1];
temp_tot += b[i - 1];
}
dfs(temp_cur, temp_tot);
dfs(cur - a[i], tot + b[i]);
return;
}
}
}
int main() {
scanf("%I64d", &n);
if (n == 0) {
printf("0\n");
return 0;
}
dfs(0, 0);
printf("%I64d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
map<char, int> m;
m['o'] = m['n'] = m['e'] = m['z'] = m['r'] = 0;
char c;
vector<char> num;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> c;
num.push_back(c);
m[c]++;
}
for (int i = 0; i < m['n']; i++) cout << "1 ";
for (int i = 0; i < m['r']; i++) cout << "0 ";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<pair<int, int>> vii;
typedef pair<int, int> pi;
#define MOD 1000000007LL
int n, k; int n2;
vector<int> chains;
int stree[1600000]={};
void add(int i, int v) {
i += n2;
for (; i >= 1; i /= 2) stree[i] += v;
}
int sum(int a, int b) {
a += n2; b += n2;
int s = 0;
while (a <= b) {
if (a%2 == 1) s += stree[a++];
if (b%2 == 0) s += stree[b--];
a /= 2; b /= 2;
}
return s;
}
int main() {
//freopen("feast.in", "r", stdin);
//freopen("feast.out", "w", stdout);
//ios_base::sync_with_stdio(false);
//cin.tie(0);
cin >> n >> k;
n2 = 1; while (n2 <= 4e5) n2 *= 2;
chains.resize(n);
for (int i = 0; i < n; i++) cin >> chains[i];
sort(chains.begin(), chains.end(), greater<int>());
int ai = 4e5, cnt = 1, ans = 1e9;
add(0, 1); add(1, -1);
//cout << "debugging: ";
//for (int i = 0; i <= 10; i++) cout << sum(0, i) << " "; cout << endl;
int idx = 0;
for (auto l : chains) { l--;
int fl = l/2, sl = l-fl;
while (sum(0, idx) == 0) idx++;
add(idx, -1); add(idx+1, 1);
add(idx+2, 1); add(idx+2+fl, -1);
add(idx+2, 1); add(idx+2+sl, -1);
if (ai < idx) cnt += 0;
else if (ai == idx) cnt -= 1;
else if (ai == idx+1) cnt -= 1;
else {
cnt -= 1;
cnt += min(ai, idx+1+fl) - (idx+1);
cnt += min(ai, idx+1+sl) - (idx+1);
}
while (cnt - sum(0, ai) >= k) { cnt -= sum(0, ai); ai--; }
if (cnt >= k) ans = min(ans, ai);
//cout << "Debugging: " << l << " " << fl << " " << sl << " " << idx << endl;
//for (int i = 0; i <= 10; i++) cout << sum(0, i) << " "; cout << endl;
//cout << ai << " " << cnt << " " << ans << endl;
}
cout << (ans==1e9 ? -1 : ans) << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
inline long long mod(long long a, long long m) { return (a % m + m) % m; }
long long extGcd(long long a, long long b, long long &p, long long &q) {
if (b == 0) {
p = 1;
q = 0;
return a;
}
long long d = extGcd(b, a % b, q, p);
q -= a / b * p;
return d;
}
pair<long long, long long> ChineseRem(long long b1, long long m1, long long b2,
long long m2) {
long long p, q;
long long d = extGcd(m1, m2, p, q);
if ((b2 - b1) % d != 0) return make_pair(0, -1);
long long m = m1 * (m2 / d);
long long tmp = (b2 - b1) / d * p % (m2 / d);
long long x = (b1 + m1 * tmp) % m;
return make_pair(x, m);
}
long long inv(long long a, long long m) {
long long b = m, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
return mod(u, m);
}
int main() {
long long a, b, p, x;
cin >> a >> b >> p >> x;
long long res = 0;
long long pow = 1;
for (long long k = 0; k < p - 1; ++k) {
long long b2 = inv(pow, p) * b % p;
pair<long long, long long> c = ChineseRem(k, p - 1, b2, p);
long long tmp = (x + (c.second - c.first) % c.second) / c.second;
res += tmp;
pow = pow * a % p;
}
cout << res << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long a[(1 << 21) + 5], b[(1 << 21) + 5], c[(1 << 21) + 5], fac[44];
int U;
void fwt(long long f[], int v) {
for (int i = 1; i <= U; i <<= 1)
for (int j = 0; j <= U; j += i << 1)
for (int k = j; k < i + j; k++) f[i + k] += f[k] * v;
}
int cnt[(1 << 21) + 5];
char s[(1 << 21) + 5];
int main() {
int n;
cin >> n;
U = (1 << n) - 1;
for (int i = 1; i <= U; i++) cnt[i] = cnt[i >> 1] + (i & 1);
fac[0] = 1;
for (int i = 1; i <= n; i++) fac[i] = fac[i - 1] * 4;
scanf("%s", s);
for (int i = 0; i <= U; i++) a[i] = s[i] - '0', a[i] = a[i] * fac[cnt[i]];
fwt(a, 1);
scanf("%s", s);
for (int i = 0; i <= U; i++) b[i] = s[i] - '0', b[i] = b[i] * fac[cnt[i]];
fwt(b, 1);
for (int i = 0; i <= U; i++) c[i] = a[i] * b[i];
fwt(c, -1);
for (int i = 0; i <= U; i++) printf("%lld", c[i] / fac[cnt[i]] & 3);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1010, size = 1 << 20, mod = 998244353, inf = 2e9;
const long long INF = 1e15;
template <class o>
void qr(o &x) {
char c = getchar();
x = 0;
int f = 1;
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) x = x * 10 + c - '0', c = getchar();
x *= f;
}
template <class o>
void qw(o x) {
if (x / 10) qw(x / 10);
putchar(x % 10 + '0');
}
template <class o>
void pr1(o x) {
if (x < 0) x = -x, putchar('-');
qw(x);
putchar(' ');
}
template <class o>
void pr2(o x) {
if (x < 0) x = -x, putchar('-');
qw(x);
putchar('\n');
}
long long gcd(long long a, long long b) { return !a ? b : gcd(b % a, a); }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long long power(long long a, long long b = mod - 2) {
long long c = 1;
while (b) {
if (b & 1) c = c * a % mod;
b /= 2;
a = a * a % mod;
}
return c;
}
int n, m, vis[N], d[N], q[N], l, r, fa[N];
vector<int> e[N];
void add(int x, int y) {
e[x].push_back(y);
e[y].push_back(x);
}
int bfs(int st, int t) {
q[l = r = 1] = st;
vis[st] = t;
d[st] = 0;
while (l <= r) {
int x = q[l++];
for (int y : e[x])
if (vis[y] < t) {
vis[y] = t;
d[y] = d[x] + 1;
q[++r] = y;
fa[y] = x;
}
}
return q[r];
}
pair<int, int> c[N];
void solve() {
qr(n);
qr(m);
for (int i = 1, x, y; i <= m; i++) qr(x), qr(y), add(x, y);
int tot = 0, ans = 0;
for (int i = 1; i <= n; i++)
if (!vis[i]) {
++tot;
int x = bfs(i, tot * 2);
int y = bfs(x, tot * 2 + 1);
ans = max(ans, d[y]);
c[tot].first = (d[y] + 1) / 2;
int z = d[y] / 2;
while (z--) y = fa[y];
c[tot].second = y;
}
if (tot > 1) {
sort(c + 1, c + tot + 1, greater<pair<int, int> >());
ans = max(ans, c[1].first + c[2].first + 1);
if (tot > 2) ans = max(ans, c[2].first + c[3].first + 2);
}
pr2(ans);
for (int i = 2; i <= tot; i++) pr1(c[1].second), pr2(c[i].second);
}
int main() {
int T;
solve();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 10;
int n, k, book[N], dis[N], ans = 1e8;
int read() {
int a;
scanf("%d", &a);
return a;
}
int main() {
cin >> n >> k;
for (int i = 1; i <= k; i++) book[read()] = 1;
queue<int> q;
q.push(0);
while (!q.empty()) {
int x = q.front();
q.pop();
for (int i = 0; i <= 1000; i++) {
int now = x + i - n;
if (book[i] && now >= 0 && now <= 1000 && !dis[now]) {
dis[now] = dis[x] + 1;
if (now == 0) {
cout << dis[now] << endl;
return 0;
}
q.push(now);
}
}
}
cout << "-1";
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3005;
int n, m, x, y, t, b[N], w[N], sub[N];
vector<int> g[N];
pair<long long, long long> dp[N][N], e;
pair<long long, long long> max_m(pair<long long, long long> p1,
pair<long long, long long> p2,
pair<long long, long long> p3) {
p2.first += p3.first, p2.second += p3.second;
if (p1.first > p2.first || (p1.first == p2.first && p1.second > p2.second))
return p1;
return p2;
}
void dfs(int x, int par) {
for (int i = 1; i < m + 1; i++) dp[x][i].second = dp[x][i].first = -1e18;
sub[x] = 1;
for (int i = 0; i < g[x].size(); i++)
if (g[x][i] != par) {
dfs(g[x][i], x);
sub[x] += sub[g[x][i]];
for (int j = min(sub[x], m); j >= 0; j--) {
dp[x][j].first += dp[g[x][i]][0].first,
dp[x][j].second += dp[g[x][i]][0].second;
for (int k = min(sub[x] - sub[g[x][i]], j - 1);
k >= j - sub[g[x][i]] && k >= 0; k--)
dp[x][j] = max_m(dp[x][j], dp[x][k], dp[g[x][i]][j - k]);
}
}
for (int i = 0; i < min(sub[x], m) + 1; i++) dp[x][i].second += w[x];
pair<long long, long long> p;
if (x != 1) {
for (int i = min(sub[x], m); i >= 1; i--) {
p.first = dp[x][i - 1].first, p.second = 0;
p.first += (dp[x][i - 1].second > 0);
dp[x][i] = max_m(dp[x][i], p, e);
}
} else {
for (int i = min(sub[x], m); i >= 1; i--) {
p.first = dp[x][i - 1].first, p.second = 0;
p.first += (dp[x][i - 1].second > 0);
dp[x][i] = p;
}
}
}
void clear() {
for (int i = 1; i < n + 1; i++) g[i].clear();
for (int i = 1; i < n + 1; i++)
for (int j = 0; j < min(m, sub[i]) + 1; j++)
dp[i][j].first = dp[i][j].second = 0;
}
int main() {
cin >> t;
while (t--) {
clear();
scanf("%d%d", &n, &m);
;
for (int i = 0; i < n; i++) scanf("%d", &b[i + 1]);
;
for (int i = 0; i < n; i++) {
scanf("%d", &w[i + 1]);
;
w[i + 1] -= b[i + 1];
}
for (int i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
;
g[x].push_back(y);
g[y].push_back(x);
}
dfs(1, 0);
cout << dp[1][m].first << endl;
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e16;
struct edge {
int a, b;
long long cap, flow;
int back;
edge(int a, int b, int c, int d, int e)
: a(a), b(b), cap(c), flow(d), back(e) {}
};
struct max_flow {
vector<vector<edge> > g;
vector<long long> ex;
vector<int> h;
vector<int> active;
vector<int> count;
int size;
max_flow(int n) : g(n), ex(n), h(n), count(2 * n), active(n) {}
void addEdge(int a, int b, long long cap) {
if (a != b) {
g[a].push_back(edge(a, b, cap, 0, g[b].size()));
g[b].push_back(edge(b, a, 0, 0, g[a].size() - 1));
}
}
long long maximum_flow(int s, int t) {
h[s] = g.size();
count[g.size()]++;
count[0] = g.size() - 1;
queue<int> qq;
active[s] = 1;
active[t] = 1;
for (int i = 0; i < g[s].size(); ++i) {
if (g[s][i].cap > g[s][i].flow) {
int vert = g[s][i].b;
g[s][i].flow += g[s][i].cap;
g[g[s][i].b][g[s][i].back].flow = -g[s][i].cap;
ex[g[s][i].b] += g[s][i].flow;
if (active[vert] == 0 && ex[vert] > 0) {
qq.push(vert);
active[vert] = 1;
}
}
}
for (;;) {
if (qq.empty()) break;
int v = qq.front();
active[v] = 0;
qq.pop();
for (int j = 0; j < g[v].size() && ex[v] > 0; ++j) {
int vert = g[v][j].b;
if (h[v] == h[vert] + 1) {
int tob = min(g[v][j].cap - g[v][j].flow, ex[v]);
if (tob > 0) {
g[v][j].flow += tob;
g[vert][g[v][j].back].flow = -g[v][j].flow;
ex[v] -= tob;
ex[vert] += tob;
if (active[vert] == 0 && ex[vert] > 0) {
active[vert] = 1;
qq.push(vert);
}
}
}
}
if (ex[v] > 0) {
if (count[h[v]] == 1) {
int k = h[v];
for (int i = 0; i < g.size(); ++i) {
if (h[i] >= k) {
count[h[i]]--;
h[i] = max(h[i], (int)g.size() + 1);
count[h[i]]++;
if (active[i] == 0 && ex[i] > 0) {
qq.push(i);
active[i] = 1;
}
}
}
} else {
count[h[v]]--;
h[v] = 2 * g.size();
for (int i = 0; i < g[v].size(); ++i) {
if (g[v][i].flow < g[v][i].cap) {
h[v] = min(h[v], h[g[v][i].b] + 1);
}
}
count[h[v]]++;
if (active[v] == 0 && ex[v] > 0) {
qq.push(v);
active[v] = 1;
}
}
}
}
long long ans = 0;
for (int i = 0; i < g[s].size(); ++i) {
ans += g[s][i].flow;
}
return ans;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
max_flow ob(n + m + 2);
int src = 0, sink = n + m + 1;
for (int i = 1; i <= n; ++i) {
int x;
cin >> x;
ob.addEdge(m + i, sink, x);
}
long long sum = 0;
for (int i = 1; i <= m; ++i) {
int a, b, c;
cin >> a >> b >> c;
sum += c;
ob.addEdge(src, i, c);
ob.addEdge(i, m + a, INF);
ob.addEdge(i, m + b, INF);
}
cout << sum - ob.maximum_flow(src, sink) << '\n';
}
| 8 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1000000000")
using namespace std;
const int maxn = (int)1e5 + 10, mod = 998244353;
const int maxm = 210;
int dp[maxn][2][maxm];
int v[maxn];
int get_sum(int pos, int tp, int l, int r) {
int ans = dp[pos][tp][r] - dp[pos][tp][l - 1];
if (ans < 0) {
ans += mod;
}
return ans;
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%d", &v[i]);
}
for (int i = 1; i <= 200; i++) {
if (v[n - 1] == -1 || v[n - 1] == i) {
dp[n - 1][0][i] = 0;
dp[n - 1][1][i] = 1;
}
dp[n - 1][1][i] += dp[n - 1][1][i - 1];
if (dp[n - 1][1][i] >= mod) {
dp[n - 1][1][i] -= mod;
}
}
for (int i = n - 2; i >= 0; i--) {
for (int j = 1; j <= 200; j++) {
if (v[i] == -1 || v[i] == j) {
dp[i][0][j] = get_sum(i + 1, 0, j + 1, 200);
dp[i][0][j] += get_sum(i + 1, 1, j, j);
if (dp[i][0][j] >= mod) {
dp[i][0][j] -= mod;
}
dp[i][1][j] = get_sum(i + 1, 0, j + 1, 200);
dp[i][1][j] += get_sum(i + 1, 1, 1, j);
if (dp[i][1][j] >= mod) {
dp[i][1][j] -= mod;
}
}
}
for (int j = 1; j <= 200; j++) {
dp[i][0][j] += dp[i][0][j - 1];
dp[i][1][j] += dp[i][1][j - 1];
if (dp[i][0][j] >= mod) {
dp[i][0][j] -= mod;
}
if (dp[i][1][j] >= mod) {
dp[i][1][j] -= mod;
}
}
}
long long ans = 0;
for (int i = 1; i <= 200; i++) {
if (v[0] == -1 || i == v[0]) {
ans += dp[0][0][i] - dp[0][0][i - 1];
ans %= mod;
if (ans < 0) {
ans += mod;
}
}
}
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:20000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
using namespace std;
const int N = 300010;
const int Mod = 1e9 + 7;
const long long INF = (long long)1e17;
vector<pair<int, int> > e[N];
int n, g[N], vis[N];
long long dp[N], ans;
void dfs(int u) {
vis[u] = true;
dp[u] = g[u];
for (pair<int, int> &v : e[u]) {
if (!vis[v.first]) {
dfs(v.first);
long long c = dp[v.first] - v.second;
ans = max(ans, dp[u] + c);
dp[u] = max(dp[u], g[u] + c);
}
}
ans = max(ans, dp[u]);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cin >> n;
for (int(i) = 0; (i) < (int)(n); ++(i)) {
cin >> g[i];
}
for (int(i) = 0; (i) < (int)(n - 1); ++(i)) {
int u, v, w;
cin >> u >> v >> w;
u--, v--;
e[u].push_back({v, w});
e[v].push_back({u, w});
}
dfs(0);
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 100;
const int E = 2e5 + 100;
int n;
int l[N], r[N];
vector<int> x;
vector<int> g[N];
vector<int> tour;
int to[E], mark[E], ecnt;
int from[E], c[E];
void add(int u, int v) {
from[ecnt] = u, to[ecnt] = v;
g[u].push_back(ecnt);
g[v].push_back(ecnt);
ecnt++;
}
void dfs(int v) {
while (((int)g[v].size())) {
int id = g[v].back();
g[v].pop_back();
int u = from[id] + to[id] - v;
if (!mark[id]) {
mark[id] = true;
dfs(u);
if (u < v)
c[id] = 1;
else
c[id] = 0;
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> l[i] >> r[i];
r[i]++;
x.push_back(l[i]);
x.push_back(r[i]);
}
sort(x.begin(), x.end());
x.resize(unique(x.begin(), x.end()) - x.begin());
for (int i = 0; i < n; ++i) {
l[i] = lower_bound(x.begin(), x.end(), l[i]) - x.begin();
r[i] = lower_bound(x.begin(), x.end(), r[i]) - x.begin();
add(l[i], r[i]);
}
int lst = -1;
for (int i = 0; i < 2 * n; ++i) {
if (((int)g[i].size()) & 1) {
if (lst == -1)
lst = i;
else {
add(lst, i);
lst = -1;
}
}
}
for (int i = 0; i < 2 * n; i++)
if (!g[i].empty()) dfs(i);
for (int i = 0; i < n; i++) cout << c[i] << " ";
cout << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
const int SIZE = 2e5 + 50;
long long p[SIZE], a[SIZE];
long long arr[SIZE];
namespace SegTree {
struct node {
long long l, r;
long long minn;
} T[SIZE * 3];
long long lazy[SIZE * 3];
void build(long long l, long long r, int rt) {
T[rt].l = l;
T[rt].r = r;
if (l == r) {
T[rt].minn = 0;
return;
}
int mid = (l + r) >> 1;
build(l, mid, rt << 1);
build(mid + 1, r, rt << 1 | 1);
T[rt].minn = 0;
}
void update(long long L, long long R, long long x, int rt) {
if (R < L) return;
if (L <= T[rt].l && R >= T[rt].r) {
T[rt].minn += x;
lazy[rt] += x;
return;
}
long long mid = (T[rt].l + T[rt].r) >> 1;
if (lazy[rt]) {
T[rt << 1].minn += lazy[rt];
T[rt << 1 | 1].minn += lazy[rt];
lazy[rt << 1] += lazy[rt];
lazy[rt << 1 | 1] += lazy[rt];
lazy[rt] = 0;
}
if (L <= mid) update(L, R, x, rt << 1);
if (R > mid) update(L, R, x, rt << 1 | 1);
T[rt].minn = std::min(T[rt << 1].minn, T[rt << 1 | 1].minn);
}
}; // namespace SegTree
int main() {
long long n;
scanf("%lld", &n);
SegTree::build(1, n, 1);
for (int i = 1; i <= n; i++) scanf("%lld", &p[i]);
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
SegTree::update(p[i] + 1, n, a[i], 1);
}
long long ans = std::min(a[1], a[n]);
for (int i = 1; i < n; i++) {
SegTree::update(p[i] + 1, n, (-1) * a[i], 1);
SegTree::update((long long)1, p[i] - 1, a[i], 1);
ans = std::min(ans, SegTree::T[1].minn);
}
printf("%lld\n", ans);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n, x;
cin >> n >> x;
if (n < 2)
cout << 1 << '\n';
else
cout << (n - 2) / x + 1 + bool((n - 2) % x) << '\n';
}
}
| 0 |
#include <bits/stdc++.h>
const int md = 1e9 + 7;
const long long hs = 199;
using namespace std;
int n, m, mx = -1;
vector<int> a, c[2];
set<int> b[2];
void work(int i, int lim, int w = 0, int to = 0) {
b[to].insert(w);
if (i == lim) return;
work(i + 1, lim, w, to);
work(i + 1, lim, (w + a[i]) % m, to);
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m;
a.resize(n);
for (int i = 0; i < n; i++) cin >> a[i];
if (n == 1) return cout << a[0] % m << '\n', 0;
work(0, n / 2, 0, 0);
work(n / 2, n, 0, 1);
for (auto &i : b[0]) c[0].push_back(i);
for (auto &i : b[1]) c[1].push_back(i);
mx = max(max(mx, c[0].back()), c[1].back());
int p1 = 0, p2 = c[1].size() - 1;
while (p1 < c[0].size() && p2 >= 0) {
if (c[0][p1] + c[1][p2] < m) {
mx = max(mx, c[0][p1] + c[1][p2]);
p1++;
} else
p2--;
}
cout << mx << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
vector<int> G[maxn];
int roop, edges, vispoint, deg[maxn], n, deg1, cnt[maxn], tot;
bool vis[maxn];
bool book[maxn];
bool dfs(int u) {
if (!vis[u]) vis[u] = true, vispoint++;
if (vispoint == tot) return true;
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
if (deg[v] == 1) cnt[u]++;
if (!vis[v]) {
if (dfs(v)) return true;
}
}
return false;
}
int main() {
int m, u, v;
while (scanf("%d%d", &n, &m) == 2) {
for (int i = 1; i <= n; i++)
if (G[i].size()) G[i].clear();
deg1 = 0;
edges = 0;
roop = 0;
vispoint = 0;
memset(deg, 0, sizeof(deg));
memset(vis, false, sizeof(vis));
memset(book, false, sizeof(book));
memset(cnt, 0, sizeof(cnt));
tot = 0;
for (int i = 0; i < m; i++) {
scanf("%d%d", &u, &v);
if (!book[u]) book[u] = true, tot++;
if (!book[v]) book[v] = true, tot++;
if (u == v)
roop++;
else {
deg[u]++, deg[v]++;
G[u].push_back(v);
G[v].push_back(u);
}
}
if (!dfs(u)) {
puts("0");
continue;
}
long long sum = 0;
for (int i = 1; i <= n; i++) sum += (long long)deg[i] * (deg[i] - 1) / 2;
sum += (long long)roop * (m - roop) + (long long)roop * (roop - 1) / 2;
printf("%I64d\n", sum);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, k, n, ans = 0;
char c[1004], d[1004];
cin >> n;
cin >> c;
cin >> d;
for (i = 0; i < n; i++) {
if (c[i] > d[i]) {
int y;
y = c[i] - d[i];
int z;
z = 10 - y;
if (y < z) {
ans = ans + y;
} else {
ans = ans + z;
}
} else {
int y;
y = d[i] - c[i];
int z;
z = 10 - y;
if (y < z) {
ans = ans + y;
} else {
ans = ans + z;
}
}
}
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int count = 0;
string a, b;
cin >> a >> b;
if (a.length() != b.length()) {
cout << "NO";
exit(0);
}
string c = a;
string d = b;
sort(c.begin(), c.end());
sort(d.begin(), d.end());
if (c != d) {
cout << "NO";
return 0;
}
for (long long int i = 0; i < a.length(); i++) {
if (a[i] != b[i]) {
count++;
}
}
if (count == 2) {
cout << "YES";
} else {
cout << "NO";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline int add(int a, int b, int mod) {
a += b;
return a >= mod ? a - mod : a;
}
inline int sub(int a, int b, int mod) {
a -= b;
return a < 0 ? a + mod : a;
}
inline int mul(long long a, int b, int mod) {
a *= b;
return a >= mod ? a % mod : a;
}
const int mods[] = {1000000007, 1000000009};
struct Int {
int vl[2];
Int(int x = 0) { vl[0] = vl[1] = x; }
Int operator+(const Int& he) const {
Int ret;
for (int i = 0; i < 2; i++) ret.vl[i] = add(vl[i], he.vl[i], mods[i]);
return ret;
}
Int operator-(const Int& he) const {
Int ret;
for (int i = 0; i < 2; i++) ret.vl[i] = sub(vl[i], he.vl[i], mods[i]);
return ret;
}
Int operator*(const Int& he) const {
Int ret;
for (int i = 0; i < 2; i++) ret.vl[i] = mul(vl[i], he.vl[i], mods[i]);
return ret;
}
long long to_ll() const { return (long long)vl[0] * mods[1] + vl[1]; }
};
int n, m;
unordered_map<long long, int> memo;
char c1[(1 << 12)][(1 << 12)];
char c2[(1 << 12)][(1 << 12)];
void init() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%s", c1[i] + 1);
for (int i = 1; i <= m; i++) scanf("%s", c2[i] + 1);
}
Int vl[(1 << 12)], bs[(1 << 12)], Bs(13131);
Int vl2[222][(1 << 12)];
Int hs_vl(int ii, int j1, int j2) {
return vl2[ii][j2] - vl2[ii][j1 - 1] * bs[j2 - j1 + 1];
}
void solve() {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) vl[i] = vl[i] * Bs + Int(c1[i][j]);
for (int i = 1; i + m - 1 <= n; i++) {
Int ret;
for (int j = 0; j < m; j++) ret = ret * bs[m] + vl[i + j];
memo[ret.to_ll()] = i;
}
for (int i = 1; i <= m; i++)
for (int j = 1; j <= n; j++) vl2[i][j] = vl2[i][j - 1] * Bs + Int(c2[i][j]);
for (int j = 1; j + m - 1 <= n; j++) {
Int ret;
for (int i = 1; i <= m; i++) ret = ret * bs[m] + hs_vl(i, j, j + m - 1);
long long val = ret.to_ll();
auto it = memo.find(val);
if (it != memo.end()) {
printf("%d %d\n", it->second, j);
exit(0);
}
}
assert(false);
}
int main() {
bs[0] = Int(1);
for (int i = 1; i < (1 << 12); i++) bs[i] = bs[i - 1] * Bs;
init();
solve();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200000 + 10;
int a[maxn];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
a[x] = i;
}
int x = 0;
for (int i = 0; i < n; i++) {
int m;
scanf("%d", &m);
int t = a[m] - x;
if (t < 0) {
printf("0 ");
} else {
printf("%d ", t);
x = a[m];
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
map<long long, int> m;
void primeFactors(long long n) {
while (n % 2 == 0) {
m[2]++;
n = n / 2;
}
for (int i = 3; i <= sqrt(n); i = i + 2) {
while (n % i == 0) {
m[i]++;
n = n / i;
}
}
if (n > 2) m[n]++;
}
long long gcd(long long a, long long b) {
if (a % b == 0)
return b;
else
return gcd(b, a % b);
}
int sum(long long a) {
int sum = 0;
while (a > 0) {
sum = sum + (a % 10);
a = a / 10;
}
return sum;
}
int count_digit(long long n) {
int count = 0;
while (n > 0) {
n = n / 10;
count++;
}
return count;
}
int binarySearch(int x, int y, long long z, long long v[]) {
int low = x;
int high = y;
int mid = x + (y - x) / 2;
while (low <= high) {
if (v[mid] == z) return mid;
if (v[mid] < z) return binarySearch(mid + 1, high, z, v);
if (v[mid] > z) return binarySearch(low, mid - 1, z, v);
}
return -1;
}
long long modularExponentiation(long long x, long long n, long long M) {
if (n == 0)
return 1;
else if (n % 2 == 0)
return modularExponentiation((x * x) % M, n / 2, M);
else
return (x * modularExponentiation((x * x) % M, (n - 1) / 2, M)) % M;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int tests = 1;
while (tests--) {
long long n;
cin >> n;
primeFactors(n);
map<long long, int>::iterator it;
long long ans = 1;
for (it = m.begin(); it != m.end(); it++) {
ans = ans * (it->second + 1);
}
cout << ans;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[101010], b[101010];
int c[101101];
int ans;
int cnt;
int x, mx;
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; n >= i; i++) {
cin >> a[i];
}
for (int i = 1; n >= i; i++) {
cin >> b[i];
cnt += b[i];
c[i] = cnt;
}
cnt = 0;
for (int i = 1; n >= i; i++) {
mx = max(0, a[i] - m * c[i]);
ans += mx;
mx = 0;
}
for (int i = n; i >= 0; i--) {
cnt += b[i];
c[i] = cnt;
}
cnt = 0;
for (int i = n; i >= 0; i--) {
x = max(0, a[i] - m * c[i]);
cnt += x;
x = 0;
}
if (ans > cnt)
cout << "Limak";
else if (ans < cnt)
cout << "Radewoosh";
else
cout << "Tie";
}
| 0 |
#include <bits/stdc++.h>
const int oo = 2139063143;
const int N = 101000;
const int P = 1000000007;
using namespace std;
template <typename T>
inline void sc(T &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;
}
template <typename T>
inline void print(T x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) print(x / 10);
putchar(x % 10 + '0');
}
template <typename T>
inline void pr(T x) {
print(x), putchar('\n');
}
struct EDGE {
int v, w, nx;
} lb[N * 20];
int tot = 1, top[N], cur[N], TOT, TOP[N];
void add(int u, int v, int w) {
lb[++tot] = (EDGE){v, w, top[u]}, top[u] = tot;
lb[++tot] = (EDGE){u, 0, top[v]}, top[v] = tot;
}
int s, t;
int dep[N];
bool bfs() {
memcpy(cur, top, sizeof(int) * (t + 1));
memset(dep, 0, sizeof(int) * (t + 1));
queue<int> q;
dep[s] = 1, q.push(s);
while (q.size()) {
int u = q.front();
q.pop();
for (int kb = top[u]; kb; kb = lb[kb].nx) {
int v = lb[kb].v, w = lb[kb].w;
if (w && !dep[v]) dep[v] = dep[u] + 1, q.push(v);
}
}
return dep[t];
}
int dinic(int u, int flow) {
if (u == t) return flow;
int rest = flow;
for (int &kb = cur[u]; kb; kb = lb[kb].nx) {
int v = lb[kb].v, w = lb[kb].w;
if (w && dep[v] == dep[u] + 1) {
int k = dinic(v, min(w, rest));
if (!k) dep[v] = 0;
rest -= k;
lb[kb].w -= k, lb[kb ^ 1].w += k;
if (!rest) break;
}
}
return flow - rest;
}
int ans[N];
bool vis[N];
int p[N], c[N], k[N];
int main() {
int n, m;
sc(n), sc(m);
for (int i = 1; i <= n; i++) sc(p[i]), ++p[i];
for (int i = 1; i <= n; i++) sc(c[i]);
int d;
sc(d);
for (int i = 1; i <= d; i++) sc(k[i]), vis[k[i]] = 1;
s = m + m + m + 10, t = s + 1;
for (int i = 1; i <= m; i++) add(s, i, 1);
for (int i = 1; i <= n; i++)
if (!vis[i])
if (p[i] <= m) add(c[i], m + p[i], 1);
for (int i = d; i >= 1; i--) {
ans[i] = ans[i + 1] + 1;
for (; ans[i] <= m + 1; ans[i]++) {
memcpy(TOP, top, sizeof(int) * (t + 1)), TOT = tot;
add(m + ans[i], t, 1);
if (!(bfs() && dinic(s, oo))) {
memcpy(top, TOP, sizeof(int) * (t + 1)), tot = TOT;
--ans[i];
break;
}
}
if (p[k[i]] <= m) add(c[k[i]], m + p[k[i]], 1);
}
for (int i = 1; i <= d; i++) pr(ans[i]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
string s, t;
map<string, set<string>> m;
map<set<string>, set<string>> o_O;
for (int i = 0; i < n; ++i) {
cin >> s;
t = "";
s = s.substr(7);
for (int j = 0; j < s.size(); ++j)
if (s[j] == '/') {
t = s.substr(j);
s = s.substr(0, j);
break;
}
m[s].insert(t);
}
for (auto& x : m) o_O[x.second].insert(x.first);
int ans = 0;
for (auto& x : o_O)
if (x.second.size() > 1) ans++;
cout << ans << "\n";
for (auto& x : o_O)
if (x.second.size() > 1) {
for (auto& y : x.second) cout << "http://" << y << " ";
cout << "\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[110];
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
bool ok = true;
int lo = 0;
while (lo < n - 1 && a[lo] < a[lo + 1]) lo++;
while (lo < n - 1 && a[lo] == a[lo + 1]) lo++;
while (lo < n - 1 && a[lo] > a[lo + 1]) lo++;
if (lo == n - 1)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> n;
long long digits[9];
memset(digits, 0, sizeof(digits));
long long curdigit = 0;
while (n) {
digits[curdigit] = n % 10;
n /= 10;
curdigit++;
}
long long firstdigit = curdigit - 1;
long long ans = 0;
for (long long i = firstdigit; i >= 0; i--) {
if (digits[i] > 1) {
ans += pow(2, i + 1) - 1;
break;
} else if (digits[i] == 1) {
ans += pow(2, i);
}
}
cout << ans << "\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int masr[1001];
int maszh[1001];
int main() {
int n, m, k, t = 0;
cin >> n >> m >> k;
for (int i = 0; i < n; i++) {
cin >> masr[i] >> maszh[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (masr[i] == masr[j] && i < j) {
maszh[i] = min(maszh[i], maszh[j]);
maszh[j] = 0;
}
}
}
for (int i = 0; i < n; i++) {
t += maszh[i];
}
if (t <= k) {
cout << t;
} else {
cout << k;
}
cin >> n;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int prime[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43};
int main() {
int cas;
scanf("%d", &cas);
while (cas--) {
int num;
scanf("%d", &num);
if (num % 2 == 0) {
printf("%d %d %d\n", num / 2, num / 2 - 1, 1);
continue;
}
for (const int& p : prime)
if ((num - 1) % p) {
printf("%d %d %d\n", p, num - 1 - p, 1);
break;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 110;
vector<int> G[N];
int vis[N];
void DFS(int cur) {
vis[cur]++;
int sz = G[cur].size();
int v;
for (int i = 0; i < sz; i++) {
v = G[cur][i];
if (!vis[v]) DFS(v);
}
}
int main() {
int n, m, u, v;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> u >> v;
G[u].push_back(v);
G[v].push_back(u);
}
DFS(1);
for (int i = 1; i <= n; i++)
if (!vis[i]) {
cout << "NO";
return 0;
}
if (n == m)
cout << "FHTAGN!";
else
cout << "NO";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long arr[100000];
long long fib[100000];
int main() {
int N, M;
cin >> N >> M;
fib[0] = 1;
fib[1] = 1;
for (int i = 2; i <= 110; ++i) {
fib[i] = fib[i - 1] + fib[i - 2];
fib[i] %= 1000000000;
}
for (int i = 1; i <= N; ++i) cin >> arr[i];
for (int i = 0; i < M; ++i) {
int t;
cin >> t;
if (t == 1) {
long long x, v;
cin >> x >> v;
arr[x] = v;
} else {
int l, r;
cin >> l >> r;
long long sum = 0;
for (int i = 0; i <= r - l; ++i) {
sum += (1LL * fib[i] * arr[l + i]);
sum %= 1000000000;
}
cout << sum << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
int f[80][80][80][2];
int posV[80], posK[80], posX[80];
int cntV[80], cntK[80], cntX[80];
int NewDist(int pos, int nV, int nK, int nX) {
int newPos;
newPos = 0;
newPos += nV > cntV[pos - 1] ? nV : cntV[pos - 1];
newPos += nK > cntK[pos - 1] ? nK : cntK[pos - 1];
newPos += nX > cntX[pos - 1] ? nX : cntX[pos - 1];
return newPos - (nV + nK + nX);
}
int main(int argc, char *argv[]) {
int n, nV, nK, nX, i, j, k, t;
char str[80];
scanf("%d\n%s", &n, str + 1);
for (i = 1, nV = nK = nX = 0; i <= n; ++i) {
cntV[i] = cntV[i - 1];
cntK[i] = cntK[i - 1];
cntX[i] = cntX[i - 1];
if (str[i] == 'V')
++cntV[posV[++nV] = i];
else if (str[i] == 'K')
++cntK[posK[++nK] = i];
else
++cntX[posX[++nX] = i];
}
memset(f, 0x70, sizeof(f));
f[0][0][0][0] = 0;
for (i = 0; i <= nV; ++i)
for (j = 0; j <= nK; ++j)
for (k = 0; k <= nX; ++k) {
if (i) {
t = f[i - 1][j][k][0] + NewDist(posV[i], i - 1, j, k);
if (t < f[i][j][k][1]) f[i][j][k][1] = t;
t = f[i - 1][j][k][1] + NewDist(posV[i], i - 1, j, k);
if (t < f[i][j][k][1]) f[i][j][k][1] = t;
}
if (j) {
t = f[i][j - 1][k][0] + NewDist(posK[j], i, j - 1, k);
if (t < f[i][j][k][0]) f[i][j][k][0] = t;
}
if (k) {
t = f[i][j][k - 1][0] + NewDist(posX[k], i, j, k - 1);
if (t < f[i][j][k][0]) f[i][j][k][0] = t;
t = f[i][j][k - 1][1] + NewDist(posX[k], i, j, k - 1);
if (t < f[i][j][k][0]) f[i][j][k][0] = t;
}
}
if (f[nV][nK][nX][0] < f[nV][nK][nX][1])
printf("%d\n", f[nV][nK][nX][0]);
else
printf("%d\n", f[nV][nK][nX][1]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
int n, m, b, mod, i, j, k;
int a[1000], f[1000][1000];
int main() {
scanf("%d%d%d%d", &n, &m, &b, &mod);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
memset(f, 0, sizeof(f));
f[0][0] = 1;
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++)
for (k = a[i]; k <= b; k++) {
f[j][k] += f[j - 1][k - a[i]];
f[j][k] %= mod;
}
int ans = 0;
for (i = 0; i <= b; i++) {
ans = ans + f[m][i];
ans = ans % mod;
}
printf("%d", ans);
}
| 5 |
#include <bits/stdc++.h>
int main() {
int n, i, mx = 1, j, x;
scanf("%d", &n);
int a[n];
scanf("%d", &a[0]);
x = a[0];
for (i = 1; i < n; i++) {
scanf("%d", &a[i]);
if (a[i] > a[mx]) mx = i;
}
while (a[0] <= a[mx]) {
a[0]++;
a[mx]--;
for (i = 1; i < n; i++)
if (a[i] > a[mx]) mx = i;
}
printf("%d", a[0] - x);
return 0;
}
| 2 |
#include <bits/stdc++.h>
long long mod = 1e9 + 7;
inline long long pwr(long long base, long long n) {
long long ans = 1;
while (n > 0) {
if (n % 2 == 1) ans = ans * base;
base = base * base;
n /= 2;
}
return ans;
}
struct range {
int l, h;
};
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int n, m, st, el, v;
cin >> n >> m >> st >> el >> v;
vector<long long int> stairsf, stairsb;
for (int i = 0; i < st; i++) {
long long int first;
cin >> first;
stairsf.push_back(first);
stairsb.push_back(-first);
}
sort(stairsb.begin(), stairsb.end());
vector<long long int> elevatorsf, elevatorsb;
for (int i = 0; i < el; i++) {
long long int first;
cin >> first;
elevatorsf.push_back(first);
elevatorsb.push_back(-first);
}
sort(elevatorsb.begin(), elevatorsb.end());
int q;
cin >> q;
while (q--) {
long long int t1 = 0, t2 = 0, t3 = 0, t4 = 0;
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
if (x1 == x2) {
cout << abs(y1 - y2) << "\n";
continue;
}
int getst =
lower_bound(stairsf.begin(), stairsf.end(), y1) - stairsf.begin();
if (getst < stairsf.size())
t1 = (stairsf[getst] - y1) + abs(x2 - x1) + abs(y2 - stairsf[getst]);
else
t1 = 1e18;
getst = lower_bound(stairsb.begin(), stairsb.end(), -y1) - stairsb.begin();
if (getst < stairsb.size())
t2 = (y1 - abs(stairsb[getst])) + abs(x2 - x1) +
abs(y2 - abs(stairsb[getst]));
else
t2 = 1e18;
int getel = lower_bound(elevatorsf.begin(), elevatorsf.end(), y1) -
elevatorsf.begin();
if (getel < elevatorsf.size()) {
t3 = (elevatorsf[getel] - y1) + abs(y2 - elevatorsf[getel]);
t3 += abs(x2 - x1) / v;
if (abs(x2 - x1) % v) t3++;
} else
t3 = 1e18;
getel = lower_bound(elevatorsb.begin(), elevatorsb.end(), -y1) -
elevatorsb.begin();
if (getel < elevatorsb.size()) {
t4 = (y1 - abs(elevatorsb[getel])) + abs(y2 - abs(elevatorsb[getel]));
t4 += abs(x2 - x1) / v;
if (abs(x2 - x1) % v) t4++;
} else
t4 = 1e18;
cout << min(t1, min(t2, min(t3, t4))) << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int maxN = 1e5 + 5;
const int maxM = 1e6 + 5;
const int base = 1e9 + 7;
using namespace std;
int N, Q;
inline void Openfile() {
std ::ios_base ::sync_with_stdio(false);
cin.tie(0);
}
inline void Init() {}
inline void Enter() { cin >> Q; }
map<long long, long long> sum;
inline void Solve() {
while (Q--) {
int type;
cin >> type;
if (type == 1) {
long long u, v, w;
cin >> u >> v >> w;
while (u != v) {
if (u < v) swap(u, v);
sum[u] += w;
u >>= 1;
}
} else {
long long u, v;
cin >> u >> v;
long long ans = 0;
while (u != v) {
if (u < v) swap(u, v);
ans += sum[u];
u >>= 1;
}
cout << ans << '\n';
}
}
}
int main() {
Openfile();
Init();
Enter();
Solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long a[350001], n, i, ans;
long long mod(long long a) { return a % 1000000007; }
long long st(long long a, long long b) {
if (b == 0) return 1LL;
long long c = st(a, b / 2);
if (b % 2 != 0)
return mod(mod(a * c) * c);
else
return mod(c * c);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + 1 + n);
for (i = 1; i <= n - 1; i++)
ans = mod(ans +
mod((st(2LL, i) - 1) * (st(2LL, n - i) - 1)) * (a[i + 1] - a[i]));
cout << ans << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[500500];
int main() {
int n, i, p = 0, x;
long long ans = 0;
scanf("%d", &n);
for (i = 0; i < n; ++i) {
scanf("%d", &x);
while (p >= 2 && a[p - 2] >= a[p - 1] && x >= a[p - 1]) {
if (a[p - 2] < x)
ans += a[p - 2];
else
ans += x;
--p;
}
a[p++] = x;
}
sort(a, a + p);
for (i = p - 3; i >= 0; --i) ans += a[i];
printf("%I64d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
char gameGrid[10], mark;
int b, c;
bool isOver(char gameGrid[]) {
for (int k = 1; k <= 9; k++) {
if (gameGrid[k] == '.') {
return false;
}
}
return true;
}
bool checkValid(char gameGrid[]) {
b = 0;
c = 0;
for (int a = 1; a <= 9; a++) {
if (gameGrid[a] == 'X')
b++;
else if (gameGrid[a] == '0')
c++;
}
if (b > (c + 1) || b < c)
return false;
else
return true;
}
bool checkWin(char gameGrid[]) {
if (gameGrid[1] == gameGrid[2] && gameGrid[2] == gameGrid[3])
mark = gameGrid[1];
else if (gameGrid[4] == gameGrid[5] && gameGrid[5] == gameGrid[6])
mark = gameGrid[4];
else if (gameGrid[7] == gameGrid[8] && gameGrid[8] == gameGrid[9])
mark = gameGrid[7];
else if (gameGrid[1] == gameGrid[4] && gameGrid[4] == gameGrid[7])
mark = gameGrid[1];
else if (gameGrid[2] == gameGrid[5] && gameGrid[5] == gameGrid[8])
mark = gameGrid[2];
else if (gameGrid[3] == gameGrid[6] && gameGrid[6] == gameGrid[9])
mark = gameGrid[3];
else if (gameGrid[1] == gameGrid[5] && gameGrid[5] == gameGrid[9])
mark = gameGrid[1];
else if (gameGrid[3] == gameGrid[5] && gameGrid[5] == gameGrid[7])
mark = gameGrid[3];
if (mark == 'X' || mark == '0')
return true;
else
return false;
}
bool checkTurn(char gameGrid[]) {
int b, c;
b = 0;
c = 0;
for (int a = 1; a <= 9; a++) {
if (gameGrid[a] == 'X')
b++;
else if (gameGrid[a] == '0')
c++;
}
if (c == b)
return true;
else if (c < b)
return false;
}
int main() {
for (int i = 1; i <= 9; i++) {
cin >> gameGrid[i];
}
if (checkValid(gameGrid) == false)
cout << "illegal" << endl;
else if (checkValid(gameGrid) == true &&
(((checkWin(gameGrid)) && mark == 'X' && b == c) ||
((checkWin(gameGrid)) && mark == '0' && b > c)))
cout << "illegal" << endl;
else {
if (isOver(gameGrid) == true) {
if (checkWin(gameGrid) == true && mark == 'X')
cout << "the first player won" << endl;
else if (checkWin(gameGrid) == true && mark == '0')
cout << "the second player won" << endl;
else
cout << "draw" << endl;
} else {
if (checkWin(gameGrid) == true && mark == 'X')
cout << "the first player won" << endl;
else if (checkWin(gameGrid) == true && mark == '0')
cout << "the second player won" << endl;
else if (checkTurn(gameGrid))
cout << "first" << endl;
else
cout << "second" << endl;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MUSHROOM = 14142;
int magic[MUSHROOM];
long long sum[MUSHROOM];
long long g[1000001];
long long d[1000001];
int visit[1000001];
int n, m;
vector<pair<int, int> > back[1000001];
vector<pair<int, int> > edge[1000001];
vector<pair<int, int> > meta[1000001];
void dfs(int ix, int stamp, vector<pair<int, int> > *edge) {
if (visit[ix] == stamp || visit[ix] > 0) return;
visit[ix] = stamp;
for (int i = 0; i < edge[ix].size(); i++) dfs(edge[ix][i].first, stamp, edge);
edge[0].push_back({ix, 0});
}
long long collect(int ix, int stamp, vector<pair<int, int> > *edge) {
if (visit[ix] == stamp) return d[ix];
visit[ix] = stamp;
long long res = 0;
for (int i = 0; i < edge[ix].size(); i++) {
res = collect(edge[ix][i].first, stamp, edge) + edge[ix][i].second;
if (d[ix] < res) d[ix] = res;
}
d[ix] += g[ix];
return d[ix];
}
void make_group(int id, const vector<pair<int, int> > &in,
const vector<pair<int, int> > *edge) {
int i, j;
int curr, to, cost;
int ix;
long long tot = 0;
for (i = 0; i < in.size(); i++) {
curr = in[i].first;
for (j = 0; j < edge[curr].size(); j++) {
to = edge[curr][j].first;
if (visit[to] != -2) continue;
cost = edge[curr][j].second;
ix = upper_bound(magic, magic + MUSHROOM, cost) - magic;
tot += ix * (long long)cost - sum[ix - 1];
}
}
for (i = 0; i < in.size(); i++) visit[in[i].first] = id;
g[id] = tot;
}
int main() {
int i, j;
int x, y, w;
int s;
int stamp = 0;
for (scanf("%d%d", &n, &m), i = 0; i < m; i++) {
scanf("%d%d%d", &x, &y, &w);
edge[x].push_back({y, w});
back[y].push_back({x, w});
}
scanf("%d", &s);
for (i = 1; i < MUSHROOM; i++) {
magic[i] = magic[i - 1] + i;
sum[i] = sum[i - 1] + magic[i];
}
for (i = 1; i <= n; i++) dfs(i, -1, edge);
for (i = edge[0].size() - 1; i >= 0; i--) {
dfs(edge[0].back().first, -2, back);
if (!back[0].empty()) make_group(++stamp, back[0], edge);
back[0].clear();
edge[0].pop_back();
}
for (i = 1; i <= n; i++) {
if (visit[i] < 0) continue;
for (j = 0; j < edge[i].size(); j++) {
y = edge[i][j].first;
if (visit[i] != visit[y]) {
meta[visit[i]].push_back({visit[y], edge[i][j].second});
}
}
}
printf("%I64d", collect(visit[s], ++stamp, meta));
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int a, b, c;
cin >> a >> b >> c;
if ((a == 3 and b == 3 and c == 3) || a == 1 || b == 1 || c == 1 ||
(a == 2 and b == 2) || (a == 2 and c == 2) || (c == 2 and b == 2) ||
(a == 4 and b == 4 and c == 2) || (a == 2 and b == 4 and c == 4) ||
(a == 4 and b == 2 and c == 4))
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void solve(istream &in, ostream &out);
int main() {
ios::sync_with_stdio(false);
solve(cin, cout);
return 0;
}
void solve(istream &in, ostream &out) {
int n;
in >> n;
vector<int> items(n);
for (int i = 0; i < n; ++i) {
in >> items[i];
}
sort(items.begin(), items.end());
int result = numeric_limits<int>::max();
for (int i = 0, j = n / 2; j < n; ++i, ++j) {
result = min(result, items[j] - items[i]);
}
out << result << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = (long long)1 << 58;
map<string, string> ss;
string olds, news;
int main() {
int n, flag;
scanf("%d", &n);
while (n--) {
flag = 0;
cin >> olds >> news;
for (map<string, string>::iterator it = ss.begin(); it != ss.end(); it++) {
if (olds == it->second) {
ss[it->first] = news;
flag = 1;
break;
}
}
if (flag == 0) {
ss[olds] = news;
}
}
printf("%d\n", ss.size());
for (map<string, string>::iterator it = ss.begin(); it != ss.end(); it++) {
cout << it->first << " " << it->second << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e5;
int N, Q, A[MAXN + 10], dp[MAXN + 10];
int tree[MAXN * 4 + 10];
void update2(int node, int tl, int tr, int y) {
tree[node]++;
if (tl == tr) return;
int mid = tl + tr >> 1;
if (y <= mid)
update2(node * 2, tl, mid, y);
else
update2(node * 2 + 1, mid + 1, tr, y);
}
int query2(int node, int tl, int tr, int k) {
if (tl == tr) return tl;
int val = tree[node * 2 + 1];
int mid = tl + tr >> 1;
if (val >= k)
return query2(node * 2 + 1, mid + 1, tr, k);
else
return query2(node * 2, tl, mid, k - val);
}
struct Data {
int l, r, p;
};
Data B[MAXN + 10];
int tree2[MAXN + 10];
void update(int i) {
for (; i <= N; i += (i & -i)) tree2[i]++;
}
int query(int i) {
int ret = 0;
for (; i > 0; i -= (i & -i)) ret += tree2[i];
return ret;
}
int query(int l, int r) { return query(r) - query(l - 1); }
int ans[MAXN + 10];
int main() {
scanf("%d%d", &N, &Q);
for (int i = 1; i <= N; i++) scanf("%d", &A[i]);
vector<pair<int, int> > V;
for (int i = 1; i <= N; i++) {
A[i] = i - A[i];
if (A[i] < 0)
;
else if (A[i] == 0) {
dp[i] = i;
update2(1, 0, N, dp[i]);
} else {
dp[i] = query2(1, 0, N, A[i]);
update2(1, 0, N, dp[i]);
}
if (A[i] >= 0) V.push_back({dp[i], i});
}
sort(V.begin(), V.end());
for (int i = 1; i <= Q; i++) {
scanf("%d%d", &B[i].l, &B[i].r), B[i].p = i;
B[i].l++;
B[i].r = N - B[i].r;
}
sort(B + 1, B + Q + 1,
[&](const Data &p, const Data &q) { return p.l < q.l; });
for (int i = Q, j = V.size() - 1; i >= 1; i--) {
for (; j >= 0 && V[j].first >= B[i].l; j--) {
update(V[j].second);
}
ans[B[i].p] = query(B[i].l, B[i].r);
}
for (int i = 1; i <= Q; i++) printf("%d\n", ans[i]);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
long long t;
cin >> t;
while (t--) {
long long i, r = 0, p = 0, st = 0;
string s;
cin >> s;
for (i = 0; i < s.length(); i++) {
if (s[i] == 'R')
r++;
else if (s[i] == 'P')
p++;
else
st++;
}
long long v = max(r, max(p, st));
if (v == r) {
for (i = 0; i < s.length(); i++) s[i] = 'P';
} else if (v == p) {
for (i = 0; i < s.length(); i++) s[i] = 'S';
} else {
for (i = 0; i < s.length(); i++) s[i] = 'R';
}
cout << s << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T myMax(T x, T y) {
return (x > y) ? x : y;
}
struct myComp1 {
constexpr bool operator()(
pair<long long, long long> const &a,
pair<long long, long long> const &b) const noexcept {
return a.second < b.second;
}
};
struct myComp2 {
constexpr bool operator()(
pair<long long, long long> const &a,
pair<long long, long long> const &b) const noexcept {
return a.second > b.second;
}
};
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
priority_queue<pair<long long, long long>, vector<pair<long long, long long> >,
myComp1>
p1;
priority_queue<pair<long long, long long>, vector<pair<long long, long long> >,
myComp2>
p2;
long long ceili(long long a, long long b) {
return a % b == 0 ? (a / b) : (a / b) + 1;
}
long long gcd(long long a, long long b) {
if (!a) return b;
return gcd(b % a, a);
}
long long power(long long x, long long y, long long p) {
long long res = 1LL;
x = x % p;
while (y > 0) {
if (y & 1) {
res = (res * x) % p;
}
y = y >> 1;
x = (x * x) % p;
}
return res;
}
void printVector(vector<long long> &vt) {
for (auto x : vt) {
cout << x << " ";
}
cout << "\n";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
std::cout.tie(NULL);
long long t;
t = 1;
while (t--) {
long long n;
cin >> n;
map<long double, long long> mp;
vector<long double> a(n), b(n);
for (auto &i : a) {
cin >> i;
}
for (auto &i : b) {
cin >> i;
}
long long depche = 0;
for (long long i = 0; i < n; i++) {
if (a[i] != 0) {
long double d = b[i] / a[i];
d = d * (-1);
mp[d]++;
}
if (a[i] == 0 && b[i] == 0) {
depche++;
}
}
long long maxi = 0;
for (auto x : mp) {
maxi = max(maxi, x.second);
}
cout << maxi + depche;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e6;
vector<int> costs;
vector<int> ans;
void init();
bool cmp(int a, int b);
int main() {
int m, n, num1, num2;
long long Ans = 0;
init();
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &num1, &num2);
costs.push_back(num2);
}
int index = upper_bound(ans.begin(), ans.end(), n) - ans.begin();
index = min(index, m);
sort(costs.begin(), costs.end(), cmp);
for (int i = 0; i < index; i++) {
Ans += costs[i];
}
printf("%d\n", Ans);
return 0;
}
void init() {
for (int i = 1; i <= 100000; i++) {
int temp;
if (i % 2 == 0)
temp = ((i - 1) * i + i) / 2;
else
temp = i * (i - 1) / 2 + 1;
if (temp > maxn) break;
ans.push_back(temp);
}
}
bool cmp(int a, int b) { return a > b; }
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxl = 200005;
int read() {
int s = 0, w = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') w = -w;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
s = s * 10 + (ch ^ '0');
ch = getchar();
}
return s * w;
}
int t, n, k, flag;
int a[maxl], b[maxl];
signed main() {
t = read();
while (t--) {
n = read(), k = read() - 1, flag = 1;
for (int i = 1; i <= n; i++) a[i] = read(), b[i] = a[i];
sort(b + 1, b + n + 1);
for (int i = 1; i <= n; i++) a[i] = lower_bound(b + 1, b + n + 1, a[i]) - b;
for (int i = 1; i < n; i++) {
if (a[i + 1] != a[i] + 1) k--;
if (k < 0) {
flag = 0;
break;
}
}
if (flag)
puts("YES");
else
puts("NO");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
long long A[200000];
long long Add[200000];
int main() {
int N, i, type, x, y;
long long Sum = 0;
int Size = 1;
A[0] = 0;
scanf("%d", &N);
for (i = 0; i < N; ++i) {
scanf("%d", &type);
if (type == 1) {
scanf("%d %d", &x, &y);
Add[x - 1] += y;
Sum += x * y;
} else if (type == 2) {
scanf("%d", &x);
A[Size++] = x;
Sum += x;
} else {
Sum -= A[Size - 1] + Add[Size - 1];
Add[Size - 2] += Add[Size - 1];
Add[Size - 1] = 0;
--Size;
}
printf("%.6f\n", 1.0 * Sum / Size);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void printvec(vector<pair<pair<int, int>, int> >& vec) {
for (int i = 0; i < vec.size(); i++) {
cout << vec[i].first.first << " " << vec[i].first.second << " "
<< vec[i].second << "\n";
}
cout << "\n";
}
int main() {
std::ios::sync_with_stdio(false);
int n, dur;
cin >> n >> dur;
int i;
vector<vector<pair<pair<int, int>, int> > > vec(3 * 100 * 1000),
vec2(3 * 100 * 1000);
for (i = 0; i < n; i++) {
int l, r, cost;
cin >> l >> r >> cost;
int tim = r - l + 1;
pair<pair<int, int>, int> temp = make_pair(make_pair(l, r), cost);
vec[tim].push_back(temp);
vec2[tim].push_back(temp);
}
int j;
for (i = 0; i < vec.size(); i++) {
sort(vec[i].begin(), vec[i].end());
sort(vec2[i].begin(), vec2[i].end());
}
for (i = 0; i < vec2.size(); i++) {
vector<pair<pair<int, int>, int> >& prev = vec2[i];
int minn = INT_MAX;
int sz = prev.size();
for (j = sz - 1; j >= 0; j--) {
minn = min(minn, prev[j].second);
prev[j].second = minn;
}
}
int ans = INT_MAX;
vector<pair<pair<int, int>, int> >::iterator it;
for (i = 0; i < vec.size(); i++) {
vector<pair<pair<int, int>, int> >& prev = vec[i];
int sz = prev.size();
for (j = 0; j < sz; j++) {
int prec = prev[j].second;
int endt = prev[j].first.second;
int left = dur - i;
if (left < 0) continue;
pair<pair<int, int>, int> temp = make_pair(make_pair(endt + 1, 0), 0);
it = lower_bound(vec2[left].begin(), vec2[left].end(), temp);
if (it == vec2[left].end()) continue;
int extrac = it->second;
if (ans > prec + extrac) {
ans = prec + extrac;
}
}
}
if (ans == INT_MAX)
cout << "-1";
else
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, x, chis = 0, chis1 = 0, chis2 = 0;
multiset<long long> sets;
vector<long long> v(1000200);
vector<long long> ans(1000100, -1);
vector<long long> pos(1000100, 0);
vector<long long> pr;
long long minim = 10001000;
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
long long n1 = n;
for (long long i = 2; i <= n; i++) {
if (ans[i] == -1) {
ans[i] = i;
for (long long j = 2 * i; j <= n; j += i) ans[j] = max(ans[j], i);
}
}
for (long long i = 2; i <= 997; i++) {
if (n1 % i == 0) {
pr.push_back(i);
while (n1 % i == 0) n1 /= i;
}
}
if (n1 != 1) pr.push_back(n1);
long long raz = pr.size(), minp = 0, ind = 2, temp = 0;
for (long long i = 0; i < raz; i++) {
chis = pr[i];
if (pr[i] == n) {
chis1 = n;
chis2 = n;
} else {
chis1 = n - pr[i] + 1;
chis2 = n;
}
for (long long j = chis1; j <= chis2; j++) {
if (ans[j] == j)
minim = min(minim, j);
else
minim = min(minim, j - ans[j] + 1);
}
}
cout << minim;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N_MAX = 3000;
int N;
int manager[N_MAX];
int get_chain(int x) {
if (manager[x] == -1) return 1;
return 1 + get_chain(manager[x]);
}
int main() {
cin >> N;
for (int i = 0; i < N; i++) {
int x;
cin >> x;
if (x > 0) x--;
manager[i] = x;
}
int best_groups = 1;
for (int i = 0; i < N; i++) {
int x = get_chain(i);
if (x > best_groups) best_groups = x;
}
cout << best_groups << '\n';
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
template <class T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
long double a[55][55], b[55][55], dp[111][55], p;
long double mat[51][51], res[51][51], rlt[51];
void pre() {
a[1][1] = p;
a[1][2] = 1 - p;
b[1][2] = 1;
for (int i = 2; i < 55; i++) {
a[i][1] = p;
a[i][2] = 1 - p;
b[i][2] = 1;
for (int j = 2; j <= 50; j++) {
a[i][j] += a[i - 1][j - 1] * a[i][j - 1];
b[i][j] += b[i][j - 1] * a[i - 1][j - 1];
}
}
mat[0][0] = 0;
long double tmp = 0;
for (int i = 2; i < 51; i++) tmp += b[50][i] * (1 - a[50][i]);
for (int i = 1; i < 50; i++)
mat[0][i] = b[50][i + 1] * (1 - a[50][i + 1]) / tmp;
for (int i = 1; i < 50; i++) {
tmp = 0;
for (int j = 0; j < i; j++) tmp += a[50][j + 1] * (1 - a[50][j + 1]);
for (int j = 0; j < i; j++)
mat[i][j] = a[50][j + 1] * (1 - a[50][j + 1]) / tmp;
}
mat[50][50] = 1;
for (int i = 0; i < 50; i++) mat[i][50] = i + 1;
}
void multi(long double a[51][51], long double b[51][51],
long double c[51][51]) {
long double tmp[51][51];
for (int i = 0; i < 51; i++) {
for (int j = 0; j < 51; j++) {
tmp[i][j] = 0;
for (int k = 0; k < 51; k++) {
tmp[i][j] += a[i][k] * b[k][j];
}
}
}
for (int i = 0; i < 51; i++)
for (int j = 0; j < 51; j++) c[i][j] = tmp[i][j];
}
void paw(long double a[51][51], int n, long double b[51][51]) {
if (n == 0) {
for (int i = 0; i < 51; i++)
for (int j = 0; j < 51; j++) b[i][j] = (i == j);
return;
}
long double c[51][51];
paw(a, n / 2, c);
multi(c, c, b);
if (n & 1) multi(a, b, b);
}
int main() {
int n, pp;
cin >> n >> pp;
p = (long double)pp / 1e9;
long double tmp, ans = 0, v;
pre();
dp[1][1] = 1;
dp[1][2] = 2;
for (int i = 2; i <= 100; i++) {
for (int j = 1; j <= 50; j++) {
tmp = 0;
dp[i][j] = 0;
if (j == 1) {
for (int k = 2; k <= 50; k++) {
v = b[min(50, i - 1)][k] * (1 - a[min(50, i - 2)][k]);
tmp += v;
dp[i][j] += dp[i - 1][k] * v;
}
} else {
for (int k = 1; k <= j - 1; k++) {
v = a[min(50, i - 1)][k] * (1 - a[min(50, i - 2)][k]);
tmp += v;
dp[i][j] += dp[i - 1][k] * v;
}
}
dp[i][j] /= tmp;
dp[i][j] += j;
}
}
if (n < 50) {
for (int i = 1; i <= 50; i++)
ans += dp[n][i] * a[min(n, 50)][i] * (1 - a[min(50, n - 1)][i]);
printf("%.10lf\n", (double)ans);
return 0;
}
paw(mat, n - 50, res);
for (int i = 0; i < 50; i++) {
for (int j = 0; j < 50; j++) {
rlt[i] += res[i][j] * dp[50][j + 1];
}
rlt[i] += res[i][50];
}
for (int i = 0; i < 50; i++)
ans += rlt[i] * a[50][i + 1] * (1 - a[50][i + 1]);
printf("%.10lf\n", (double)ans);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e4 + 10;
int a[maxn];
int n;
int i_mod_now, now_mod_i;
void solve() {
cin >> n;
if (n == 1) {
cout << "! 1\n";
return;
}
int now = 1;
for (int i = 2; i <= n; i++) {
cout << "? " << now << " " << i << "\n";
cin >> now_mod_i;
cout << "? " << i << " " << now << "\n";
cin >> i_mod_now;
if (i_mod_now > now_mod_i) {
a[i] = i_mod_now;
} else {
a[now] = now_mod_i;
now = i;
}
}
cout << "! ";
for (int i = 1; i <= n; i++) {
if (!a[i]) {
a[i] = n;
}
cout << a[i] << " ";
}
cout << "\n";
}
int main() {
ios::sync_with_stdio(false);
solve();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int movei[] = {0, 0, 1, -1, 1, 1, -1, -1};
int movej[] = {1, -1, 0, 0, 1, -1, 1, -1};
const double PI = acos(-1.0);
const int MXN = 1e5 + 7;
int d, m;
int msb(int x) { return 31 - __builtin_clz(x); }
long long add(long long x, long long y) { return (x + y) % m; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int tcs;
cin >> tcs;
while (tcs--) {
cin >> d >> m;
long long ans = 0;
long long pre = 0;
for (int amt = msb(d); amt >= 0; amt--) {
long long f = 0;
if (amt == msb(d)) {
f = d - (1 << amt) + 1;
} else {
f = (1 << amt);
}
ans = add(ans, add(f, f * pre));
pre = ans;
}
cout << ans << '\n';
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
cout << n / 2 << '\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
int abs(int a) {
if (a < 0) return -1 * a;
return a;
}
int big(int a, int b) {
if (a > b) return a;
return b;
}
int small(int a, int b) {
if (a < b) return a;
return b;
}
int compare(const void *a, const void *b) {
int *p1 = (int *)a;
int *p2 = (int *)b;
return *p1 - *p2;
}
int main() {
int m, l, ans, min, max, n, i, j, k, x, y, t;
long long sum = 0;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &x);
sum += x;
sum += (long long)i * (x - 1);
}
printf("%lld", sum);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int m, p;
scanf("%d %d", &m, &p);
if (p % 2)
printf("%d\n", (p + 1) / 2);
else
printf("%d\n", (m + 2 - p) / 2);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300010;
vector<vector<pair<int, int> > > g, T;
int n, m, dfs_low[N], dfs_num[N], cnt = 0, P[N], a, b;
bool bridge[N], can[N], vis[N], can2[N];
void DFS(int node, int prnt) {
vis[node] = true;
dfs_low[node] = dfs_num[node] = cnt++;
for (int i = 0; i < g[node].size(); i++) {
int newnode = g[node][i].first;
if (newnode == prnt) continue;
if (vis[newnode])
dfs_low[node] = min(dfs_low[node], dfs_num[newnode]);
else {
DFS(newnode, node);
dfs_low[node] = min(dfs_low[node], dfs_low[newnode]);
if (dfs_num[node] < dfs_low[newnode]) bridge[g[node][i].second] = true;
}
}
}
int Find(int u) { return (u == P[u] ? u : P[u] = Find(P[u])); }
bool DFS2(int node, int prnt, bool one) {
if (can2[node]) one = true;
if (node == b) return one;
for (int i = 0; i < T[node].size(); i++) {
int newnode = T[node][i].first;
if (newnode == prnt) continue;
if (DFS2(newnode, node, (T[node][i].second == 1 ? 1 : one))) return true;
}
return false;
}
int main() {
scanf("%d%d", &n, &m);
g.resize(n + 1);
T.resize(n + 1);
for (int i = 1; i <= n; i++) P[i] = i;
for (int i = 0; i < m; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
can[i] = w;
g[u].push_back(make_pair(v, i));
g[v].push_back(make_pair(u, i));
}
scanf("%d%d", &a, &b);
DFS(1, -1);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < g[i].size(); j++) {
if (i > g[i][j].first) continue;
if (bridge[g[i][j].second]) continue;
int u = Find(i);
int v = Find(g[i][j].first);
P[u] = v;
if (can2[u] || can[g[i][j].second]) can2[v] = true;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < g[i].size(); j++) {
if (i > g[i][j].first) continue;
if (!bridge[g[i][j].second]) continue;
int u = Find(i);
int v = Find(g[i][j].first);
T[u].push_back(make_pair(v, can[g[i][j].second]));
T[v].push_back(make_pair(u, can[g[i][j].second]));
}
}
a = Find(a);
b = Find(b);
if (DFS2(a, -1, 0))
puts("YES");
else
puts("NO");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long int INF = 1000000000000000ll;
long long int i, j, k, x, y, a, b, V, E;
long long int R[100100], Ans[100100];
long long int find(long long int x) {
if (R[x] == x) return x;
return R[x] = find(R[x]);
}
void merge(long long int x, long long int y) { R[find(x)] = find(y); }
int main(void) {
ios::sync_with_stdio(false);
cin >> V >> E;
Ans[0] = 1;
for (i = 1; i <= 100000; i++) Ans[i] = (Ans[i - 1] * 2) % 1000000009ll;
for (i = 1; i <= V; i++) R[i] = i;
for (y = V, i = 1; i <= E; i++) {
cin >> a >> b;
if (find(a) == find(b)) {
cout << Ans[i - V + y] - 1 << endl;
continue;
}
y--;
cout << Ans[i - V + y] - 1 << endl;
merge(a, b);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
set<int> distinct;
vector<int> indices;
int main() {
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
int rating;
cin >> rating;
if (distinct.find(rating) == distinct.end()) {
distinct.insert(rating);
indices.push_back(i);
}
}
if (distinct.size() >= k) {
cout << "YES" << '\n';
for (int i = 0; i < k; i++) {
cout << indices[i] << " ";
}
} else {
cout << "NO" << '\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, -1, 0, 1};
bool a[2010][2010];
int n;
int kp;
short x[4000010], y[4000010];
bool u[2010][2010];
int s[2010][2010];
void dfs(int cx, int cy) {
x[kp] = cx;
y[kp] = cy;
u[cx][cy] = true;
kp++;
for (int q = 0; q < (int)(4); q++) {
int nx = cx + dx[q];
int ny = cy + dy[q];
if (nx >= 0 && ny >= 0 && nx < n && ny < n)
if (a[nx][ny] && !u[nx][ny]) dfs(nx, ny);
}
}
bool isBorder(int cx, int cy) {
if (cx == 0 || cy == 0 || cx == n - 1 || cy == n - 1) return true;
for (int q = 0; q < (int)(4); q++) {
int nx = cx + dx[q];
int ny = cy + dy[q];
if (a[nx][ny] == 0) return true;
}
return false;
}
int main() {
scanf("%d", &n);
int z;
for (int i = 0; i < (int)(n); i++)
for (int j = 0; j < (int)(n); j++) {
scanf("%d", &z);
a[i][j] = z;
}
for (int q = 0; q < (int)(2); q++) {
for (int i = 0; i < (int)(n); i++)
for (int j = 0; j < (int)(n); j++)
s[i + 1][j + 1] = s[i + 1][j] + s[i][j + 1] - s[i][j] + a[i][j];
for (int i = 0; i < (int)(n); i++)
for (int j = 0; j < (int)(n); j++) {
if (i < 4 || j < 4)
a[i][j] = 0;
else {
int ss = s[i + 1][j + 1] - s[i + 1][j - 4] - s[i - 4][j + 1] +
s[i - 4][j - 4];
a[i][j] = ss > 12;
}
}
}
int ci = 0, sq = 0;
for (int i = 0; i < (int)(n); i++)
for (int j = 0; j < (int)(n); j++)
if (a[i][j] && !u[i][j]) {
kp = 0;
dfs(i, j);
double sx = 0, sy = 0;
for (int i = 0; i < (int)(kp); i++) {
sx += x[i];
sy += y[i];
}
sx /= kp, sy /= kp;
double maxD = -1, minD = 1e9;
for (int i = 0; i < (int)(kp); i++) {
if (!isBorder(x[i], y[i])) continue;
double d = (x[i] - sx) * (x[i] - sx) + (y[i] - sy) * (y[i] - sy);
if (d < minD) minD = d;
if (d > maxD) maxD = d;
}
if (maxD / minD < 1.5)
ci++;
else
sq++;
}
printf("%d %d\n", ci, sq);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void solve();
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed;
cout.precision(12);
solve();
return 0;
}
template <typename T>
void prv(vector<T> v) {
for (int __ii = 0; __ii < ((int)v.size()); __ii++) {
if (__ii) cout << ' ';
cout << v[__ii];
}
cout << '\n';
}
template <typename T>
void prm(vector<vector<T>> v) {
for (int __ii = 0; __ii < ((int)v.size()); __ii++) {
for (int __jj = 0; __jj < v[__ii].size(); __jj++) {
if (__jj) cout << ' ';
cout << v[__ii][__jj];
}
cout << '\n';
}
}
template <typename T>
void sc(T& x) {
cin >> x;
}
template <typename Head, typename... Tail>
void sc(Head& head, Tail&... tail) {
cin >> head;
sc(tail...);
}
template <typename T>
void pr(const T& x) {
cout << x << '\n';
}
template <typename Head, typename... Tail>
void pr(const Head& head, const Tail&... tail) {
cout << head << ' ';
pr(tail...);
}
template <typename... T>
void err(const T&... cod) {
pr(cod...);
exit(0);
}
void solve() {
int n, m;
sc(n, m);
vector<vector<pair<int, int>>> g(n);
for (int i = 0; i < m; i++) {
int u, v, w;
sc(u, v, w);
u--;
v--;
g[u].emplace_back(v, w);
g[v].emplace_back(u, w);
}
vector<map<int, int>> make_pair(n);
for (int i = 0; i < n; i++) {
int k;
sc(k);
vector<int> t(k);
for (int __ii = 0; __ii < k; __ii++) cin >> t[__ii];
sort(t.begin(), t.end());
{
int p = 0;
while (p < ((int)t.size())) {
int q = p + 1;
while (q < ((int)t.size()) && t[q] == t[q - 1] + 1) {
q++;
}
while (p < q) {
make_pair[i][t[p]] = q - p;
p++;
}
}
}
}
priority_queue<pair<int, int>> pq;
int t = 0;
if (make_pair[0].count(t)) t += make_pair[0][t];
pq.emplace(-t, 0);
vector<int> dist(n, -1);
dist[0] = t;
while (!pq.empty()) {
pair<int, int> p = pq.top();
pq.pop();
int u = p.second, d = p.first;
d *= -1;
assert(dist[u] != -1);
if (d > dist[u]) continue;
for (auto p : g[u]) {
int v = p.first, w = p.second;
if (v != n - 1 && make_pair[v].count(d + w)) w += make_pair[v][d + w];
if (dist[v] == -1 || d + w < dist[v]) {
dist[v] = d + w;
pq.emplace(-dist[v], v);
}
}
}
pr(dist[n - 1]);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
while (n--) {
int c, sum;
scanf("%d %d", &c, &sum);
if (sum % c == 0)
cout << c * (sum / c * sum / c) << endl;
else {
int temp = sum / c;
long long int total = (temp * temp) * c;
int mod = sum % c;
total += mod * ((temp + 1) * (temp + 1));
total -= mod * (temp * temp);
cout << total << endl;
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, a[200005], pos[200005], x;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) scanf("%d", &x), pos[x] = i;
int res = 0, mm = 0;
for (int i = 1; i <= n; i++) {
if (pos[a[i]] < mm) {
res = n - i + 1;
break;
}
mm = max(mm, pos[a[i]]);
}
cout << res;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long int n, m;
cin >> n >> m;
queue<pair<long long int, long long int>> q;
map<long long int, long long int> ma;
for (long long int i = 0; i < n; ++i) {
long long int a;
cin >> a;
q.push(make_pair(a, 0));
ma[a] = 1;
}
vector<long long int> vi;
long long int h = 0, dis = 0;
while (h < m) {
long long int u = q.front().first;
long long int v = q.front().second;
q.pop();
if (ma[u + 1] == 0) {
++h;
q.push(make_pair(u + 1, v + 1));
dis += v + 1;
vi.push_back(u + 1);
ma[u + 1] = 1;
}
if (ma[u - 1] == 0 && h < m) {
++h;
q.push(make_pair(u - 1, v + 1));
dis += v + 1;
vi.push_back(u - 1);
ma[u - 1] = 1;
}
}
cout << dis << endl;
for (long long int i = 0; i < h; ++i) cout << vi[i] << " ";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int w, h;
char c;
cin >> w >> h;
string* m = new string[h];
string* n = new string[2 * w];
string t;
for (int i = 0; i < h; ++i) {
for (int j = 0; j < w; ++j) {
cin >> c;
m[i] += c;
}
}
for (int j = 0; j < w * 2; j += 2) {
t = "";
for (int k = h - 1; k >= 0; --k) t += m[k][j / 2];
for (int i = t.size() - 1; i >= 0; --i) {
n[j] += t[i];
n[j] += t[i];
}
}
for (int i = 1; i < (2 * w); i += 2) n[i] += n[i - 1];
for (int i = 0; i < (2 * w); ++i) cout << n[i] << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
using ld = long double;
template <class T>
using Table = vector<vector<T>>;
const ld eps = 1e-9;
vector<int> unis;
vector<int> c_nums;
int N, K;
long long int getans(const int now, const int from,
const vector<vector<int>>& edges) {
long long int ans = 0;
for (auto e : edges[now]) {
if (e == from)
continue;
else {
ans += K - abs(K - c_nums[e]);
ans += getans(e, now, edges);
}
}
return ans;
}
int dfs(const int now, const int from, const vector<vector<int>>& edges) {
int c = unis[now];
for (auto e : edges[now]) {
if (e == from)
continue;
else {
c += dfs(e, now, edges);
}
}
return c_nums[now] = c;
}
int main() {
cin >> N >> K;
unis.resize(N);
c_nums.resize(N);
for (int i = 0; i < 2 * K; ++i) {
int a;
cin >> a;
a--;
unis[a] = true;
}
vector<vector<int>> edges(N);
for (int i = 0; i < N - 1; ++i) {
int a, b;
cin >> a >> b;
a--;
b--;
edges[a].push_back(b);
edges[b].push_back(a);
}
long long int ans;
dfs(0, -1, edges);
for (int i = 0; i < edges.size(); ++i) {
ans = getans(i, -1, edges);
break;
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
const double eps = 1e-10;
const float epsf = 1e-6;
using namespace std;
inline long long int __gcd(long long int a, long long int b) {
if (a == 0 || b == 0) {
return max(a, b);
}
long long int tempa, tempb;
while (1) {
if (a % b == 0)
return b;
else {
tempa = a;
tempb = b;
a = tempb;
b = tempa % tempb;
}
}
}
inline int compfloat(float& x, float& y) {
if (fabs(x - y) < epsf)
return 0;
else if (x - y > 0)
return 1;
return -1;
}
inline int compdouble(double x, double y) {
if (fabs(x - y) < eps)
return 0;
else if (x - y > 0)
return 1;
else
return -1;
}
bool prime(long long int k) {
for (long long int i = 2; i * i <= k; i++)
if (k % i == 0) {
return false;
}
return true;
}
void pdash(int n = 1) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < 30; j++) {
cout << "-";
}
cout << "\n";
}
}
long long int power(long long int x, long long int y) {
long long int result = 1;
while (y > 0) {
if (y & 1) {
result = (result * x);
}
y = y >> 1;
x = (x * x);
}
return result;
}
long long int power(long long int x, long long int y, long long int z) {
long long int result = 1;
x = x % z;
while (y > 0) {
if (y & 1) {
result = (result * x) % z;
}
y = y >> 1;
x = (x * x) % z;
}
return result;
}
long long int modInverse(long long int n, long long int p) {
return power(n, p - 2, p);
}
long long int nCrF(long long int n, long long int r, long long int p) {
if (r == 0) return 1;
long long int f[n + 1];
f[0] = 1;
for (long long int i = 1; i <= n; i++) f[i] = f[i - 1] * i % p;
return (f[n] * modInverse(f[r], p) % p * modInverse(f[n - r], p) % p) % p;
}
void cordinate_compression(vector<int>& v) {
vector<int> p = v;
sort(p.begin(), p.end());
p.erase(unique(p.begin(), p.end()), p.end());
for (int i = 0; i < (int)((v).size()); i++)
v[i] = (int)(lower_bound(p.begin(), p.end(), v[i]) - p.begin());
}
void solve() {
int n;
cin >> n;
vector<int> vec[n + 1];
for (int i = 0; i < n; i++) {
int a;
cin >> a;
vec[a].push_back(i + 1);
}
int k = 0;
vector<int> ans;
while (1) {
if (k < 0) break;
if (vec[k].empty())
k -= 3;
else {
ans.push_back(vec[k].back());
vec[k].pop_back();
k++;
}
}
if (ans.size() != n) {
cout << "Impossible\n";
return;
}
cout << "Possible\n";
for (auto& j : ans) cout << j << " ";
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int from, to, capacity, cost, compete;
};
vector<vector<int>> adj, cost, capacity;
const int INF = 1e9;
void shortest_paths(int n, int v0, vector<int>& d, vector<int>& p) {
d.assign(n, INF);
d[v0] = 0;
vector<bool> inq(n, false);
queue<int> q;
q.push(v0);
p.assign(n, -1);
while (!q.empty()) {
int u = q.front();
q.pop();
inq[u] = false;
for (int v : adj[u]) {
if (capacity[u][v] > 0 && d[v] > d[u] + cost[u][v]) {
d[v] = d[u] + cost[u][v];
p[v] = u;
if (!inq[v]) {
inq[v] = true;
q.push(v);
}
}
}
}
}
int min_cost_flow(int N, vector<Edge> edges, int K, int s, int t) {
adj.assign(N, vector<int>());
cost.assign(N, vector<int>(N, 0));
capacity.assign(N, vector<int>(N, 0));
for (Edge e : edges) {
adj[e.from].push_back(e.to);
adj[e.to].push_back(e.from);
cost[e.from][e.to] = e.cost;
cost[e.to][e.from] = -e.cost;
capacity[e.from][e.to] = e.capacity;
}
int flow = 0;
int cost = 0;
vector<int> d, p;
while (flow < K) {
shortest_paths(N, s, d, p);
if (d[t] == INF) break;
int f = K - flow;
int cur = t;
while (cur != s) {
f = min(f, capacity[p[cur]][cur]);
cur = p[cur];
}
flow += f;
cost += f * d[t];
cur = t;
while (cur != s) {
capacity[p[cur]][cur] -= f;
capacity[cur][p[cur]] += f;
cur = p[cur];
}
}
if (flow < K)
return -1;
else
return cost;
}
int main() {
int nw[55], w[55];
int g[55][55];
int s = 0, t = 3002;
char ch[55][55];
int n, m;
cin >> n >> m;
vector<Edge> edges;
memset(w, 0, sizeof(w));
memset(nw, 0, sizeof(nw));
memset(g, 0, sizeof(g));
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) ch[i][j] = '0';
}
int u, v;
for (int i = 1; i <= m; i++) {
cin >> u >> v;
w[u]++;
g[u][v] = 1;
ch[u][v] = '1', ch[v][u] = '0';
g[v][u] = 1;
}
int mnode = n + 1;
int K = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (j != i && g[j][i] == 0 && g[i][j] == 0) {
Edge ed, ed2, ed3;
ed.from = s, ed.to = mnode, ed.cost = 0, ed.capacity = 1,
ed.compete = -1;
edges.push_back(ed);
ed2.from = mnode, ed2.to = i, ed2.cost = 0, ed2.capacity = 1,
ed2.compete = j;
ed3.from = mnode, ed3.to = j, ed3.cost = 0, ed3.capacity = 1,
ed3.compete = i;
edges.push_back(ed2), edges.push_back(ed3);
nw[i]++, nw[j]++;
g[j][i] = 1;
g[i][j] = 1;
mnode++;
K++;
}
}
}
int cnt = mnode;
for (int i = 1; i <= n; i++) {
cnt += nw[i];
}
t = cnt;
for (int i = 1; i <= n; i++) {
int val = 1;
for (int j = 1; j <= nw[i]; j++) {
Edge ed;
ed.from = i, ed.to = mnode, ed.capacity = 1, ed.cost = 2 * w[i] + val,
ed.compete = -1;
Edge ed2;
ed2.from = mnode, ed2.to = t, ed2.capacity = 1, ed2.cost = 0,
ed2.compete = -1;
edges.push_back(ed);
edges.push_back(ed2);
mnode++;
val = val + 2;
}
}
int sum = min_cost_flow(t + 5, edges, K, s, t);
for (auto ed : edges) {
int x = ed.from, y = ed.to, z = ed.compete;
if (y >= 1 && y <= n && z >= 1 && z <= n) {
if (capacity[x][y] == 0)
ch[y][z] = '1';
else
ch[y][z] = '0';
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) cout << ch[i][j];
cout << endl;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
int dr[] = {2, 2, -2, -2, 1, -1, 1, -1};
int dc[] = {1, -1, 1, -1, 2, 2, -2, -2};
int dr1[] = {0, 0, 1, 1, 1, -1, -1, -1};
int dc1[] = {1, -1, 1, 0, -1, 0, 1, -1};
int dr2[] = {0, 0, 1, -1};
int dc2[] = {1, -1, 0, 0};
using namespace std;
double a[500005];
double pre[500005];
int main() {
string t;
long long int i, j;
cin >> t;
pre[1] = 1;
for (i = 2; i < 500005; i++) {
double p = i;
double p1 = 1.00;
pre[i] = pre[i - 1] + (p1 / p);
}
for (long long int i = 0; i < t.size(); i++) {
if (t[i] == 'A' || t[i] == 'E' || t[i] == 'O' || t[i] == 'I' ||
t[i] == 'U' || t[i] == 'Y')
a[i + 1] = 1;
}
long long int m = t.size();
for (long long int i = 1; i < m + 1; i++) a[i] += a[i - 1];
double ans = 0;
for (i = 1; i <= m; i++) {
ans += (a[i] * pre[i]);
}
double ans1 = 0;
for (long long int i = 1; i < m + 1; i++) {
ans1 += (pre[m - i] * a[i]);
}
double ans2 = ans - ans1;
cout << fixed << setprecision(8) << ans2 << endl;
return 0;
}
| 6 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.