solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int n, m;
map<int, vector<int> > even, odd;
int a[N], used[N];
int e = 2, o = 1;
bool flag = true;
int get_even() {
while (used[e]) {
e += 2;
if (e >= N) return -1;
}
used[e] = 1;
if (e > m) flag = false;
return e;
}
int get_odd() {
while (used[o]) {
o += 2;
if (o >= N) return -1;
}
used[o] = 1;
if (o > m) flag = false;
return o;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
memset(used, 0, sizeof used);
int sz_e = 0, sz_o = 0;
for (int i = 0; i < n; ++i) {
cin >> a[i];
int tmp = a[i];
if (tmp & 1) {
odd[tmp].push_back(i);
sz_o++;
} else {
even[tmp].push_back(i);
sz_e++;
}
if (tmp < N) used[tmp] = 1;
}
int ans = 0;
map<int, vector<int> >::iterator i = even.begin(), j = odd.begin();
while (sz_e != sz_o) {
ans += 1;
if (sz_o > sz_e) {
vector<int> od;
if (j != odd.end()) {
while ((*j).second.size() == 1) {
j++;
if (j == odd.end()) break;
}
if (j != odd.end()) od = (*j).second;
}
if (j == odd.end()) {
int id_o = (*odd.begin()).second[0];
odd.erase(odd.begin());
a[id_o] = get_even();
even[a[id_o]].push_back(id_o);
} else {
int id_o = od[od.size() - 1];
od.pop_back();
int new_even = get_even();
a[id_o] = new_even;
even[new_even].push_back(id_o);
odd[(*j).first] = od;
}
sz_o--;
sz_e++;
} else {
vector<int> ev;
if (i != even.end()) {
while ((*i).second.size() == 1) {
i++;
if (i == even.end()) break;
}
if (i != even.end()) ev = (*i).second;
}
if (i == even.end()) {
int id_e = (*even.begin()).second[0];
even.erase(even.begin());
a[id_e] = get_odd();
odd[a[id_e]].push_back(id_e);
} else {
int id_e = ev[ev.size() - 1];
ev.pop_back();
int new_odd = get_odd();
a[id_e] = new_odd;
odd[new_odd].push_back(id_e);
even[(*i).first] = ev;
}
sz_e--;
sz_o++;
}
}
for (map<int, vector<int> >::iterator i = even.begin(), j = odd.begin();;) {
vector<int> ev = (*i).second, od = (*j).second;
while (min(od.size(), ev.size()) > 1) {
ans += 2;
int id_e = ev[ev.size() - 1], id_o = od[od.size() - 1];
od.pop_back();
ev.pop_back();
int new_odd = get_odd(), new_even = get_even();
odd[new_odd].push_back(id_e);
even[new_even].push_back(id_o);
a[id_e] = new_odd;
a[id_o] = new_even;
}
even[(*i).first] = ev, odd[(*j).first] = od;
if (ev.size() == 1) i++;
if (od.size() == 1) j++;
if (i == even.end() || j == odd.end()) {
break;
}
}
for (map<int, vector<int> >::iterator i = even.begin(); i != even.end();
++i) {
vector<int> ev = (*i).second;
while (ev.size() > 1) {
ans++;
int id = ev[ev.size() - 1];
a[id] = get_even();
even[a[id]].push_back(id);
ev.pop_back();
}
even[(*i).first] = ev;
}
for (map<int, vector<int> >::iterator j = odd.begin(); j != odd.end(); ++j) {
vector<int> od = (*j).second;
while (od.size() > 1) {
ans++;
int id = od[od.size() - 1];
a[id] = get_odd();
odd[a[id]].push_back(id);
od.pop_back();
}
odd[(*j).first] = od;
}
if (!flag) {
cout << -1 << endl;
return 0;
}
cout << ans << endl;
for (int i = 0; i < n; ++i) {
cout << a[i] << " ";
}
cout << endl;
return 0;
}
| 5 |
#include <iostream>
#include <cmath>
using namespace std;
int main() {
double x;
while(cin >> x) {
double y;
y=4.9*((x/9.8)*(x/9.8));
cout << ceil(y/5)+1 << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int n;
cin>>n;
vector <int> a(n);
for(int i=0;i<n;i++) a[i]=i+1;
do{
for(int i=0;i<n;i++){
if(i) cout<<" ";
cout<<a[i];
}
cout<<endl;
}while(next_permutation(a.begin(),a.end()));
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, a, b, ans, vis[200005], odd, even;
vector<long long> adj[100005];
void dfs(long long x) {
vis[x] % 2 == 0 ? even++ : odd++;
long long sz = adj[x].size();
for (int i = 0; i < sz; i++) {
long long y = adj[x][i];
if (vis[y] == -1) {
vis[y] = (vis[x] ^ 1);
dfs(y);
}
}
}
int main() {
cin >> n;
for (int i = 1; i < n; i++) {
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
memset(vis, -1, sizeof vis);
odd = even = 0;
vis[1] = 1;
dfs(1);
ans = ((odd * even) - (n - 1));
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, d, b, l, r, need, ans1, ans2;
long long a[500011], n1[500011], n2[500011];
int main() {
scanf("%lld%lld%lld", &n, &d, &b);
long long re = (n >> 1) * b;
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (int i = 1; i <= n; i++)
n1[i] = min(a[i], re) + n1[i - 1], re -= min(a[i], re);
re = (n >> 1) * b;
for (int i = n; i; i--)
n2[i] = min(a[i], re) + n2[i + 1], re -= min(a[i], re);
for (int i = 1; i <= n / 2; i++) {
r = min(r + d + 1, n);
if (need + b <= n1[r])
need += b;
else
ans1++;
}
l = n + 1;
need = 0;
for (int i = n; i >= ((n + 1) / 2) + 1; i--) {
l = max(1LL, l - d - 1);
if (need + b <= n2[l])
need += b;
else
ans2++;
}
printf("%lld\n", max(ans1, ans2));
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define repl(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define repr(i, a, b) for (int i = (int)(a - 1); i >= b; i--)
#define rep(i, n) repl(i, 0, n)
#define each(itr, v) for (auto itr : v)
#define pb(s) push_back(s)
#define all(x) (x).begin(), (x).end()
#define dbg(x) cout << #x " = " << x << endl
#define maxch(x, y) x = max(x, y)
#define minch(x, y) x = min(x, y)
#define uni(x) x.erase(unique(all(x)), x.end())
#define exist(x, y) (find(all(x), y) != x.end())
#define bcnt(x) bitset<32>(x).count()
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> P;
#define INF INT_MAX / 3
int main() {
cin.sync_with_stdio(false);
int n;
cin >> n;
if (n == 0)
cout << 1 << endl;
else if (n == 1)
cout << 2 << endl;
else if (n == 2)
cout << 1 << endl;
else
cout << 0 << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
int in[maxn], in1[maxn];
int dp[maxn];
int dp1[maxn];
int dp2[maxn];
int s[maxn];
int vis[maxn];
int dp3[maxn];
vector<int> g[maxn];
int a[maxn];
int k;
int flag;
void dfs(int u, int pa) {
int p = g[u].size();
dp1[u] = 1;
vis[u] = 1;
for (int i = 0; i < p; i++) {
if (g[u][i] != pa) {
dfs(g[u][i], u);
dp1[u] = max(dp1[u], dp1[g[u][i]] + 1);
}
}
}
int pre[maxn], ou[maxn];
int nex[maxn];
void dfs1(int u, int pa) {
s[u] = 0;
if (in1[u] != in[u]) {
s[u] = 1;
}
int p = (int)g[u].size();
int ss = 0;
int s1 = 0;
int tot = 0;
int y = 0, q = 0;
for (int i = 0; i < p; i++) {
if (g[u][i] != pa) {
dfs1(g[u][i], u);
if (flag) return;
if (s[g[u][i]] == 0) {
ss += dp[g[u][i]];
} else {
s1 = max(s1, dp[g[u][i]]);
s[u] = 1;
y++;
q = g[u][i];
}
}
}
dp[u] = ss + s1 + 1;
dp3[u] = ss;
if (dp[u] >= k) {
flag = 1;
}
if (y == 1 && in[u] == in1[u])
nex[u] = q;
else
nex[u] = 0;
dp2[u] = dp[u];
tot = 0;
for (int i = 0; i < p; i++) {
if (g[u][i] != pa) {
if (s[g[u][i]] == 0) continue;
if (tot == 0)
pre[tot] = dp[g[u][i]];
else
pre[tot] = max(pre[tot - 1], dp[g[u][i]]);
tot++;
}
}
int w = tot;
ou[w] = 0;
for (int i = p - 1; i >= 0; i--) {
if (g[u][i] != pa) {
if (s[g[u][i]] == 0) continue;
w--;
ou[w] = max(ou[w + 1], dp[g[u][i]]);
}
}
int f = 0;
for (int i = 0; i < p; i++) {
if (g[u][i] != pa) {
if (s[g[u][i]] == 0) continue;
if (f == 0) {
dp2[u] = max(dp2[u], dp[g[u][i]] + ou[1] + ss + 1);
} else {
dp2[u] = max(dp2[u], dp[g[u][i]] + max(pre[f - 1], ou[f + 1]) + ss + 1);
}
dp2[u] = max(dp2[u], dp[g[u][i]] + ss + 1);
f++;
}
}
if (dp2[u] >= k) {
flag = 1;
return;
}
if (pa == -1) {
int p = u;
int s = 0;
while (nex[p]) {
s += dp3[p] + 1;
p = nex[p];
if (s + dp2[p] >= k) {
flag = 1;
return;
}
}
}
}
struct pi {
int a;
int b;
} pp[maxn];
int main() {
int i, n;
cin >> n >> k;
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 0; i < n - 1; i++) {
scanf("%d%d", &pp[i].a, &pp[i].b);
in[pp[i].a]++;
in[pp[i].b]++;
}
int le = 1, ri = 1000000, mid;
while (le <= ri) {
mid = (le + ri) / 2;
for (i = 1; i <= n; i++) {
g[i].clear();
vis[i] = 0;
in1[i] = 0;
}
for (i = 0; i < n - 1; i++) {
if (a[pp[i].a] < mid || a[pp[i].b] < mid) continue;
g[pp[i].a].push_back(pp[i].b);
g[pp[i].b].push_back(pp[i].a);
in1[pp[i].a]++;
in1[pp[i].b]++;
}
flag = 0;
for (i = 1; i <= n; i++) {
if (a[i] < mid) continue;
if (!vis[i]) {
dfs(i, -1);
dfs1(i, -1);
if (flag) {
break;
}
}
}
if (flag)
le = mid + 1;
else
ri = mid - 1;
}
printf("%d\n", ri);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct DSU {
int count;
vector<int> vs, ss;
DSU(int n) : count(n), vs(n, -1), ss(n, 1) {
for (int i = 0; i < n; i++) vs[i] = i;
}
int get(int x) { return x == vs[x] ? x : vs[x] = get(vs[x]); }
void unite(int a, int b) {
a = get(a);
b = get(b);
if (a == b) return;
if (ss[a] > ss[b]) {
vs[b] = a;
ss[a] += ss[b];
} else {
vs[a] = b;
ss[b] += ss[a];
}
}
};
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
vector<int> cs(k);
for (int i = 0; i < k; i++) {
scanf("%d", &cs[i]);
cs[i]--;
}
DSU dsu(n);
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
u--, v--;
dsu.unite(u, v);
}
int biggestCap = -1, biggestSize = -1;
vector<int> capitals(n, -1);
for (int i = 0; i < k; i++) {
int capSet = dsu.get(cs[i]);
capitals[capSet] = cs[i];
if (dsu.ss[capSet] > biggestSize) {
biggestSize = dsu.ss[capSet];
biggestCap = cs[i];
}
}
for (int i = 0; i < n; i++) {
int nodeSet = dsu.get(i);
if (capitals[nodeSet] < 0) {
dsu.unite(i, biggestCap);
}
}
set<int> sets;
for (int i = 0; i < n; i++) sets.insert(dsu.get(i));
int total = 0;
for (int s : sets) {
int ssize = dsu.ss[s];
total += ssize * (ssize - 1) / 2;
}
total -= m;
printf("%d\n", total);
return 0;
}
| 1 |
#include <bits/stdc++.h>
int main() {
int n, *a, count = 0, min = 2000000000;
scanf("%i", &n);
a = new int[n];
for (int i = 0; i < n; ++i) {
scanf("%i", &a[i]);
}
std::sort(a, a + n);
for (int i = 0; i < n - 1; ++i) {
if (min > abs(a[i] - a[i + 1])) {
min = abs(a[i] - a[i + 1]);
count = 1;
continue;
}
if (min == abs(a[i] - a[i + 1])) ++count;
}
printf("%i %i", min, count);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, ok, nn, mm, kk;
queue<pair<pair<int, int>, int> > q;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
pair<int, int> mk[m + 1][k + 1], nk[n + 1][k + 1], nm[n + 1][m + 1],
qmk[m + 1][k + 1], qnk[n + 1][k + 1], qnm[n + 1][m + 1];
int nmk[n + 1][m + 1][k + 1];
for (int i = 1; i <= m; i++)
for (int j = 1; j <= k; j++) {
cin >> mk[i][j].first;
if (mk[i][j].first == 0) mk[i][j].first = -1;
qmk[i][j].first = 1;
q.push(make_pair(make_pair(1, i), j));
}
for (int i = 1; i <= m; i++)
for (int j = 1; j <= k; j++) {
cin >> mk[i][j].second;
if (mk[i][j].second == 0) mk[i][j].second = -1;
qmk[i][j].second = n;
q.push(make_pair(make_pair(n, i), j));
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= k; j++) {
cin >> nk[i][j].first;
if (nk[i][j].first == 0) nk[i][j].first = -1;
qnk[i][j].first = 1;
q.push(make_pair(make_pair(i, 1), j));
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= k; j++) {
cin >> nk[i][j].second;
if (nk[i][j].second == 0) nk[i][j].second = -1;
qnk[i][j].second = m;
q.push(make_pair(make_pair(i, m), j));
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
cin >> nm[i][j].first;
if (nm[i][j].first == 0) nm[i][j].first = -1;
qnm[i][j].first = 1;
q.push(make_pair(make_pair(i, j), 1));
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
cin >> nm[i][j].second;
if (nm[i][j].second == 0) nm[i][j].second = -1;
qnm[i][j].second = k;
q.push(make_pair(make_pair(i, j), k));
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
for (int u = 1; u <= k; u++) nmk[i][j][u] = 0;
while (!q.empty()) {
nn = q.front().first.first;
mm = q.front().first.second;
kk = q.front().second;
q.pop();
ok = 1;
if (nmk[nn][mm][kk] != -1) {
if (qnm[nn][mm].first == kk)
if (ok == 1 &&
(nmk[nn][mm][kk] == 0 || nmk[nn][mm][kk] == nm[nn][mm].first))
nmk[nn][mm][kk] = nm[nn][mm].first;
else
ok = -1;
if (qnm[nn][mm].second == kk)
if (ok == 1 &&
(nmk[nn][mm][kk] == 0 || nmk[nn][mm][kk] == nm[nn][mm].second))
nmk[nn][mm][kk] = nm[nn][mm].second;
else
ok = -1;
if (qnk[nn][kk].first == mm)
if (ok == 1 &&
(nmk[nn][mm][kk] == 0 || nmk[nn][mm][kk] == nk[nn][kk].first))
nmk[nn][mm][kk] = nk[nn][kk].first;
else
ok = -1;
if (qnk[nn][kk].second == mm)
if (ok == 1 &&
(nmk[nn][mm][kk] == 0 || nmk[nn][mm][kk] == nk[nn][kk].second))
nmk[nn][mm][kk] = nk[nn][kk].second;
else
ok = -1;
if (qmk[mm][kk].first == nn)
if (ok == 1 &&
(nmk[nn][mm][kk] == 0 || nmk[nn][mm][kk] == mk[mm][kk].first))
nmk[nn][mm][kk] = mk[mm][kk].first;
else
ok = -1;
if (qmk[mm][kk].second == nn)
if (ok == 1 &&
(nmk[nn][mm][kk] == 0 || nmk[nn][mm][kk] == mk[mm][kk].second))
nmk[nn][mm][kk] = mk[mm][kk].second;
else
ok = -1;
}
if (ok == -1 || nmk[nn][mm][kk] == -1) {
nmk[nn][mm][kk] = -1;
if (qnm[nn][mm].first == kk) {
qnm[nn][mm].first++;
if (kk < k) q.push(make_pair(make_pair(nn, mm), kk + 1));
}
if (qnm[nn][mm].second == kk) {
qnm[nn][mm].second--;
if (kk > 1) q.push(make_pair(make_pair(nn, mm), kk - 1));
}
if (qnk[nn][kk].first == mm) {
qnk[nn][kk].first++;
if (mm < m) q.push(make_pair(make_pair(nn, mm + 1), kk));
}
if (qnk[nn][kk].second == mm) {
qnk[nn][kk].second--;
if (mm > 1) q.push(make_pair(make_pair(nn, mm - 1), kk));
}
if (qmk[mm][kk].first == nn) {
qmk[mm][kk].first++;
if (nn < n) q.push(make_pair(make_pair(nn + 1, mm), kk));
}
if (qmk[mm][kk].second == nn) {
qmk[mm][kk].second--;
if (nn > 1) q.push(make_pair(make_pair(nn - 1, mm), kk));
}
}
}
ok = 1;
for (int i = 1; i <= m; i++)
for (int j = 1; j <= k; j++) {
if (qmk[i][j].first > n && mk[i][j].first != -1) ok = -1;
if (qmk[i][j].second < 1 && mk[i][j].second != -1) ok = -1;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= k; j++) {
if (qnk[i][j].first > m && nk[i][j].first != -1) ok = -1;
if (qnk[i][j].second < 1 && nk[i][j].second != -1) ok = -1;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
if (qnm[i][j].first > k && nm[i][j].first != -1) ok = -1;
if (qnm[i][j].second < 1 && nm[i][j].second != -1) ok = -1;
}
if (ok == -1) {
cout << "-1";
return 0;
} else
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
for (int u = 1; u <= k; u++)
if (nmk[i][j][u] != -1)
cout << nmk[i][j][u] << ' ';
else
cout << '0' << ' ';
}
| 6 |
#include <iostream>
#include <cstring>
#include <string>
#include <vector>
#include <algorithm>
#include <cassert>
using namespace std;
#define SZ(a) int((a).size())
#define REP(i,n) for(int i=0,_n=(n);i<_n;++i)
#define FOR(i,a,b) for(int i=(a),_b=(b);i<=_b;++i)
typedef long long llong;
typedef vector<int> VI;
typedef vector<VI> VVI;
#define MAXM 100004
llong N, nblocks;
int K;
VI A;
int MM;
char B[7][MAXM];
int ncomps;
int C[7][MAXM];
void flood_fill(int r, int c) {
if (r < 0 || r >= MM || c < 0 || c >= 7) return;
if (B[c][r] == '#') return;
if (C[c][r]) return;
C[c][r] = ncomps;
flood_fill(r-1, c);
flood_fill(r, c-1);
flood_fill(r, c+1);
flood_fill(r+1, c);
}
int dfs(const VVI& adj, VI& vis, int u) {
int res = 1;
vis[u] = 1;
for (int v : adj[u]) {
if (!vis[v])
res += dfs(adj, vis, v);
}
return res;
}
llong solve() {
MM = (K % 7) ? K : K/7;
//cerr << "MM: " << MM << endl;
for (int rem : A) {
for (; rem < 7*MM; rem += K) {
int r = rem / 7;
int c = rem % 7;
B[c][r] = '#';
}
}
/*
REP(r, MM) {
REP(c, 7)
cerr << B[c][r];
cerr << endl;
}
*/
REP(r, MM) {
REP(c, 7) {
if (B[c][r] != '#' && C[c][r] == 0) {
++ncomps;
flood_fill(r, c);
}
}
}
/*
REP(r, MM) {
REP(c, 7)
cerr << C[c][r] << ' ';
cerr << endl;
}
*/
VVI adj(ncomps);
REP(c, 7) {
int u = C[c][0] - 1, v = C[c][MM-1] - 1;
if (u >= 0 && v >= 0) {
adj[u].push_back(v);
if (u != v)
adj[v].push_back(u);
}
}
llong nblocks = N / MM;
//cerr << "Number of blocks = " << nblocks << endl;
llong res = 0;
VI vis(ncomps);
REP(u, ncomps) {
if (vis[u]) continue;
if (adj[u].empty())
res += nblocks;
else {
bool self = find(adj[u].begin(), adj[u].end(), u) != adj[u].end();
int cnt = dfs(adj, vis, u);
if (self)
++res;
else {
FOR(len, 1, cnt-1) {
if (nblocks >= len)
res += 2;
}
res += max(nblocks - cnt + 1, 0LL);
}
}
}
return res;
}
int main(int argc, char* argv[]) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int Q;
cin >> N >> K >> Q;
memset(B, '.', sizeof(B));
A = VI(Q);
REP(j, Q)
cin >> A[j];
llong res = solve();
cout << res << endl;
return 0;
}
| 0 |
#include<iostream>
using namespace std;
int main()
{
int x,y,z; cin>>x>>y>>z;
cout<<z<<' '<<x<<' '<<y;
cout<<'\n';
} | 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
using ull = unsigned long long int;
using P = pair<int, int>;
using P3 = pair<P,ll>;
using PP = pair<P, P>;
constexpr int INF = 1 << 30;
constexpr ll MOD = ll(1e9)+7;
constexpr int di[] = {0, 1, 0, -1};
constexpr int dj[] = {1, 0, -1, 0};
constexpr double EPS = 1e-9;
int gcd(int p, int q){
if(q==0) return p;
return gcd(q,p%q);
}
void compress(vector<P> &v){
int g = 0;
for(auto &p : v){
g = gcd(abs(p.first), g);
g = gcd(abs(p.second), g);
}
for(auto &p : v){
p.first /= g;
p.second /= g;
}
}
void rotate90(vector<P> &v){
for(auto &p : v){
int x = p.first, y = p.second;
p.first = y;
p.second = -x;
}
}
void rev(vector<P> &v){
reverse(v.begin(), v.end());
for(auto &p : v){
p.first *= -1;
p.second *= -1;
}
}
int solve(){
int n;
cin >> n;
if(n == 0) return 1;
vector<vector<P> > lines(n+1);
for(int i=0;i<n+1;i++){
int m, px, py;
cin >> m;
for(int j=0;j<m;j++){
int x, y;
cin >> x >> y;
if(j>0) lines[i].push_back(P(x-px,y-py));
px = x;
py = y;
}
compress(lines[i]);
}
for(int i=1;i<=n;i++){
bool same = false;
if(lines[0].size() != lines[i].size()) continue;
for(int j=0;j<2;j++){
for(int k=0;k<4;k++){
same |= lines[0] == lines[i];
rotate90(lines[i]);
}
rev(lines[i]);
}
if(same) cout << i << endl;
}
cout << "+++++" << endl;
return 0;
}
int main(){
while(solve()==0);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<pair<int, int> > ans[111];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) ans[i].push_back(make_pair(i, i));
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
ans[x].push_back(make_pair(n + i, x));
ans[y].push_back(make_pair(n + i, y));
}
for (int i = 1; i <= n; i++) {
printf("%d\n", ans[i].size());
for (int j = 0; j < (int)ans[i].size(); j++)
printf("%d %d\n", ans[i][j].first, ans[i][j].second);
}
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int a,b,c;
scanf("%d %d %d",&a,&b,&c);
if(a%2==1||b%2==1||c%2==1)
{
printf("0\n");
return 0;
}
for(int i=1;i<=1000000;i++)
{
int na=(b+c)/2,nb=(a+c)/2,nc=(b+c)/2;
if(na%2==1||nb%2==1||nc%2==1)
{
printf("%d\n",i);
return 0;
}
a=na;
b=nb;
c=nc;
}
printf("-1");
} | 0 |
#include <bits/stdc++.h>
using namespace std;
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cout << *it << " = " << a << endl;
err(++it, args...);
}
const long long int nax = 1e5 + 5;
long long int n, m, ans;
vector<long long int> d;
vector<vector<long long int> > g;
void dfs(long long int u, long long int v) {
d[u] = 1;
for (auto x : g[u]) {
if (x == v) continue;
dfs(x, u);
ans = max(ans, d[x] + d[u]);
d[u] = max(d[u], d[x] + 1);
}
}
void solve() {
cin >> n >> m;
d = vector<long long int>(n, 0);
g = vector<vector<long long int> >(n + 5);
for (long long int i = 0, u, v; i < m; i++) {
cin >> u >> v;
u--, v--;
g[u].push_back(v), g[v].push_back(u);
}
ans = 0;
dfs(0, -1);
cout << ans - 1;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t = 1;
while (t--) solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
using namespace std;
constexpr long long int M = 1e9 + 7;
long long int inv(long long int a, long long int b = M) {
return 1 < a ? b - inv(b % a, a) * b / a : 1;
}
long long int f[200010], fi[200010];
long long int dp[2010];
long long int choose(long long int n, long long int k) {
return f[n] * fi[n - k] % M * fi[k] % M;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
f[0] = fi[0] = 1;
for (long long int i = 1; i < 200010; ++i) {
f[i] = f[i - 1] * i % M;
fi[i] = fi[i - 1] * inv(i) % M;
}
long long int h, w;
cin >> h >> w;
long long int n;
cin >> n;
vector<pair<long long int, long long int>> points;
for (long long int i = 0; i < n; ++i) {
long long int x, y;
cin >> y >> x;
points.push_back({y - 1, x - 1});
}
points.push_back({h - 1, w - 1});
sort(points.begin(), points.end());
for (long long int i = 0; i <= n; ++i) {
dp[i] = choose((points[i].second) + (points[i].first), (points[i].second));
for (long long int j = 0; j <= n; ++j) {
if (i == j || !((points[j].second) <= (points[i].second) &&
(points[j].first) <= (points[i].first)))
continue;
long long int ways = dp[j] *
choose((points[i].second) - (points[j].second) +
(points[i].first) - (points[j].first),
(points[i].second) - (points[j].second)) %
M;
dp[i] = (dp[i] - ways + M) % M;
}
}
cout << dp[n] << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int N, K, S, i, ans=0; cin >> N >> K >> S;
for(i=0; i<K; i++){ cout << S << " "; }
if(S<=2){ for(i=K; i<N; i++){ cout << S+1 << " "; } }
else{ for(i=K; i<N; i++){ cout << S-1 << " "; } }
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const int maxn = 1e5+23;
int a[maxn];
const int mod = 1e9+7;
int n,k;
int fac[maxn],inv[maxn];
int qpow(int a,int b)
{
int ans=1;
while(b){
if(b&1) ans=1ll*ans*a%mod;
b>>=1;
a=1ll*a*a%mod;
}
return ans;
}
int comb(int i,int j)
{
if(i<j) return 0;
return 1ll*fac[i]*inv[j]%mod*inv[i-j]%mod;
}
int main()
{
cin>>n>>k;
fac[0]=1;
for(int i=1;i<=n;i++) fac[i]=1ll*fac[i-1]*i%mod;
inv[n]=qpow(fac[n],mod-2);
for(int i=n-1;i>=0;i--) inv[i]=1ll*inv[i+1]*(i+1)%mod;
for(int i=0;i<n;i++) scanf("%d",a+i);
sort(a,a+n);ll ans=0;
for(int i=n-1;i>=0;i--){
ans=(ans+1ll*a[i]*comb(i,k-1)%mod)%mod;
}
for(int i=0;i<n;i++){
ans=(ans-1ll*a[i]*comb(n-i-1,k-1)%mod+mod)%mod;
}
cout<<ans;
}
| 0 |
// Ref : https://book.mynavi.jp/ec/products/detail/id=35408
#include <iostream>
#include <string>
#include <algorithm>
#include <vector>
using namespace std;
int n, pos;
vector<int> pre, in, post;
void rec(int l, int r) {
if (l >= r) return;
int root = pre[pos++];
int m = distance(in.begin(), find(in.begin(), in.end(), root));
rec(l, m);
rec(m + 1, r);
post.push_back(root);
}
void solve() {
pos = 0;
rec(0, pre.size());
for (int i = 0; i < n; i++) {
if ( i ) cout << " ";
cout << post[i];
}
cout << endl;
}
int main() {
int cache;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> cache;
pre.push_back(cache);
}
for (int i = 0; i < n; i++) {
cin >> cache;
in.push_back(cache);
}
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(10);
int n;
while (cin >> n, n) {
vector<string> f(n);
vector<int> w(n), s(n), ord(n);
for (int i = 0; i < n; i++) {
cin >> f[i] >> w[i] >> s[i];
ord[i] = i;
}
double G = 1e9;
vector<int> ans(n);
do {
int sum = 0, no = 0;
for (int i = n - 1; i >= 0; i--) {
if (s[ord[i]] < sum) no++;
sum += w[ord[i]];
}
if (no) continue;
int tmp = 0;
for (int i = 0; i < n; i++) {
tmp += (i + 1) * w[ord[i]];
}
double g = 1. * tmp / sum;
if (G - g > 1e-10) {
G = g;
ans = ord;
}
} while (next_permutation(ord.begin(), ord.end()));
for (int i = 0; i < n; i++) {
cout << f[ans[i]] << endl;
}
}
return 0;
}
| 0 |
#include<bits/stdc++.h>
#define mo 1000000007
using namespace std;
long long read(){
long long xx=0,flagg=1;
char ch=getchar();
while((ch<'0'||ch>'9')&&ch!='-')
ch=getchar();
if(ch=='-'){
flagg=-1;
ch=getchar();
}
while(ch>='0'&&ch<='9'){
xx=xx*10+ch-'0';
ch=getchar();
}
return xx*flagg;
}
void pus(long long xx,long long flagg){
if(xx<0){
putchar('-');
xx=-xx;
}
if(xx>=10)
pus(xx/10,0);
putchar(xx%10+'0');
if(flagg==1)
putchar(' ');
if(flagg==2)
putchar('\n');
return;
}
long long n,m,i,j,f[5005][5005],sum;
int main(){
n=read();m=read();
f[0][m]=1;
for(i=1;i<=n;i++){
sum=0;
for(j=m;j>=1;j--){
f[i][j]=(sum*j+f[i-1][j]*(j+1))%mo;
sum=(sum*2+f[i-1][j])%mo;
}
}
sum=0;
for(i=1;i<=m;i++)
sum=(sum+f[n][i])%mo;
pus(sum,2);
return 0;
}
| 0 |
#include<cstdio>
#include<iostream>
#include<string>
using namespace std;
int main() {
string t;
while(getline(cin,t)) {
for(int i = 0; i < 26; i++) {
for(int j = 0; j < t.size(); j++) {
if(t[j] == ' ' || t[j] == '.') continue;
t[j] += 1;
if(t[j] > 'z') t[j] -= 26;
}
if(t.find("the") != string::npos || t.find("that") != string::npos || t.find("this") != string::npos) {
cout << t << endl;
break;
}
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N , K;
cin >> N >> K;
if(K == 1)
cout << 0;
else
cout << N-K;
} | 0 |
#include<iostream>
#include<bits/stdc++.h>
#define ll long long
#define pb push_back
#define mod 1000000007
using namespace std;
bool is_sorted(ll a[],ll n)
{
for(ll i=1;i<n;i++)
if(a[i]<a[i-1])
return false;
return true;
}
int main()
{
#ifndef ONLINE_JUDGE
//for getting input from file input.txt
freopen("input.txt","r",stdin);
//for writing output to output.txt
freopen("output.txt","w",stdout);
#endif
ios_base::sync_with_stdio(false); cin.tie(NULL);
ll t,i;
cin>>t;
while(t--)
{
ll n,i,x;
cin>>n>>x;
ll a[n];
for(i=0;i<n;i++)
cin>>a[i];
ll ans=0;
for(i=0;i<n;i++)
{
if(is_sorted(a,n))
{
cout<<ans<<endl;
break;
}
if(a[i]<=x)
continue;
else
swap(a[i],x),ans++;
}
if(i==n)
cout<<-1<<endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int prime[103];
int dp[300003][103];
long long dfs(long long n, int m) {
if (prime[0] == 1 || n == 0) return 0;
if (n < 300001 && dp[n][m] > -1) return dp[n][m];
long long ans = 0;
if (m == 0)
ans = n;
else
ans = dfs(n, m - 1) - dfs(n / prime[m - 1], m - 1);
if (n < 300001) return dp[n][m] = ans;
return ans;
}
int main() {
int i, m;
long long n;
memset(dp, -1, sizeof(dp));
scanf("%I64d %d", &n, &m);
for (i = 0; i < m; i++) scanf("%d", prime + i);
sort(prime, prime + m);
cout << dfs(n, m) << endl;
return 0;
}
| 5 |
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int INF = 1e9;
const ll LINF = 1e18;
template<class S,class T> ostream& operator << (ostream& out,const pair<S,T>& o){ out << "(" << o.first << "," << o.second << ")"; return out; }
template<class T> ostream& operator << (ostream& out,const vector<T> V){ for(int i = 0; i < V.size(); i++){ out << V[i]; if(i!=V.size()-1) out << " ";} return out; }
template<class T> ostream& operator << (ostream& out,const vector<vector<T> > Mat){ for(int i = 0; i < Mat.size(); i++) { if(i != 0) out << endl; out << Mat[i];} return out; }
template<class S,class T> ostream& operator << (ostream& out,const map<S,T> mp){ out << "{ "; for(auto it = mp.begin(); it != mp.end(); it++){ out << it->first << ":" << it->second; if(mp.size()-1 != distance(mp.begin(),it)) out << ", "; } out << " }"; return out; }
/*
<url:https://onlinejudge.u-aizu.ac.jp/services/room.html#ACPC2018Day2/problems/C>
問題文============================================================
=================================================================
解説=============================================================
長さNの数列Aを循環列として考える。
今回のクエリでのスワップとは、循環列での始点を変更するに等しい
================================================================
*/
int main(void) {
cin.tie(0); ios_base::sync_with_stdio(false);
ll N,Q; cin >> N >> Q;
ll from = 0;
while(Q--){
ll com,k; cin >> com >> k;
if(com == 1){
from = (from + k)%N;
}else{
ll out = (from + k)%N;
if(out == 0) out = N;
cout << out << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 310;
int n, tot;
vector<int> edges[MAX];
vector<int> path[MAX][MAX];
vector<int> ans;
bool vis[MAX];
vector<int> p;
int root;
void get_tot(int v) {
vis[v] = 1;
bool is = 1;
for (int u : edges[v]) {
if (!vis[u]) {
get_tot(u);
is = 0;
}
}
tot += is;
}
void dfs(int v) {
vis[v] = 1;
p.push_back(v);
for (int u : p) {
path[root][v].push_back(u);
}
for (int u : edges[v]) {
if (!vis[u]) {
dfs(u);
}
}
p.pop_back();
}
int main() {
cin >> n;
for (int i = 0; i < n - 1; ++i) {
int u, v;
cin >> u >> v;
u--, v--;
edges[u].push_back(v);
edges[v].push_back(u);
}
for (int i = 0; i < n; ++i) {
root = i;
dfs(i);
for (int j = 0; j < n; ++j) {
vis[j] = 0;
}
}
get_tot(0);
int start = 0, leaf;
for (int i = 0; i < tot; ++i) {
cin >> leaf;
leaf--;
for (int i = 1; i < ((int)(path[start][leaf]).size()); ++i) {
ans.push_back(path[start][leaf][i] + 1);
}
start = leaf;
}
for (int i = 1; i < ((int)(path[start][0]).size()); ++i) {
ans.push_back(path[start][0][i] + 1);
}
if (((int)(ans).size()) + 1 > 2 * n - 1) {
cout << -1;
} else {
cout << 1 << ' ';
for (int u : ans) {
cout << u << ' ';
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char a[300];
int main() {
scanf("%s", a);
int n;
n = strlen(a);
int i;
int flag = 0;
int sum = 0;
for (i = 0; i < n; i++) {
if (a[0] == '@' || a[n - 1] == '@' || (a[i + 1] == '@' && a[i] == '@') ||
(a[i + 2] == '@' && a[i] == '@'))
flag = 1;
if (a[i] == '@') sum++;
}
if (flag == 1 || sum == 0)
printf("No solution\n");
else {
printf("%c", a[0]);
int sum1 = 0;
for (i = 1; i < n; i++) {
printf("%c", a[i]);
if (a[i - 1] == '@') {
sum1++;
if (sum1 < sum) printf(",");
}
}
printf("\n");
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char s[2021];
bool tog1, tog2;
int t1, t2;
int main() {
cin >> s;
t2 = strlen(s);
for (int i = 0; s[i]; i++) {
if (i && s[i] == s[i - 1] && s[i] == '.') {
puts("NO");
return 0;
}
if (i && s[i] == s[i - 1] && s[i] == '/') {
puts("NO");
return 0;
}
if (s[i] == '@') {
if (!tog1 && i)
tog1 = true, t1 = i;
else {
puts("NO");
return 0;
}
}
if (s[i] == '/') {
if (!tog2 && i && tog1)
tog2 = true, t2 = i;
else {
puts("NO");
return 0;
}
}
}
if (!tog1) {
puts("NO");
return 0;
}
if (t1 > 16) {
puts("NO");
return 0;
}
for (int i = 0; i < t1; i++) {
if ((s[i] >= 'a' && s[i] <= 'z') || (s[i] >= 'A' && s[i] <= 'Z') ||
(s[i] >= '0' && s[i] <= '9') || s[i] == '_')
continue;
else {
puts("NO");
return 0;
}
}
if (t2 - t1 <= 1) {
puts("NO");
return 0;
}
if (t2 - t1 - 1 > 32 || t2 - t1 - 1 < 0) {
puts("NO");
return 0;
}
int len1 = 0;
for (int i = t1 + 1; i < t2; i++) {
if ((s[i] >= 'a' && s[i] <= 'z') || (s[i] >= 'A' && s[i] <= 'Z') ||
(s[i] >= '0' && s[i] <= '9') || s[i] == '_')
len1++;
else if (s[i] == '.') {
if (len1 <= 0 || len1 > 16 || i == t2 - 1) {
puts("NO");
return 0;
} else
len1 = 0;
} else {
puts("NO");
return 0;
}
if (len1 > 16) {
puts("NO");
return 0;
}
}
int len2 = 0;
if (tog2) {
if (!s[t2 + 1]) {
puts("NO");
return 0;
}
for (int i = t2 + 1; s[i]; i++)
if ((s[i] >= 'a' && s[i] <= 'z') || (s[i] >= 'A' && s[i] <= 'Z') ||
(s[i] >= '0' && s[i] <= '9') || s[i] == '_')
len2++;
else {
puts("NO");
return 0;
}
if (len2 < 0 || len2 > 16) {
puts("NO");
return 0;
}
}
puts("YES");
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
ifstream fin("frac1.in");
ofstream fout("frac1.out");
class compare : public std::binary_function<double, double, bool> {
public:
compare(double arg = 1e-7) : e(arg) {}
bool operator()(const double &left, const double &right) const {
return (abs(left - right) > e) && (left < right);
}
double e;
};
inline int d_compare(double x, double y) {
return (fabs(x - y) <= 1e-7) ? 0 : (x > y) ? 1 : -1;
}
inline int mod(long long x, int y) {
if (y == 0) return x;
if (x < 0) x = -x;
if (x >= y) x %= y;
return x;
}
inline int cmod(int x, int y) {
if (y == 0) return x;
if (x < 0) x += (abs(x) / y + 1) * y;
if (x >= y) x = x % y;
return x;
}
int Bcount(int mask) {
int n = 0;
while (mask) n += ((mask & -mask) != 0), mask &= ~(mask & -mask);
return n;
}
inline bool Bstate(int mask, int idx) { return (mask & (1 << idx)); }
inline int B1(int mask, int idx) { return mask | (1 << idx); }
inline int B0(int mask, int idx) { return mask & ~(1 << idx); }
inline int drift(int mask, int n) { return mask & ((1 << n) - 1); }
void debugmask(int mask, int n) {
for (int i = 0; i < n; i++) cout << Bstate(mask, i);
}
int dr[4] = {0, 0, -1, 1}, dc[4] = {-1, 1, 0, 0};
template <typename Ty>
void clear(Ty &q) {
Ty empty;
swap(q, empty);
}
int main() {
deque<int> s;
stack<int> temp;
int n, m;
int w[501];
int vis[501] = {0};
int o[1001];
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> w[i + 1];
for (int i = 0; i < m; i++) {
cin >> o[i];
if (!vis[o[i]]) s.push_back(o[i]), vis[o[i]] = 1;
}
int ans = 0;
for (int i = 0; i < m; i++) {
while (s.front() != o[i]) {
ans += w[s.front()];
temp.push(s.front());
s.pop_front();
}
s.pop_front();
while (!temp.empty()) {
s.push_front(temp.top());
temp.pop();
}
s.push_front(o[i]);
}
cout << ans << endl;
return 0;
}
| 3 |
//#pragma GCC target("avx2")
//#pragma GCC optimize("O3")
//#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
#define ll long long
#define ld long double
#define rep(i, n) for(ll i = 0; i < n; ++i)
#define rep2(i, a, b) for(ll i = a; i <= b; ++i)
#define rrep(i, a, b) for(ll i = a; i >= b; --i)
#define pii pair<int, int>
#define pll pair<ll, ll>
#define fi first
#define se second
#define pb push_back
#define eb emplace_back
#define vi vector<int>
#define vll vector<ll>
#define vpii vector<pii>
#define vpll vector<pll>
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define endl '\n'
using namespace std;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
const int MOD=1000000007;
//const int MOD=998244353;
const ll INF=9223372036854775807;
const int inf=2147483647;
const double PI=acos(-1);
int dx[8] = {1,0,-1,0,1,1,-1,-1};
int dy[8] = {0,1,0,-1,-1,1,1,-1};
const int MAX = 310000;
using Graph = vector<vector<int>>;
Graph G;
signed main(){
cin.tie(0);
ios::sync_with_stdio(false);
ll n;
cin >> n;
if(n%2 == 1){
n++;
n/=2;
ll num = n*(n+1)/2;
num*=4;
cout << num << endl;
}
else{
n /= 2;
n++;
ll num = n*n;
cout << num << endl;
}
return 0;
} | 2 |
#include <bits/stdc++.h>
using namespace std;
bool in[2001][2001];
int x[3000], y[3000], n, i, j, ans;
int main() {
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d%d", x + i, y + i);
in[x[i] + 1000][y[i] + 1000] = true;
}
for (i = 0; i < n; i++)
for (j = 0; j < i; j++)
if (~(x[i] ^ x[j]) & 1 && ~(y[i] ^ y[j]) & 1 &&
in[(x[i] + x[j]) / 2 + 1000][(y[i] + y[j]) / 2 + 1000])
ans++;
printf("%d\n", ans);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int a[maxn];
pair<int, int> b[maxn];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> b[i].first;
}
for (int i = 0; i < n; i++) {
cin >> b[i].second;
}
sort(b, b + n);
for (int i = 0; i < n; i++) cout << b[i].second << " ";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(int a, int b) {
if (!b) return a;
return gcd(b, a % b);
}
bool isprime(long long n) {
if (n == 2) {
return true;
}
if (n % 2 == 0) {
return false;
}
for (long long i = 3; i <= sqrt(n); i += 2) {
if (n % i == 0) {
return false;
}
}
return true;
}
int main() {
int n;
double k;
cin >> n >> k;
double a[n];
double sum = 0;
for (int(i) = (0); (i) < (n); (i)++) {
cin >> a[i];
sum += a[i];
}
double d = floor((n * k - 0.5 * n - sum) / 0.5);
cout << max(d, 0.0);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int N, K;
long long ans = 0;
int arr[1000005];
pair<int, int> srt[1000005];
set<int> st;
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> N >> K;
for (int i = 1; i <= N; i++) {
cin >> arr[i];
ans -= arr[i];
srt[i] = {arr[i], i};
}
sort(srt + 1, srt + 1 + N, greater<pair<int, int>>());
st.insert(0), st.insert(N + 1);
for (int i = 1; i <= N; i++) {
auto it = st.lower_bound(srt[i].second);
int r = *it, l = *(--it);
r--, l++;
int p = srt[i].second, v = srt[i].first;
int mn = min(r - p, p - l), mx = max(r - p, p - l);
mn++, mx++;
long long l1 = (mn - 1) / (K - 1);
long long cnt = (2 + l1 * (K - 1)) * (l1 + 1) / 2;
long long l2 = (mx - 1) / (K - 1);
cnt += (l2 - l1) * (mn);
long long l3 = (r - l) / (K - 1);
if (l2 != l3) {
long long k = (r - l + 1) - (l3) * (K - 1);
cnt += (2 * k + (l3 - l2 - 1) * (K - 1)) * (l3 - l2) / 2;
}
ans += cnt % 1000000007 * v;
ans %= 1000000007;
st.insert(p);
}
cout << ans << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T rin(T &r) {
int b = 1, c = getchar();
r = 0;
while (c < '0' || '9' < c) b = c == '-' ? -1 : b, c = getchar();
while ('0' <= c && c <= '9')
r = (r << 1) + (r << 3) + (c ^ '0'), c = getchar();
return r *= b;
}
template <class T>
inline void wri(const T &r) {
if (r < 10)
putchar(char('0' + r));
else
wri(r / 10), putchar(char('0' + r % 10));
}
const int PRES[] = {3, 5, 17, 257, 641, 65537, 6700417};
const int SQRPRES[] = {2, 3, 5, 17, 26, 257, 2589};
const unsigned long long CONF = 18446744073709551615ull;
int ncas;
unsigned long long varr[10];
int nontag[10];
unsigned long long nim[256][256];
unsigned long long nimMul(unsigned long long a, unsigned long long b,
unsigned long long L = 64) {
if (a <= 1 || b <= 1) return a * b;
if (a < 256 && b < 256 && nim[a][b]) return nim[a][b];
unsigned long long S = (1ull << L) - 1;
if (a <= S && b <= S) return nimMul(a, b, L >> 1);
unsigned long long A = nimMul(a >> L, b >> L, L >> 1),
B = nimMul((a >> L) ^ (a & S), (b >> L) ^ (b & S), L >> 1),
C = nimMul(a & S, b & S, L >> 1);
S++;
unsigned long long r = nimMul(A, S >> 1, L >> 1) ^ (S * (C ^ B)) ^ C;
if (a < 256 && b < 256) nim[a][b] = r;
return r;
}
unsigned long long nimPow(unsigned long long a, unsigned long long b) {
unsigned long long r = 1;
while (b) {
if (b & 1) r = nimMul(a, r);
a = nimMul(a, a), b >>= 1;
}
return r;
}
int solve(const unsigned long long &a, const unsigned long long &b,
const int &conp, const int &consqr) {
unsigned long long x = nimPow(a, CONF / conp), y = nimPow(b, CONF / conp);
map<unsigned long long, int> mem;
unsigned long long tmp = y;
for (int i = 0; i <= consqr; i++, tmp = nimMul(tmp, x))
if (!mem.count(tmp)) mem[tmp] = i;
tmp = 1;
unsigned long long tmp_per = nimPow(x, consqr);
for (int i = 0; i <= consqr; i++, tmp = nimMul(tmp, tmp_per))
if (mem.count(tmp) && i * consqr >= mem[tmp]) return i * consqr - mem[tmp];
return -1;
}
int main() {
rin(ncas);
while (ncas--) {
unsigned long long a, b;
rin(a), rin(b);
bool fai = false;
memset(nontag, false, sizeof nontag);
for (int i = 0; i < 7; i++) {
int res = solve(a, b, PRES[i], SQRPRES[i]);
if (res == -2) {
nontag[i] = true;
continue;
}
if (res == -1) {
fai = true;
break;
}
varr[i] = res;
unsigned long long _b = nimMul(b, nimPow(a, CONF - res)),
_a = nimPow(a, PRES[i]);
a = _a, b = _b;
}
if (a != b || nimMul(a, a) != b) fai = true;
if (fai)
printf("-1\n");
else {
unsigned long long x = 0, mod = 1;
for (int i = 6; ~i; i--) {
if (nontag[i]) continue;
mod *= PRES[i];
x = x * PRES[i] + varr[i];
if (x < 0) x += mod;
}
wri(x), putchar('\n');
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long double pi = 3.14159265359;
template <typename T>
T abs(T x) {
return x > 0 ? x : -x;
}
template <typename T>
T sqr(T x) {
return x * x;
}
const int maxn = 405 * 4;
char isV[maxn];
vector<int> g[maxn];
vector<int> gt[maxn];
int enc(int v, int vo, int neg) { return v * 4 + vo * 2 + neg; }
void add(int u, int v) {
g[u].push_back(v);
gt[v].push_back(u);
}
void remove(int u, int v) {
g[u].pop_back();
gt[v].pop_back();
}
vector<int> order;
int used[maxn];
void dfs(int v) {
used[v] = 1;
for (int to : g[v]) {
if (!used[to]) {
dfs(to);
}
}
order.push_back(v);
}
int comp[maxn];
int cc = 0;
void dfs2(int v) {
comp[v] = cc;
for (int to : gt[v]) {
if (comp[to] == -1) {
dfs2(to);
}
}
}
bool check() {
fill(comp, comp + maxn, -1);
fill(used, used + maxn, 0);
cc = 0;
order.clear();
for (int i = 0; i < maxn; i++) {
if (!used[i]) {
dfs(i);
}
}
reverse(order.begin(), order.end());
for (int v : order) {
if (comp[v] == -1) {
cc++;
dfs2(v);
}
}
for (int i = 0; i < maxn; i++) {
if (comp[i] == comp[i ^ 1]) {
return false;
}
}
return true;
}
char alp[26];
int asz;
char s[maxn];
int main() {
srand(time(NULL));
scanf("%s\n", alp);
asz = strlen(alp);
for (int i = 0; i < asz; i++) {
isV[i] = alp[i] == 'V';
}
int n, m;
scanf("%d %d\n", &n, &m);
for (int i = 0; i < n; i++) {
add(enc(i, 0, 0), enc(i, 1, 1));
add(enc(i, 0, 1), enc(i, 1, 0));
add(enc(i, 1, 0), enc(i, 0, 1));
add(enc(i, 1, 1), enc(i, 0, 0));
}
for (int i = 0; i < m; i++) {
char c1, c2;
int u, v;
scanf("%d %c %d %c\n", &u, &c1, &v, &c2);
u--, v--;
add(enc(u, c1 == 'V', 0), enc(v, c2 == 'V', 0));
add(enc(v, c2 == 'V', 1), enc(u, c1 == 'V', 1));
}
scanf("%s", s);
if (!check()) {
cout << -1 << endl;
return 0;
}
for (int i = n; i >= 0; i--) {
for (int j = 0; j < i; j++) {
add(enc(j, isV[s[j] - 'a'], 1), enc(j, isV[s[j] - 'a'], 0));
}
bool good = false;
int kk;
if (i != n) {
bool wasV = false, wasC = false;
for (int k = s[i] - 'a' + 1; k < asz; k++) {
if (wasV && isV[k]) {
continue;
}
if (wasC && !isV[k]) {
continue;
}
if (isV[k]) {
wasV = true;
} else {
wasC = true;
}
add(enc(i, isV[k], 1), enc(i, isV[k], 0));
if (check()) {
good = true;
kk = k;
break;
}
remove(enc(i, isV[k], 1), enc(i, isV[k], 0));
}
} else {
good = check();
}
string ans;
if (good) {
for (int j = 0; j < i; j++) {
ans += s[j];
}
if (i != n) {
ans += char('a' + kk);
}
vector<pair<int, int>> hh;
for (int j = i + 1; j < n; j++) {
bool wasV = false, wasC = false;
for (int k = 0; k < asz; k++) {
if (wasV && isV[k]) {
continue;
}
if (wasC && !isV[k]) {
continue;
}
if (isV[k]) {
wasV = true;
} else {
wasC = true;
}
add(enc(j, isV[k], 1), enc(j, isV[k], 0));
hh.push_back(make_pair(enc(j, isV[k], 1), enc(j, isV[k], 0)));
if (check()) {
ans += char('a' + k);
break;
}
remove(enc(j, isV[k], 1), enc(j, isV[k], 0));
hh.pop_back();
}
}
if (ans.size() != n) {
reverse(hh.begin(), hh.end());
for (auto x : hh) {
remove(x.first, x.second);
}
if (i != n) {
remove(enc(i, isV[kk], 1), enc(i, isV[kk], 0));
}
} else {
cout << ans << endl;
return 0;
}
}
for (int j = i - 1; j >= 0; j--) {
remove(enc(j, isV[s[j] - 'a'], 1), enc(j, isV[s[j] - 'a'], 0));
}
}
cout << -1 << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, t, a[1005], maxn = -99999999;
string s[1005];
map<string, int> k, kp;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s[i] >> a[i];
k[s[i]] += a[i];
}
for (int i = 0; i < n; i++) {
maxn = max(maxn, k[s[i]]);
}
for (int i = 0; i < n; i++) {
kp[s[i]] += a[i];
if (k[s[i]] == maxn && kp[s[i]] >= maxn) {
s[0] = s[i];
break;
}
}
cout << s[0] << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> a[1005];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i].first);
a[i].second = i;
}
sort(a, a + n, greater<pair<int, int>>());
int res = 0;
for (int i = 0; i < n; i++) res += i * a[i].first + 1;
printf("%d\n", res);
for (int i = 0; i < n; i++) {
if (i == 0)
printf("%d", a[i].second + 1);
else
printf(" %d", a[i].second + 1);
}
printf("\n");
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, ans = 2000000000, x, y;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> x >> y;
ans = min(ans, y - x + 1);
}
cout << ans << endl;
for (int i = 0; i < n; i++) cout << i % ans << " ";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, t;
cin >> n;
t = sqrt(n);
long long m = n;
for (int i = 2; i < t + 1; i++) {
if (n % i == 0) {
m = i;
break;
}
}
if (m != n)
cout << (n - m) / 2 + 1;
else
cout << n / m;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char gc() {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
long long read() {
char ch = getchar();
long long x = 0;
int op = 1;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') op = -1;
for (; isdigit(ch); ch = getchar()) x = (x << 1) + (x << 3) + ch - '0';
return x * op;
}
int n;
int ask(int x, int y) {
printf(y ? "! " : "? ");
printf("%d\n", x);
fflush(stdout);
if (!y)
return read();
else
exit(0);
}
int main() {
n = read();
if (n % 4 == 2) ask(-1, 1);
int x = ask(1, 0), y = ask(1 + n / 2, 0);
int l = 2, r = n / 2, mid;
while (l <= r) {
mid = l + r >> 1;
int a = ask(mid, 0), b = ask(mid + n / 2, 0);
if (a == b) ask(mid, 1);
if ((a < b) ^ (x < y))
r = mid - 1;
else
l = mid + 1;
}
ask(-1, 1);
return 0;
}
| 2 |
#include <iostream>
#include <stdio.h>
#include <math.h>
using namespace std;
int n;
double r[505];
double p[505];
int main(void)
{
cin >> n;
for(int i = 1; i <= n; i++) cin >> r[i];
p[1] = r[1];
for(int i = 2; i <= n; i++){
p[i] = r[i];
for(int j = 1; j < i; j++){
double r1 = r[i], r2 = r[j];
if(r1 > r2) swap(r1, r2);
double l = sqrt( (r1+r2)*(r1+r2)-(r2-r1)*(r2-r1) );
p[i] = max(p[i], p[j]+l);
}
}
double ans = 0;
for(int i = 1; i <= n; i++) ans = max(ans, p[i]+r[i]);
printf("%.11f\n", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long INF = 1e18;
const long long base = 311;
long long gcd(long long a, long long b) {
while (b != 0) {
long long r = a % b;
a = b;
b = r;
}
return a;
}
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
long long binmul(long long a, long long b) {
if (b == 0) return 0;
long long v = binmul(a, b / 2);
long long res = v + v;
if (res >= mod) res -= mod;
if (b % 2) {
res += a;
if (res >= mod) res -= mod;
}
return res;
}
long long binpow(long long a, long long b) {
if (b == 0) return 1;
long long v = binpow(a, b / 2);
if (b % 2) return v * v % mod * a % mod;
return v * v % mod;
}
long long bpowmul(long long a, long long b) {
if (b == 0) return 1;
long long v = bpowmul(a, b / 2);
if (b % 2) return binmul(binmul(v, v), a);
return binmul(v, v);
}
const int MaxN = 2e5 + 4;
long long n;
void solve() {
cin >> n;
cout << (n + 1) / 10 << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int test;
cin >> test;
while (test--) solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using lli = long long int;
using pll = pair<lli, lli>;
using vi = vector<lli>;
using vvi = vector<vi>;
using pii = tuple<lli, lli>;
using vii = vector<pii>;
using vvii = vector<vii>;
string TYPE(const int*) { return "%d"; }
string TYPE(const lli*) { return "%lld"; }
string TYPE(const char*) { return "%c"; }
string TYPE(const char**) { return "%s"; }
string TYPE(const unsigned int*) { return "%u"; }
const int MAX_BUF = 1000 * 1000 + 42;
char buf[MAX_BUF];
void RD() {}
template <typename T, typename... Args>
void RD(T* v, Args... args) {
scanf((" " + TYPE(v)).c_str(), v);
RD(args...);
}
template <typename... Args>
void RD(string* v, Args... args) {
scanf(" %s", buf);
(*v) = buf;
RD(args...);
}
void PR(bool nl = true) {
if (nl) printf("\n");
}
template <typename T, typename... Args>
void PR(bool nl, T v, Args... args) {
printf((TYPE(&v) + " ").c_str(), v);
PR(nl, args...);
}
template <typename... Args>
void PR(bool nl, string& v, Args... args) {
printf("%s", v.c_str());
PR(nl, args...);
}
template <typename... Args>
void PR(Args... args) {
PR(true, args...);
}
const long long int oo = 1000 * 1000 * 1000;
struct Coord {
int x, y;
Coord(int x = 0, int y = 0) : x(x), y(y) {}
Coord operator+(const Coord& droite) const {
return Coord(x + droite.x, y + droite.y);
}
};
struct AB {
int k;
vector<lli> arbre;
AB(int _k = 20, lli def = 0) {
k = _k;
for (lli i = 0; i < (lli)(1 << k); ++i)
arbre.push_back(i < (1 << (k - 1)) ? 0LL : def);
for (lli i = (((1 << (k - 1)) - 1)); i >= (lli)(1); --i)
arbre[i] = arbre[i << 1] + arbre[(i << 1) ^ 1];
}
void set(int i, lli x) {
int feuille = i + (1 << (k - 1));
arbre[feuille] = x;
iset(feuille >> 1);
}
void iset(int noeud) {
if (noeud) {
arbre[noeud] = arbre[noeud << 1] + arbre[(noeud << 1) ^ 1];
iset(noeud >> 1);
}
}
lli sum(int deb, int fin, int noeud = 1, int p = 0, int q = -1) {
if (q < p) q = 1 << (k - 1);
if (deb <= p && q <= fin) return arbre[noeud];
if (deb >= q || fin <= p) return 0LL;
int mil = (p + q) / 2;
return sum(deb, fin, noeud << 1, p, mil) +
sum(deb, fin, (noeud << 1) ^ 1, mil, q);
}
};
int n;
int nbP, nbG;
int main() {
RD(&n);
lli nimber = 0;
for (lli i = 0; i < (lli)(n); ++i) {
int tmp;
RD(&tmp);
int j = 0, s = 1;
while (s <= tmp) {
++j;
s += j + 1;
}
nimber ^= j;
}
PR(!nimber ? "YES" : "NO");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct UF {
int par[3005], rank[3005];
int cost[3005];
void init(int n) {
for (int i = 0; i < n; i++) {
par[i] = i;
rank[i] = cost[i] = 0;
}
}
void add(int k, int x) { cost[k] = x; }
int find(int x) {
if (x == par[x]) return x;
return par[x] = find(par[x]);
}
int unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y) return 0;
if (rank[x] < rank[y]) {
par[x] = y;
cost[y] += cost[x];
return cost[y];
} else {
par[y] = x;
cost[x] += cost[y];
if (rank[x] == rank[y]) rank[x]++;
return cost[x];
}
}
};
UF uf;
vector<pair<int, int> > vec[10005];
int main() {
int n;
scanf("%d", &n);
if (n == 1) {
puts("0");
return 0;
}
for (int i = 0; i < n - 1; i++) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
a--;
b--;
vec[c].push_back(pair<int, int>(a, b));
}
uf.init(n + 2);
int all = 0;
for (int i = 0; i < n; i++) {
int a;
scanf("%d", &a);
all += a;
uf.add(i, a + 1);
}
int ret = 1;
for (int i = 1; i < 10005; i++) {
int gt = 0;
for (int j = 0; j < vec[i].size(); j++) {
pair<int, int> p = vec[i][j];
gt = max(gt, uf.unite(p.first, p.second));
}
if (gt > all) break;
ret = i + 1;
}
printf("%d\n", ret);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
string a;
string b;
string c;
int ilea[550], ileb[550], ilec[550];
int wyn1, wyn2;
int ilez[550];
int aktu2;
int main() {
cin >> a;
cin >> b;
cin >> c;
for (int i = 0; i < a.size(); i++) {
ilea[a[i]]++;
}
for (int i = 0; i < b.size(); i++) {
ileb[b[i]]++;
}
for (int i = 0; i < c.size(); i++) {
ilec[c[i]]++;
}
for (int aktu1 = 0; aktu1 < (a.size() / b.size()); aktu1++) {
aktu2 = 0;
for (char i = 'a'; i <= 'z'; i++) {
ilez[i] = ilea[i] - aktu1 * ileb[i];
if (ilez[i] < 0) {
aktu2 = -1;
break;
}
}
if (aktu2 < 0) continue;
aktu2 = a.size() + 5;
for (char i = 'a'; i <= 'z'; i++) {
if (ilec[i]) aktu2 = min(aktu2, ilez[i] / ilec[i]);
}
if (aktu1 + aktu2 > wyn1 + wyn2) {
wyn1 = aktu1;
wyn2 = aktu2;
}
}
for (int i = 1; i <= wyn1; i++) {
for (int j = 0; j < b.size(); j++) {
printf("%c", b[j]);
ilea[b[j]]--;
}
}
for (int i = 1; i <= wyn2; i++) {
for (int j = 0; j < c.size(); j++) {
printf("%c", c[j]);
ilea[c[j]]--;
}
}
for (char i = 'a'; i <= 'z'; i++) {
for (int j = 0; j < ilea[i]; j++) printf("%c", i);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool checkbitt(long long int num, int pos);
long long int setbitt(long long int num, long long int pos);
long long int resetbitt(long long int num, int pos);
void read(int &a) { scanf("%d", &a); }
void read(int &a, int &b) { scanf("%d %d", &a, &b); }
void read(int &a, int &b, int &c) { scanf("%d %d %d", &a, &b, &c); }
void read(long long int &a) { scanf("%lld", &a); }
void read(long long int &a, long long int &b) { scanf("%lld %lld", &a, &b); }
void read(long long int &a, long long int &b, long long int &c) {
scanf("%lld %lld %lld", &a, &b, &c);
}
void read(int *aa, int sz) {
for (int i = 0; i < sz; i++) scanf("%d", (aa + i));
}
void read(long long int *aa, int sz) {
for (int i = 0; i < sz; i++) scanf("%lld", (aa + i));
}
void read(int *aa, int s, int e) {
for (int i = s; i < e + s; i++) scanf("%d", (aa + i));
}
const long long int mod = 1e9 + 7;
const long long int N = 1e6 + 10;
int maxia[N];
int maxib[N];
int solve() {
int n;
read(n);
int arr[n + 10];
read(arr, 1, n);
int problem[n + 10];
memset(problem, 0, sizeof(problem));
arr[n + 1] = INT_MAX;
arr[0] = -INT_MAX;
int res = -INT_MAX;
for (int i = n; i >= 1; i--) {
if (arr[i] < arr[i + 1]) {
maxia[i] = 1 + maxia[i + 1];
} else
maxia[i] = 1;
res = max(res, maxia[i]);
}
for (int i = 1; i <= n; i++) {
if (arr[i] > arr[i - 1]) {
maxib[i] = 1 + maxib[i - 1];
} else
maxib[i] = 1;
res = max(res, maxib[i]);
}
for (int i = n; i >= 2; i--) res = max(maxia[i] + 1, res);
for (int i = 1; i < n; i++) res = max(maxib[i] + 1, res);
maxib[n + 1] = 0;
maxia[0] = 0;
for (int i = 1; i <= n; i++) {
if (arr[i + 1] > arr[i - 1] + 1) {
res = max(res, maxia[i + 1] + maxib[i - 1] + 1);
}
}
cout << res << endl;
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int cs = 1;
int cn = 1;
while (cs--) {
solve();
}
}
bool checkbitt(long long int num, int pos) { return (num >> pos) & 1; }
long long int setbitt(long long int num, long long int pos) {
return (1 << pos) | num;
}
long long int resetbitt(long long int num, int pos) {
if (!checkbitt(num, pos))
return num;
else
return (1 << pos) ^ num;
}
| 3 |
#include <iostream>
using namespace std;
int main(){
int N, X, T;
cin >> N >> X >> T;
cout << (N+X-1)/X*T << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define int long long
int mod=1000000007;
int32_t main() {
int n;
cin>>n;
vector<int>a(64,0);
for(int j=0;j<n;j++){
int x;
cin>>x;
bitset<64>c(x);
for(int i=0;i<64;i++)
if(c.test(i))
a[i]++;
}
int ans=0;
int j=1;
for(int i=0;i<64;i++){
if(i!=0) {
j*=2;
j%=mod;
}
ans=(ans+j*(a[i]*(n-a[i])%mod))%mod;
}
cout<<ans<<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> ans;
int tmp, tp, a, b, u, v, n, m, to[500010], deep[500010], nxt[500010],
hd[500010], fa[100010], tofa[500010], num = -1, cf[500010];
bool tree[500010], vis[100010], flag;
void add(int u, int v) {
nxt[++num] = hd[u], to[num] = v, hd[u] = num;
nxt[++num] = hd[v], to[num] = u, hd[v] = num;
}
void dfs1(int pos, int f, int dp) {
fa[pos] = f;
vis[pos] = 1;
deep[pos] = dp;
for (int i = hd[pos]; i != -1; i = nxt[i]) {
if (!vis[to[i]]) {
tofa[to[i]] = i, tree[i] = 1;
dfs1(to[i], pos, dp + 1);
}
}
}
void dfs(int pos) {
vis[pos] = 1;
for (int i = hd[pos]; i != -1; i = nxt[i]) {
if (tree[i]) dfs(to[i]), cf[pos] += cf[to[i]];
}
}
int main() {
memset(hd, -1, sizeof hd);
memset(nxt, -1, sizeof nxt);
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &a, &b);
add(a, b);
}
for (int i = 1; i <= n; i++)
if (!vis[i]) dfs1(i, 0, 1);
for (int i = 0; i <= num; i += 2) {
if (tree[i] || tree[i + 1])
continue;
else
u = to[i], v = to[i + 1];
if (deep[u] < deep[v]) swap(u, v);
cf[u]++;
cf[v]--;
}
memset(vis, 0, sizeof vis);
for (int i = 1; i <= n; i++)
if (!vis[i]) dfs(i);
for (int i = 0; i <= num; i += 2) {
if (tree[i] || tree[i + 1])
continue;
else
u = to[i], v = to[i + 1];
if (deep[u] < deep[v]) swap(u, v);
flag = 0;
tmp = u;
for (; fa[tmp] != v; tmp = fa[tmp]) {
if (cf[tmp] != 1) {
flag = 1;
break;
}
}
if (!flag && cf[tmp] == 1) {
ans.push_back((i + 2) / 2);
while (u != v) {
ans.push_back((tofa[u] + 2) / 2);
u = fa[u];
}
}
}
sort(ans.begin(), ans.end());
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) cout << ans[i] << " ";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int h = 1e9, e = 1e9, l1 = 1e9, l2 = 1e9, o = 1e9;
int main() {
string s;
cin >> s;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'h') {
h = i;
break;
}
}
for (int i = h; i < s.size(); i++) {
if (s[i] == 'e') {
e = i;
break;
}
}
for (int i = e + 1; i < s.size(); i++) {
if (s[i] == 'l') {
l1 = i;
break;
}
}
for (int i = l1 + 1; i < s.size(); i++) {
if (s[i] == 'l') {
l2 = i;
break;
}
}
for (int i = l2 + 1; i < s.size(); i++) {
if (s[i] == 'o') {
o = i;
break;
}
}
if (h < s.size() && e < s.size() && l1 < s.size() && l2 < s.size() &&
o < s.size()) {
puts("YES");
} else {
puts("NO");
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a[102];
int l[102], r[102];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
long long bsum = 0;
for (int i = 1; i <= m; ++i) {
scanf("%d %d", &l[i], &r[i]);
long long snow = 0;
for (int j = l[i]; j <= r[i]; ++j) snow += a[j];
bsum += max(0LL, snow);
}
printf("%I64d", bsum);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 60;
struct Tree {
int val[maxn];
int N;
inline int lowbit(int x) { return x & (-x); }
void init(int n) {
N = n;
for (int i = 1; i <= n; i++) {
val[i] = 0;
}
}
void add(int pos, int v) {
while (pos > 0) {
val[pos] += v;
pos -= lowbit(pos);
}
}
int sum(int pos) {
int res = 0;
while (pos <= N) {
res += val[pos];
pos += lowbit(pos);
}
return res;
}
} T;
int saveori[maxn];
int saveans[maxn];
struct node {
int l, r;
int id;
bool operator<(const node &n) const {
if (r != n.r) {
return r < n.r;
} else {
return l < n.l;
}
}
} saveq[maxn];
int n, q;
int cjladd(int x, int r) {
int l = 1;
int pos = -1;
while (l <= r) {
int mid = l + r;
mid /= 2;
if (T.sum(mid) >= x) {
pos = mid;
l = mid + 1;
} else {
r = mid - 1;
}
}
return pos;
}
void solve() {
cin >> n >> q;
T.init(n + 10);
for (int i = 1; i <= n; i++) {
scanf("%d", &saveori[i]);
saveori[i] = i - saveori[i];
}
for (int i = 1; i <= q; i++) {
int x, y;
scanf("%d %d", &x, &y);
saveq[i].l = 1 + x;
saveq[i].r = n - y;
saveq[i].id = i;
}
sort(saveq + 1, saveq + 1 + q);
int nowrarr = 1;
for (int i = 1; i <= q; i++) {
node nownode = saveq[i];
while (nowrarr <= nownode.r) {
if (saveori[nowrarr] == 0) {
T.add(nowrarr, 1);
nowrarr++;
} else if (saveori[nowrarr] < 0) {
nowrarr++;
continue;
} else {
int d = cjladd(saveori[nowrarr], nowrarr);
if (d != -1) {
T.add(d, 1);
}
nowrarr++;
}
}
saveans[nownode.id] = T.sum(nownode.l);
}
for (int i = 1; i <= q; i++) {
cout << saveans[i] << endl;
}
}
int main() { solve(); }
| 5 |
#include <bits/stdc++.h>
using namespace std;
int i, j, k, n, m, t, K, an, num;
int fa[100010][20], dfn[100010], dep[100010], b[100010], g[100010], F[100010],
f[100010];
vector<int> a[100010], c[100010];
inline int lca(int x, int y) {
if (dep[x] > dep[y]) swap(x, y);
int i;
for (i = 19; i >= 0; i--)
if (dep[x] + (1 << i) <= dep[y]) y = fa[y][i];
if (x == y) return x;
for (i = 19; i >= 0; i--)
if (fa[x][i] != fa[y][i]) x = fa[x][i], y = fa[y][i];
return fa[x][0];
}
void dfs(int x, int y) {
dfn[x] = ++t;
for (auto i : a[x]) {
if (i == y) continue;
int j;
dep[i] = dep[x] + 1;
fa[i][0] = x;
for (j = 1; j <= 19; j++) fa[i][j] = fa[fa[i][j - 1]][j - 1];
dfs(i, x);
}
}
inline bool cc1(const int &A, const int &B) { return dfn[A] < dfn[B]; }
inline void Cl(int x) {
c[x].clear();
f[x] = 0;
}
inline void Add(int x, int y) {
if (x == y) return;
c[x].push_back(y);
}
void Dfs(int x, int y) {
int f1 = 0, f2 = 0;
for (auto i : c[x]) {
Dfs(i, x);
if (F[i] == num || f[i]) f1++;
if (fa[i][0] == x && F[i] == num) f2 = 1;
}
if (F[x] == num) {
if (f2)
an = -1;
else if (an >= 0)
an += f1;
} else {
if (f1 == 1) f[x] = 1;
if (f1 > 1) {
if (an >= 0) an++;
}
}
}
int main() {
scanf("%d", &n);
for (i = 1; i <= n - 1; i++) {
int x, y;
scanf("%d%d", &x, &y);
a[x].push_back(y);
a[y].push_back(x);
}
dfs(1, 0);
scanf("%d", &m);
for (i = 1; i <= m; i++) {
scanf("%d", &K);
++num;
for (j = 1; j <= K; j++) scanf("%d", &b[j]), F[b[j]] = num;
sort(b + 1, b + K + 1, cc1);
for (j = 1; j <= K; j++) Cl(b[j]);
int v = 0;
for (j = 1; j <= K; j++) {
for (; v > 1 && dfn[g[v - 1]] >= dfn[lca(g[v], b[j])]; v--) {
int A = lca(g[v - 1], g[v]);
if (A != g[v - 1]) Cl(A);
Add(A, g[v - 1]);
Add(A, g[v]);
g[v - 1] = A;
}
g[++v] = b[j];
}
for (; v > 1; v--) {
int A = lca(g[v], g[v - 1]);
if (A != g[v - 1]) Cl(A);
Add(A, g[v - 1]);
Add(A, g[v]);
g[v - 1] = A;
}
int root = g[1];
an = 0;
Dfs(root, 0);
printf("%d\n", an);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
int n, q;
bool f[100005];
bool a[3][100005];
void init() {
cin >> n >> q;
memset(f, 1, sizeof(f));
memset(a, 1, sizeof(a));
}
bool chk(int k) {
if (a[1][k] && a[1][k + 1]) return true;
if (a[2][k] && a[2][k + 1]) return true;
return false;
}
void exeCute() {
int nopass = 0;
for (int i = 1; i <= q; i++) {
int r, c;
cin >> r >> c;
if (a[r][c]) {
a[r][c] = !a[r][c];
if (c > 1) {
bool now = chk(c - 1);
if (!now && f[c - 1]) nopass++;
f[c - 1] = now;
}
if (c < n) {
bool now = chk(c);
if (!now && f[c]) nopass++;
f[c] = now;
}
} else {
a[r][c] = !a[r][c];
if (c > 1) {
bool now = chk(c - 1);
if (now && !f[c - 1]) nopass--;
f[c - 1] = now;
}
if (c < n) {
bool now = chk(c);
if (now && !f[c]) nopass--;
f[c] = now;
}
}
if (nopass == 0)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
int main(int argc, char* argv[]) {
init();
exeCute();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
int T;
T = 1;
while (T--) {
int n, i, j;
cin >> n;
int ar[n + 1], visited[n + 1];
for (i = 1; i <= n; ++i) {
cin >> ar[i];
visited[i] = 0;
}
int ct = 0;
for (i = 1; i <= n; ++i) {
if (visited[i] == 1)
continue;
else {
j = ar[i];
visited[j] = 1;
while (j != i) {
j = ar[j];
visited[j] = 1;
++ct;
}
}
}
if ((3 * n - ct) % 2 == 0)
cout << "Petr" << endl;
else
cout << "Um_nik" << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
#include <time.h>
using namespace std;
#define ll long long
#define ld long double
#define precision(x,d) cout<<fixed<<setprecision(d)<<x
#define all(x) x.begin(),x.end()
#define IOS ios_base::sync_with_stdio(false),cin.tie(0),cout.tie(0);srand(time(NULL));
#define MOD 1000000007
#define INF LONG_LONG_MAX
#define NINF LONG_LONG_MIN
#define endl "\n"
#define yes cout<<"YES"<<endl
#define no cout<<"NO"<<endl
#define db4(x,y,z,k) cout<<#x<<" : "<<x<<"\t"<<#y<<" : "<<y<<"\t"<<#z<<" : "<<z<<"\t"<<#k<<" : "<<k<<endl;
int main()
{
IOS;
ll t,n,m,k,u,v,x,y;
t=1;
cin >> t;
while(t--)
{
cin >> n;
vector<ll> a(n);
for(int i=0;i<n;i++)
cin >> a[i];
sort(all(a));
ll ans = 0;
for(int i=1;i<n;i++)
{
m = i;
ans -= m*a[i];
k = (n-i-1);
ans += k*a[i];
}
ans += a[n-1];
cout << ans << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const long double eps = 1e-7;
const int inf = 1000000010;
const long long INF = 10000000000000010LL;
const int mod = 1000000007;
const int MAXN = 100010;
int n, m, k, u, v, x, y, t, a, b, ans;
vector<int> vec[26];
string s;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> s;
for (int i = 0; i < s.size(); i++) vec[s[i] - 'A'].push_back(i & 1);
for (int i = 0; i < 26; i++) {
a = b = 0;
for (int x : vec[i]) {
if (x & 1)
a = max(a, b + 1);
else
b = max(b, a + 1);
}
ans = max(ans, max(a, b));
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
long long binpow(long long x, long long y) {
long long res = 1;
while (y > 0) {
if (y & 1) res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
long long binpowmod(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long mod_inverse(long long n, long long p) {
return binpowmod(n, p - 2, p);
}
long long gcd(long long x, long long y) {
if (y == 0) return x;
return gcd(y, x % y);
}
bool isPowerOfTwo(long long x) { return x && (!(x & (x - 1))); }
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);
}
};
void swap(int &x, int &y) {
int temp = x;
x = y;
y = temp;
}
unsigned int onesComplement(unsigned int n) {
int number_of_bits = floor(log2(n)) + 1;
return ((1 << number_of_bits) - 1) ^ n;
}
bool comp1(pair<int, int> x, pair<int, int> y) { return x.second < y.second; }
class cmp {
public:
bool operator()(pair<long long, long long> &a,
pair<long long, long long> &b) {
return abs(a.first) > abs(b.first);
}
};
void solve() {
long long n, k, x;
cin >> n >> k >> x;
vector<long long> a(n);
int cnt = 0;
for (int i = 0; i < n; ++i) {
cin >> a[i];
if (a[i] < 0) cnt++;
}
if (cnt % 2 == 0) {
int j = 0;
for (int i = 0; i < n; ++i) {
if (abs(a[i]) / x + 1 == abs(a[j]) / x + 1) {
if (abs(a[i]) < abs(a[j])) j = i;
} else if (abs(a[i]) / x + 1 < abs(a[j]) / x + 1) {
j = i;
}
}
if (abs(a[j]) / x + 1 <= k) {
long long tim = abs(a[j]) / x + 1;
if (a[j] < 0) {
a[j] += tim * x;
} else {
a[j] -= tim * x;
}
k -= tim;
} else {
int j = 0;
for (int i = 0; i < n; ++i) {
if (abs(a[i]) < abs(a[j])) j = i;
}
if (a[j] < 0) {
a[j] += k * x;
} else {
a[j] -= k * x;
}
for (long long &x : a) cout << x << ' ';
return;
}
}
priority_queue<pair<long long, long long>, vector<pair<long long, long long>>,
cmp>
pq;
for (int i = 0; i < n; ++i) pq.push({a[i], i});
while (k > 0) {
auto top = pq.top();
pq.pop();
if (top.first >= 0)
top.first += x;
else
top.first -= x;
a[top.second] = top.first;
pq.push(top);
k--;
}
for (long long &x : a) cout << x << ' ';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout << fixed << setprecision(15);
solve();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int t, n, lenn;
long long int last(long long int x) {
long long int tr = x;
lenn = 0;
while (x > 0) {
tr = x % 10;
x /= 10;
++lenn;
}
return tr;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> t;
long long int x, lllll;
while (t--) {
cin >> n;
lllll = last(n);
if (lenn == 1) {
x = 1;
} else if (lenn == 2) {
x = 3;
} else if (lenn == 3) {
x = 6;
} else {
x = 10;
}
cout << x + 10 * (lllll - 1) << "\n";
}
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
//BEGIN CUT HERE
template<typename T>
struct BIT2D{
int n,m;
T d;
vector<vector<T> > bit;
//1-indexed
BIT2D():n(-1),m(-1){}
BIT2D(int n_,int m_,T d_):n(n_),m(m_),d(d_),bit(n_+1,vector<T>(m+1,d_)){}
T sum(int i,int j){
T s=d;
for(int x=i;x>0;x-=(x&-x))
for(int y=j;y>0;y-=(y&-y))
s+=bit[x][y];
return s;
}
void add(int i,int j,T a){
if(i==0||j==0) return;
for(int x=i;x<=n;x+=(x&-x))
for(int y=j;y<=m;y+=(y&-y))
bit[x][y]+=a;
}
// (x1,x2] * (y1,y2];
T sum(int x1,int y1,int x2,int y2){
return sum(x1,y1)-sum(x1,y2)-sum(x2,y1)+sum(x2,y2);
}
};
//END CUT HERE
signed main(){
cin.tie(0);
ios::sync_with_stdio(0);
int h,w,t,q;
cin>>h>>w>>t>>q;
BIT2D<int> beet(h+100,w+100,0);
BIT2D<int> ushi(h+100,w+100,0);
typedef pair<int,int> P;
typedef pair<int,P> PP;
queue<PP> qq;
for(int i=0;i<q;i++){
int a,c,x1,y1;
cin>>a>>c>>x1>>y1;
while(!qq.empty()&&qq.front().first<=a){
P p=qq.front().second;qq.pop();
int x=p.first,y=p.second;
assert(beet.sum(x-1,y-1,x,y)==1);
beet.add(x,y,-1);
assert(ushi.sum(x-1,y-1,x,y)==0);
ushi.add(x,y,1);
}
if(c==0){
assert(beet.sum(x1-1,y1-1,x1,y1)==0);
beet.add(x1,y1,1);
qq.push(PP(a+t,P(x1,y1)));
}
if(c==1){
if(ushi.sum(x1-1,y1-1,x1,y1)==0) continue;
ushi.add(x1,y1,-1);
}
if(c==2){
int x2,y2;
cin>>x2>>y2;
x1--;y1--;
cout<<ushi.sum(x1,y1,x2,y2)<<" "<<beet.sum(x1,y1,x2,y2)<<endl;
}
}
return 0;
}
/*
verified on 2017/09/22
http://judge.u-aizu.ac.jp/onlinejudge/cdescription.jsp?cid=ACPC2017Day3&pid=E
*/ | 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
int m;
int k;
vector<int> v;
int main() {
cin >> n >> m >> k;
for (long long int i = 1; i * i <= n; i++) {
v.push_back(i);
v.push_back(n / i);
}
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
long long int ans = 0;
for (int i = 0; i < v.size(); i++) {
long long int rig = 0;
if (n % v[i] == 0) {
rig = n / v[i];
rig--;
} else {
rig = n / v[i];
rig--;
}
rig = min(rig, (long long int)k);
ans = max(ans, v[i] * (m / (k - rig + 1)));
}
if (ans == 0LL) {
ans = -1;
}
printf("%lld\n", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
#define fi first
#define se second
#define pii pair<int,int>
#define mp make_pair
#define pb push_back
#define space putchar(' ')
#define enter putchar('\n')
#define MAXN 200005
#define eps 1e-12
//#define ivorysi
using namespace std;
typedef long long int64;
typedef unsigned int u32;
typedef double db;
template<class T>
void read(T &res) {
res = 0;T f = 1;char c = getchar();
while(c < '0' || c > '9') {
if(c == '-') f = -1;
c = getchar();
}
while(c >= '0' && c <= '9') {
res = res * 10 + c - '0';
c = getchar();
}
res *= f;
}
template<class T>
void out(T x) {
if(x < 0) {x = -x;putchar('-');}
if(x >= 10) {
out(x / 10);
}
putchar('0' + x % 10);
}
const int MOD = 1000000007;
int inc(int a,int b) {
return a + b >= MOD ? a + b - MOD : a + b;
}
int mul(int a,int b) {
return 1LL * a * b % MOD;
}
int fpow(int x,int c) {
int res = 1,t = x;
while(c) {
if(c & 1) res = mul(res,t);
t = mul(t,t);
c >>= 1;
}
return res;
}
void update(int &x,int y) {
x = inc(x,y);
}
struct node {
int to,next;
}E[MAXN * 4];
int x[MAXN],y[MAXN],N,fac[MAXN],invfac[MAXN];
map<pii,int> zz;
int head[MAXN],sumE;
bool vis[MAXN];
int sum,Ncnt,fa[MAXN],s,t,pos[MAXN],par[MAXN];
vector<int> c[MAXN],r[MAXN],rec,cyc;
int rpos[MAXN],cpos[MAXN],siz[MAXN];
vector<int> son[MAXN];
void add(int u,int v) {
E[++sumE].to = v;
E[sumE].next = head[u];
head[u] = sumE;
}
pii depos(int a,int b) {
if(a > b) swap(a,b);
b -= N;
return mp(a,b);
}
bool dfs(int u) {
++Ncnt;
bool flag = 0;
vis[u] = 1;
for(int i = head[u] ; i ; i = E[i].next) {
++sum;
int v = E[i].to;
if(!vis[v]) {
fa[v] = u;
if(dfs(v)) {
flag = 1;
pos[zz[depos(u,v)]] = u;
}
}
else if(v != fa[u] && !flag){
s = u,t = v;
flag = 1;
rec.pb(zz[depos(u,v)]);
}
}
if(!flag && fa[u]) {
pos[zz[depos(u,fa[u])]] = u;
}
if(fa[u]) rec.pb(zz[depos(u,fa[u])]);
return flag;
}
int Calc(int u) {
siz[u] = 1;
int res = 1;
for(auto v : son[u]) {
res = mul(res,Calc(v));
res = mul(res,invfac[siz[v]]);
siz[u] += siz[v];
}
res = mul(res,fac[siz[u] - 1]);
return res;
}
int Process() {
int res = 0;
for(auto t : rec) par[t] = 0;
for(auto t : rec) {
if(pos[t] > N) {
for(int i = 0 ; i < cpos[t] ; ++i) {
par[zz[mp(c[y[t]][i],y[t])]] = t;
}
}
else {
for(int i = 0 ; i < rpos[t] ; ++i) {
par[zz[mp(x[t],r[x[t]][i])]] = t;
}
}
son[t].clear();
}
son[0].clear();
for(auto t : rec) {
son[par[t]].pb(t);
}
return Calc(0);
}
void Solve() {
read(N);
for(int i = 1 ; i <= 2 * N ; ++i) {
read(x[i]);read(y[i]);add(x[i],y[i] + N);add(y[i] + N,x[i]);
zz[mp(x[i],y[i])] = i;
r[x[i]].pb(y[i]);c[y[i]].pb(x[i]);
}
for(int i = 1 ; i <= N ; ++i) {
sort(r[i].begin(),r[i].end());
sort(c[i].begin(),c[i].end());
for(int j = 1 ; j < r[i].size() ; ++j) rpos[zz[mp(i,r[i][j])]] = j;
for(int j = 1 ; j < c[i].size() ; ++j) cpos[zz[mp(c[i][j],i)]] = j;
}
fac[0] = 1;
for(int i = 1 ; i <= 2 * N ; ++i) fac[i] = mul(fac[i - 1],i);
invfac[2 * N] = fpow(fac[2 * N],MOD - 2);
for(int i = 2 * N - 1 ; i >= 0 ; --i) invfac[i] = mul(invfac[i + 1],i + 1);
int ans = fac[2 * N];
for(int i = 1 ; i <= 2 * N ; ++i) {
if(!vis[i]) {
sum = 0;Ncnt = 0;
rec.clear();
dfs(i);
ans = mul(ans,invfac[Ncnt]);
if(Ncnt * 2 != sum) {puts("0");return;}
int p = s;
cyc.clear();
while(1) {
cyc.pb(p);
if(p == t) break;
p = fa[p];
}
int tmp = 0;
cyc.pb(s);
for(int i = 0 ; i < cyc.size() - 1 ; ++i) {
pos[zz[depos(cyc[i],cyc[i + 1])]] = cyc[i];
}
update(tmp,Process());
for(int i = cyc.size() - 1 ; i >= 1 ; --i) {
pos[zz[depos(cyc[i],cyc[i - 1])]] = cyc[i];
}
update(tmp,Process());
ans = mul(ans,tmp);
}
}
out(ans);enter;
}
int main() {
#ifdef ivorysi
freopen("f1.in","r",stdin);
#endif
Solve();
} | 0 |
#include <bits/stdc++.h>
int n, m, a, b, h[3001][3001], que[3001], beg, end, nh[3001][3001];
long long ans;
int main() {
int x, y, z;
scanf("%d%d%d%d%d%d%d%d", &n, &m, &a, &b, &h[1][1], &x, &y, &z);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (i != n || j != m)
h[i + (j + 1) / (m + 1)][j % m + 1] = (1ll * h[i][j] * x + y) % z;
for (int i = 1; i <= n; i++) {
beg = 1;
end = 0;
for (int j = 1; j <= m; j++) {
while (beg <= end && que[beg] <= j - b) beg++;
while (beg <= end && h[i][que[end]] >= h[i][j]) end--;
que[++end] = j;
if (j >= b) nh[i][j - b + 1] = h[i][que[beg]];
}
}
m = m - b + 1;
for (int j = 1; j <= m; j++) {
beg = 1;
end = 0;
for (int i = 1; i <= n; i++) {
while (beg <= end && que[beg] <= i - a) beg++;
while (beg <= end && nh[que[end]][j] >= nh[i][j]) end--;
que[++end] = i;
if (i >= a) ans += nh[que[beg]][j];
}
}
printf("%lld\n", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long a[100];
vector<pair<int, int> > can[100];
int ones(int mask) {
int ans = 0;
while (mask) {
ans += mask % 2;
mask /= 2;
}
return ans;
}
int memo[1 << 23];
bool vis[1 << 23];
int dp(int u, int mask) {
if (u == 0) return 1;
int &ret = memo[mask];
if (vis[mask]) return ret;
vis[mask] = 1;
ret = 100;
mask &= (~(1 << (u + 1)));
mask |= (1 << u);
for (int i = 0; i < can[u].size(); i++) {
int x = can[u][i].first, y = can[u][i].second;
ret = min(ret, dp(u - 1, (mask | (1 << x)) | (1 << y)));
}
ret = max(ret, ones(mask));
return ret;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
for (int j = 0; j < i; j++) {
for (int k = 0; k <= j; k++) {
if (a[i] == a[j] + a[k]) can[i].push_back(make_pair(j, k));
}
}
if (i && can[i].empty()) return cout << -1 << endl, 0;
}
memset(memo, -1, sizeof memo);
cout << dp(n - 1, 0) << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
const int Maxn = 1005;
char s[Maxn][Maxn];
int dw[Maxn][Maxn];
int rt[Maxn][Maxn];
struct rec {
short X1, Y1, X2, Y2;
rec(short a, short b, short c, short d) {
X1 = a;
Y1 = b;
X2 = c;
Y2 = d;
}
};
void print(rec x) {
printf("%d %d %d %d\n", x.X1 + 1, 1 + x.Y1, 1 + x.X2, 1 + x.Y2);
}
int f(rec x) { return 2 * abs(x.X1 - x.X2) + 2 * abs(x.Y1 - x.Y2); }
vector<pair<int, int> > av;
int g[Maxn][Maxn];
int dc;
inline void Add(int x, int y, int v) {
if (!g[x][y]) dc++;
g[x][y] += v;
if (!g[x][y]) dc--;
}
void Paint(rec x, int v = 1) {
for (int i = x.X1; i <= x.X2; i++) {
Add(i, x.Y1, v);
Add(i, x.Y2, v);
}
for (int i = x.Y1 + 1; i < x.Y2; i++) {
Add(x.X1, i, v);
Add(x.X2, i, v);
}
}
bool check(rec a, rec b) {
Paint(a);
Paint(b);
int c2 = 0;
for (int i = 0; i < av.size(); i++) {
int x = av[i].first, y = av[i].second;
if (g[x][y])
c2++;
else {
Paint(a, -1);
Paint(b, -1);
return false;
}
}
bool ret = c2 == dc;
Paint(a, -1);
Paint(b, -1);
return ret;
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
int cnt = 0;
pair<int, int> lo, hi;
lo = make_pair(23333, 23333), hi = make_pair(0, 0);
for (int i = 0; i < n; i++) {
scanf("%s", s[i]);
for (int j = 0; j < m; j++) {
if (s[i][j] == '#') {
cnt++;
lo = min(lo, make_pair(i, j));
if (j > hi.second || (j == hi.second && i > hi.first)) {
hi = make_pair(i, j);
}
av.push_back(make_pair(i, j));
}
}
}
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < m; j++) {
if (s[i][j] == '#') {
dw[i][j] = dw[i + 1][j] + 1;
} else {
dw[i][j] = 0;
}
}
}
for (int i = 0; i < n; i++) {
for (int j = m - 1; j >= 0; j--) {
if (s[i][j] == '#') {
rt[i][j] = rt[i][j + 1] + 1;
} else {
rt[i][j] = 0;
}
}
}
if (cnt > 8000 || cnt < 8) {
printf("NO\n");
return 0;
}
vector<pair<rec, rec> > V;
for (int i = 3; i + lo.first <= n && i <= dw[lo.first][lo.second]; i++) {
for (int j = 3; j + lo.second <= m && j <= rt[lo.first][lo.second]; j++) {
int ex = i + lo.first - 1, ey = j + lo.second - 1;
if (rt[ex][lo.second] >= j && dw[lo.first][ey] >= i) {
if (make_pair(ex, ey) != hi) {
for (int k = 0; k < av.size(); k++) {
int X = av[k].first, Y = av[k].second;
if (X + 2 <= hi.first && Y + 2 <= hi.second &&
dw[X][Y] + X - 1 >= hi.first && rt[X][Y] + Y - 1 >= hi.second &&
rt[hi.first][Y] + Y - 1 >= hi.second &&
dw[X][hi.second] + X - 1 >= hi.first) {
V.push_back(make_pair(
rec(lo.first, lo.second, lo.first + i - 1, lo.second + j - 1),
rec(X, Y, hi.first, hi.second)));
pair<rec, rec> xx = V.back();
rec _1 = xx.first, _2 = xx.second;
int cc = f(_1) + f(_2);
if (cc < cnt) {
V.pop_back();
}
}
}
} else {
for (int k = 0; k < av.size(); k++) {
int X = av[k].first, Y = av[k].second;
int nd = cnt - f(rec(lo.first, lo.second, lo.first + i - 1,
lo.second + j - 1));
for (int push = 3; X + push <= n && push <= dw[X][Y]; push++) {
for (int q = max(3, (nd - 2 * (push - 1)) / 2 + 1);
Y + q <= m && q <= rt[X][Y]; q++) {
if (rt[X + push - 1][Y] >= q && dw[X][Y + q - 1] >= push) {
V.push_back(
make_pair(rec(lo.first, lo.second, lo.first + i - 1,
lo.second + j - 1),
rec(X, Y, X + push - 1, Y + q - 1)));
pair<rec, rec> xx = V.back();
rec _1 = xx.first, _2 = xx.second;
int cc = f(_1) + f(_2);
if (cc < cnt) {
V.pop_back();
}
}
}
}
}
}
}
}
}
for (int i = 0; i < V.size(); i++) {
rec _1 = V[i].first, _2 = V[i].second;
int cc = f(_1) + f(_2);
if (cc < cnt) {
continue;
}
if (check(_1, _2)) {
printf("YES\n");
print(_1);
print(_2);
return 0;
}
}
printf("NO\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
int tot = 0;
int evens[5];
memset(evens, 0, sizeof evens);
for (int j = 0; j < s.size(); j++) {
int temp = s[j] - '0';
tot += temp;
if (temp % 2 == 0) evens[temp / 2]++;
}
bool ok =
(evens[0] > 1 or (evens[0] == 1 and
((evens[1] + evens[2] + evens[3] + evens[4]) >= 1)));
if (tot % 3 == 0 and ok)
cout << "red" << endl;
else
cout << "cyan" << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
const int INF = ~0u >> 2;
int main() {
int n;
scanf("%d", &n);
std::vector<int> c(n);
for (int i = 0; i < n; ++i) {
scanf("%d", &c[i]);
}
int ans = INF;
for (int i = 1; i < n; ++i) {
for (int j = i; j < n; ++j) {
int x = c[i - 1] - 1;
int y = 0;
for (int k = i; k <= j; ++k) {
int tmp = x / c[k];
x -= tmp * c[k];
y += tmp;
}
x = c[i - 1] - 1 - x + c[j];
++y;
int w = x;
if (x < ans) {
for (int k = 0; k < n; ++k) {
int tmp = x / c[k];
x -= tmp * c[k];
y -= tmp;
}
if (y < 0) ans = w;
}
}
}
if (ans == INF)
puts("-1");
else
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
string s, p, q;
string a[210];
int n, i, d[210];
int RS;
int nr;
int main() {
cin >> n;
while (n--) {
cin >> s >> p >> q;
for (i = 0; i < s.size(); i++)
if (s[i] >= 'A' && s[i] <= 'Z') s[i] = s[i] + 'a' - 'A';
for (i = 0; i < q.size(); i++)
if (q[i] >= 'A' && q[i] <= 'Z') q[i] = q[i] + 'a' - 'A';
int pos1 = 0, pos2 = 0;
for (i = 1; i <= nr && !pos1; i++)
if (s == a[i]) pos1 = i;
for (i = 1; i <= nr && !pos2; i++)
if (q == a[i]) pos2 = i;
if (!pos1) a[++nr] = s, pos1 = nr;
d[pos1] = d[pos2] + 1;
RS = max(RS, d[pos1]);
}
cout << RS + 1;
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int a,b,c,m,A;
cin>>a>>b>>c;
m=max(a,max(b,c));
A=a+b+c-m;
cout<<A<<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define FOR(i,a,b) for(int i=(a);i<=(b);++i)
#define RFOR(i,a,b) for(int i=(a);i>=(b);--i)
int Q, A, B, C, D;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> Q;
FOR(i,1,Q) {
cin >> A >> B >> C >> D;
int K = (max(A,B)+min(A,B))/(min(A,B)+1);
int lo = 0, hi = A+B+1;
while (hi-lo > 1) {
int mid = (lo+hi)/2;
int nb = (mid-1)/(K+1);
int na = (mid-1) - nb;
if (1LL*K*(A-na) >= B-nb) lo = mid;
else hi = mid;
}
//cout << "q " << i << " :: " << K << " partition at " << lo << " " << hi << endl;
FOR(i,C,D){
if (i <= lo) {
cout << (i%(K+1) == 0 ? 'B' : 'A');
} else {
cout << ((A+B-i+1)%(K+1) == 0 ? 'A' : 'B');
}
}
cout << '\n';
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int bins(int curInd, int d, int n, int* a) {
int l = 1;
int r = n;
int x = a[curInd + 1] - 1 + d;
if (a[n] < x) return n + 1;
while (l <= r) {
int m = (l + r) / 2;
if (a[m] >= x) {
r = m - 1;
continue;
} else if (a[m] < x && a[m + 1] >= x)
return m;
else {
l = m + 1;
continue;
}
}
return -1;
}
bool canJump(int ind, int s, int* a) { return (a[ind + 1] - a[ind] - 2 >= s); }
void printAns(queue<string>& op, queue<int>& dist) {
while (!op.empty()) {
cout << op.front() << " " << dist.front() << "\n";
op.pop();
dist.pop();
}
}
int main() {
int n, m, s, d;
cin >> n >> m >> s >> d;
int* a = new int[n + 1];
queue<string> op;
queue<int> dist;
a[0] = -1;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + 1 + n);
if (a[1] == 1 || d == 1 || s > a[1] - 1) {
cout << "IMPOSSIBLE" << endl;
return 0;
}
int curInd = 0;
int minPosInd = 0;
while (1) {
if (curInd == n) {
if (m - a[n] - 1 != 0) {
op.push("RUN");
dist.push(m - a[n] - 1);
}
printAns(op, dist);
return 0;
}
if (curInd == n - 1) {
op.push("RUN");
dist.push(a[curInd + 1] - a[curInd] - 2);
op.push("JUMP");
dist.push(2);
if (m - a[n] - 1 != 0) {
op.push("RUN");
dist.push(m - a[n] - 1);
}
printAns(op, dist);
return 0;
}
int nextInd = bins(curInd, d, n, a);
if (nextInd == -1) {
cout << "IMPOSSIBLE" << endl;
return 0;
}
if (nextInd == n + 1) {
op.push("RUN");
dist.push(a[curInd + 1] - a[curInd] - 2);
op.push("JUMP");
dist.push(a[n] - a[curInd + 1] + 2);
if (m - a[n] - 1 != 0) {
op.push("RUN");
dist.push(m - a[n] - 1);
}
printAns(op, dist);
return 0;
}
int tmp = nextInd;
while (nextInd > minPosInd && !canJump(nextInd, s, a)) nextInd--;
if (nextInd == minPosInd) {
cout << "IMPOSSIBLE" << endl;
return 0;
} else {
op.push("RUN");
dist.push(a[curInd + 1] - a[curInd] - 2);
op.push("JUMP");
dist.push(a[nextInd] - a[curInd + 1] + 2);
curInd = nextInd;
minPosInd = tmp;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int M = N * 25;
int n, m;
long long C[M], x, y, tar[N], dep[N], in[M];
int fir[N], ne[M], to[M], cnt = 1, fa[N], fan[N];
void add(int x, int y) {
ne[++cnt] = fir[x];
fir[x] = cnt;
to[cnt] = y;
}
void link(int x, int y) {
add(x, y);
add(y, x);
}
bool vis[N];
int dfs(int x, int f) {
int res = 0;
fa[x] = f;
dep[x] = dep[f] + 1;
vis[x] = 1;
for (int i = fir[x]; i; i = ne[i]) {
int V = to[i];
if (vis[V]) {
if (V != f) {
if ((dep[V] + dep[x]) & 1)
;
else
res = i;
}
continue;
}
int cur = 0;
if (cur = dfs(V, x)) res = cur;
if (tar[V]) {
tar[x] -= tar[V];
C[i] += tar[V];
C[i ^ 1] += tar[V];
tar[V] = 0;
}
fan[V] = i;
}
return res;
}
void Bush(int x) {
while (fa[x]) {
tar[fa[x]] -= tar[x];
C[fan[x]] += tar[x];
C[fan[x] ^ 1] += tar[x];
tar[x] = 0;
x = fa[x];
}
}
int main(void) {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%lld", &tar[i]);
for (int i = 1; i <= m; ++i) scanf("%d%d", &x, &y), link(x, y);
for (int i = 1; i <= n; ++i) {
if (!vis[i]) {
int cur = dfs(i, 0), a;
if ((tar[i]) & 1 || (!cur && tar[i])) return puts("NO") * 0;
a = (dep[to[cur]] & 1);
C[cur] = C[cur ^ 1] += tar[i] / 2 * (a ? 1 : (-1));
tar[to[cur ^ 1]] = tar[to[cur]] = -tar[i] / 2 * (a ? 1 : (-1));
Bush(to[cur]);
Bush(to[cur ^ 1]);
}
}
puts("YES");
for (int i = 1; i <= m; ++i) printf("%lld\n", C[i * 2]);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll next(ll n, ll k)
{
ll num = n + n / (k - 1);
for (ll i = 1;; i++) {
if (num - (num / k) - 1 == n) {
return num;
}
num++;
}
}
int main()
{
ll N, k;
cin >> N >> k;
ll num = 0;
for (ll i = 2; i <= N; i++) {
num = next(num, k);
}
cout << num << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int a, b;
long long int c, d;
long long int f = 0, g = 0;
long long int a1 = 0, a2 = 0;
long long int b1 = 0, b2 = 0;
cin >> a >> b;
c = a + b;
while (c) {
if (c % 10 != 0) f = f * 10 + c % 10;
c = c / 10;
}
while (f) {
g = g * 10 + f % 10;
f = f / 10;
}
while (a) {
if (a % 10 != 0) a1 = a1 * 10 + a % 10;
a = a / 10;
}
while (a1) {
a2 = a2 * 10 + a1 % 10;
a1 = a1 / 10;
}
while (b) {
if (b % 10 != 0) b1 = b1 * 10 + b % 10;
b = b / 10;
}
while (b1) {
b2 = b2 * 10 + b1 % 10;
b1 = b1 / 10;
}
d = a2 + b2;
if (d == g)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ull = unsigned long long;
using ll = long long;
const int N = 2005;
int n, m;
vector<vector<char>> a;
vector<vector<int>> c, u;
bool check2(int i, int j, int i1, int j2) {
if (i < 1 || j < 1 || i1 < 1 || j2 < 1) return 0;
if (i > n || j > m || i1 > n || j2 > m) return 0;
return c[i1][j2] - c[i - 1][j2] - c[i1][j - 1] + c[i - 1][j - 1] ==
(i1 - i + 1) * (j2 - j + 1);
}
bool check(int vl) {
for (int i = 0; i < n + 2; ++i) {
for (int j = 0; j < m + 2; ++j) {
u[i][j] = 0;
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (a[i][j] == 'X' && check2(i - vl, j - vl, i + vl, j + vl)) {
++u[i - vl][j - vl];
--u[i - vl][j + vl + 1];
--u[i + vl + 1][j - vl];
++u[i + vl + 1][j + vl + 1];
}
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
u[i][j] += u[i - 1][j] + u[i][j - 1] - u[i - 1][j - 1];
if (a[i][j] == 'X' && u[i][j] == 0) {
return 0;
}
if (a[i][j] == '.' && u[i][j] != 0) {
abort();
}
}
}
return 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cin >> n >> m;
a.resize(n + 2, vector<char>(m + 2, 0));
c.resize(n + 2, vector<int>(m + 2, 0));
u.resize(n + 2, vector<int>(m + 2, 0));
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
cin >> a[i][j];
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
c[i][j] = c[i - 1][j] + c[i][j - 1] - c[i - 1][j - 1] + (a[i][j] == 'X');
}
}
int l = 0, r = max(n, m), mid;
while (r - l > 1) {
mid = (l + r) >> 1;
if (check(mid)) {
l = mid;
} else {
r = mid;
}
}
cout << l << '\n';
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (a[i][j] == 'X' && check2(i - l, j - l, i + l, j + l)) {
cout << 'X';
} else {
cout << '.';
}
}
cout << '\n';
}
return 0;
}
| 5 |
#include<algorithm>
#include<cstdio>
#include<cstring>
#define M 10001
#define N 101
using namespace std;
int A[N][N],B[M],C[N][N],D[N][N],b[N],d[N],m,n;bool a[N][N],c[N];
bool dfs(int u)
{
c[u]=true;
for(int i=1;i<=n;i++)if(a[u][i]&&(!d[i]||!c[d[i]]&&dfs(d[i])))
{
b[d[i]=u]=i;
return true;
}
return false;
}
int main()
{
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++)for(int j=1,u;j<=m;j++)scanf("%d",&u),B[u]=A[i][(u+m-1)/m],A[i][(u+m-1)/m]=u;
for(int i=1;i<=n;i++)for(int j=1;j<=n;j++)a[i][j]=A[i][j];
for(int i=1;i<=m;i++)
{
for(int j=1;j<=n;j++)if(!b[j])dfs(j),memset(c+1,0,n);
for(int j=1;j<=n;j++)C[j][i]=A[j][b[j]];
for(int j=1;j<=n;j++)if(!(A[j][b[j]]=B[A[j][b[j]]]))b[j]=d[b[j]]=a[j][b[j]]=0;
}
for(int i=1;i<=n;i++)for(int j=1;j<=m;j++)printf("%d%c",C[i][j],j==m?'\n':' ');
for(int i=1;i<=n;i++)for(int j=1;j<=m;j++)D[j][i]=C[i][j];
for(int i=1;i<=m;i++)sort(D[i]+1,D[i]+n+1);
for(int i=1;i<=n;i++)for(int j=1;j<=m;j++)printf("%d%c",D[j][i],j==m?'\n':' ');
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18;
long long n, m, a[200020], dp[200020][2];
vector<pair<long long, long long> > seg[200020];
void Solve() {
cin >> n >> m;
for (long long i = 2; i <= n + 1; ++i) {
cin >> a[i];
}
sort(a + 2, a + n + 2);
a[1] = -inf;
a[n + 2] = inf;
n += 2;
for (long long i = 1; i <= n; ++i) seg[i].clear(), dp[i][0] = dp[i][1] = inf;
for (long long i = 1; i <= m; ++i) {
long long l, r;
cin >> l >> r;
long long pl = lower_bound(a + 1, a + n + 1, l) - a;
long long pr = upper_bound(a + 1, a + n + 1, r) - a;
if (pl ^ pr) continue;
seg[pl].emplace_back(l, r);
}
dp[1][0] = dp[1][1] = 0;
for (long long i = 2; i <= n; ++i) {
sort(seg[i].begin(), seg[i].end());
long long r = a[i];
for (long long j = (long long)seg[i].size(); j >= 0; --j) {
if (j < (long long)seg[i].size()) {
r = min(r, seg[i][j].second);
}
long long l = a[i - 1];
if (j > 0) {
l = seg[i][j - 1].first;
}
dp[i][0] = min(dp[i][0], dp[i - 1][0] + (l - a[i - 1]) + 2 * (a[i] - r));
dp[i][0] =
min(dp[i][0], dp[i - 1][1] + 2 * (l - a[i - 1]) + 2 * (a[i] - r));
dp[i][1] = min(dp[i][1], dp[i - 1][0] + (l - a[i - 1]) + (a[i] - r));
dp[i][1] = min(dp[i][1], dp[i - 1][1] + 2 * (l - a[i - 1]) + (a[i] - r));
}
}
cout << min(dp[n][0], dp[n][1]) << '\n';
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long T;
cin >> T;
while (T--) Solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int T = 1e5 + 5;
struct node {
int num, x;
} t;
vector<node> p[T];
bool flag[T];
int dfs(int now) {
queue<int> q;
int l = p[now].size();
for (int i = 0; i < l; i++) {
node k = p[now][i];
if (flag[k.num])
continue;
else
flag[k.num] = 1;
int r = dfs(k.x);
if (r)
printf("%d %d %d\n", now, k.x, r);
else
q.push(k.x);
}
while (q.size() >= 2) {
int v1 = q.front();
q.pop();
int v2 = q.front();
q.pop();
printf("%d %d %d\n", v1, now, v2);
}
while (!q.empty()) {
int v3 = q.front();
q.pop();
return v3;
}
return 0;
}
int main() {
int n, m, a, b;
while (scanf("%d%d", &n, &m) != EOF) {
for (int i = 0; i < n; i++) p[i].clear();
for (int i = 1; i <= m; i++) {
scanf("%d%d", &a, &b);
t.num = i;
t.x = a;
p[b].push_back(t);
t.x = b;
p[a].push_back(t);
}
if (m % 2 == 1)
printf("No solution\n");
else {
memset(flag, 0, sizeof(flag));
dfs(1);
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
const int maxm = 1e6 + 10;
const int INF = 0x3f3f3f3f;
int casn, n, m, k;
int st, pre[maxn], deg[maxn];
int to[maxn], nex[maxn], head[maxn], nume;
int dfn[maxn], cnt, ans1[maxn], ans2[maxn], cnt2;
void dfs(int now) {
for (int i = head[now]; i; i = nex[i]) {
if (to[i] != now) dfs(to[i]);
}
dfn[++cnt] = now;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> pre[i];
deg[pre[i]]++;
if (pre[i]) {
deg[i]++;
to[++nume] = i;
nex[nume] = head[pre[i]];
head[pre[i]] = nume;
} else
st = i;
}
dfs(st);
cnt = 0;
for (int i = 1; i < n; i++) {
if (deg[dfn[i]] & 1) {
ans2[++cnt2] = dfn[i];
} else
ans1[++cnt] = dfn[i], deg[pre[dfn[i]]]--;
}
if (deg[dfn[n]] & 1)
cout << "NO\n";
else {
ans1[++cnt] = dfn[n];
cout << "YES\n";
for (int i = 1; i <= cnt; i++) cout << ans1[i] << '\n';
for (int i = cnt2; i; i--) cout << ans2[i] << '\n';
}
return 0;
}
| 2 |
#include<iostream>
#include<string>
#include<cstdio>
#include<cstring>
#include<sstream>
#include<algorithm>
#include<map>
#include<vector>
using namespace std;
typedef pair<int,string> P;
int main(){
int n;
string str;
while(1){
cin >> n;
if(n == 0) break;
map<string,int> count;
vector<P> v;
getchar();
for(int i=0;i<n;i++){
//cin.ignore();
getline(cin,str);
stringstream ss(str);
while(ss >> str){
count[str]++;
}
}
char key; cin >> key;
for(map<string,int>::iterator i=count.begin(),l=count.end();i!=l;i++){
if(key==i->first[0]){
v.push_back(make_pair(-i->second,i->first));
}
}
sort(v.begin(),v.end());
if(v.empty()) cout << "NA" << endl;
else {
bool flg = false;
int s = v.size();
for(int i=0;i<5&&i<s;i++){
if(flg) cout << " ";
else flg = true;
cout << v[i].second;
}
cout << endl;
}
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define lli long long int
#define REP(i,s,l) for(lli i=s;i<l;i++)
#define DEBUG 0
#define INF (1LL<<50)
#define MOD 1000000007
lli b(lli bit){
if(bit)return -1;
else return 1;
}
signed main(){
lli n,m;
cin>>n>>m;
vector<lli> x(n),y(n),z(n);
REP(i,0,n)cin>>x[i]>>y[i]>>z[i];
lli last=-INF;
for(lli i=0;i<8;i++){
vector<lli> ans(n,0);
REP(j,0,n) ans[j] = b(i&1)*x[j] + b(i&2)*y[j] + b(i&4) * z[j];
sort(ans.rbegin(),ans.rend());
lli sum=0;
REP(j,0,m)sum+=ans[j];
last = max(last,sum);
}
cout<<last<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10, maxm = (1 << 17), mod = 1e9 + 7, hash = 701;
const double PI = 3.14159265359, E = 2.71828;
long long a[maxn];
pair<long long, long long> d[maxn];
int main() {
ios::sync_with_stdio(0);
long long n, sum;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) {
sum = a[i], d[i] = make_pair((1 << 30), (1 << 30));
for (int j = i - 1; j >= 0; j--) {
if (sum >= d[j].second) {
if (d[j].first + i - j - 1 < d[i].first)
d[i].first = d[j].first + i - j - 1;
if (d[i].first == d[j].first + i - j - 1)
d[i].second = min(d[i].second, sum);
}
sum += a[j];
}
}
cout << d[n].first << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using namespace chrono;
void _print(long long t) { cerr << t; }
void _print(int t) { cerr << t; }
void _print(string t) { cerr << t; }
void _print(char t) { cerr << t; }
void _print(long double t) { cerr << t; }
void _print(double t) { cerr << t; }
void _print(unsigned long long t) { cerr << t; }
template <class T, class V>
void _print(pair<T, V> p);
template <class T>
void _print(vector<T> v);
template <class T>
void _print(set<T> v);
template <class T, class V>
void _print(map<T, V> v);
template <class T>
void _print(multiset<T> v);
template <class T, class V>
void _print(pair<T, V> p) {
cerr << "{";
_print(p.first);
cerr << ",";
_print(p.second);
cerr << "}";
}
template <class T>
void _print(vector<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(set<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(multiset<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T, class V>
void _print(map<T, V> v) {
cerr << "[ ";
for (auto i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
long long gcd(long long a, long long b) {
if (b > a) {
return gcd(b, a);
}
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
long long expo(long long a, long long b, long long mod) {
long long res = 1;
while (b > 0) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b = b >> 1;
}
return res;
}
void extendgcd(long long a, long long b, long long *v) {
if (b == 0) {
v[0] = 1;
v[1] = 0;
v[2] = a;
return;
}
extendgcd(b, a % b, v);
long long x = v[1];
v[1] = v[0] - v[1] * (a / b);
v[0] = x;
return;
}
long long mminv(long long a, long long b) {
long long arr[3];
extendgcd(a, b, arr);
return arr[0];
}
long long mminvprime(long long a, long long b) { return expo(a, b - 2, b); }
bool revsort(long long a, long long b) { return a > b; }
void swap(int &x, int &y) {
int temp = x;
x = y;
y = temp;
}
long long combination(long long n, long long r, long long m, long long *fact,
long long *ifact) {
long long val1 = fact[n];
long long val2 = ifact[n - r];
long long val3 = ifact[r];
return (((val1 * val2) % m) * val3) % m;
}
void google(int t) { cout << "Case #" << t << ": "; }
vector<long long> sieve(int n) {
int *arr = new int[n + 1]();
vector<long long> vect;
for (int i = 2; i <= n; i++)
if (arr[i] == 0) {
vect.push_back(i);
for (int j = 2 * i; j <= n; j += i) arr[j] = 1;
}
return vect;
}
long long mod_add(long long a, long long b, long long m) {
a = a % m;
b = b % m;
return (((a + b) % m) + m) % m;
}
long long mod_mul(long long a, long long b, long long m) {
a = a % m;
b = b % m;
return (((a * b) % m) + m) % m;
}
long long mod_sub(long long a, long long b, long long m) {
a = a % m;
b = b % m;
return (((a - b) % m) + m) % m;
}
long long mod_div(long long a, long long b, long long m) {
a = a % m;
b = b % m;
return (mod_mul(a, mminvprime(b, m), m) + m) % m;
}
long long phin(long long n) {
long long number = n;
if (n % 2 == 0) {
number /= 2;
while (n % 2 == 0) n /= 2;
}
for (long long i = 3; i <= sqrt(n); i += 2) {
if (n % i == 0) {
while (n % i == 0) n /= i;
number = (number / i * (i - 1));
}
}
if (n > 1) number = (number / n * (n - 1));
return number;
}
int binarySearch(int arr[], int n, int key) {
int s = 0, e = n;
while (s <= e) {
int mid = (s + e) / 2;
if (arr[mid] == key) {
return mid;
} else if (arr[mid] > key) {
e = mid - 1;
} else {
s = mid + 1;
}
}
}
int isprime(int N) {
if (N < 2 || (!(N & 1) && N != 2)) return 0;
for (int i = 3; i * i <= N; i += 2) {
if (!(N % i)) return 0;
}
return 1;
}
int bin_pow(int ind, int power) {
if (power == 0) {
return 1;
}
if (power & 1) {
return ind * bin_pow(ind, power - 1) % 1000000007;
} else {
return bin_pow((ind * ind) % 1000000007, power / 2) % 1000000007;
}
}
int fact(int x) {
int ret = 1;
for (int i = 2; i <= x; i++) {
ret *= i;
ret %= 1000000007;
}
return ret;
}
int ncr(int n, int r) {
if (r > n) return 0;
return (fact(n) *
(bin_pow((fact(r) * fact(n - r)) % 1000000007, 1000000007 - 2))) %
1000000007;
}
long long maxsubarraysum(long long *array, long long n) {
long long best = 0, sum = 0;
for (long long k = 0; k < n; k++) {
sum = max(array[k], sum + array[k]);
best = max(best, sum);
}
return best;
}
void printBinary(int num) {
for (int i = 10; i >= 0; --i) {
cout << ((num >> i) & 1);
}
cout << endl;
}
void jaiMaheshmati() {
int n, k;
cin >> n >> k;
vector<int> a(2 * n + 1);
for (auto &x : a) cin >> x;
for (int i = 1; i < (2 * n + 1); i += 2) {
if (k == 0) break;
if (a[i - 1] < (a[i] - 1) && (a[i] - 1) > a[i + 1]) {
a[i] -= 1;
k--;
}
}
for (auto &x : a) cout << x << " ";
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
auto start1 = high_resolution_clock::now();
jaiMaheshmati();
auto stop1 = high_resolution_clock::now();
auto duration = duration_cast<microseconds>(stop1 - start1);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
namespace std {
bool operator<(const complex<double> &lhs, const complex<double> &rhs) {
if (real(lhs) == real(rhs)) {
return imag(lhs) < imag(rhs);
} else {
return real(lhs) < real(rhs);
}
}
} // namespace std
ostream &operator<<(ostream &os, const complex<double> &p) {
return os << "(" << p.real() << "," << p.imag() << ")";
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "[";
for (const auto &v : vec) {
os << v << ",";
}
os << "]";
return os;
}
complex<double> counter_clock_wise(complex<double> p, double rad) {
double a = abs(p);
return polar(a, arg(p) + rad);
}
const double EPS = 1e-7;
const double PI = 3.141592653589793;
double dot(complex<double> a, complex<double> b) { return real(conj(a) * b); }
double point_distance(complex<double> a, complex<double> b) {
return abs(a - b);
}
bool is_square(vector<complex<double> > ps) {
sort(ps.begin(), ps.end());
vector<double> dist;
for (long long i = 0; i < 4; i++) {
for (long long j = i + 1; j < 4; j++) {
if (abs(ps[i] - ps[j]) < EPS) return false;
dist.push_back(abs(ps[i] - ps[j]));
}
}
sort(dist.begin(), dist.end());
for (long long i = 0; i < 4; i++) {
if (abs(dist[0] - dist[i]) > EPS) return false;
}
for (long long i = 4; i < 6; i++) {
if (abs(sqrt(2) * dist[1] - dist[i]) > EPS) return false;
}
return true;
}
const long long INF = 100000000;
long long solve(vector<long long> y, vector<long long> x, vector<long long> b,
vector<long long> a) {
long long ret = INF;
;
;
for (long long i = 0; i < static_cast<long long>(4); i++) {
for (long long j = 0; j < static_cast<long long>(4); j++) {
for (long long k = 0; k < static_cast<long long>(4); k++) {
for (long long l = 0; l < static_cast<long long>(4); l++) {
vector<long long> cur = {i, j, k, l};
vector<complex<double> > ps;
for (long long m = 0; m < static_cast<long long>(4); m++) {
complex<double> p(x[m], y[m]);
p -= complex<double>(a[m], b[m]);
p = counter_clock_wise(p, (PI / 2) * cur[m]);
p += complex<double>(a[m], b[m]);
ps.push_back(p);
}
sort(ps.begin(), ps.end());
if (is_square(ps)) {
;
;
ret = min(ret, i + j + k + l);
}
}
}
}
}
if (ret == INF) return -1;
return ret;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n;
cin >> n;
for (long long i = 0; i < n; i++) {
vector<long long> y(4), x(4), b(4), a(4);
for (long long j = 0; j < 4; j++) {
cin >> x[j] >> y[j] >> a[j] >> b[j];
}
long long ret = solve(y, x, b, a);
cout << ret << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, x1, x2;
cin >> n;
long long ans[n + 1], prev = 1;
for (long long i = 2; i <= n; i++) {
cout << "? " << prev << " " << i << endl;
cin >> x1;
cout << "? " << i << " " << prev << endl;
cin >> x2;
if (x1 > x2) {
ans[prev] = x1;
prev = i;
} else
ans[i] = x2;
}
ans[prev] = n;
cout << "! ";
for (long long i = 1; i <= n; i++) cout << ans[i] << " ";
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) solve();
return 0;
}
| 3 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <sstream>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <cmath>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <bitset>
#define rep(i, n) for(int i = 0; i < (n); i++)
#define FOR(i, a, b) for(int i = (a); i < (b); i++)
#define all(v) (v).begin(), (v).end()
#define rev(s) (s).rbegin(), (s).rend()
#define MP make_pair
#define X first
#define Y second
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef vector<int> vi;
void fin(){
freopen("test.txt", "r", stdin);
}
ll ytoi(ll y){
y--;
return y*365+y/4-y/100+y/400;
}
int isu(int y){
if(y%400 == 0) return 1;
if(y%100 == 0) return 0;
if(y%4 == 0) return 1;
return 0;
}
int mon[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int mtoi(int m, int y){
int u = isu(y);
mon[2] += u;
int days = 0;
rep(i, m) days += mon[i];
mon[2] -= u;
return days;
}
ll ymdtoi(ll y, ll m, ll d){
return ytoi(y)+mtoi(m, y)+d;
}
int itoy(ll i){
int yl=0, yh=10000001;
while(yh-yl>1){
int mid = (yh+yl)/2;
if(i > ytoi(mid)) yl = mid;
else yh = mid;
}
return yl;
}
int itom(int i, int y){
int u = isu(y);
for(int j = 1; j <= 12 ; j++){
i -= mon[j] + (u&&(j==2));
if(i <= 0) return j;
}
return -1;
}
void itoymd(ll i){
int y = itoy(i);
i -= ytoi(y);
int m = itom(i, y);
i -= mtoi(m, y);
int d = i;
cout << y << '.' << m << '.' << d << endl;
}
ll bkatwkitoi(ll b, ll ka, ll t, ll w, ll ki){
ka += b*20;
t += ka*20;
w += t*18;
ki += w*20;
return ki+ymdtoi(2012, 12, 21);
}
void itobkatwki(ll i){
i -= ymdtoi(2012, 12, 21);
ll ki = i%20; i /= 20;
ll w = i%18; i /= 18;
ll t = i%20; i /= 20;
ll ka = i%20; i /= 20;
ll b = i%13;
cout << b << '.' << ka << '.' << t <<
'.' << w << '.' << ki << endl;
}
int dotcnt(string s){
int cnt = 0;
rep(i, s.size()) if(s[i] == '.') cnt++;
return cnt;
}
int main(){
// fin();
string s;
while(cin >> s, s != "#"){
stringstream ss;
ss << s;
if( dotcnt(s) == 2){
int y, m, d; char c;
ss >> y >> c >> m >> c >> d;
itobkatwki(ymdtoi(y, m, d));
}else{
int b, ka, t, w, ki; char c;
ss >> b >> c >> ka >> c >> t >> c >> w >> c >> ki;
itoymd(bkatwkitoi(b, ka, t, w, ki));
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
using namespace std::chrono;
int arr[3][101];
int main() {
int t, n;
cin >> t;
while (t--) {
cin >> n;
for (int i = 0; i < (int)(n); ++i) cin >> arr[0][i];
for (int i = 0; i < (int)(n); ++i) cin >> arr[1][i];
for (int i = 0; i < (int)(n); ++i) cin >> arr[2][i];
vector<int> ans(n);
ans[0] = arr[0][0];
for (int i = (1); i < (int)(n - 1); ++i) {
for (int j = 0; j < (int)(3); ++j)
if (arr[j][i] != ans[i - 1]) ans[i] = arr[j][i];
}
for (int j = 0; j < (int)(3); ++j)
if (arr[j][n - 1] != ans[n - 2] && arr[j][n - 1] != ans[0])
ans[n - 1] = arr[j][n - 1];
for (int i = 0; i < (int)(n); ++i) cout << ans[i] << " ";
cout << endl;
}
return 0;
}
| 1 |
#include<bits/stdc++.h>
#define ll long long
using namespace std;
int n,m,i,j,x,f[1010][1010];
char a[1010][1010];
int main(){
scanf("%d%d",&n,&m);
for(i=1;i<=n;i++)scanf("%s",a[i]+1);
memset(f,44,sizeof(f));
if(a[1][1]=='.')f[1][1]=0;
else f[1][1]=1;
for(i=1;i<=n;i++)
for(j=1;j<=m;j++){
if(i<n){
x=0;
if(a[i+1][j]=='#'&&a[i][j]=='.')x=1;
f[i+1][j]=min(f[i+1][j],f[i][j]+x);
}
if(j<m){
x=0;
if(a[i][j+1]=='#'&&a[i][j]=='.')x=1;
f[i][j+1]=min(f[i][j+1],f[i][j]+x);
}
}
printf("%d",f[n][m]);
} | 0 |
#include <iostream>
using namespace std;
int main() {
int A, B, K;
cin >> A >> B >> K;
for (int i = 0; i < K; ++i) {
if (i % 2) {
A += B / 2;
B /= 2;
}
else {
B += A / 2;
A /= 2;
}
}
cout << A << " " << B;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
int n, m;
struct node {
int x, can;
} a[N];
bool cmp(node x, node y) {
if (x.can != y.can) return x.can < y.can;
return x.x > y.x;
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i].x;
a[i].can = 0;
}
for (int i = 1; i <= m; i++) {
int p;
cin >> p;
a[p].can = 1;
}
sort(a + 1, a + 1 + n, cmp);
long long sum = 0;
for (int i = 1; i <= (n - m); i++) sum += a[i].x;
for (int i = n - m + 1; i <= n; i++)
sum = max(sum * 2, sum + (long long)a[i].x);
cout << sum;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[100005], f[100005][320], n, m, t, x, k;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
t = int(sqrt(double(n)));
cin >> m;
for (int i = 1; i <= t; i++) {
for (int j = n; j >= 1; j--) {
if (j + a[j] + i > n)
f[j][i] = 1;
else
f[j][i] = f[j + a[j] + i][i] + 1;
}
}
for (int i = 1; i <= m; i++) {
int ans = 0;
cin >> x >> k;
if (k <= t) {
cout << f[x][k] << endl;
} else {
while (x <= n) {
ans++;
x += a[x] + k;
}
cout << ans << endl;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <int R, int C, class T>
struct Matrix {
T m[R][C];
inline T *operator[](int r) { return m[r]; }
inline const T *operator[](int r) const { return m[r]; }
};
template <int R, int C, class T>
void print(const Matrix<R, C, T> &m) {
int w = 1;
for (int r = int(0); r < int(R); ++r)
for (int c = int(0); c < int(C); ++c)
w = max(w, 1 + int(log(m[r][c]) / log(10)));
for (int r = int(0); r < int(R); ++r) {
for (int c = int(0); c < int(C); ++c) printf(" %*d", w, (int)m[r][c]);
putchar('\n');
}
putchar('\n');
}
template <int R, int C, class T>
void mzero(Matrix<R, C, T> &m) {
memset(m.m, 0, sizeof(m.m));
}
template <int R, int C, class T>
void mone(Matrix<R, C, T> &m) {
for (int r = int(0); r < int(R); ++r)
for (int c = int(0); c < int(C); ++c) m[r][c] = (r == c);
}
template <class T>
inline void add(T &a, const T &b, T M) {
if (a += b >= M) a -= M;
}
template <int R, int C, class T>
void madd(Matrix<R, C, T> &a, const Matrix<R, C, T> &b, T M) {
for (int r = int(0); r < int(R); ++r)
for (int c = int(0); c < int(C); ++c) add(a[r][c], b[r][c], M);
}
template <class T>
inline void sub(T &a, const T &b, T M) {
if (a < b) a += M;
a -= b;
}
template <int R, int C, class T>
void msub(Matrix<R, C, T> &a, const Matrix<R, C, T> &b, T M) {
for (int r = int(0); r < int(R); ++r)
for (int c = int(0); c < int(C); ++c) sub(a[r][c], b[r][c], M);
}
template <int R, int C>
void mmul(Matrix<R, C, int> &a, const Matrix<C, C, int> &b, int M) {
Matrix<R, C, int> t;
for (int r = int(0); r < int(R); ++r)
for (int c = int(0); c < int(C); ++c) {
t[r][c] = 0;
for (int i = int(0); i < int(C); ++i)
t[r][c] = (int)((t[r][c] + (long long)a[r][i] * b[i][c]) % M);
}
a = t;
}
template <int S, class I, class T>
void mpow(Matrix<S, S, T> &m, I n, T M) {
if (n >= 2) {
Matrix<S, S, T> t = m;
mpow(t, n / 2, M);
mmul(t, t, M);
if (n % 2) mmul(t, m, M);
m = t;
} else if (n == 0)
mone(m);
}
template <int S, class I, class T>
void mpowsum(Matrix<S, S, T> &m, I n, T M) {
assert(n > 0);
if (n >= 2) {
Matrix<S, S, T> x = m, y = m;
if (n % 2)
mpow(m, n, M);
else
mzero(m);
mpowsum(x, n / 2, M);
madd(m, x, M);
mpow(y, n / 2, M);
mmul(x, y, M);
madd(m, x, M);
}
}
const int MOD = 1000003;
namespace {
int solve(int C, int W, int H) {
Matrix<101, 101, int> trans;
mzero(trans);
for (int r = 0; r <= W; ++r) trans[r][0] = 1;
for (int c = 1; c <= W; ++c) trans[c - 1][c] = H;
mpow(trans, C, MOD);
int res = 0;
for (int c = 0; c <= 100; ++c) res = (res + trans[0][c]) % MOD;
return res;
}
} // namespace
int main() {
int C = 0, W = 0, H = 0;
cin >> C >> W >> H;
cout << solve(C, W, H) << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> ints(pair<int, int> a, pair<int, int> b) {
if (a.first > b.first) swap(a, b);
if (b.first > a.second) return {1050000000, -1050000000};
int end(min(a.second, b.second));
return {b.first, end};
}
void solve() {
int n;
scanf("%d", &n);
vector<pair<int, int> > hm(n);
long double total(1);
for (int i(0), _l((int)(n)-1); i <= _l; ++i) {
scanf("%d%d", &hm[i].first, &hm[i].second);
total *= (hm[i].second - hm[i].first + 1);
}
long double have(0);
int to(1 << n);
double check(0);
for (int cost(1), _l(10000); cost <= _l; ++cost) {
for (int paid(0), _l((int)(to)-1); paid <= _l; ++paid) {
if (paid == 0) continue;
bool ok(true);
int cnt0(0);
for (int i(0), _l((int)(n)-1); i <= _l; ++i)
if ((paid & (1 << i))) ++cnt0;
for (int i(0), _l((int)(n)-1); i <= _l; ++i)
if ((paid & (1 << i)) && (hm[i].first > cost || hm[i].second < cost))
ok = false;
if (!ok) continue;
for (int paid_more(0), _l((int)(to)-1); paid_more <= _l; ++paid_more) {
if (cnt0 == 1 && paid_more == 0) continue;
int cnt2(0);
for (int i(0), _l((int)(n)-1); i <= _l; ++i)
if ((1 << i) & (paid_more)) cnt2++;
if (cnt2 > 1) continue;
ok = true;
if (paid_more & paid) continue;
pair<int, int> can(-1050000000, 1050000000);
if (paid_more == 0) can = make_pair(cost + 1, cost + 1);
for (int i(0), _l((int)(n)-1); i <= _l; ++i)
if ((paid_more & (1 << i))) {
can = ints(can, hm[i]);
if (can.first > can.second) ok = false;
}
if (!ok) continue;
can.first = max(can.first, cost + 1);
if (can.first > can.second) continue;
long double q2(1);
for (int i(0), _l((int)(n)-1); i <= _l; ++i)
if ((!(paid_more & (1 << i))) && (!(paid & (1 << i)))) {
pair<int, int> crn(hm[i]);
crn = ints(crn, {-1050000000, cost - 1});
if (crn.first > crn.second) crn.first = crn.second + 1;
q2 *= (crn.second - crn.first + 1);
}
check += (can.second - can.first + 1) * q2;
have += cost * (can.second - can.first + 1) * q2;
}
}
}
printf("%.15lf\n", (double)(have / total));
}
int main() {
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct vertex {
char type;
vector<int> in;
bool val;
bool change;
};
int n;
vector<vertex> g;
int dfs1(int v) {
switch (g[v].type) {
case 'A':
g[v].val = dfs1(g[v].in[0]) & dfs1(g[v].in[1]);
break;
case 'O':
g[v].val = dfs1(g[v].in[0]) | dfs1(g[v].in[1]);
break;
case 'X':
g[v].val = dfs1(g[v].in[0]) ^ dfs1(g[v].in[1]);
break;
case 'N':
g[v].val = !dfs1(g[v].in[0]);
break;
}
return g[v].val;
}
void dfs2(int v) {
if (g[v].change == false)
for (int i = 0; i < g[v].in.size(); i++) g[g[v].in[i]].change = false;
else
switch (g[v].type) {
case 'A':
if (g[v].val == (!g[g[v].in[0]].val & g[g[v].in[1]].val))
g[g[v].in[0]].change = false;
else
g[g[v].in[0]].change = true;
if (g[v].val == (g[g[v].in[0]].val & !g[g[v].in[1]].val))
g[g[v].in[1]].change = false;
else
g[g[v].in[1]].change = true;
break;
case 'O':
if (g[v].val == (!g[g[v].in[0]].val | g[g[v].in[1]].val))
g[g[v].in[0]].change = false;
else
g[g[v].in[0]].change = true;
if (g[v].val == (g[g[v].in[0]].val | !g[g[v].in[1]].val))
g[g[v].in[1]].change = false;
else
g[g[v].in[1]].change = true;
break;
case 'X':
if (g[v].val == (!g[g[v].in[0]].val ^ g[g[v].in[1]].val))
g[g[v].in[0]].change = false;
else
g[g[v].in[0]].change = true;
if (g[v].val == (g[g[v].in[0]].val ^ !g[g[v].in[1]].val))
g[g[v].in[1]].change = false;
else
g[g[v].in[1]].change = true;
break;
case 'N':
if (g[v].val == (!!g[g[v].in[0]].val))
g[g[v].in[0]].change = false;
else
g[g[v].in[0]].change = true;
break;
}
for (int i = 0; i < g[v].in.size(); i++) dfs2(g[v].in[i]);
}
int main() {
scanf("%d", &n);
g.resize(n);
for (int i = 0; i < n; i++) {
char c[4];
scanf("%s", c);
g[i].type = c[0];
int x;
switch (g[i].type) {
case 'I':
scanf("%d", &x);
g[i].val = x;
break;
case 'N':
scanf("%d", &x);
g[i].in.push_back(x - 1);
break;
default:
scanf("%d", &x);
g[i].in.push_back(x - 1);
scanf("%d", &x);
g[i].in.push_back(x - 1);
break;
}
}
dfs1(0);
g[0].change = true;
dfs2(0);
for (int i = 0; i < n; i++)
if (g[i].type == 'I') printf("%d", g[0].val ^ g[i].change);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, i, ans;
cin >> a >> b;
if (a == b) {
cout << "infinity\n";
return 0;
}
a -= b;
ans = 0;
for (i = 1; i * i <= a; i++) {
if (!(a % i)) {
if (i > b) ans++;
if (i * i < a && a / i > b) ans++;
}
}
cout << ans << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, d, x, a[101010], b[101010], c[101010], ans, s, mp[101010], k;
vector<int> v;
long long getNextX() {
x = (x * 37 + 10007) % 1000000007;
return x;
}
void initAB() {
int i;
for (i = 0; i < n; i = i + 1) {
a[i] = i + 1;
}
for (i = 0; i < n; i = i + 1) {
swap(a[i], a[getNextX() % (i + 1)]);
}
for (i = 0; i < n; i = i + 1) {
if (i < d)
b[i] = 1;
else
b[i] = 0;
}
for (i = 0; i < n; i = i + 1) {
swap(b[i], b[getNextX() % (i + 1)]);
}
for (int i = n; i >= 1; i--) {
a[i] = a[i - 1];
b[i] = b[i - 1];
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> d >> x;
initAB();
s = min(n, (long long)40);
for (int i = 1; i <= n; i++) {
mp[a[i]] = i;
}
for (int i = 1; i <= n; i++) {
if (b[i]) v.push_back(i);
if (v.empty()) {
c[i] = 0;
continue;
}
for (int j = n; j >= n - s + 1; j--) {
if (mp[j] <= i && b[i - mp[j] + 1]) {
c[i] = j;
break;
}
}
if (c[i]) continue;
k = v.size() - 1;
ans = 0;
for (int j = 0; j <= k; j++) {
ans = max(ans, a[i - v[j] + 1]);
}
c[i] = ans;
}
for (int i = 1; i <= n; i++) {
cout << c[i] << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int ff[55], ss[55];
long double p[55];
long double dp[55][5500];
int n, r;
bool check(long double ans) {
for (int j = 0; j <= r; ++j) {
if (n == 1 and j == r) {
dp[n][r] =
p[n] * (ff[n] <= j ? (long double)ff[n] : (long double)ff[n] + ans) +
(1.0 - p[n]) *
(ss[n] <= j ? (long double)ss[n] : (long double)ss[n] + ans);
} else {
dp[n][j] = min(
ans,
p[n] * (ff[n] <= j ? (long double)ff[n] : (long double)ff[n] + ans) +
(1.0 - p[n]) *
(ss[n] <= j ? (long double)ss[n] : (long double)ss[n] + ans));
}
}
for (int i = n - 1; i >= 1; --i) {
for (int j = 0; j <= r; ++j) {
long double a =
p[i] * (ff[i] <= j ? (long double)ff[i] + dp[i + 1][j - ff[i]]
: (long double)ff[i] + ans) +
(1.0 - p[i]) * (ss[i] <= j ? (long double)ss[i] + dp[i + 1][j - ss[i]]
: (long double)ss[i] + ans);
if (i == 1 and j == r) {
dp[i][j] = a;
} else
dp[i][j] = min(ans, a);
}
}
return dp[1][r] < ans;
}
int main() {
cin >> n >> r;
for (int i = 1; i <= n; ++i) {
cin >> ff[i] >> ss[i] >> p[i];
p[i] /= 100.0;
}
long double lo = 0, hi = 1e18, md;
for (int i = 0; i < 180; ++i) {
md = (lo + hi) / 2.0;
if (check(md))
hi = md;
else
lo = md;
}
cout << fixed << setprecision(10) << hi << endl;
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.