solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
long double p[111], a[111];
int n;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
a[i] = x / 100.0;
}
if (n == 1) {
puts("1.00000000");
return 0;
}
long double cur = 1.0;
for (int i = 1; i <= n; i++) p[i] = 1 - a[i], cur *= a[i];
long double ans = n;
for (int i = 1; i <= 500000; i++) {
ans += 1 - cur;
long double tpcur = 0;
int cs;
for (int j = 1; j <= n; j++) {
if (cur / (1 - p[j]) * (1 - p[j] * (1 - a[j])) > tpcur) {
cs = j;
tpcur = cur / (1 - p[j]) * (1 - p[j] * (1 - a[j]));
}
}
cur = cur / (1 - p[cs]) * (1 - p[cs] * (1 - a[cs]));
p[cs] *= (1 - a[cs]);
}
cout << fixed << setprecision(12) << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int a[3];
for (int i = 0; i < 3; i++) {
cin >> a[i];
}
long long int result;
result = (a[0] + a[1] + a[2]) / 3;
sort(a, a + 3);
if ((a[0] + a[1]) < result) {
result = a[0] + a[1];
}
cout << result;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int orientation(int x1, int y1, int x2, int y2, int x3, int y3) {
int val = (y2 - y1) * (x3 - x2) - (y3 - y2) * (x2 - x1);
if (val == 0) return 0;
return val > 0 ? 1 : 2;
}
int onSegment(int x1, int y1, int x2, int y2, int x3, int y3) {
if (x2 <= max(x1, x3) && x2 >= min(x1, x3) && y2 <= max(y1, y3) &&
y2 >= min(y1, y3))
return 1;
return 0;
}
float area(int x1, int y1, int x2, int y2, int x3, int y3) {
return abs((x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2)) / 2.0);
}
bool check(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4,
int x, int y) {
float A = area(x1, y1, x2, y2, x3, y3) + area(x1, y1, x4, y4, x3, y3);
float A1 = area(x, y, x1, y1, x2, y2);
float A2 = area(x, y, x2, y2, x3, y3);
float A3 = area(x, y, x3, y3, x4, y4);
float A4 = area(x, y, x1, y1, x4, y4);
return (A == A1 + A2 + A3 + A4);
}
int dointersect(int x1, int y1, int x2, int y2, int x3, int y3, int x4,
int y4) {
int o1 = orientation(x1, y1, x2, y2, x3, y3);
int o2 = orientation(x1, y1, x2, y2, x4, y4);
int o3 = orientation(x3, y3, x4, y4, x1, y1);
int o4 = orientation(x3, y3, x4, y4, x2, y2);
if (o1 != o2 && o3 != o4) {
return 1;
}
if (o1 == 0 && onSegment(x1, y1, x3, y3, x2, y2)) return 1;
if (o2 == 0 && onSegment(x1, y1, x4, y4, x2, y2)) return 1;
if (o3 == 0 && onSegment(x3, y3, x1, y1, x4, y4)) return 1;
if (o4 == 0 && onSegment(x3, y3, x2, y2, x4, y4)) return 1;
return 0;
}
int main() {
int x1[4], y1[4], x2[4], y2[4];
for (int i = 0; i < 4; i++) cin >> x1[i] >> y1[i];
for (int i = 0; i < 4; i++) cin >> x2[i] >> y2[i];
int cx, cy;
cx = (x1[0] + x1[2]) / 2;
cy = (y1[0] + y1[2]) / 2;
if (check(x2[0], y2[0], x2[1], y2[1], x2[2], y2[2], x2[3], y2[3], cx, cy)) {
cout << "YES";
return 0;
}
cx = (x2[0] + x2[2]) / 2;
cy = (y2[0] + y2[2]) / 2;
if (check(x1[0], y1[0], x1[1], y1[1], x1[2], y1[2], x1[3], y1[3], cx, cy)) {
cout << "YES";
return 0;
}
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
int t = dointersect(x1[i], y1[i], x1[(i + 1) % 4], y1[(i + 1) % 4], x2[j],
y2[j], x2[(j + 1) % 4], y2[(j + 1) % 4]);
if (t == 1) {
cout << "YES";
return 0;
}
}
}
cout << "NO";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300005;
const long long inf = 1 << 27;
const long long mod = 1e9 + 7;
int n;
double r, v, s, f;
double PI = acos(-1.0);
int check(double t) {
double angle = fmod(v * t, 2 * PI * r) / (2 * r);
return v * t + 2 * r * abs(sin(angle)) >= f - s;
}
int main() {
scanf("%d%lf%lf", &n, &r, &v);
while (n--) {
scanf("%lf%lf", &s, &f);
double l = 0, r = 999999999999;
for (int i = 0; i < 100; i++) {
double mid = (l + r) / 2;
if (check(mid))
r = mid;
else
l = mid;
}
printf("%.15lf\n", l);
}
return 0;
}
| 2 |
#include <bits/stdc++.h> // g++ -std=c++14 -o a a.cpp
using namespace std;
typedef pair<int, int> P;
typedef long long ll;
#define rep(i, n) for(int i = 0; i < (n); i++)
#define repto(i, n) for(int i = 0; i <= (n); i++)
#define all(c) (c).begin(), (c).end()
#define uniq(c) c.erase(unique(all(c)), (c).end()) // ユニークなvectorにする。連続した値を除去して切り出す。
#define _1 first
#define _2 second
#define pb push_back
#define INF 1145141919
#define MOD 1000000007
#define DEBUG(x) cout << #x << ": " << x << endl;
__attribute__((constructor))
void initial() {
cin.tie(0);
ios::sync_with_stdio(false);
}
int main() {
int N;
cin >> N;
vector<int> d;
rep(i, N) {
int di;
cin >> di;
d.pb(di);
}
int maxGo = 0;
for (int i = 0; i < N; i++) {
// DEBUG(i);
// DEBUG(maxGo);
if(maxGo < i) break;
maxGo = max((d[i] / 10) + i, maxGo);
}
if (maxGo < (N - 1)) {
cout << "no" << endl;
return 0;
}
int minBack = N - 1;
for(int i = N - 1; i > 0 ; i--) {
// DEBUG(i);
// DEBUG(minBack);
if(i < minBack) break;
minBack = min(minBack, i - (d[i] / 10));
}
if (minBack > 0) {
cout << "no" << endl;
return 0;
}
cout << "yes" << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("O0")
#pragma GCC optimize("O1")
long long pw(int a, int b) {
long long ret = 1;
long long mul = a;
while (b > 0) {
if (b & 1) ret *= mul;
mul *= mul;
b /= 2;
}
return ret;
}
long long to_int(string s) {
long long ret = 0;
for (int(i) = (0); (i) < (s.size()); (i)++) {
ret += pw(10, s.size() - i - 1) * (long long)(s[i] - '0');
}
return ret;
}
const int MAXN = 1e5 + 15;
int a[MAXN], b[MAXN], bit[2][MAXN], n, p1, p2 = 1;
long long k, ans, inv;
void upd(int r, int d, int t) {
for (; r < n; r |= (r + 1)) bit[t][r] += d;
}
int get(int r, int t) {
int ret = 0;
for (; r >= 0; r = (r & (r + 1)) - 1) ret += bit[t][r];
return ret;
}
int main() {
cin >> n >> k;
for (int(i) = (0); (i) < (n); (i)++) cin >> a[i], b[i] = a[i];
sort(b, b + n);
map<int, int> key;
int cur = 1;
for (int(i) = (0); (i) < (n); (i)++)
if (key[b[i]] == 0) key[b[i]] = cur++;
for (int(i) = (0); (i) < (n); (i)++) a[i] = key[a[i]] - 1;
for (int(i) = (0); (i) < (n); (i)++) {
inv += i - (i > 0) - get(a[i], 1) + (i && a[0] > a[i]);
upd(a[i], 1, (i > 0));
}
while (p2 < n - 1 or p1 < n - 2) {
if (inv <= k and p1 < p2 - 1) {
ans += n - p2;
p1++;
inv += get(a[p1] - 1, 1) + p1 - get(a[p1], 0);
upd(a[p1], 1, 0);
} else {
if (p2 == n - 1) break;
if (inv <= k) ans++;
inv -= get(a[p2] - 1, 1) + p1 + 1 - get(a[p2], 0);
upd(a[p2], -1, 1);
p2++;
}
}
ans += (inv <= k);
cout << ans << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, a[100005], sum, z;
int main() {
ios_base::sync_with_stdio(0);
cin >> n; z = n * (n + 1) / 2;
for(int i = 0; i < n; ++i) cin >> a[i], sum += a[i];
a[n] = a[0];
if(sum % z) return cout << "NO\n", 0;
for(int i = 0; i < n; ++i)
if(-a[i + 1] + a[i] + sum / z < 0 || (-a[i + 1] + a[i] + sum / z) % n) return cout << "NO\n", 0;
cout << "YES\n";
return 0;
}
| 0 |
#include <cstdio>
#define MOD 1000000007
typedef long long ll;
ll pw[2005], dp[2005][2005];
int main()
{
// freopen("ARC068-F.in", "r", stdin);
int n, k;
scanf("%d%d", &n, &k);
pw[0] = 1;
for (int i = 1; i <= n; i++)
pw[i] = pw[i - 1] * 2 % MOD;
ll ans = 0;
for (int i = 2; i <= n; i++)
dp[1][i] = 1;
for (int i = 1; i < k - 1; i++)
{
ll sum = dp[i][n - i + 1];
for (int j = n - i; j >= 2; j--)
{
(sum += dp[i][j]) %= MOD;
(dp[i + 1][j] += sum) %= MOD;
}
}
for (int i = 2; i <= n; i++)
(ans += dp[k - 1][i]) %= MOD;
if (k == 1)
ans = 1;
if (n == k)
printf("%lld\n", ans);
else
printf("%lld\n", ans * pw[n - k - 1] % MOD);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool prime(int n) {
bool x = 0;
for (int i = 2; i < n; i++)
if (n % i == 0) x = 1;
if (x)
return 0;
else
return 1;
}
int main() {
int n, m, x = 1;
cin >> n >> m;
bool b;
for (int i = n + 1; i <= m; i++) {
b = prime(i);
if (b && i != m) {
x = 1;
break;
}
if (b && i == m) x = 2;
}
if (x == 1)
cout << "NO";
else
cout << "YES";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<pair<int, int> > v;
bool compS(const pair<int, int>& a, const pair<int, int>& b) {
return a.second < b.second;
}
bool solve(vector<pair<int, int> > v, int pos) {
int x = v[pos].first, y = v[pos].second;
int mix = INT_MAX, maxx = 0, miy = INT_MAX, may = 0, i;
sort((v).begin(), (v).end());
for (i = (0); i <= (4 * n); i++) {
if (v[i].first == x && v[i].second == y) continue;
mix = min(mix, v[i].first);
maxx = max(maxx, v[i].first);
}
sort((v).begin(), (v).end(), compS);
for (i = (0); i <= (4 * n); i++) {
if (v[i].first == x && v[i].second == y) continue;
miy = min(miy, v[i].second);
may = max(may, v[i].second);
}
if (maxx - mix != may - miy) return false;
for (i = (0); i <= (4 * n); i++) {
if (v[i].first == x && v[i].second == y) continue;
if (v[i].first == mix || v[i].first == maxx) continue;
if (v[i].second == miy || v[i].second == may) continue;
return false;
}
return true;
}
int main(int argc, char const* argv[]) {
cin >> n;
int i;
v = vector<pair<int, int> >(4 * n + 1);
for (i = (0); i <= (4 * n); i++) cin >> v[i].first >> v[i].second;
pair<int, int> ans = {-1, -1};
for (i = (0); i <= (4 * n); i++) {
if (solve(v, i)) {
ans = {v[i].first, v[i].second};
break;
}
}
cout << ans.first << " " << ans.second << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize(3, "Ofast", "inline")
#pragma GCC target("avx,avx2")
using namespace std;
template <class t>
inline t read(t &x) {
char c = getchar();
bool f = 0;
x = 0;
while (!isdigit(c)) f |= c == '-', c = getchar();
while (isdigit(c)) x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
if (f) x = -x;
return x;
}
template <class t>
inline void write(t x) {
if (x < 0)
putchar('-'), write(-x);
else {
if (x > 9) write(x / 10);
putchar('0' + x % 10);
}
}
const int N = 1005;
int n, id, pos, nxt[N], a[N], m;
bool v[N];
bitset<1005> f;
signed main() {
read(n);
read(id);
for (int i = 1, x; i <= n; i++)
if (read(x)) v[i] = 1, nxt[x] = i;
for (int i = 1; i <= n; i++)
if (!v[i]) {
int cnt = 1;
bool flag = 1;
for (int x = i; x && flag; cnt++, x = nxt[x])
if (x == id) {
flag = 0;
pos = cnt;
break;
}
if (flag) a[++m] = cnt - 1;
}
f[0] = 1;
for (int i = 1; i <= m; i++) f |= f << a[i];
for (int i = 0; i + pos <= n; i++)
if (f[i]) write(i + pos), puts("");
}
| 2 |
#include<iostream>
#define r(i,n) for(int i=0;i<n;i++)
using namespace std;
int H,W;
char f[55][55];
int dx[] = {0,0,-1,1};
int dy[] = {1,-1,0,0};
int main(){
cin >> H >> W;
r(i,H)r(j,W) cin >> f[i][j];
r(i,H)r(j,W) if(f[i][j]=='#'){
int sum = 0;
r(k,4){
int y = i+dy[k];
int x = j+dx[k];
if(y<0||x<0||y>=H||x>=W) continue;
if(f[y][x]=='#') sum++;
}
if(!sum){
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
int q, l1, r1, l2, r2;
cin >> q;
while (q--) {
cin >> l1 >> r1 >> l2 >> r2;
cout << l1 << " " << ((l1 == l2) ? r2 : l2) << "\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxv = 200000 + 5;
vector<int> G[maxv];
int a[maxv], b[maxv], in[maxv], out[maxv];
int tim;
void dfs(int cur, int fa) {
in[cur] = ++tim;
b[tim] = a[cur];
for (auto o : G[cur])
if (o != fa) {
dfs(o, cur);
}
out[cur] = tim;
}
const int maxn = maxv << 2 + 5;
int tree[maxn], lazy[maxn];
void pushup(int rt) { tree[rt] = tree[rt << 1] + tree[rt << 1 | 1]; }
void build(int l, int r, int rt) {
if (l == r) {
tree[rt] = b[l];
return;
}
int mid = (l + r) / 2;
build(l, mid, rt << 1);
build(mid + 1, r, rt << 1 | 1);
pushup(rt);
}
void pushdown(int l, int r, int rt) {
if (lazy[rt]) {
int mid = (l + r) / 2;
tree[rt << 1] = (mid - l + 1) - tree[rt << 1];
tree[rt << 1 | 1] = (r - (mid + 1) + 1) - tree[rt << 1 | 1];
lazy[rt << 1] ^= 1;
lazy[rt << 1 | 1] ^= 1;
lazy[rt] = 0;
}
}
int query(int ql, int qr, int l, int r, int rt) {
if (ql <= l && r <= qr) return tree[rt];
pushdown(l, r, rt);
int ret = 0, mid = (l + r) / 2;
if (ql <= mid) ret += query(ql, qr, l, mid, rt << 1);
if (qr > mid) ret += query(ql, qr, mid + 1, r, rt << 1 | 1);
return ret;
}
void update(int ql, int qr, int l, int r, int rt) {
if (ql <= l && r <= qr) {
tree[rt] = (r - l + 1) - tree[rt];
lazy[rt] ^= 1;
return;
}
pushdown(l, r, rt);
int mid = (l + r) / 2;
if (ql <= mid) update(ql, qr, l, mid, rt << 1);
if (qr > mid) update(ql, qr, mid + 1, r, rt << 1 | 1);
pushup(rt);
}
int main() {
int n;
scanf("%d", &n);
for (int i = 2, x; i <= n; i++) {
scanf("%d", &x);
G[x].push_back(i);
}
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
tim = 0;
dfs(1, -1);
build(1, n, 1);
int q;
scanf("%d\n", &q);
while (q--) {
char cmd[10];
int id;
scanf("%s %d", cmd, &id);
if (cmd[0] == 'g') {
printf("%d\n", query(in[id], out[id], 1, n, 1));
} else {
update(in[id], out[id], 1, n, 1);
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-9;
const int inf = (1 << 30) - 1;
const long long inf64 = ((long long)1 << 62) - 1;
const long double pi = 3.1415926535897932384626433832795;
template <class T>
T sqr(T x) {
return x * x;
}
template <class T>
T abs(T x) {
return x < 0 ? -x : x;
}
const int mod = 1000000007;
long long sum(long long a, long long b) { return (a + b) % mod; }
long long prod(long long a, long long b) { return (a * b) % mod; }
int main() {
int n, n1 = 0, n2 = 0;
cin >> n;
for (int i = 0; i < n; ++i) {
int t;
cin >> t;
if (t == 1)
n1++;
else
n2++;
}
long long m = 1;
long long m_old = 1;
for (int i = 2; i <= n1; ++i) {
long long m_new = sum(m, prod(m_old, i - 1));
m_old = m;
m = m_new;
}
for (int i = 0; i < n2; ++i) {
m = prod(m, n1 + i + 1);
}
cout << m << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int to, nxxt;
} e[100002];
int n, m, blk, bel[100002], fa[100002], dep[100002], siz[100002], son[100002],
dfn[100002], rev[100002], tot[100002], c[100002], head[100002], cnt = 1, js;
int t[100002], laz[320], lx[320], rx[320], cn, ans, sum[320], st[100002];
short b[320][100002 << 1];
bool vis[100002];
inline void ins(int u, int v) {
e[cnt] = (edge){v, head[u]};
head[u] = cnt++;
}
void df5(int te) {
siz[te] = 1;
for (int i = head[te]; i; i = e[i].nxxt) {
int j = e[i].to;
dep[j] = dep[te] + 1;
df5(j);
siz[te] += siz[j];
if (siz[j] > siz[son[te]]) son[te] = j;
}
}
void dfs(int te) {
tot[te] = te == son[fa[te]] ? tot[fa[te]] : te;
dfn[te] = ++js, rev[js] = te;
if (son[te]) dfs(son[te]);
for (int i = head[te]; i; i = e[i].nxxt)
if (e[i].to ^ son[te]) dfs(e[i].to);
}
inline void chng(int x, int y) {
for (int i = x; i <= n; i += (i & (-i))) c[i] += y;
}
inline int ask(int x) {
int ret = 0;
for (int i = x; i; i -= (i & (-i))) ret += c[i];
return ret;
}
inline void clr(int x) {
for (int i = lx[x]; i <= rx[x]; i++)
if (!vis[i]) b[x][t[i]] = 0;
for (int i = lx[x]; i <= rx[x]; i++)
if (!vis[i]) t[i] += laz[x];
laz[x] = 0;
ans -= sum[x];
sum[x] = 0;
}
inline void bt(int x) {
for (int i = lx[x]; i <= rx[x]; i++)
if (!vis[i]) {
b[x][t[i]]++;
if (t[i] > n) sum[x]++;
}
ans += sum[x];
}
inline void cg(int l, int r, int op) {
if (bel[r] - bel[l] <= 1) {
for (int i = bel[l]; i <= bel[r]; i++) clr(i);
for (int i = l; i <= r; i++) t[i] += op;
for (int i = bel[l]; i <= bel[r]; i++) bt(i);
return;
}
clr(bel[l]);
for (int i = l; i <= rx[bel[l]]; i++) t[i] += op;
bt(bel[l]);
clr(bel[r]);
for (int i = lx[bel[r]]; i <= r; i++) t[i] += op;
bt(bel[r]);
for (int i = bel[l] + 1; i < bel[r]; i++) {
ans -= sum[i];
if (op > 0) {
laz[i]++;
if (n - laz[i] + 1 >= 0 && n - laz[i] + 1 <= 2 * n)
sum[i] += b[i][n - laz[i] + 1];
} else {
if (n - laz[i] + 1 >= 0 && n - laz[i] + 1 <= 2 * n)
sum[i] -= b[i][n - laz[i] + 1];
laz[i]--;
}
ans += sum[i];
}
}
int main() {
scanf("%d%d", &n, &m);
blk = sqrt(n) + 1;
for (int i = 1, j; i <= n; i = j + 1) {
j = min(n, i + blk - 1);
cn++;
for (int ii = i; ii <= j; ii++) bel[ii] = cn;
lx[cn] = i, rx[cn] = j;
}
for (int i = 2; i <= n; i++) {
scanf("%d", &fa[i]);
ins(fa[i], i);
}
df5(1);
dfs(1);
for (int i = 1; i <= n; i++) scanf("%d", &st[i]), t[dfn[i]] = n - st[i];
for (int i = 1; i <= cn; i++) bt(i);
while (m--) {
int x;
scanf("%d", &x);
if (x > 0) {
chng(dfn[x], 1);
clr(bel[dfn[x]]);
vis[dfn[x]] = 1;
bt(bel[dfn[x]]);
while (x) cg(dfn[tot[x]], dfn[x], 1), x = fa[tot[x]];
} else {
x = -x;
chng(dfn[x], -1);
clr(bel[dfn[x]]);
vis[dfn[x]] = 0;
t[dfn[x]] = n + ask(dfn[x] + siz[x] - 1) - ask(dfn[x] - 1) - st[x];
bt(bel[dfn[x]]);
x = fa[x];
while (x) cg(dfn[tot[x]], dfn[x], -1), x = fa[tot[x]];
}
printf("%d\n", ans);
}
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
void solve(int n, int w, vector<int> v){
int bars[12] = {};
int max_v = *max_element(v.begin(), v.end());
int n_bar = ceil((double)max_v / (double)w) + (max_v % w == 0);
double delta_ink = 1.0 / (double)(n_bar - 1);
for(int i=0;i<n;i++){
bars[v[i] / w]++;
}
int max_h = *max_element(bars, bars+n_bar);
double ans = 0.01;
double ink = 1.0;
for(int i=0;i<n_bar;i++){
ans += ((double)bars[i] / (double)max_h) * ink;
ink -= delta_ink;
}
cout << fixed << setprecision(6) << ans << endl;
return;
}
int main(){
while(true){
int n, w;
vector<int> v;
cin >> n >> w;
if(!(n || w)) break;
for(int i=0;i<n;i++){
int tmp;
cin >> tmp;
v.push_back(tmp);
}
solve(n, w, v);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long val[110000];
long long Left[110000][2], Right[110000][2];
int main() {
int i, j, h;
int T, n, m;
int cas = 1;
while (scanf("%d", &n) != EOF) {
for (i = 1; i < n; i++) {
scanf("%I64d", &val[i]);
}
Left[1][0] = Left[1][1] = 0;
for (i = 2; i <= n; i++) {
if (val[i - 1] >= 2)
Left[i][1] = Left[i - 1][1] + val[i - 1] / 2 * 2;
else
Left[i][1] = 0;
if (val[i - 1] & 1)
Left[i][0] = val[i - 1] + max(Left[i - 1][0], Left[i - 1][1]);
else
Left[i][0] = val[i - 1] + max(Left[i - 1][0], Left[i - 1][1]) - 1;
}
Right[n][0] = Right[n][1] = 0;
for (i = n - 1; i >= 1; i--) {
if (val[i] >= 2)
Right[i][1] = Right[i + 1][1] + val[i] / 2 * 2;
else
Right[i][1] = 0;
if (val[i] & 1)
Right[i][0] = val[i] + max(Right[i + 1][0], Right[i + 1][1]);
else
Right[i][0] = val[i] + max(Right[i + 1][0], Right[i + 1][1]) - 1;
}
long long ans = 0;
for (i = 1; i <= n; i++) {
ans = max(ans, Left[i][1] + Right[i][1]);
ans = max(ans, Left[i][1] + Right[i][0]);
ans = max(ans, Left[i][0] + Right[i][1]);
}
printf("%I64d\n", ans);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
n /= 1000;
puts(n & 1 ? "1" : "3");
return 0;
}
| 4 |
#include <vector>
#include <iostream>
#include <map>
using namespace std;
template<typename T, typename S> vector<T>& operator<<(vector<T>& a, S b) { a.push_back(b); return a; }
#define rep(i,n) for(int i=0;i<n;i++)
int main(){
map<char,int> t;
t['I']=1, t['X']=10, t['V'] = 5;
t['L'] = 50 , t['C'] = 100 , t['M'] = 1000 , t['D'] = 500;
string s;
while(cin >> s){
int ret = 0;
ret += t[s[0]];
rep(i,s.length()-1){
if(t[s[i+1]] > t[s[i]])ret -= 2*t[s[i]];
ret += t[s[i+1]];
}
cout << ret << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int r, h;
cin >> r >> h;
int sum = 0;
sum += (h / r) * 2;
int a = h % r;
if ((float)a / r - 0.866 >= 0)
sum += 3;
else if ((float)a / r - 0.5 >= 0)
sum += 2;
else
sum += 1;
cout << sum << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n = 0;
cin >> n;
vector<vector<long long>> arr(n, vector<long long>(n));
for (long long i = 0; i < n; i++) {
string s;
cin >> s;
for (long long j = 0; j < n; j++) {
for (long long j = 0; j < n; j++) arr[i][j] = s[j] - '0';
}
}
long long n1 = arr[0][1];
long long n2 = arr[1][0];
long long n3 = arr[n - 1][n - 2];
long long n4 = arr[n - 2][n - 1];
if (n1 == n2 && n2 == n3 && n3 == n4) {
cout << 2 << "\n";
cout << 1 << " " << 2 << "\n";
cout << 2 << " " << 1 << "\n";
} else if (n1 == n2 && n3 == n4) {
cout << 0 << "\n";
} else if (n1 == n2) {
cout << 1 << "\n";
if (n2 == n3)
cout << n << " " << n - 1 << "\n";
else
cout << n - 1 << " " << n << "\n";
} else if (n3 == n4) {
cout << 1 << "\n";
if (n1 == n3)
cout << 1 << " " << 2 << "\n";
else
cout << 2 << " " << 1 << "\n";
} else if (n1 == n3) {
cout << 2 << "\n";
cout << 1 << " " << 2 << "\n";
cout << n - 1 << " " << n << "\n";
} else {
cout << 2 << "\n";
cout << 1 << " " << 2 << "\n";
cout << n << " " << n - 1 << "\n";
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long t = 1;
cin >> t;
while (t--) solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
map<pair<int, int>, int> edge_no;
int max_day = 0;
vector<int> build_schedule[200001];
void addEdge(vector<int> adj[], int u, int v) {
adj[u].push_back(v);
adj[v].push_back(u);
}
void DFSUtil(int u, vector<int> adj[], vector<bool> &visited, int day) {
visited[u] = true;
int build_day = 1;
for (int i = 0; i < adj[u].size(); i++)
if (visited[adj[u][i]] == false) {
if (build_day != day) {
max_day = max(max_day, build_day);
build_schedule[build_day].push_back(edge_no[make_pair(u, adj[u][i])]);
DFSUtil(adj[u][i], adj, visited, build_day++);
} else {
max_day = max(max_day, build_day + 1);
build_schedule[build_day + 1].push_back(
edge_no[make_pair(u, adj[u][i])]);
DFSUtil(adj[u][i], adj, visited, ++build_day);
build_day++;
}
}
}
void DFS(vector<int> adj[], int V) {
vector<bool> visited(V, false);
for (int u = 1; u < V; u++)
if (visited[u] == false) DFSUtil(u, adj, visited, 0);
}
int main() {
int n, a, b;
scanf("%d", &n);
vector<int> adj[n + 1];
for (int i = 1; i < n; i++) {
scanf("%d%d", &a, &b);
addEdge(adj, a, b);
edge_no.insert(pair<pair<int, int>, int>(make_pair(a, b), i));
edge_no.insert(pair<pair<int, int>, int>(make_pair(b, a), i));
}
DFS(adj, n + 1);
printf("%d\n", max_day);
for (int i = 1; i <= max_day; i++) {
printf("%d ", build_schedule[i].size());
for (auto it = build_schedule[i].begin(); it != build_schedule[i].end();
it++) {
printf("%d ", *it);
}
printf("\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int ans;
char a[N];
int main() {
scanf("%s", &a);
int len = strlen(a);
for (int i = 0; i < len; i++) {
if (a[i] == 'A')
ans++;
else if (a[i] == '1')
ans += 10;
else
ans += a[i] - '0';
}
printf("%d\n", ans);
return 0;
}
| 6 |
#include <iostream>
#include <iomanip>
#include <vector>
#include <algorithm>
#include <cmath>
using namespace std;
const double EPS = 1e-8;
const double INF = 1e12;
#define EQ(n,m) (abs((n)-(m)) < EPS)
struct Point{
double x,y,z;
Point(double x, double y, double z):x(x), y(y), z(z){}
Point(){}
Point &operator +=(const Point &a){ x+=a.x; y+=a.y; z+=a.z; return *this; }
Point &operator -=(const Point &a){ x-=a.x; y-=a.y; z-=a.z; return *this; }
Point &operator *=(const double &a){ x*=a; y*=a; z*=a; return *this; }
Point operator +(const Point &a) const{ return Point(x+a.x, y+a.y, z+a.z); }
Point operator -(const Point &a) const{ return Point(x-a.x, y-a.y, z-a.z); }
Point operator *(const double &a) const{ return Point(a*x, a*y, a*z); }
Point operator -() { return Point(-x, -y, -z); }
};
double dot(const Point &a, const Point &b){
return a.x*b.x +a.y*b.y +a.z*b.z;
}
Point cross(const Point &a, const Point &b){
return Point(a.y*b.z -a.z*b.y, a.z*b.x -a.x*b.z, a.x*b.y -a.y*b.x);
}
double abs(const Point &a){
return sqrt(dot(a, a));
}
Point unit(const Point &a){
return a *(1/abs(a));
}
bool operator ==(const Point &a, const Point &b){
return abs(a-b) < EPS;
}
Point projectionLP3(Point p, Point q, Point c){
double t = dot(unit(q-p), c-p);
return p +unit(q-p) *t;
}
double distancePlP(Point a, Point b, Point c, Point p){
Point normal = unit(cross(b-a, c-a));
return abs(dot(normal, p-a));
}
int main(){
Point p[2][3], v[2];
for(int i=0; i<2; i++){
for(int j=0; j<3; j++){
cin >> p[i][j].x >> p[i][j].y >> p[i][j].z;
}
v[i] = cross(p[i][1], p[i][2]);
p[i][1] += p[i][0];
p[i][2] += p[i][0];
}
if(abs(cross(v[0], v[1])) < EPS){
cout << "NO" << endl;
return 0;
}
Point commondir = unit(cross(v[0], v[1]));
double angle = acos(dot(v[0], v[1]));
double d = distancePlP(p[1][0], p[1][1], p[1][2], p[0][0]) /sin(angle);
Point tocp = unit(cross(v[0], commondir));
Point cp;
if(distancePlP(p[1][0], p[1][1], p[1][2], p[0][0] +tocp*d) < EPS){
cp = p[0][0] +tocp*d;
}else{
cp = p[0][0] -tocp*d;
}
Point pro = projectionLP3(cp, cp +commondir, p[0][0]);
double dsq = dot(pro -p[0][0], pro -p[0][0]);
double dist = sqrt(1 -dsq);
if((abs(pro +commondir*dist -p[1][0]) +EPS < 1) !=
(abs(pro -commondir*dist -p[1][0]) +EPS < 1)){
cout << "YES" << endl;
}else{
cout << "NO" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char ar[] = {'q', 'w', 'e', 'r', 't', 'y', 'u', 'i', 'o', 'p',
'a', 's', 'd', 'f', 'g', 'h', 'j', 'k', 'l', ';',
'z', 'x', 'c', 'v', 'b', 'n', 'm', ',', '.', '/'};
int main() {
char dir;
cin >> dir;
string in;
cin >> in;
for (int i = 0; i < in.length(); i++) {
char c = in[i];
int pos;
for (int j = 0; j < 30; j++)
if (c == ar[j]) pos = j;
if (dir == 'R')
pos--;
else
pos++;
cout << ar[pos];
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
istream &operator>>(istream &is, vector<T> &vec) {
for (auto &v : vec) is >> v;
return is;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "[";
for (auto v : vec) os << v << ", ";
os << "]";
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const deque<T> &vec) {
os << "deq[";
for (auto v : vec) os << v << ", ";
os << "]";
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const set<T> &vec) {
os << "{";
for (auto v : vec) os << v << ", ";
os << "}";
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const unordered_set<T> &vec) {
os << "{";
for (auto v : vec) os << v << ", ";
os << "}";
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const multiset<T> &vec) {
os << "{";
for (auto v : vec) os << v << ", ";
os << "}";
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const unordered_multiset<T> &vec) {
os << "{";
for (auto v : vec) os << v << ", ";
os << "}";
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &pa) {
os << "(" << pa.first << ", " << pa.second << ")";
return os;
}
template <typename TK, typename TV>
ostream &operator<<(ostream &os, const map<TK, TV> &mp) {
os << "{";
for (auto v : mp) os << v.first << ": " << v.second << ", ";
os << "}";
return os;
}
template <typename TK, typename TV>
ostream &operator<<(ostream &os, const unordered_map<TK, TV> &mp) {
os << "{";
for (auto v : mp) os << v.first << ": " << v.second << ", ";
os << "}";
return os;
}
template <typename T>
void ndarray(vector<T> &vec, int len) {
vec.resize(len);
}
template <typename T, typename... Args>
void ndarray(vector<T> &vec, int len, Args... args) {
vec.resize(len);
for (auto &v : vec) ndarray(v, args...);
}
template <typename T>
bool chmax(T &m, const T q) {
if (m < q) {
m = q;
return true;
} else
return false;
}
template <typename T>
bool chmin(T &m, const T q) {
if (q < m) {
m = q;
return true;
} else
return false;
}
template <typename T1, typename T2>
pair<T1, T2> operator+(const pair<T1, T2> &l, const pair<T1, T2> &r) {
return make_pair(l.first + r.first, l.second + r.second);
}
template <typename T1, typename T2>
pair<T1, T2> operator-(const pair<T1, T2> &l, const pair<T1, T2> &r) {
return make_pair(l.first - r.first, l.second - r.second);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int len, shows, target;
cin >> len >> shows >> target;
vector<int> arr(len);
for (int i = 0; i < len; i++) {
cin >> arr[i];
}
map<int, int> m;
for (int i = 0; i < target; i++) m[arr[i]]++;
int small = m.size();
for (int i = 1; i <= len - target; i++) {
if (m[arr[i - 1]] == 1) {
m.erase(arr[i - 1]);
} else {
m[arr[i - 1]] -= 1;
}
m[arr[i + target - 1]]++;
if (m.size() < small) small = m.size();
}
cout << small << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m, q, dp[1010][1010];
char s[1010], t[1010];
bool used[1010];
int main() {
scanf("%d%d%d", &n, &m, &q);
scanf("%s", s + 1);
scanf("%s", t);
for (int i = 1; i + m - 1 <= n; i++) {
bool f = true;
for (int j = 0; j < m; j++) {
if (s[i + j] != t[j]) {
f = false;
break;
}
}
used[i] = f;
}
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
dp[i][j] = max(dp[i][j], dp[i][j - 1]);
if (j - m + 1 >= i && used[j - m + 1]) {
dp[i][j]++;
}
}
}
while (q--) {
int l, r;
scanf("%d%d", &l, &r);
printf("%d\n", dp[l][r]);
}
return 0;
}
| 2 |
#include<iostream>
#include<string>
using namespace std;
int main()
{
string str;
int sum = 0;
while( cin >> str )
{
int digit = 1;
for( int i = str.size() - 1; i >= 0; i-- )
{
if( '0' <= str[i] && str[i] <= '9' )
{
sum += ( str[i] - '0' ) * digit;
digit *= 10;
}
else
digit = 1;
}
}
cout << sum << endl;
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
const int MOD = 1e9+7;
int main()
{
ios_base::sync_with_stdio(0);
cin.tie(0);
int n,k;
cin >> n >> k;
ll arr[n];
int negative = 0;
for(int i = 0; i < n;i++){
cin >> arr[i];
if(arr[i] < 0)
negative++;
}
ll ans = 1;
sort(arr,arr+n);
if(n == k){
for(int i = 0; i < n;i++){
ans = ((ans*arr[i])%MOD + MOD)%MOD;
}
cout << ans << "\n";
}
else if(negative == n){
if(k&1){
for(int i = n-1; i > n-k-1;i--){
ans = ((ans * arr[i])%MOD + MOD)%MOD;
}
}
else{
for(int i = 0; i < k;i++){
ans = ((ans * arr[i])%MOD + MOD)%MOD;
}
}
cout << ans << "\n";
}
else{
int left = 0;
int right = n-1;
if(k&1){
k--;
ans = ((ans * arr[right])%MOD + MOD) %MOD;
right--;
}
while(k){
if(k > 1){
ll temp = 1;
if(arr[left] * arr[left+1] > arr[right]*arr[right-1]){
temp = ((arr[left] * arr[left+1])%MOD + MOD)%MOD;
left += 2;
}
else{
temp = ((arr[right] * arr[right-1])%MOD + MOD)%MOD;
right -= 2;
}
ans = ((ans * temp)%MOD + MOD)%MOD;
k -= 2;
}
else{
ans = ((ans * arr[right--])%MOD + MOD)%MOD;
k--;
}
}
cout << ans << "\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
vector<long long> v1;
vector<long long> v2;
int n, m;
cin >> n >> m;
int p = n;
int pp = m;
while (p--) {
long long x;
cin >> x;
v1.push_back(x);
}
while (pp--) {
long long x;
cin >> x;
v2.push_back(x);
}
sort(v1.begin(), v1.end(), greater<int>());
sort(v2.begin(), v2.end());
if (v1[0] > v2[0])
cout << "-1" << endl;
else {
int f = 0;
for (int i = 1; i < v2.size(); i++) v2[i] += v2[i - 1];
if (v1[0] == v2[0]) {
long long sm = v2[v2.size() - 1];
for (int i = 1; i < v1.size(); i++) sm = sm + v1[i] * m;
cout << sm << endl;
} else {
long long sm = v2[v2.size() - 1] + v1[0] - v1[1];
for (int i = 1; i < v1.size(); i++) sm = sm + v1[i] * m;
cout << sm << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool b[101][101];
int main() {
int n, m;
cin >> n >> m;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int q[m], w[m];
for (int i = 0; i < m; i++) {
cin >> q[i] >> w[i];
q[i]--;
w[i]--;
b[q[i]][w[i]] = true;
b[w[i]][q[i]] = true;
}
int ans = 987654321;
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (j != q[i] && j != w[i]) {
if (b[j][q[i]] && b[j][w[i]]) {
ans = min(ans, a[j] + a[w[i]] + a[q[i]]);
}
}
}
}
if (ans == 987654321) {
cout << -1;
return 0;
}
cout << ans;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100 + 10;
vector<pair<int, int>> G[maxn];
void dfs(int, int, double);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n - 1; ++i) {
int a, b;
cin >> a >> b;
G[a].push_back(make_pair(b, i));
G[b].push_back(make_pair(a, i));
}
cout << n - 1 << endl;
dfs(1, 0, 0.0);
return 0;
}
void dfs(int x, int fa, double d) {
int deg = 0, ind = 0;
for (auto u : G[x]) ++deg;
for (auto u : G[x])
if (u.first != fa) {
cout << 1 << ' ' << u.second << ' ';
++ind;
double t = d + (double)ind * (double)2 / (double)deg;
while (t > 2.0) t -= 2.0;
if (t > 1.0)
cout << x << ' ' << u.first << ' ' << fixed << setprecision(10)
<< t - 1.0 << endl;
else
cout << u.first << ' ' << x << ' ' << fixed << setprecision(10) << t
<< endl;
dfs(u.first, x, t >= 1 ? t - 1 : t + 1);
}
}
| 6 |
#include<bits/stdc++.h>
using namespace std;
double a;
string b;
long double ans;
int main(){
int n;
scanf("%d",&n);
for(int i=1;i<=n;i++){
cin>>a>>b;
if(b=="JPY") ans+=a;
else ans+=380000.0*a;
}
cout<<ans<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, p, k, x, y;
cin >> n >> p >> k;
x = p - k;
if (x <= 0) x = 1;
y = p + k;
if (y > n) y = n;
if (x > 1) cout << "<<";
for (int i = x; i <= y; i++) {
if (i == p)
cout << "(" << i << ")";
else
cout << " " << i << " ";
}
if (y < n) cout << ">>";
return 0;
}
| 1 |
#include <bits/stdc++.h>
#define syosu(x) fixed<<setprecision(x)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> P;
typedef pair<double,double> pdd;
typedef pair<ll,ll> pll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<string> vs;
typedef vector<P> vp;
typedef vector<vp> vvp;
typedef vector<pll> vpll;
typedef pair<int,P> pip;
typedef vector<pip> vip;
const int inf=1<<30;
const ll INF=1ll<<60;
const double pi=acos(-1);
const double eps=1e-8;
const ll mod=1e9+7;
const int dx[4]={-1,0,1,0},dy[4]={0,-1,0,1};
class Union_Find_Tree{
public:
int n;
vi Par;
Union_Find_Tree(int n){
Par=vi(n);
for(int i=0;i<n;i++) Par[i]=i;
}
int Find_Par(int x){
if(Par[x]==x) return x;
return Par[x]=Find_Par(Par[x]);
}
bool Unite(int x,int y){
x=Find_Par(x);
y=Find_Par(y);
if(x==y) return 0;
Par[x]=y;
return 1;
}
bool Same(int x,int y){
return Find_Par(x)==Find_Par(y);
}
};
class Graph{
private:
int n,t=0,id=0;
vvp g;
vi dis,low,par;
vp br;
void DFS(int v,int k,int pre){
dis[v]=low[v]=k;
for(auto p:g[v]){
int u=p.first,I=p.second;
if(!dis[u]){
par[u]=v;
DFS(u,k+1,I);
low[v]=min(low[v],low[u]);
if(dis[v]<low[u]) t++;
}
else if(I!=pre) low[v]=min(low[v],dis[u]);
}
}
public:
int Bridge(){
dis=low=par=vi(n);
for(int i=0;i<n;i++) if(!dis[i]) DFS(i,1,-1);
return t;
}
Graph(int v){
n=v;
g=vvp(v);
}
void add_edge(int s,int t){
g[s].push_back({t,id});
g[t].push_back({s,id++});
}
};
const int M=10001;
int n,m;
vi s[M],t[M];
int main(){
cin>>n>>m;
for(int i=0;i<m;i++){
int u,v,c;
cin>>u>>v>>c;
s[c].push_back(u-1);
t[c].push_back(v-1);
}
Union_Find_Tree uft(n);
int A=0,B=0;
for(int i=0;i<M;i++){
int cnt=0;
map<int,int> mp;
for(int j=0;j<s[i].size();j++){
int u=uft.Find_Par(s[i][j]),v=uft.Find_Par(t[i][j]);
if(u==v) continue;
if(mp.find(u)==mp.end()) mp[u]=cnt++;
if(mp.find(v)==mp.end()) mp[v]=cnt++;
}
if(!cnt) continue;
Graph g(cnt);
for(int j=0;j<s[i].size();j++){
int u=uft.Find_Par(s[i][j]),v=uft.Find_Par(t[i][j]);
u=mp[u];v=mp[v];
g.add_edge(u,v);
}
int N=g.Bridge();
A+=N;
B+=N*i;
for(int j=0;j<s[i].size();j++) uft.Unite(s[i][j],t[i][j]);
}
cout<<A<<' '<<B<<endl;
}
| 0 |
#include <cstdio>
#include <cstring>
#include <iostream>
#include <string>
#include <cmath>
#include <bitset>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <deque>
#include <algorithm>
#include <complex>
#include <unordered_map>
#include <unordered_set>
#include <random>
#include <cassert>
#include <fstream>
#include <utility>
#include <functional>
#include <time.h>
#include <stack>
#include <array>
#define popcount __builtin_popcount
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
bitset<50000> bs[50000];
bool prevx1[505][100010];
bool prevx2[505][100010];
bool prevy1[505][100010];
int main()
{
int n, m, t;
cin>>n>>m>>t;
int x[100010], y[100010];
for(int i=0; i<m; i++){
cin>>x[i]>>y[i];
x[i]--; y[i]--;
}
if(t==2){
set<P> st;
for(int i=0; i<m; i++) st.insert({x[i], y[i]});
int a=-1, b=-1;
for(int i=0; i<n; i++){
for(int j=i+1; j<n; j++){
if(st.find({i, j})==st.end()){
a=i, b=j;
break;
}
}
if(a>=0) break;
}
if(a>=0){
string ans;
for(int i=0; i<m; i++){
if(x[i]==a || x[i]==b){
ans+='^';
}else{
ans+='v';
}
}
cout<<ans<<endl;
return 0;
}
bool dp[505][505]={};
for(int i=0; i<n; i++) for(int j=i+1; j<n; j++) dp[i][j]=1;
for(int i=0; i<m; i++){
dp[x[i]][y[i]]=dp[y[i]][x[i]]=0;
bool myon[505]={};
for(int j=0; j<n; j++){
if(j==y[i] || j==x[i]) continue;
if(dp[j][x[i]] || dp[x[i]][j]){
myon[j]=1, prevy1[j][i]=1;
}
}
for(int j=0; j<n; j++){
if(j==x[i] || j==y[i]) continue;
if(dp[j][y[i]] || dp[y[i]][j]){
if(j<x[i]) dp[j][x[i]]=1, prevx1[j][i]=1;
else dp[x[i]][j]=1, prevx1[j][i]=1;
}else if(dp[j][x[i]] || dp[x[i]][j]){
prevx2[j][i]=1;
}
}
for(int j=0; j<n; j++){
if(myon[j]){
if(j<y[i]) dp[j][y[i]]=1;
else dp[y[i]][j]=1;
}
}
}
for(int i=0; i<n; i++){
for(int j=i+1; j<n; j++){
if(dp[i][j]){
a=i, b=j;
}
}
}
if(a==-1){
cout<<-1<<endl;
return 0;
}
string ans;
for(int i=0; i<m; i++) ans+='v';
int k=2*m;
for(int i=m-1; i>=0; i--){
if(a==x[i]){
if(prevx1[b][i]){
ans[i]='^';
a=y[i];
}else if(prevx2[b][i]){
ans[i]='^';
}
}else if(a==y[i]){
if(prevy1[b][i]){
a=x[i];
}
}else if(b==x[i]){
if(prevx1[a][i]){
ans[i]='^';
b=y[i];
}else if(prevx2[a][i]){
ans[i]='^';
}
}else if(b==y[i]){
if(prevy1[a][i]){
b=x[i];
}
}else{
continue;
}
if(a>b) swap(a, b);
}
cout<<ans<<endl;
return 0;
}
for(int i=0; i<n; i++) bs[i][i]=1;
for(int i=m-1; i>=0; i--){
bs[x[i]]|=bs[y[i]];
bs[y[i]]|=bs[x[i]];
}
bitset<50000> bsa=bs[0];
for(int i=1; i<n; i++){
bsa&=bs[i];
}
int a=-1;
for(int i=0; i<n; i++){
if(bsa[i]){
a=i; break;
}
}
if(a==-1){
cout<<-1<<endl;
return 0;
}
bool ok[50050]={};
ok[a]=1;
string ans;
for(int i=m-1; i>=0; i--){
if(ok[x[i]] && !ok[y[i]]){
ans+='^';
}else{
ans+='v';
}
ok[x[i]]|=ok[y[i]]; ok[y[i]]|=ok[x[i]];
}
reverse(ans.begin(), ans.end());
cout<<ans<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MXN = 60 + 10;
const long long MXM = 5e2 + 10;
const long long MX5 = 1e5 + 10;
const long long MX6 = 1e6 + 10;
const long long LOG = 20;
const long long INF = 8e18;
const double eps = 1e-9;
const long long MOD = 1e9 + 7;
long long power(long long a, long long b, long long md) {
return (!b ? 1
: (b & 1 ? a * power(a * a % md, b / 2, md) % md
: power(a * a % md, b / 2, md) % md));
}
long long bmm(long long a, long long b) {
return (a % b == 0 ? b : bmm(b, a % b));
}
string base2(long long n) {
string a = "";
while (n >= 2) {
a += (char)(n % 2 + '0');
n /= 2;
}
a += (char)(n + '0');
reverse((a).begin(), (a).end());
return a;
}
void solve() {
long long n, m, t = 0;
bool vis[MXN][MXN], flag = 0;
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
char a;
cin >> a;
if (a == 'A')
vis[i][j] = 1, flag = 1, t++;
else
vis[i][j] = 0;
}
}
if (!flag) {
cout << "MORTAL" << '\n';
return;
}
if (t == n * m) {
cout << 0 << '\n';
return;
}
bool f, f1 = 1, f2 = 1, f3 = 1, f4 = 1;
for (int i = 0; i < m; i++) {
if (vis[0][i] == 0) f1 = 0;
if (vis[n - 1][i] == 0) f2 = 0;
}
for (int i = 0; i < n; i++) {
if (vis[i][0] == 0) f3 = 0;
if (vis[i][m - 1] == 0) f4 = 0;
}
if (f1 || f2 || f3 || f4) {
cout << 1 << '\n';
return;
}
for (int i = 0; i < n; i++) {
f = 1;
for (int j = 0; j < m; j++) {
if (vis[i][j] == 0) f = 0;
}
if (f == 1) {
cout << 2 << '\n';
return;
}
}
for (int i = 0; i < m; i++) {
f = 1;
for (int j = 0; j < n; j++) {
if (vis[j][i] == 0) f = 0;
}
if (f == 1) {
cout << 2 << '\n';
return;
}
}
if (vis[0][0] || vis[0][m - 1] || vis[n - 1][0] || vis[n - 1][m - 1]) {
cout << 2 << '\n';
return;
}
f1 = 0, f2 = 0, f3 = 0, f4 = 0;
for (int i = 0; i < m; i++) {
if (vis[0][i] == 1) f1 = 1;
if (vis[n - 1][i] == 1) f2 = 1;
}
for (int i = 0; i < n; i++) {
if (vis[i][0] == 1) f3 = 1;
if (vis[i][m - 1] == 1) f4 = 1;
}
if (f1 || f2 || f3 || f4) {
cout << 3 << '\n';
return;
}
cout << 4 << '\n';
return;
}
int main() {
long long q;
cin >> q;
while (q--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n;
cin >> n;
long long int s = 0;
for (long long int i = 0; i < n; i++) {
long long int x;
cin >> x;
s += x;
}
if (s % n == 0)
cout << n;
else
cout << n - 1;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool isPrime(long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
long long seve[1000000] = {0};
set<long long> check;
void seive() {
long long i, j;
seve[0] = 1;
seve[1] = 1;
for (i = 2; i <= 1000000; i++) {
if (seve[i] == 0) {
check.insert(i);
for (j = i * i; j <= 1000000; j = j + i) seve[j] = 1;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long m, i, j = 0, f = 0, k = 0, y, x, n;
string s;
cin >> n;
long long a[2 * n];
for (i = 0; i < 2 * n; i++) cin >> a[i];
sort(a, a + 2 * n);
if (a[0] == a[2 * n - 1])
cout << "-1";
else
for (i = 0; i < 2 * n; i++) {
cout << a[i] << " ";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int len, c = 0, c1 = 0;
char s[51];
cin >> s;
len = strlen(s);
for (int i = 0; i < len - 1; i++) {
if (s[i] == s[i + 1]) {
c++;
}
}
if (c == len - 1) {
cout << "0";
} else if (len == 1) {
cout << "0";
} else {
for (int i = 0; i < len / 2; i++) {
if (s[i] == s[len - 1 - i]) {
c1++;
} else {
cout << len;
break;
}
}
if (c1 == len / 2) {
cout << len - 1;
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void scanint(int &x) {
register int c = getchar();
x = 0;
int neg = 0;
for (; ((c < 48 || c > 57) && c != '-'); c = getchar())
;
if (c == '-') {
neg = 1;
c = getchar();
}
for (; c > 47 && c < 58; c = getchar()) {
x = (x << 1) + (x << 3) + c - 48;
}
if (neg) x = -x;
}
int cmp(int a, int b) {
if (a > b)
return a;
else
return b;
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
int n, m, i, j, k;
cin >> n >> m;
int a[n][3];
for (i = 0; i < n; i++) {
for (j = 0; j < 3; j++) {
a[i][j] = 55;
}
}
for (i = 0; i < n; i++) {
string s;
cin >> s;
for (j = 0; j < m; j++) {
int ctr = 2;
if (s[j] == '#' || s[j] == '*' || s[j] == '&')
ctr = 0;
else if (s[j] >= '0' && s[j] <= '9')
ctr = 1;
if (a[i][ctr] > min(j, m - j)) a[i][ctr] = min(j, m - j);
}
}
int ans = 200;
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
if (i == j) continue;
for (k = 0; k < n; k++) {
if (i == k || k == j) continue;
ans = min(ans, a[i][0] + a[j][1] + a[k][2]);
}
}
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int cnt, n;
bool dis[200];
string x;
int main() {
cin >> n >> x;
for (int i = 0; i < x.length(); i++) {
if (!dis[x[i]] && cnt < n) cnt++, dis[x[i]] = 1;
}
if (cnt == n) {
cout << "YES";
for (int i = 0; i < x.length(); i++) {
if (dis[x[i]]) {
dis[x[i]] = 0;
cout << endl;
}
cout << x[i];
}
} else
cout << "NO";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int fun(int n, int* input, int m) {
queue<pair<int, int>> curr;
for (int i = 0; i < n; i++) {
pair<int, int> temp;
temp.first = input[i];
temp.second = i + 1;
curr.push(temp);
}
while (curr.size() > 0) {
if (curr.size() == 1) return curr.front().second;
pair<int, int> temp = curr.front();
curr.pop();
temp.first -= m;
if (temp.first > 0) curr.push(temp);
}
}
int main() {
int n, m;
cin >> n >> m;
int* input = new int[n];
for (int i = 0; i < n; i++) cin >> input[i];
cout << fun(n, input, m);
return 0;
}
| 1 |
#include<bits/stdc++.h>
//#define int long long
#define loop(i, a, b) for(int i = a; i < b; i++)
#define rep(i, a) loop(i, 0, a)
#define all(a) (a).begin(),(a).end()
using namespace std;
const int MOD = 1e9 + 7, INF = 1e9;
using vi = vector <int>;
using vvi = vector <vi>;
//g++ -std==c++14
#define MAX_V (1100)
struct edge{int to, cap, rev; };
vector <edge> G[MAX_V];
bool used[MAX_V];
void add_edge(int from, int to, int cap){
G[from].push_back((edge){to, cap, (int)G[to].size()});
G[to].push_back((edge){from, 0, (int)G[from].size() - 1});
}
int dfs(int v, int t, int f){
if(v == t)return f;
used[v] = true;
for(int i = 0; i < G[v].size(); i++){
edge &e = G[v][i];
if(!used[e.to] && e.cap > 0){
int d = dfs(e.to, t, min(f, e.cap));
if(d > 0){
e.cap -= d;
G[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
int max_flow(int s, int t){
int flow = 0;
for(;;){
memset(used, 0, sizeof(used));
int f = dfs(s, t, INF);
if(f == 0) return flow;
flow += f;
}
}
int gcd(int a, int b){
return (b == 0 ? a : gcd(b, a % b));
}
signed main(){
int m ,n;
while(cin >> m >> n, n){
int b[m], r[n];
rep(i, MAX_V){
G[i].clear();
used[i] = false;
}
rep(i, m)
cin >> b[i];
rep(i, n)
cin >> r[i];
rep(i, m)rep(j, n)
if(gcd(b[i], r[j]) != 1)
add_edge(i, j + m, 1);
rep(i, m)
add_edge(n + m, i, 1);
rep(i, n)
add_edge(m + i, n + m + 1, 1);
cout << max_flow(n + m, m + n + 1) << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, Case = 0, Cases;
char f[50], m[50], s[50];
scanf("%d", &Cases);
cin >> f >> m >> s;
if (strcmp(f, m) == 0 && strcmp(f, s) == 0)
printf("?\n", ++Case);
else if (strcmp(f, m) != 0 && strcmp(f, s) != 0 && strcmp(m, s) != 0)
printf("?\n", ++Case);
else {
int P = 0, R = 0, S = 0;
if (strcmp(f, "paper") == 0) P++;
if (strcmp(m, "paper") == 0) P++;
if (strcmp(s, "paper") == 0) P++;
if (strcmp(f, "scissors") == 0) S++;
if (strcmp(m, "scissors") == 0) S++;
if (strcmp(s, "scissors") == 0) S++;
if (strcmp(f, "rock") == 0) R++;
if (strcmp(m, "rock") == 0) R++;
if (strcmp(s, "rock") == 0) R++;
if (S == 0) {
if (P > R)
printf("?\n");
else if (strcmp(f, "paper") == 0)
printf("F\n");
else if (strcmp(m, "paper") == 0)
printf("M\n");
else
printf("S\n");
}
if (R == 0) {
if (S > P)
printf("?\n");
else if (strcmp(f, "scissors") == 0)
printf("F\n");
else if (strcmp(m, "scissors") == 0)
printf("M\n");
else
printf("S\n");
}
if (P == 0) {
if (R > S)
printf("?\n");
else if (strcmp(f, "rock") == 0)
printf("F\n");
else if (strcmp(m, "rock") == 0)
printf("M\n");
else
printf("S\n");
}
}
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main()
{
int n,a[10][10];
cin>>n;
memset(a,0,sizeof(a));
for(int i=1;i<=n;i++){
a[to_string(i)[0]-'0'][i%10]++;
}
int ans=0;
for(int i=0;i<10;i++){
for(int j=0;j<10;j++){
ans+=a[i][j]*a[j][i];
}
}
cout<<ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mod = (int)1e9+7;
int main(){
int H, W, K; cin >> H >> W >> K;
vector<vector<int>> dp(H+1, vector<int>(W+1, 0));
dp[0][1] = 1;
for(int y=0; y<H; ++y){
for(int x=1; x<=W; ++x){
for(int i=0; i<(1 << (W-1)); ++i){
bool ok = true;
for(int k=0; k<W-2; ++k){
if(((i >> k) & 3) == 3)
ok = false;
}
if(ok){
if(x - 1 >= 1 && ((i >> (x-2)) & 1))
dp[y+1][x-1] = (dp[y+1][x-1] + dp[y][x]) % mod;
else if(x + 1 <= W && ((i >> (x-1)) & 1))
dp[y+1][x+1] = (dp[y+1][x+1] + dp[y][x]) % mod;
else
dp[y+1][x] = (dp[y+1][x] + dp[y][x]) % mod;
}
}
}
}
cout << dp[H][K] << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int dp[100007];
vector<int> v[100007];
void dfs(int x) {
if (v[x].size() == 0) {
dp[x] = 1;
return;
}
for (auto &u : v[x]) {
dfs(u);
dp[x] += dp[u];
}
}
int main() {
int n, x;
cin >> n;
for (int i = 2; i <= n; i++) {
cin >> x;
v[x].push_back(i);
}
dfs(1);
sort(dp + 1, dp + n + 1);
for (int i = 1; i <= n; i++) cout << dp[i] << " ";
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
int inp() {
char c = getchar();
while (c < '0' || c > '9') c = getchar();
int sum = 0;
while (c >= '0' && c <= '9') {
sum = sum * 10 + c - '0';
c = getchar();
}
return sum;
}
int head[3010], nxt[6010], end[6010], fa[3010];
long long size[3010];
bool used[3010];
int cou = 0;
void link(int a, int b) {
nxt[++cou] = head[a];
head[a] = cou;
end[cou] = b;
}
std::vector<std::pair<int, int> > vec[3010];
int d[3010][3010], sz[3010][3010];
void _dfs(int cur, int last, int rt, int dis) {
vec[dis].push_back(std::make_pair(rt, cur));
d[rt][cur] = dis;
sz[rt][cur] = 1;
for (int x = head[cur]; x != -1; x = nxt[x])
if (end[x] != last) {
_dfs(end[x], cur, rt, dis + 1);
sz[rt][cur] += sz[rt][end[x]];
}
}
long long f[3010][3010];
int main() {
memset(head, -1, sizeof(head));
int n = inp();
for (int i = 1; i < n; i++) {
int u = inp();
int v = inp();
link(u, v);
link(v, u);
}
for (int i = 1; i <= n; i++) {
f[i][i] = 0;
_dfs(i, 0, i, 0);
}
for (int i = 0; i <= n; i++) {
for (int j = 0; j < (int)(vec[i].size()); j++) {
int u = vec[i][j].first;
int v = vec[i][j].second;
for (int x = head[v]; x != -1; x = nxt[x]) {
if (d[u][end[x]] > d[u][v])
f[u][end[x]] =
std::max(f[u][end[x]], f[u][v] + sz[u][end[x]] * sz[end[x]][u]);
}
for (int x = head[u]; x != -1; x = nxt[x])
if (d[end[x]][v] > d[u][v])
f[end[x]][v] =
std::max(f[end[x]][v], f[u][v] + sz[end[x]][v] * sz[v][end[x]]);
}
}
long long ans = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
ans = std::max(ans, f[i][j]);
}
printf("%lld\n", ans);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const double eps = 1e-8;
const long long INF = 0x3f3f3f3f;
const long long maxn = 1e5 + 5;
const long long maxm = 1e6 + 5;
long long n, vis[10] = {8, -1, -1, 3, 6, 9, 4, 7, 0, 5};
char s[maxn];
inline long long read();
signed main() {
scanf("%s", s);
n = strlen(s);
for (long long i = 0; i < n; ++i) {
if (vis[s[i] - '0'] != s[n - i - 1] - '0') {
puts("NO");
exit(0);
}
}
puts("YES");
return 0;
}
inline long long read() {
long long 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 << 1) + (x << 3) + (ch ^ 48), ch = getchar();
return x * f;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int i = 0; i < t; i++) {
int n, m;
cin >> n >> m;
if (m > n) swap(m, n);
if (m * 2 >= n)
cout << m * 2 * m * 2 << endl;
else
cout << n * n << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 100008;
const int Mod = 1e9 + 7;
vector<int> A[maxn], B[maxn];
void deal() {
for (int i = 1; i < maxn; i++) {
for (int j = i; j < maxn; j += i) A[j].push_back(i);
}
}
int main() {
int n, x, y;
deal();
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
;
cin >> n;
for (int k = 1; k <= n; k++) {
cin >> x >> y;
if (y == 0) {
cout << A[x].size() << endl;
for (int i = 1; i <= A[x].size(); i++) {
int v = A[x][i - 1];
B[v].push_back(k);
}
continue;
}
int ans = 0;
for (int i = 1; i <= A[x].size(); i++) {
int v = A[x][i - 1], a = k - y, b = k - 1;
if (B[v].size() == 0)
ans++;
else {
if (upper_bound(B[v].begin(), B[v].end(), b) -
lower_bound(B[v].begin(), B[v].end(), a) ==
0)
ans++;
}
B[v].push_back(k);
}
cout << ans << endl;
}
}
| 2 |
#include<stdio.h>
long long f(long long x,long long y)
{
if(x==0) return -y;
else return (y/x)*x*2 + f(y%x,x);
}
int main()
{
long long n,x;
scanf("%lld%lld",&n,&x);
printf("%lld",f(x,n-x)+n);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
bool eq(double a, double b) { return abs(a - b) < eps; }
bool le(double a, double b) { return a < b + eps; }
int main() {
int x1, y1, r1;
scanf("%d%d%d", &x1, &y1, &r1);
int x2, y2, r2;
scanf("%d%d%d", &x2, &y2, &r2);
if (r1 > r2) {
swap(x1, x2);
swap(y1, y2);
swap(r1, r2);
}
double dc = sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1));
if (le(dc + r1, r2)) {
printf("%.11f", (double)(r2 - r1 - dc) / 2);
return 0;
}
if (le(dc, r1 + r2)) {
printf("%.11f", (double)(0) / 2);
return 0;
}
printf("%.11f", (double)(dc - r1 - r2) / 2);
return 0;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int pow_mod(int b, int p) {
int r = 1;
b %= 1000000007;
while (p) {
if (p & 1) r = ((int)((((long long)(r)) * (b)) % 1000000007));
p >>= 1;
b = ((int)((((long long)(b)) * (b)) % 1000000007));
}
return r;
}
int a[1000000], coun[1000000], b[1000000], pos[1000000];
vector<int> V[1000000];
int main() {
int n, k, i, N, j, res, ch, ch2;
long long l, m;
scanf("%d%I64d%d", &n, &l, &k);
m = l / n;
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
b[i] = a[i];
}
sort(a, a + n);
N = 0;
coun[0] = 1;
for (i = 1; i < n; i++) {
if (a[i] == a[N]) {
coun[N]++;
} else {
a[++N] = a[i];
coun[N] = 1;
}
}
N++;
V[0].push_back(coun[0]);
for (i = 1; i < k; i++)
V[0].push_back(
((int)((((long long)(coun[0])) * (V[0][i - 1])) % 1000000007)));
for (j = 1; j < N; j++) {
V[j].push_back((V[j - 1][0] + coun[j]) % 1000000007);
for (i = 1; i < k; i++)
V[j].push_back(
(V[j - 1][i] +
((int)((((long long)(coun[j])) * (V[j][i - 1])) % 1000000007))) %
1000000007);
}
for (i = 0; i < l % n; i++) {
pos[i] = lower_bound(a, a + N, b[i]) - a;
}
res = l % n;
for (i = 0; i < m && i < k; i++) {
res = (res + ((int)((((long long)((m - i) % 1000000007)) * (V[N - 1][i])) %
1000000007))) %
1000000007;
if (i != k - 1)
for (j = 0; j < l % n; j++) res = (res + V[pos[j]][i]) % 1000000007;
}
printf("%d\n", res);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e5 + 10;
long long n, k, a[MAXN][2], dp[MAXN][2];
inline char *ans() {
for (int i = 1; i <= n; ++i) {
dp[i][0] = max(0ll, dp[i - 1][0] + a[i][0] - k * a[i][1]);
dp[i][1] = max(0ll, dp[i - 1][1] + a[i][1] - k * a[i][0]);
if (dp[i][0] > k || dp[i][1] > k) return "NO";
}
return "YES";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; ++i) cin >> a[i][0];
for (int i = 1; i <= n; ++i) cin >> a[i][1];
cout << ans();
cout.flush();
return 0;
}
| 6 |
#include<bits/stdc++.h>
using namespace std;
int main(){
string d[3];
cin>>d[0]>>d[1]>>d[2];
int n=0;
while(1){
int t=n;
if(d[n].size()==0)break;
t=d[n][0]-'a';
d[n].erase(d[n].begin());
n=t;
}
cout<<(char)('A'+n)<<endl;
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
template<typename T> inline void read(T &x)
{
x=0;char c=getchar();bool flag=false;
while(!isdigit(c)){if(c=='-')flag=true;c=getchar();}
while(isdigit(c)){x=(x<<1)+(x<<3)+(c^48);c=getchar();}
if(flag)x=-x;
}
int n;
int main()
{
read(n);
if(n==(n&(-n)))
{
puts("No");
return 0;
}
printf("Yes\n1 2\n2 3\n3 %d\n%d %d\n%d %d\n",n+1,n+1,n+2,n+2,n+3);
for(int i=4;i+1<=n;i+=2) printf("1 %d\n1 %d\n%d %d\n%d %d\n",i,i+1,i,i+1+n,i+1,i+n);
if(!(n&1))
{
for(int i=2;i<n;++i)
{
if(i==3) continue;
int p=n^i^1;
if(p!=3&&p<n)
{
printf("%d %d\n%d %d\n",i,n,p,2*n);
break;
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(){
long long a,b;
cin>>a>>b;
if(a%b==0) cout<<-1<<endl;
else{
cout<<a<<endl;
}
}
| 0 |
#include<iostream>
#include<algorithm>
using namespace std;
//l-child, r-sibling representation
int n;
int p[100010], l[100010], r[100010];
void dfs(int depth, int n){
if(p[n] == -1){
cout << "depth = " << depth << ", ";
return ;
}
dfs(depth + 1, p[n]);
return ;
}
void searchsibling(int c){
cout << '[';
for(int i = 0;;i++){
if(c == -1) break;
cout << (i?", ":"");
cout << c;
c = r[c];
}
cout << ']' << endl;
}
void solve(){
for(int i = 0;i < n;i++){
cout << "node " << i << ": ";
cout << "parent = " << p[i] << ", ";
dfs(0, i);
if(p[i] == -1) cout << "root, ";
else if(l[i] != -1) cout << "internal node, ";
else cout << "leaf, ";
searchsibling(l[i]);
}
}
int main(){
cin >> n;
for(int i = 0;i < n;i++) p[i] = l[i] = r[i] = -1;
for(int i = 0;i < n;i++){
int id, k, c, s;
cin >> id >> k;
for(int j = 0;j < k;j++){
cin >> c;
if(j == 0) l[id] = c;
else r[s] = c;
p[c] = id;
s = c;
}
}
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline int in() {
int32_t x;
scanf("%d", &x);
return x;
}
inline long long lin() {
long long x;
scanf("%lld", &x);
return x;
}
inline string get() {
char ch[2000010];
scanf("%s", ch);
return ch;
}
const int MAX_LG = 21;
const int maxn = 1e5 + 10;
const int base = 29;
const int mod = 1e9 + 7;
const int INF = 1e9 + 100;
vector<int> g[maxn];
int Root[maxn * 80], L[maxn * 80], R[maxn * 80], st[maxn], en[maxn], cur;
vector<pair<int, int> > query[maxn];
inline void dfs(int node, int fa = -1) {
st[node] = cur++;
for (auto u : g[node]) {
if (u - fa) dfs(u, node);
}
en[node] = cur - 1;
}
int n, q;
int lazy[maxn * 80], stree[maxn * 80];
inline int add(int ql, int qr, int p, int l = 0, int r = n - 1) {
if (l > qr || r < ql) return p;
int ret = cur++;
if (l >= ql && r <= qr) {
L[ret] = L[p], R[ret] = R[p];
stree[ret] = lazy[ret] = r - l + 1;
return ret;
}
int mid = (l + r) >> 1;
lazy[ret] = lazy[p];
L[ret] = add(ql, qr, L[p], l, mid);
R[ret] = add(ql, qr, R[p], mid + 1, r);
stree[ret] = lazy[ret] ? r - l + 1 : stree[L[ret]] + stree[R[ret]];
return ret;
}
int res[maxn];
inline void calc(int node, int fa = 0) {
Root[node] = Root[fa];
for (auto q : query[node]) Root[node] = add(q.first, q.second, Root[node]);
res[node] = max(stree[Root[node]] - 1, 0);
for (auto u : g[node])
if (u - fa) calc(u, node);
}
inline void build(int p, int l = 0, int r = n - 1) {
if (l == r) return;
L[p] = cur++;
R[p] = cur++;
int mid = (l + r) >> 1;
build(L[p], l, mid), build(R[p], mid + 1, r);
}
int32_t main() {
n = in(), q = in();
for (int i = 0; i < n - 1; i++) {
int v = in(), u = in();
g[v].push_back(u), g[u].push_back(v);
}
dfs(1);
cur = 1;
Root[0] = 0;
build(0, 0, n - 1);
for (int i = 0; i < q; i++) {
int a = in(), b = in();
query[a].push_back({st[b], en[b]});
query[b].push_back({st[a], en[a]});
}
for (int i = 1; i <= n; i++)
if (query[i].size()) query[i].push_back({st[i], en[i]});
calc(1);
for (int i = 1; i <= n; i++) cout << res[i] << " ";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s1, s2;
while (cin >> s1 >> s2) {
set<int> s[30];
for (int i = 0; i < s1.size(); i++) s[s1[i] - 'a'].insert(i);
int flag = -1;
int ans = 1;
for (int i = 0; i < s2.size(); i++) {
int t = s2[i] - 'a';
if (s[t].empty()) {
puts("-1");
return 0;
}
set<int>::iterator it = s[t].upper_bound(flag);
if (it == s[t].end()) {
flag = -1;
ans++;
}
flag = *(s[t].upper_bound(flag));
}
printf("%d\n", ans);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
const long long INF = (long long)2e18;
const long long BASE = (long long)1e9 + 7;
const int BLOCK = 710;
const int MAXN = 200010;
const long double PI = acos(-1.);
void solve();
using namespace std;
int main() {
int t = 1;
while (t--) {
solve();
}
return 0;
}
int n;
int a[MAXN];
char s[MAXN];
void solve() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
}
scanf("\n%s", s + 1);
set<int> ss;
bool ok = true;
int l = 1;
for (int i = 1; i <= n && ok; i++) {
ss.insert(a[i]);
if (s[i] == '0') {
for (int j = l; j <= i; j++) {
if (ss.find(j) == ss.end()) {
ok = false;
break;
}
}
ss.clear();
l = i + 1;
}
}
if (ok) {
cout << "YES\n";
} else
cout << "NO\n";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2000005;
const int mod = 1000000007;
vector<int> aa(1 << 10, 0), res(2, 0);
const double PI = acos(-1);
void fft(vector<complex<double> >& a, int f) {
int n = a.size();
for (int i = 1, j = 0; i < n; i++) {
int temp = n >> 1;
for (; j >= temp; temp >>= 1) j -= temp;
j += temp;
if (j > i) swap(a[i], a[j]);
}
for (int l = 2; l <= n; l <<= 1) {
double theta = 2 * PI / l * (f ? -1 : 1);
complex<double> wl(cos(theta), sin(theta));
for (int i = 0; i < n; i += l) {
complex<double> w(1);
for (int j = 0; j < l / 2; j++) {
complex<double> u = a[i + j], v = w * a[i + j + l / 2];
a[i + j] = u + v;
a[i + j + l / 2] = u - v;
w *= wl;
}
}
}
if (f)
for (int i = 0; i < n; i++) a[i] /= n;
}
void multiply(vector<int>& a, vector<int>& b, vector<int>& res) {
vector<complex<double> > fa(a.begin(), a.end()), fb(b.begin(), b.end());
int n = 1;
while (n < max(a.size(), b.size())) n <<= 1;
n <<= 1;
fa.resize(n), fb.resize(n);
fft(fa, 0), fft(fb, 0);
for (int i = 0; i < n; i++) {
fa[i] *= fb[i];
}
fft(fa, 1);
res.resize(n);
for (int i = 0; i < n; i++) res[i] = int(fa[i].real() + 0.5);
}
void power(int k) {
for (; k; k >>= 1) {
if (k & 1) multiply(res, aa, res);
multiply(aa, aa, aa);
for (int i = 0; i < aa.size(); i++)
if (aa[i]) aa[i] = 1;
for (int i = 0; i < res.size(); i++)
if (res[i]) res[i] = 1;
}
}
int main() {
ios_base::sync_with_stdio(false);
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
aa[a] = 1;
}
res[0] = 1;
power(k);
for (int i = 0; i < res.size(); i++)
if (res[i]) cout << i << ' ';
return 0;
}
| 5 |
#include <bits/stdc++.h>
#define REP(i, a, n) for(ll i = ((ll) a); i < ((ll) n); i++)
using namespace std;
typedef long long ll;
class MaxFlow {
public:
struct edge { ll to, cap, rev; };
const ll INF = 1LL << 60;
ll N;
vector< vector<edge> > E;
vector<bool> used;
MaxFlow(ll n): N(n), E(n), used(n) {};
void add_directed_edge(ll from, ll to, ll cap) {
E[from].push_back((edge) { to, cap, (ll) E[to].size() });
E[to].push_back((edge) { from, 0, (ll) E[from].size() - 1 });
}
void add_undirected_edge(ll from, ll to, ll cap) {
E[from].push_back((edge) { to, cap, (ll) E[to].size() });
E[to].push_back((edge) { from, cap, (ll) E[from].size() - 1 });
}
ll dfs(ll v, ll t, ll f) {
if(v == t) return f;
used[v] = true;
REP(i, 0, E[v].size()) {
edge &e = E[v][i];
if(!used[e.to] && e.cap > 0) {
ll d = dfs(e.to, t, min(f, e.cap));
if(d > 0) {
e.cap -= d;
E[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
ll max_flow(ll s, ll t) {
ll flow = 0;
while(1) {
REP(i, 0, N) used[i] = false;
ll f = dfs(s, t, INF);
if(f == 0 || f == INF) break;
flow += f;
}
return flow;
}
};
int main(void) {
ll N, A, B;
cin >> N >> A >> B;
vector<ll> a(N), b(N);
REP(i, 0, N) cin >> a[i] >> b[i];
ll ans = 0;
vector<bool> used(N, false);
REP(i, 0, N) {
ll d = abs(a[i] - b[i]);
if(d <= A || (B <= d && d <= 2 * A)) {
used[i] = true;
ans++;
}
}
const ll s = N, t = N + 1;
MaxFlow flow(N + 2);
REP(i, 0, N) if(!used[i]) {
ll d = a[i] - b[i];
if(d > 0) flow.add_directed_edge(s, i, 1);
if(d < 0) flow.add_directed_edge(i, t, 1);
}
REP(i, 0, N) REP(j, 0, N) if(!used[i] && !used[j]) {
ll di = a[i] - b[i];
ll dj = a[j] - b[j];
ll d = abs(di + dj);
if(d <= A || (B <= d && d <= 2 * A)) {
if(di > 0 && dj < 0) flow.add_directed_edge(i, j, 1);
if(di < 0 && dj > 0) flow.add_directed_edge(j, i, 1);
}
}
ans += flow.max_flow(s, t);
cout << ans << endl;
}
| 0 |
#include<bits/stdc++.h>
#define FOR(i,a,b) for(int i=a;i<=b;i++)
using namespace std;
typedef unsigned long long ULL;
typedef long long ll;
int n;
struct node{
double x,y;
char dir[4];
}A[100050];
double cal(double x){
double ml=1e10,mr=-1e10,mu=-1e10,md=1e10;
FOR(i,1,n){
pair<double,double>tmp;
tmp.first=A[i].x,tmp.second=A[i].y;
switch(A[i].dir[0]){
case 'U':tmp.second+=x;break;
case 'D':tmp.second-=x;break;
case 'L':tmp.first-=x;break;
case 'R':tmp.first+=x;break;
}
ml=min(ml,tmp.first);
mr=max(mr,tmp.first);
mu=max(mu,tmp.second);
md=min(md,tmp.second);
}
//cout<<x<<" "<<(mr-ml)*(mu-md)<<endl;
return (mr-ml)*(mu-md);
}
int main(){
cin>>n;
FOR(i,1,n){
scanf("%lf%lf%s",&A[i].x,&A[i].y,A[i].dir);
}
double l=0,r=1e12,ans=1e18;
FOR(k,0,300){
double m1=(l+(r-l)/3),m2=(l+(r-l)*2/3);
double tmp1=cal(m1),tmp2=cal(m2);
if(tmp1>tmp2)l=m1;
else r=m2;
ans=min(ans,tmp1);
ans=min(ans,tmp2);
}
printf("%.10f",ans);
}
| 0 |
#include <bits/stdc++.h>
const int maxn = 301, maxe = 100001;
int n, lim, m, a[maxn], b[maxn], g[maxn];
int tot, len, path[maxn], cnt, ans[maxn * maxn * 2][3];
bool vis[maxn];
struct Edge {
int nxt, v;
} e[maxe];
int min(int x, int y) { return x < y ? x : y; }
void dfs(int u) {
vis[u] = 1;
path[len++] = u;
if (a[u] < b[u]) {
int &sta = path[0], &end = path[len - 1];
int cost = min(a[sta] - b[sta], b[end] - a[end]);
if (cost) {
for (int i = 0; i < len - 1; i++) {
int flow = min(cost, lim - a[path[i + 1]]);
if (flow) {
ans[cnt][0] = path[i];
ans[cnt][1] = path[i + 1];
ans[cnt++][2] = flow;
}
}
for (int i = len - 2; i >= 0; i--) {
int flow = cost - min(cost, lim - a[path[i + 1]]);
if (flow) {
ans[cnt][0] = path[i];
ans[cnt][1] = path[i + 1];
ans[cnt++][2] = flow;
}
}
a[sta] -= cost;
a[end] += cost;
}
}
if (a[path[0]] > b[path[0]])
for (int it = g[u]; it; it = e[it].nxt) {
if (!vis[e[it].v]) dfs(e[it].v);
}
--len;
}
int main() {
scanf("%d%d%d", &n, &lim, &m);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
for (int i = 1; i <= n; i++) scanf("%d", b + i);
while (m--) {
int u, v;
scanf("%d%d", &u, &v);
e[++tot] = (Edge){g[u], v};
g[u] = tot;
e[++tot] = (Edge){g[v], u};
g[v] = tot;
}
for (int i = 1; i <= n; i++) {
if (a[i] > b[i]) {
memset(vis, 0, sizeof vis);
dfs(i);
}
}
for (int i = 1; i <= n; i++) {
if (a[i] != b[i]) {
puts("NO");
return 0;
}
}
printf("%d\n", cnt);
for (int i = 0; i < cnt; i++)
printf("%d %d %d\n", ans[i][0], ans[i][1], ans[i][2]);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t;
cin >> t;
while (t--) {
long long n, k;
cin >> n >> k;
if (k >= n) {
long long res = (n * (n - 1)) / 2 + 1;
cout << res << '\n';
;
} else {
long long res = (k * (k + 1)) / 2;
cout << res << '\n';
;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
ll n,ans=0;
cin>>n;
if(n%2!=0){cout<<0<<endl;}
else{while(n>0){ans+=n/10;n/=5;}cout<<ans<<endl;}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int arr[200][2];
int vis[200];
vector<int> f;
int main() {
std::ios::sync_with_stdio(false);
int n;
int i;
cin >> n;
int nf = 0, nb = 0;
for (i = 1; i <= n; i++) {
int a, b;
cin >> a >> b;
if (a == 0) nf++;
if (b == 0) nb++;
arr[i][0] = a;
arr[i][1] = b;
}
for (i = 1; i <= n; i++) {
if (nf == 1 && nb == 1) break;
int j;
if (arr[i][0] == 0) {
int cur = i;
while (arr[cur][1]) {
cur = arr[cur][1];
}
for (j = 1; j <= n; j++) {
if (arr[j][0] == 0 && j != i) {
arr[cur][1] = j;
arr[j][0] = cur;
j = n + 1;
nf--;
nb--;
}
}
}
}
for (i = 1; i <= n; i++) {
cout << arr[i][0] << " " << arr[i][1] << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, R, Max[6000021 * 4], lz[6000021 * 4], cnt;
struct line {
int l, r, pos, y;
line(int a = 0, int b = 0, int c = 0, int d = 0) : l(a), r(b), pos(c), y(d) {}
bool operator<(const line& z) const { return y < z.y; }
} ln[300021 * 4];
void push_up(int u) { Max[u] = max(Max[u << 1], Max[u << 1 | 1]); }
void push_down(int u) {
if (!lz[u]) return;
lz[u << 1 | 1] += lz[u];
lz[u << 1] += lz[u];
Max[u << 1 | 1] += lz[u];
Max[u << 1] += lz[u];
lz[u] = 0;
}
void update(int u, int l, int r, int x, int y, int add) {
if (l == x && r == y) {
lz[u] += add;
Max[u] += add;
return;
}
int mid = l + r >> 1;
push_down(u);
if (x > mid)
update(u << 1 | 1, mid + 1, r, x, y, add);
else if (y <= mid)
update(u << 1, l, mid, x, y, add);
else
update(u << 1, l, mid, x, mid, add),
update(u << 1 | 1, mid + 1, r, mid + 1, y, add);
push_up(u);
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> R;
for (int a, b, x, y, i = 1; i <= n; i++) {
cin >> a >> b;
x = a + b;
y = a - b;
ln[++cnt] = line(x + 3000003 - R, x + 3000003 + R, 1, y - R);
ln[++cnt] = line(x + 3000003 - R, x + 3000003 + R, -1, y + R + 1);
}
sort(ln + 1, ln + 1 + cnt);
int last = 1, ans = 0;
for (int i = 1; i <= cnt; i++) {
update(1, 1, 6000006, ln[i].l, ln[i].r, ln[i].pos);
if (i != n && ln[i].y == ln[i + 1].y) continue;
ans = max(ans, Max[1]);
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 2 * acos(0.0);
const int Mod = 1E9 + 7;
inline void yes() { std::cout << "Yes\n"; }
inline void no() { std::cout << "No\n"; }
using namespace std;
long long int isPrime(long long int num) {
long long int flag = 0;
for (long long int i = 1; i <= num; i++) {
if (num % i == 0) {
flag++;
if (flag > 3) break;
}
}
if (flag == 3)
return 1;
else
return 0;
}
long long int binomialCoeff(long long int n, long long int k) {
long long int C[k + 1];
memset(C, 0, sizeof(C));
C[0] = 1;
for (long long int i = 1; i <= n; i++) {
for (long long int j = min(i, k); j > 0; j--) C[j] = C[j] + C[j - 1];
}
return C[k];
}
long long int factorial(long long int n) {
if (n == 0) return 1;
return n * factorial(n - 1);
}
bool isPalindrome(string str) {
int l = 0;
int h = str.length() - 1;
while (h > l) {
if (str[l++] != str[h--]) {
return false;
}
}
return true;
}
bool check(long long int n) {
double y = sqrt(n);
if (y - floor(y) == 0)
return 1;
else
return 0;
}
bool isprime(long long 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 main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int x, y, cnt = 0, l, o, t, n, sum = 0, lasum = 0, ans = 0, las = 0,
flag = 0, ma = LLONG_MAX, av1, av2, sum1 = 0, sum2 = 0;
string a;
cin >> a;
l = a.length();
for (long long int i = 0; i < l; i++) {
if (a[i] == 'H' || a[i] == 'Q' || a[i] == '9') {
cout << "YES";
return 0;
}
}
cout << "NO";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long x, y, a, b, M, m;
cin >> x >> y;
cin >> a >> b;
M = max(x, y);
m = min(x, y);
cout << (M - m) * a + min((m * b), (m * 2 * a)) << endl;
}
}
| 1 |
#include <iostream>
#include <algorithm>
#include <vector>
#include <stack>
#include <string>
#include <queue>
#include <cmath>
#include <numeric>
#include <list>
#include <sstream>
#include <fstream>
#include <iomanip>
#include <climits>
#include <memory.h>
#include <memory>
#include <cstdio>
#include <cstdlib>
#include <cctype>
#include <map>
#define _USE_MATH_DEFINES
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<int, P> PP;
typedef vector<int> vec;
typedef vector<vec> mat;
const int INF = 1 << 30;
const double EPS = 1e-9;
map<int, bool> hos;
int dist[100][101];
vector<P> G[100];
int main(){
int N, M, L, K, A, H;
int h;
int x, y, dis;
while(cin >> N >> M >> L >> K >> A >> H && (N || M || L|| K|| A|| H)){
for(int i = 0; i < L; i++){
cin >> h;
hos[h] = true;
}
for(int i = 0; i < K; i++){
cin >> x >> y >> dis;
G[x].push_back(P(y, dis));
G[y].push_back(P(x, dis));
}
bool f = true;
fill(&dist[0][0], &dist[99][100] + 1, INF);
dist[A][M] = 0;
priority_queue<PP, vector<PP>, greater<PP> > que;
que.push(PP(0, P(A, M)));
while(!que.empty()){
PP pp = que.top();
que.pop();
int time = pp.first;
int place = pp.second.first;
int rest = pp.second.second;
if(time < dist[place][rest]) continue;
if(place == H){
cout << dist[place][rest] << endl;
f = false;
break;
}
if(hos[place]){
for(int i = rest + 1; i <= M; i++){
if(dist[place][i] > dist[place][rest] + i - rest){
dist[place][i] = dist[place][rest] + i - rest;
que.push(PP(dist[place][i], P(place, i)));
}
}
}
for(int i = 0; i < G[place].size(); i++){
P p = G[place][i];
if(rest - p.second < 0) continue;
if(dist[p.first][rest - p.second] > dist[place][rest] + p.second){
dist[p.first][rest - p.second] = dist[place][rest] + p.second;
que.push(PP(dist[p.first][rest - p.second], P(p.first, rest - p.second)));
}
}
}
if(f) cout << "Help!" << endl;
for(int i = 0; i < 100; i++) G[i].clear();
hos.clear();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int day = 0;
while (true) {
n--;
day++;
if (day % m == 0) {
n += 1;
}
if (n == 0) break;
}
cout << day << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
vector<long long> T[n];
long long m;
long long maxi = 0;
long long Maxi[n];
long long nb[n];
int i;
for (i = 0; i < n; i++) {
cin >> m;
nb[i] = m;
for (int j = 0; j < m; j++) {
int sa;
cin >> sa;
T[i].push_back(sa);
if (sa > maxi) {
maxi = sa;
}
}
Maxi[i] = maxi;
maxi = 0;
}
long long som = 0;
long long M = Maxi[0];
for (i = 0; i < n; i++) {
if (Maxi[i] > M) {
M = Maxi[i];
}
}
long long Moin[n];
for (i = 0; i < n; i++) {
som += (M - Maxi[i]) * nb[i];
}
cout << som << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long powmod(long long a, long long b) {
long long res = 1;
if (a >= 1000000007) a %= 1000000007;
for (; b; b >>= 1) {
if (b & 1) res = res * a;
if (res >= 1000000007) res %= 1000000007;
a = a * a;
if (a >= 1000000007) a %= 1000000007;
}
return res;
}
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long n, m;
long long mod(long long x, long long y) {
if (x < 0)
return (x % y) + y;
else
return x % y;
}
struct FenwickTree {
vector<long long> bit;
long long n;
long long prime;
FenwickTree(long long n, long long prime) {
this->n = n;
this->prime = prime;
bit.assign(n, 0);
}
long long sum(long long r) {
long long ret = 0;
for (; r >= 0; r = (r & (r + 1)) - 1) ret = mod(ret + bit[r], this->prime);
return ret;
}
void add(long long idx, long long delta) {
for (; idx < n; idx = idx | (idx + 1))
bit[idx] = mod(bit[idx] + delta, this->prime);
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
FenwickTree st(n + 5, m);
st.add(1, 1);
st.add(2, -1);
for (long long i = 1; i <= n; i++) {
long long cur_val = st.sum(i);
st.add(i + 1, cur_val);
st.add(n + 1, -cur_val);
long long mul = 2;
while (i * mul <= n) {
st.add(i * mul, cur_val);
st.add(min(n + 1, i * mul + (mul - 1) + 1), -cur_val);
mul++;
}
}
cout << st.sum(n) << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
int n, k;
ll res;
const int MAX = 2e5 + 10;
ll s[MAX][5];
ll q[MAX][5];
vi e[MAX];
int v[MAX];
void dfs(int x) {
v[x] = 1;
q[x][0] += 1;
for (int y : e[x]) {
if (v[y]) continue;
dfs(y);
for (int i = 0; i < k; i++) {
for (int j = 0; j < k; j++) {
res += s[x][i] * q[y][j];
res += s[y][j] * q[x][i];
int c1 = (i + j + 1) / k;
if ((i + j + 1) % k) c1++;
int c2 = i / k + j / k;
if (i % k) c2++;
if (j % k) c2++;
res += q[x][i] * q[y][j] * (c1 - c2);
}
}
for (int i = 0; i < k; i++) {
q[x][(i + 1) % k] += q[y][i];
s[x][(i + 1) % k] += s[y][i];
}
s[x][1 % k] += q[y][0];
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> k;
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
e[a].push_back(b);
e[b].push_back(a);
}
dfs(1);
cout << res << "\n";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
string s;
cin >> s;
int cnt = 0;
for (int i = 0; i < n; i++) {
int up = 0, le = 0;
for (int j = i; j < n; j++) {
if (s[j] == 'U') up++;
if (s[j] == 'D') up--;
if (s[j] == 'L') le++;
if (s[j] == 'R') le--;
if (up == 0 && le == 0) cnt++;
}
}
cout << cnt << endl;
}
| 1 |
#include "bits/stdc++.h"
// http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=1182&lang=jp
using namespace std;
typedef long long ll;
#define INF 1<<25
#define LINF 1LL<<60
#define MAX_D 20010
int main() {
cin.tie(0); ios::sync_with_stdio(false);
ll n, m, c, s, g;
while (cin >> n >> m >> c >> s >> g, n | m | c | s | g) {
/* input */
vector<vector<vector<int>>> dist(c + 1, vector<vector<int>>(n + 1, vector<int>(n + 1, INF)));
for (int i = 0;i < m;i++) {
int x, y, d, c; cin >> x >> y >> d >> c;
dist[c][x][y] = dist[c][y][x] = min(d,dist[c][x][y]);
}
vector<int> p(c + 1);
for (int i = 1; i <= c;i++) cin >> p[i];
vector<vector<int>> q(c + 1);
vector<vector<int>> r(c + 1);
vector<vector<int>> fare(c + 1, vector<int>(MAX_D, 0));
for (int i = 1; i <= c;i++) {
for (int j = 1; j <= p[i] - 1;j++) {
int a; cin >> a;
q[i].push_back(a);
}
q[i].push_back(INF);
for (int j = 1; j <= p[i];j++) {
int a; cin >> a;
r[i].push_back(a);
}
int at = 0;
for (int j = 1; j < MAX_D;j++) {
fare[i][j] = fare[i][j - 1] + r[i][at];
if (j == q[i][at]) at++;
}
}
for (int C = 1; C <= c;C++) {
for (int i = 1; i <= n;i++) {
for (int j = 1; j <= n;j++) {
for (int k = 1; k <= n;k++) {
dist[C][j][k] = min(dist[C][j][k], dist[C][j][i] + dist[C][i][k]);
}
}
}
}
vector<vector<int>> cost(n + 1, vector<int>(n + 1, INF));
for (int i = 1; i <= n;i++) cost[i][i] = 0;
for (int C = 1; C <= c;C++) {
for (int i = 1; i <= n;i++) {
for (int j = 1; j <= n;j++) {
if (dist[C][i][j] == INF)continue;
cost[i][j] = min(cost[i][j], fare[C][dist[C][i][j]]);
}
}
}
for (int i = 1; i <= n;i++) {
for (int j = 1; j <= n;j++) {
for (int k = 1; k <= n;k++) {
cost[j][k] = min(cost[j][k], cost[j][i] + cost[i][k]);
}
}
}
cout << ((cost[s][g] == INF) ? -1 : cost[s][g]) << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using graph = vector<vector<int>>;
struct RMS {
using ll = long long;
static const ll INF = 1e17;
struct type {
ll left, right, all, sum;
type() : left(-INF), right(-INF), all(-INF), sum(0) {}
type(ll val) : left(val), right(val), all(val), sum(val) {}
type(ll l, ll r, ll a, ll s) : left(l), right(r), all(a), sum(s) {}
};
static type id() { return type(); }
static type op(const type& l, const type & r) {
return type(max(l.left, l.sum + r.left), max(r.right, r.sum + l.right), max({ l.all, r.all, l.right + r.left }), l.sum + r.sum);
}
};
class lct_node {
using M = RMS;
using T = typename M::type;
using U = long long;
lct_node *l, *r, *p;
bool rev;
T val, all;
int size;
bool flag;
U lazy;
int pos() {
if (p && p->l == this) return -1;
if (p && p->r == this) return 1;
return 0;
}
void update() { // * fix
size = (l ? l->size : 0) + (r ? r->size : 0) + 1;
all = M::op(l ? l->all : M::id(), M::op(val, r ? r->all : M::id()));
}
void update_lazy(U v) { // * fix
val = T(v);
all = v > 0 ? T(v * size) : T(v, v, v, v * size);
lazy = v;
flag = true;
}
void rev_data() { // * fix
swap(val.left, val.right);
swap(all.left, all.right);
}
void push() {
if (pos()) p->push();
if (rev) {
swap(l, r);
if (l) l->rev ^= true, l->rev_data();
if (r) r->rev ^= true, r->rev_data();
rev = false;
}
if (flag) {
if (l) l->update_lazy(lazy);
if (r) r->update_lazy(lazy);
flag = false;
}
}
void rot() {
lct_node *par = p;
lct_node *mid;
if (p->l == this) {
mid = r;
r = par;
par->l = mid;
}
else {
mid = l;
l = par;
par->r = mid;
}
if (mid) mid->p = par;
p = par->p;
par->p = this;
if (p && p->l == par) p->l = this;
if (p && p->r == par) p->r = this;
par->update();
update();
}
void splay() {
push();
while (pos()) {
int st = pos() * p->pos();
if (!st) rot();
else if (st == 1) p->rot(), rot();
else rot(), rot();
}
}
public:
lct_node() : l(nullptr), r(nullptr), p(nullptr), rev(false), val(M::id()), all(M::id()), size(1), flag(false) {}
lct_node(const T& v) : l(nullptr), r(nullptr), p(nullptr), rev(false), val(v), all(v), size(1), flag(false) {}
void init(U v) {
val = all = T(v);
}
void expose() {
for (lct_node *x = this, *y = nullptr; x; y = x, x = x->p) x->splay(), x->r = y, x->update();
splay();
}
void link(lct_node *x) {
x->expose();
expose();
p = x;
}
void cut() {
expose();
l->p = nullptr;
l = nullptr;
update();
}
void evert() {
expose();
rev = true;
rev_data();
}
T find() {
expose();
return all;
}
void update(U v) {
expose();
update_lazy(v);
}
};
const int MAX = 2e5;
lct_node lct[MAX];
int w[MAX];
void build(int v, int prev, const graph& G) {
lct[v].init(w[v]);
for (auto to : G[v]) if (to != prev) {
build(to, v, G);
lct[to].link(&lct[v]);
}
}
int main()
{
ios::sync_with_stdio(false), cin.tie(0);
int N, Q;
cin >> N >> Q;
for (int i = 0; i < N; i++) {
cin >> w[i];
}
graph G(N);
for (int i = 0; i < N - 1; i++) {
int u, v;
cin >> u >> v; u--, v--;
G[u].push_back(v);
G[v].push_back(u);
}
build(0, -1, G);
while (Q--) {
int t, a, b, c;
cin >> t >> a >> b >> c; a--, b--;
if (t == 1) {
lct[a].evert();
lct[b].update(c);
}
else {
lct[a].evert();
printf("%d\n", (int)lct[b].find().all);
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = int(3e5) + 100;
int n, x, a[N], b[N], xa[N], xb[N];
int c, sa, sb, aa, bb;
pair<int, int> p[N];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x;
if (x == 1) {
a[i] = a[i - 1] + 1;
xa[a[i]] = i;
b[i] = b[i - 1];
} else {
b[i] = b[i - 1] + 1;
xb[b[i]] = i;
a[i] = a[i - 1];
}
}
int k, j;
for (int t = 1; t <= n; t++) {
sa = 0;
sb = 0;
aa = 0;
bb = 0;
bool ok = 0;
for (int i = 0; i <= n; i += t) {
k = xa[aa + t];
j = xb[bb + t];
if (k == n && x == 1 && j == 0) ok = 1;
if (j == n && x == 2 && k == 0) ok = 1;
if (k == j) break;
if (k == 0) {
bb = b[j];
sb++;
continue;
}
if (j == 0) {
aa = a[k];
sa++;
continue;
}
if (k < j && k > 0) {
sa++;
aa = a[k];
bb = b[k];
}
if (k > j && j > 0) {
sb++;
aa = a[j];
bb = b[j];
}
}
if (ok) {
if (x == 1) {
if (sa > sb) p[++c] = make_pair(sa, t);
}
if (x == 2)
if (sb > sa) p[++c] = make_pair(sb, t);
}
}
sort(p + 1, p + c + 1);
cout << c << endl;
for (int i = 1; i <= c; i++) {
cout << p[i].first << " " << p[i].second << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int max_N = 250000 + 10;
bool mark[max_N];
char c[max_N];
vector<int> adj[max_N];
vector<pair<char, int>> vc;
void dfs(int v, int r) {
mark[v] = true;
vc.push_back({'B', v});
for (int u : adj[v])
if (!mark[u]) dfs(u, r);
if (v != r) {
vc.push_back({'D', v});
vc.push_back({'R', v});
}
}
void dfs_all(int n) {
for (int i = 0; i < n; i++)
if (!mark[i] && c[i] == '.') dfs(i, i);
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int x = i * m + j;
scanf(" %c", &c[x]);
if (c[x] == '#') continue;
if (i > 0 && c[x - m] == '.')
adj[x].push_back(x - m), adj[x - m].push_back(x);
if (j > 0 && c[x - 1] == '.')
adj[x].push_back(x - 1), adj[x - 1].push_back(x);
}
}
dfs_all(n * m);
printf("%d\n", (int)vc.size());
for (auto t : vc)
printf("%c %d %d\n", t.first, (t.second / m) + 1, (t.second % m) + 1);
return 0;
}
| 4 |
#include<bits/stdc++.h>
int main(){int H,A;std::cin>>H>>A;std::cout<<(H+A-1)/A<<"\n";}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200000, INF = (1 << 30) - 1;
int n, m, sk, a[N + 9];
struct thing {
int t, id;
thing(int T = 0, int Id = 0) {
t = T;
id = Id;
}
};
vector<thing> ord;
void into() {
int x;
scanf("%d%d%d%d", &n, &x, &sk, &m);
sk >>= 1;
for (int i = 1; i <= n; ++i) {
int t;
scanf("%d%d", &x, &t);
t %= sk;
ord.emplace_back(t, i);
ord.emplace_back(t + sk, i);
}
}
int ans, val;
void Get_ans() {
sort(ord.begin(), ord.end(), [&](const thing &a, const thing &b) {
return a.t < b.t || a.t == b.t && a.id < b.id;
});
val = INF;
for (int i = 0, j = 0; i < n << 1; ++i) {
for (; ord[j].t + m <= ord[i].t; ++j)
;
if (i >= n && i - j < val) ans = ord[i].t, val = i - j;
}
}
void work() { Get_ans(); }
void outo() {
printf("%d %d\n", val, ans % sk);
for (int i = 0; i < n << 1; ++i) {
int l = ans - m, r = ans;
if (l < ord[i].t && ord[i].t < r) printf("%d ", ord[i].id);
}
puts("");
}
int main() {
int T = 1;
for (; T--;) {
into();
work();
outo();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, p;
cin >> n;
int a[n], b[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
b[n - 1] = a[n - 1];
for (int i = 0; i < n - 1; i++) {
b[i] = a[i] + a[i + 1];
}
for (int i = 0; i < n; i++) {
cout << b[i] << " ";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int a;
cin >> a;
cout << a*a*a;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int di[] = {-1, 0, 1, 0};
const int dj[] = {0, 1, 0, -1};
const long long MOD = 1e9 + 7;
const long long INF = 1e9;
const double EPS = 1e-5;
vector<bool> rvl(30);
bool match(string a, string b) {
for (int i = 0; i < a.length(); i++)
if (!(a[i] == '*' && !rvl[b[i] - 'a'] || a[i] == b[i])) return false;
return true;
}
int n;
string word;
vector<string> ch;
bool valid(char c) {
for (int i = 0; i < ch.size(); i++) {
bool f = false;
for (int j = 0; j < ch[i].size(); j++) {
if (word[j] == '*' && ch[i][j] == c) {
f = true;
break;
}
}
if (!f) return false;
}
return true;
}
int main() {
ios::sync_with_stdio(false), cin.tie(0);
cin >> n;
cin >> word;
for (int i = 0; i < word.length(); i++)
if (word[i] != '*') rvl[word[i] - 'a'] = true;
int x;
cin >> x;
for (int i = 0; i < x; i++) {
string s;
cin >> s;
if (match(word, s)) ch.push_back(s);
}
int r = 0;
for (char c = 'a'; c <= 'z'; c++)
if (valid(c)) r++;
cout << r << endl;
cin.ignore(), cin.get();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int aa[323456], cap[212345], dsu[212345];
int findi(int pos) {
if (cap[pos] > 0) {
return pos;
}
dsu[pos] = findi(dsu[pos]);
return dsu[pos];
}
int main() {
std::ios::sync_with_stdio(false);
int n;
cin >> n;
int i;
for (i = 0; i < n; i++) {
cin >> cap[i];
aa[i] = cap[i];
dsu[i] = i + 1;
}
cap[n] = 3;
int m;
cin >> m;
int t, p, x, lef;
while (m--) {
cin >> t;
if (t == 1) {
cin >> p >> x;
p--;
while (p != n && x != 0) {
lef = min(cap[p], x);
cap[p] -= lef;
x -= lef;
p = findi(p);
}
} else {
cin >> p;
p--;
cout << aa[p] - cap[p] << endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int nod(int z) {
int digits = 0;
while (z != 0) {
if ((z - (10 * (z / 10))) == 4 || (z - (10 * (z / 10))) == 7) digits++;
z /= 10;
}
return digits;
}
int main() {
int n, k;
cin >> n >> k;
int i, a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
}
int sum = 0;
for (i = 0; i < n; i++) {
if (nod(a[i]) <= k) {
sum++;
}
}
cout << sum << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-15;
bool eq(long double a, long double b) { return abs(a - b) < eps; }
bool le(long double a, long double b) { return a < b && !eq(a, b); }
struct Point {
long double x, y;
Point() : x(0), y(0) {}
Point(int x, int y) : x(x), y(y) {}
Point(long double x, long double y) : x(x), y(y) {}
Point operator+(Point p) { return {x + p.x, y + p.y}; }
Point operator-(Point p) { return {x - p.x, y - p.y}; }
Point operator*(long double k) { return {x * k, y * k}; }
Point operator/(long double k) { return {x / k, y / k}; }
bool operator==(Point p) { return eq(x, p.x) && eq(y, p.y); }
long double norm() { return ((x) * (x)) + ((y) * (y)); }
Point perp() { return Point(-y, x); }
};
int n, x[3], y[3], r[3];
vector<Point> v, in[3];
vector<Point> inter(Point c1, long double r1, Point c2, long double r2) {
Point d = c2 - c1;
long double d2 = d.norm();
long double pd = (d2 + ((r1) * (r1)) - ((r2) * (r2))) / 2;
long double h2 = ((r1) * (r1)) - ((pd) * (pd)) / d2;
Point p = c1 + d * pd / d2;
if (eq(h2, 0))
return {p};
else if (le(h2, 0))
return {};
else {
Point u = d.perp() * sqrt(h2 / d2);
return {p - u, p + u};
}
}
void insert(vector<Point> &v, Point p) {
for (auto q : v)
if (p == q) return;
v.push_back(p);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < (n); i++) cin >> x[i] >> y[i] >> r[i];
for (int i = 0; i < (n); i++)
for (int j = 0; j < (i); j++) {
if (((x[i] - x[j]) * (x[i] - x[j])) + ((y[i] - y[j]) * (y[i] - y[j])) >
((r[i] + r[j]) * (r[i] + r[j])))
continue;
if (((x[i] - x[j]) * (x[i] - x[j])) + ((y[i] - y[j]) * (y[i] - y[j])) <
((r[i] - r[j]) * (r[i] - r[j])))
continue;
auto P = inter({x[i], y[i]}, r[i], {x[j], y[j]}, r[j]);
for (auto p : P) insert(v, p), insert(in[i], p), insert(in[j], p);
}
int res = 0, f = 0;
for (int i = 0; i < (n); i++)
if (in[i].size()) {
res += in[i].size();
if (!f) res += 2;
f = 1;
} else {
res++;
}
if (f)
res -= v.size();
else
res++;
cout << res << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[200], p, q, count = 0, aa, n;
cin >> n;
cin >> p;
for (int i = 0; i < p; i++) {
cin >> aa;
a[i] = aa;
}
cin >> q;
for (int i = p; i < p + q; i++) {
cin >> aa;
a[i] = aa;
}
sort(a, a + (p + q));
for (int i = 0; i < p + q; i++) {
if (a[i] != a[i + 1]) {
count++;
}
}
if (count == n) {
cout << "I become the guy." << endl;
} else
cout << "Oh, my keyboard!" << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, l, r, dp[100005][3];
string s;
dp[0][0] = dp[0][1] = dp[0][2] = 0;
cin >> s;
for (int i = 0; i < s.size(); i++) {
dp[i + 1][0] = dp[i][0];
dp[i + 1][1] = dp[i][1];
dp[i + 1][2] = dp[i][2];
dp[i + 1][s[i] - 'x'] = dp[i][s[i] - 'x'] + 1;
}
cin >> n;
while (n--) {
cin >> l >> r;
int x = dp[r][0] - dp[l - 1][0];
int y = dp[r][1] - dp[l - 1][1];
int z = dp[r][2] - dp[l - 1][2];
if (r - l + 1 < 3 ||
(abs(x - y) <= 1 && abs(x - z) <= 1 && abs(y - z) <= 1)) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int s[200005], ji[200005], ou[200005];
int main() {
int a;
scanf("%d", &a);
for (int i = 1; i <= a; i++) scanf("%d", &s[i]);
int l = 0, r = 0;
ji[0] = 0;
ou[0] = 0;
for (int i = a; i >= 1; i--)
if (i % 2)
++l, ji[l] = ji[l - 1] + s[i];
else
++r, ou[r] = ou[r - 1] + s[i];
int jj = 0, oo = 0, ans = 0;
for (int i = 1; i <= a; i++) {
if (i % 2) {
if (jj + ou[r] == oo + ji[l] - s[i]) {
ans++;
}
l--, jj += s[i];
} else {
if (jj + ou[r] - s[i] == oo + ji[l]) {
ans++;
}
r--, oo += s[i];
}
}
printf("%d\n", ans);
return 0;
}
| 2 |
/*
Name:-Kautik Khokhar
ID:-201901064
*/
#include <bits/stdc++.h>
using namespace std;
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define endl "\n"
#define inarr(a,n) for(int i=0;i<n;i++) cin>>a[i]
#define outarr(a,n) for(int i=0;i<n;i++) cout<<a[i]<<" "; cout<<endl
#define maxa(a,n) *max_element(a,a+n)
#define mina(a,n) *min_element(a,a+n)
#define Max(x,y,z) max(x,max(y,z))
#define Min(x,y,z) min(x,min(y,z))
#define fr(i,s,e) for(int i=s;i<e;i++)
#define rf(i,s,e) for(int i=s-1;i>=e;i--)
#define rsort(a,n) sort(a,a+n,greater<int>())
#define cp(m) cout<<setprecision(m)
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define outvect(s) for(auto x:s) cout<<x<<" ";
typedef long long ll;
typedef long double ld;
typedef unsigned int uint;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<long long, long long> pll;
typedef vector<int> vi;
typedef vector<long long> vll;
typedef vector<pair<int,int> > vpi;
#define PI 3.141592653589793
#define MOD 1000000007
bool sortbysec(const pair<int,int> &a,const pair<int,int> &b)
{
return (a.second < b.second);
}
ll gcd(ll a,ll b)
{
if (b == 0)
return a;
return gcd(b, a % b);
}
ll pox(ll n,ll x)
{
int ans=0;
while(n%x==0)
{
ans++;
n/=x;
}
return ans;
}
ll s2n(string s)
{
stringstream geek(s);
ll x = 0;
geek >> x;
return x;
}
string n2s(ll n)
{
string s=to_string(n);
}
string revers_string(string s)
{
string s1=string(s1.rbegin(),s1.rend());
return s1;
}
int N=10000;
bool prime[10000];
void sieveOfEratosthenes()
{
fr(i,0,10000)
prime[i]=true;
for (int i = 2; i <= sqrt(10000); ++i) {
if (prime[i]) {
for (int j = i * i; j <=10000; j += i) {
prime[j] = false;
}
}
}
}
int main()
{
IOS;
int n;
cin>>n;
cout<<(n/2+1)*((1-n%2)*(n/2+1)+(n%2)*(2*(n/2+2)));
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 12;
const int M = 10005;
const int lim = 200000;
const int inf = 1e9;
int T;
int n, m;
int x[N];
char s[N][M];
int cnt[M];
int b[M];
int ans[M];
bool cmp(int i, int j) { return cnt[i] < cnt[j]; }
int main() {
scanf("%d", &T);
while (T--) {
scanf("%d%d", &n, &m);
for (int i = 0; i <= n - 1; ++i) scanf("%d", &x[i]);
for (int i = 0; i <= n - 1; ++i) scanf("%s", s[i]);
int ret = -inf;
for (int mask = 0; mask <= (1 << n) - 1; ++mask) {
for (int j = 0; j <= m - 1; ++j) cnt[j] = 0;
for (int i = 0; i <= n - 1; ++i) {
for (int j = 0; j <= m - 1; ++j) {
if (s[i][j] == '1') {
if (mask & (1 << i))
++cnt[j];
else
--cnt[j];
}
}
}
for (int j = 0; j <= m - 1; ++j) b[j] = j;
sort(b, b + m, cmp);
int tmp = 0;
for (int i = 0; i <= n - 1; ++i) {
int r = 0;
for (int j = 0; j <= m - 1; ++j) {
if (s[i][b[j]] == '1') {
r += j + 1;
}
}
if (mask & (1 << i))
tmp += r - x[i];
else
tmp -= r - x[i];
}
if (tmp > ret) {
ret = tmp;
for (int j = 0; j <= m - 1; ++j) ans[b[j]] = j + 1;
}
}
for (int j = 0; j <= m - 1; ++j) printf("%d ", ans[j]);
printf("\n");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
using namespace std;
template <class T1, class T2>
inline bool chmax(T1 &a, T2 b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T1, class T2>
inline bool chmin(T1 &a, T2 b) {
if (a > b) {
a = b;
return true;
}
return false;
}
const double EPS = 1e-9, PI = acos(-1);
const double pi = 3.141592653589793238462643383279;
template <int mod>
struct ModInt {
int x;
ModInt() : x(0) {}
ModInt(int64_t y) : x(y >= 0 ? y % mod : (mod - (-y) % mod) % mod) {}
ModInt &operator+=(const ModInt &p) {
if ((x += p.x) >= mod) x -= mod;
return *this;
}
ModInt &operator-=(const ModInt &p) {
if ((x += mod - p.x) >= mod) x -= mod;
return *this;
}
ModInt &operator*=(const ModInt &p) {
x = (int)(1LL * x * p.x % mod);
return *this;
}
ModInt &operator/=(const ModInt &p) {
*this *= p.inverse();
return *this;
}
ModInt operator-() const { return ModInt(-x); }
ModInt operator+(const ModInt &p) const { return ModInt(*this) += p; }
ModInt operator-(const ModInt &p) const { return ModInt(*this) -= p; }
ModInt operator*(const ModInt &p) const { return ModInt(*this) *= p; }
ModInt operator/(const ModInt &p) const { return ModInt(*this) /= p; }
bool operator==(const ModInt &p) const { return x == p.x; }
bool operator!=(const ModInt &p) const { return x != p.x; }
ModInt inverse() const {
int a = x, b = mod, u = 1, v = 0, t;
while (b > 0) {
t = a / b;
swap(a -= t * b, b);
swap(u -= t * v, v);
}
return ModInt(u);
}
ModInt pow(int64_t n) const {
ModInt ret(1), mul(x);
while (n > 0) {
if (n & 1) ret *= mul;
mul *= mul;
n >>= 1;
}
return ret;
}
friend ostream &operator<<(ostream &os, const ModInt &p) { return os << p.x; }
friend istream &operator>>(istream &is, ModInt &a) {
int64_t t;
is >> t;
a = ModInt<mod>(t);
return (is);
}
static int get_mod() { return mod; }
};
using modint = ModInt<998244353>;
template <typename T>
struct Combination {
vector<T> _fact, _rfact, _inv;
Combination(int sz) : _fact(sz + 1), _rfact(sz + 1), _inv(sz + 1) {
_fact[0] = _rfact[sz] = _inv[0] = 1;
for (int i = 1; i <= sz; i++) _fact[i] = _fact[i - 1] * i;
_rfact[sz] /= _fact[sz];
for (int i = sz - 1; i >= 0; i--) _rfact[i] = _rfact[i + 1] * (i + 1);
for (int i = 1; i <= sz; i++) _inv[i] = _rfact[i] * _fact[i - 1];
}
inline T fact(int k) const { return _fact[k]; }
inline T rfact(int k) const { return _rfact[k]; }
inline T inv(int k) const { return _inv[k]; }
T P(int n, int r) const {
if (r < 0 || n < r) return 0;
return fact(n) * rfact(n - r);
}
T C(int p, int q) const {
if (q < 0 || p < q) return 0;
return fact(p) * rfact(q) * rfact(p - q);
}
T H(int n, int r) const {
if (n < 0 || r < 0) return (0);
return r == 0 ? 1 : C(n + r - 1, r);
}
};
long long GCD(long long a, long long b) { return (b == 0) ? a : GCD(b, a % b); }
long long LCM(long long a, long long b) { return a / GCD(a, b) * b; }
long long H, W, r, k;
long long calc(long long y, long long x) {
long long t1 = 0, t2 = 0;
if (0 <= y && y < r && H - r <= y && y < H) {
t1 += H - r + 1;
} else if (0 <= y && y < r) {
t1 += y + 1;
} else if (H - r <= y && y < H) {
t1 += H - y;
} else {
t1 += r;
}
if (0 <= x && x < r && W - r <= x && x < W) {
t2 += W - r + 1;
} else if (0 <= x && x < r) {
t2 += x + 1;
} else if (W - r <= x && x < W) {
t2 += W - x;
} else {
t2 += r;
}
return t1 * t2;
}
int dxy[5] = {-1, 0, 1, 0, -1};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(12);
cin >> H >> W >> r >> k;
long long ans = 0;
priority_queue<pair<long long, long long>> pq;
long long sy = H / 2, sx = W / 2;
pq.push({calc(sy, sx), sy * W + sx});
set<long long> st;
st.insert(sy * W + sx);
long long t = 0;
while (t < k && pq.size()) {
auto p = pq.top();
pq.pop();
ans += p.first;
t++;
int y = p.second / W, x = p.second % W;
if (pq.size() >= k * 10) {
continue;
}
for (int i = 0; i < 4; i++) {
long long ny = y + dxy[i], nx = x + dxy[i + 1];
if (ny >= 0 && ny < H && nx >= 0 && nx < W) {
if (st.find(ny * W + nx) != st.end()) continue;
pq.push({calc(ny, nx), ny * W + nx});
st.insert(ny * W + nx);
}
}
}
cout << (double)(ans) / (double)((H - r + 1) * (W - r + 1)) << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
int arr[101];
int first;
vector<pair<int, int>> v, v2;
int mx;
int sum;
int sum2;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
cin >> arr[0];
first = arr[0];
sum += first;
sum2 += first;
for (int i = 1; i < n; i++) {
cin >> arr[i];
sum += arr[i];
if (arr[i] <= first / 2) {
v.push_back(make_pair(arr[i], i + 1));
}
}
if (first > sum / 2) {
cout << 1 << endl;
cout << 1;
return 0;
}
sort(v.begin(), v.end());
for (int i = 0; i < v.size() && i < n - 2; i++) {
sum2 += v[i].first;
if (sum2 > sum / 2) {
cout << i + 2 << endl;
cout << 1 << " ";
for (int j = 0; j <= i; j++) cout << v[j].second << " \0"[j == i];
return 0;
}
}
cout << 0;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a[100010];
int d[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
set<int> adj[100010];
int bad(int x, int y) {
int p = a[(x - 1) * m + y];
for (int i = 0; i < 4; i++) {
int nx = x + d[i][0], ny = y + d[i][1];
if (1 <= nx && nx <= n && 1 <= ny && ny <= m)
if (adj[p].find(a[(nx - 1) * m + ny]) != adj[p].end()) return 1;
}
return 0;
}
int ok() {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (bad(i, j)) return 0;
return 1;
}
void calc() {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
for (int k = 0; k < 4; k++) {
int x = i + d[k][0], y = j + d[k][1];
if (1 <= x && x <= n && 1 <= y && y <= m)
adj[(i - 1) * m + j].insert(a[(x - 1) * m + y]);
}
}
int main() {
cin >> n >> m;
int j = 1, cnt = 0;
for (int i = 1; i <= n * m; i++) a[j++] = i;
calc();
j = 1;
for (int i = 1; i <= n * m; i += 2) a[j++] = i;
for (int i = 2; i <= n * m; i += 2) a[j++] = i;
while (!ok() && cnt++ < 1000) random_shuffle(a + 1, a + n * m + 1);
if (!ok())
cout << "NO" << endl;
else {
cout << "YES" << endl;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) cout << a[(i - 1) * m + j] << " ";
cout << endl;
}
}
return 0;
}
| 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.