solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int N = 233;
const int M = 1023;
int a[N];
int n, m;
long long dp[N][M], f[N][M];
inline void upd(long long& x, long long y) { x = (x + y) % MOD; }
void solve() {
int now = 0, i, j, k, w;
long long t;
memset(dp, 0, sizeof dp);
dp[0][0] = 1LL;
for (i = 1; i <= n; ++i) {
memset(f, 0, sizeof f);
for (j = 0; j < i; ++j) {
for (k = 0; k <= m; ++k) {
if (t = dp[j][k]) {
w = j * (a[i] - a[i - 1]) + k;
if (w > m) continue;
upd(f[j][w], t);
upd(f[j + 1][w], t);
if (j) upd(f[j - 1][w], t * j % MOD);
upd(f[j][w], t * j % MOD);
}
}
}
for (j = 0; j <= n; ++j)
for (k = 0; k <= m; ++k) dp[j][k] = f[j][k];
}
long long ans = 0LL;
for (i = 0; i <= m; ++i) upd(ans, dp[0][i]);
printf("%I64d\n", ans);
return;
}
int main() {
while (scanf("%d %d", &n, &m) != EOF) {
for (int i = 1; i <= n; ++i) scanf("%d", a + i);
sort(a + 1, a + 1 + n);
a[0] = 0;
solve();
}
return 0;
}
| 6 |
#include "bits/stdc++.h"
using namespace std;
//#define int long long
#define DBG 0
#define dump(o) if(DBG){cerr<<#o<<" "<<o<<endl;}
#define dumpc(o) if(DBG){cerr<<#o; for(auto &e:(o))cerr<<" "<<e;cerr<<endl;}
#define rep(i,a,b) for(int i=(a);i<(b);i++)
#define rrep(i,a,b) for(int i=(b)-1;i>=(a);i--)
#define each(it,c) for(auto it=(c).begin();it!=(c).end();it++)
#define all(c) c.begin(),c.end()
const int INF = sizeof(int) == sizeof(long long) ? 0x3f3f3f3f3f3f3f3fLL : 0x3f3f3f3f;
const int MOD = (int)(1e9 + 7);
//?????§??¬?´???°
int gcd(int x, int y) { return y ? gcd(y, x%y) : x; }
signed main() {
string s; cin >> s;
int dot = -1, l = -1, r = -1;
string t = "";
rep(i, 0, s.size()) {
if (s[i] == '.')dot = i;
else if (s[i] == '(')l = i;
else if (s[i] == ')')r = i;
else t += s[i];
}
if (l == -1) {
int w = s.size() - dot - 1;
dump(w);
int a = stoi(t);
int b = pow(10, w);
int g = gcd(a, b);
cout << a / g << "/" << b / g << endl;
}
else {
dump(t);
string u = t.substr(0, l - 1);
dump(u);
int a = stoi(t) - stoi(u);
dump(a);
int w = r - l - 1;
dump(w);
int b = (pow(10, w) - 1)*pow(10, (l - dot - 1));
dump(b);
int g = gcd(a, b);
cout << a / g << "/" << b / g << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
constexpr int MAX_N = 100100;
using namespace std;
int n, d;
int arr[MAX_N];
int max_pre[MAX_N];
int main() {
scanf(" %d %d", &n, &d);
for (int i = 0; i < n; ++i) {
scanf(" %d", &arr[i]);
}
bool poss = true;
int cur_min = 0;
for (int i = 0; i < n; ++i) {
if (arr[i] == 0) {
cur_min = max(cur_min, 0);
} else {
cur_min += arr[i];
}
if (cur_min > d) {
poss = false;
}
}
if (!poss) {
printf("-1\n");
} else {
for (int i = n - 1; i >= 0; --i) {
max_pre[i] = max(arr[i], arr[i] + max_pre[i + 1]);
}
int ans = 0;
int cur = 0;
for (int i = 0; i < n; ++i) {
if (arr[i] == 0) {
if (cur < 0) {
++ans;
cur = d - max_pre[i];
}
} else {
cur += arr[i];
}
}
printf("%d\n", ans);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int64_t inf = 1e18;
vector<vector<int64_t> > adj;
int64_t inp() {
int64_t x;
cin >> x;
return x;
}
vector<int64_t> level;
int64_t res = 0;
void dfs(int64_t u, int64_t LV = 0) {
level[u] = LV;
res = max(res, LV);
for (auto v : adj[u]) {
dfs(v, LV + 1);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
for (int64_t _ = (1); _ >= (1); _--) {
int64_t n;
cin >> n;
adj.resize(n + 1);
level.resize(n + 1);
for (int64_t node = (1); node <= (n); node++)
adj[max(inp(), int64_t(0))].push_back(node);
dfs(0);
cout << res;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-10;
int dcmp(double x) {
if(fabs(x) < eps) return 0;
return x < 0 ? -1 : 1;
}
bool same(double a, double b) {return dcmp(a - b) == 0;}
#define Vector P
struct P {
double x, y;
P(double x = 0, double y = 0): x(x), y(y) {}
P operator + (P b) {return P(x + b.x, y + b.y);}
P operator - (P b) {return P(x - b.x, y - b.y);}
P operator * (double b) {return P(x * b, y * b);}
P operator / (double b) {return P(x / b, y / b);}
double operator * (P b) {return x * b.x + y * b.y;} // Dot
double operator ^ (P b) {return x * b.y - y * b.x;} // Cross
double abs() {return hypot(x, y);}
P unit() {return *this / abs();}
P spin(double o) {
double c = cos(o), s = sin(o);
return P(c * x - s * y, s * x + c * y);
}
};
struct Line {
//ax + by + c = 0
double a, b, c, theta;
P pa, pb;
Line(): a(0), b(0), c(0), theta(0), pa(), pb() {}
Line(P pa, P pb): a(pa.y - pb.y), b(pb.x - pa.x), c(pa ^ pb), theta(atan2(-a, b)), pa(pa), pb(pb) {} P projection(P p) {return pa + (pb - pa).unit() * ((pb - pa) * (p - pa) / (pb - pa).abs());} P reflection(P p) {return p + (projection(p) - p) * 2;}
double get_ratio(P p) {return (p - pa) * (pb - pa) / ((pb - pa).abs() * (pb - pa).abs());}
P dis(P p) {return ((pb - pa) ^ (p - pa)) / (pb - pa).abs();} // directed distance
};
struct Circle {
P c;
double r;
Circle(P c, double r = 0): c(c), r(r) {}
};
bool onsegment(P p, P a, P b) {
return dcmp((a - p) ^ (b - p)) == 0 && dcmp((a - p) * (b - p)) <= 0;
}
bool segment_intersection(P p1, P p2, P p3, P p4) { // end points are not allowed
return dcmp((p2 - p1) ^ (p3 - p1)) * dcmp((p2 - p1) ^ (p4 - p1)) < 0
&& dcmp((p4 - p3) ^ (p1 - p3)) * dcmp((p4 - p3) ^ (p2 - p3)) < 0;
}
bool parallel(Line l1, Line l2) {return same(l1.a * l2.b, l1.b * l2.a);}
P line_intersection(Line l1, Line l2) {
return P(-l1.b * l2.c + l1.c * l2.b, l1.a * l2.c - l1.c * l2.a) / (-l1.a * l2.b + l1.b * l2.a); }
double Area(vector<P> &p) {
double res = 0;
for(int i = 1; i < (int)p.size() - 1; i++)
res += (p[i] - p[0]) ^ (p[i + 1] - p[0]);
return res * 0.5;
}
int main() {
ios_base::sync_with_stdio(false); cin.tie(0);
int n; cin >> n;
vector<P> vec;
for(int i = 0; i < n; i++) {
P p; cin >> p.x >> p.y;
vec.push_back(p);
}
bool flag = 1;
for(int i = 0; i < n; i++) {
P p0 = vec[i], p1 = vec[(i + 1) % n], p2 = vec[(i + 2) % n];
Vector v1 = p1 - p0, v2 = p2 - p1;
if(dcmp(v1 ^ v2) == -1) flag = 0;
}
cout << flag << '\n';
return 0;
}
| 0 |
#include <iostream>
#include <string>
#include <sstream>
#include <algorithm>
#include <vector>
#include <utility>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
using namespace std;
#define rep(i,n) for(int i=0; i<(n); i++)
#define repc(i,s,e) for(int i=(s); i<(e); i++)
#define pb(n) push_back((n))
#define mp(n,m) make_pair((n),(m))
#define all(r) r.begin(),r.end()
#define fi first
#define se second
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vii;
typedef vector<ll> vl;
typedef vector<vl> vll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
int main() {
ll n, s = 0, a;
cin >> n;
rep(i, n) {
cin >> a;
s += a;
}
s /= n;
cout << s << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int a[105][105];
int main() {
int ans, i, j, k, l, n, m, x, y, kk;
scanf("%d%d%d", &n, &m, &kk);
ans = n * m;
for (i = 0; i < n; i++)
for (j = 0; j < m; j++) scanf("%d", &a[i][j]);
if (m > k) {
for (k = 0; k < m; k++) {
int sum = 0;
for (j = 0; j < m; j++) {
int now = 0;
for (i = 0; i < n; i++) {
if (a[i][j] == a[i][k]) now++;
}
sum += std::min(now, n - now);
}
ans = std::min(ans, sum);
}
} else {
for (int w = 0; w < (1 << m); w++) {
int sum = 0;
for (i = 0; i < n; i++) {
int now = 0;
for (j = 0; j < m; j++) {
if (a[i][j] == ((w >> j) & 1)) now++;
}
sum += std::min(now, m - now);
}
ans = min(ans, sum);
}
}
if (ans > kk)
puts("-1");
else
printf("%d\n", ans);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int dr[] = {0, 0, 1, -1};
int dc[] = {1, -1, 0, 0};
vector<string> mat;
vector<vector<int>> D;
int n, m;
int id = 0;
int dfs(int x, int y) {
D[x][y] = id;
int suma = 1;
for (int h = 0; h < 4; h++) {
int dx = x + dr[h], dy = y + dc[h];
if (0 <= dx and dx < n and 0 <= dy and dy < m and D[dx][dy] == -1 and
mat[dx][dy] == '.') {
suma += dfs(dx, dy);
}
}
return suma;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
D.assign(n, vector<int>(m, -1));
mat.resize(n);
for (int i = 0; i < n; i++) cin >> mat[i];
vector<int> cont;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (D[i][j] == -1 and mat[i][j] == '.') {
cont.push_back(dfs(i, j));
id++;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (mat[i][j] == '*') {
int suma = 0;
set<int> S;
for (int h = 0; h < 4; h++) {
int dx = i + dr[h], dy = j + dc[h];
if (0 <= dx and dx < n and 0 <= dy and dy < m and
mat[dx][dy] == '.') {
S.insert(D[dx][dy]);
}
}
for (auto& s : S) suma += cont[s];
mat[i][j] = char((suma + 1) % 10 + '0');
}
for (int i = 0; i < n; i++) cout << mat[i] << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void get_int(T &x) {
char t = getchar();
bool neg = false;
x = 0;
for (; (t > '9' || t < '0') && t != '-'; t = getchar())
;
if (t == '-') neg = true, t = getchar();
for (; t <= '9' && t >= '0'; t = getchar()) x = x * 10 + t - '0';
if (neg) x = -x;
}
template <typename T>
void print_int(T x) {
if (x < 0) putchar('-'), x = -x;
short a[20] = {}, sz = 0;
while (x > 0) a[sz++] = x % 10, x /= 10;
if (sz == 0) putchar('0');
for (int i = sz - 1; i >= 0; i--) putchar('0' + a[i]);
}
const int inf = 0x3f3f3f3f;
const long long Linf = 1ll << 61;
const double pi = acos(-1.0);
int n, c, a[200111], cnt[200111];
int b[200111], cc;
set<int> s;
int main() {
get_int(c), get_int(n);
for (int i = 1; i <= n; i++) {
get_int(a[i]);
cnt[a[i]]++;
s.insert(a[i]);
}
for (int k = 1; k <= c; k++) {
cc = 0;
int cur = c;
bool use = 0;
while (cur > 0) {
set<int>::iterator it = s.upper_bound(cur);
if (it == s.begin()) {
if (!use && cur >= k) cur -= k;
break;
}
it--;
if (!use && k >= (*it) && k <= cur) {
cur -= k;
use = 1;
continue;
} else {
int t = min(cnt[*it], cur / (*it));
cur -= t * (*it);
b[cc++] = *it;
s.erase(*it);
}
}
for (int i = 0; i < cc; i++) s.insert(b[i]);
if (cur) {
printf("%d\n", k);
return 0;
}
}
puts("Greed is good");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, arr[100000], a = 0;
cin >> n;
cin >> arr[0];
for (int i = 1; i < n; i++) {
cin >> arr[i];
if (arr[i - 1] > arr[i]) a++;
}
if (a == 0) {
cout << "yes" << endl << 1 << ' ' << 1;
return 0;
}
for (int j = 1; j < n; j++) {
if (arr[j] < arr[j - 1]) {
int x, y;
x = j - 1;
if (j == n - 1) y = j;
for (int i = j + 1; i < n; i++) {
if (arr[i - 1] < arr[i]) {
y = i - 1;
break;
} else if (i == n - 1) {
y = i;
break;
}
}
reverse(arr + x, arr + y + 1);
for (int l = 0; l < n - 1; l++) {
if (arr[l] > arr[l + 1]) {
cout << "no";
return 0;
}
}
cout << "yes" << endl << x + 1 << ' ' << y + 1;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int mxN = 1e6 + 5;
int n, m, ans[mxN];
vector<int> a[mxN];
vector<pair<int, int> > add[mxN], del[mxN];
pair<int, int> seg[mxN];
int first[mxN];
void Upd(int pos) {
for (int i = pos; i < mxN; i |= i + 1) ++first[i];
}
int Get(int pos) {
int ans = 0;
for (int i = pos; i >= 0; i &= i + 1, --i) ans += first[i];
return ans;
}
int main() {
ios ::sync_with_stdio(false), cin.tie(nullptr);
cin >> n >> m;
for (int i = 1; i <= n; ++i) cin >> seg[i].first >> seg[i].second;
sort(seg + 1, seg + 1 + n);
for (int i = 1; i <= m; ++i) {
int sz;
cin >> sz;
a[i].push_back(0);
for (int j = 1; j <= sz; ++j) {
int x;
cin >> x;
a[i].push_back(x);
}
for (int j = 1; j <= sz; ++j) {
int x = a[i][j - 1] + 1;
int addi = lower_bound(seg + 1, seg + 1 + n, make_pair(x, 0)) - seg;
int deli = lower_bound(seg + 1, seg + 1 + n, make_pair(a[i][j] + 1, 0)) -
seg - 1;
if (addi <= deli) {
add[addi].push_back({i, a[i][j]});
del[deli].push_back({i, a[i][j]});
}
}
}
for (int i = 1; i <= n; ++i) {
for (auto x : add[i]) ans[x.first] -= Get(mxN - 1) - Get(x.second - 1);
Upd(seg[i].second);
for (auto x : del[i]) ans[x.first] += Get(mxN - 1) - Get(x.second - 1);
}
for (int i = 1; i <= m; ++i) cout << ans[i] << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool check_down(int i, int j, int n, vector<vector<int>> &dpc,
vector<vector<int>> &arr) {
if (i == n - 1) return false;
return dpc[i][j] - dpc[n - 1][j] != 0;
}
bool check_up(int i, int j, int n, vector<vector<int>> &dpc,
vector<vector<int>> &arr) {
if (i == 0) return false;
return arr[i][j] - dpc[i][j] != 0;
}
bool check_left(int i, int j, int m, vector<vector<int>> &dpr,
vector<vector<int>> &arr) {
if (j == 0) return false;
return arr[i][j] - dpr[i][j] != 0;
}
bool check_right(int i, int j, int m, vector<vector<int>> &dpr,
vector<vector<int>> &arr) {
if (j == m - 1) return false;
return dpr[i][j] - dpr[i][m - 1] != 0;
}
int main() {
int n, m;
cin >> n >> m;
vector<vector<int>> arr(n, vector<int>(m, 0));
vector<vector<int>> dpc(n, vector<int>(m, 0));
vector<vector<int>> dpr(n, vector<int>(m, 0));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> arr[i][j];
if (i == 0)
dpc[i][j] = arr[i][j];
else
dpc[i][j] = arr[i][j] + dpc[i - 1][j];
if (j == 0)
dpr[i][j] = arr[i][j];
else
dpr[i][j] = arr[i][j] + dpr[i][j - 1];
}
}
int sum = 0;
for (int i = 0; i < n; i++) {
int cur_val = 0;
for (int j = 0; j < m; j++) {
if (arr[i][j] == 0) {
cur_val += check_down(i, j, n, dpc, arr) + check_up(i, j, n, dpc, arr) +
check_left(i, j, m, dpr, arr) +
check_right(i, j, m, dpr, arr);
}
}
sum += cur_val;
}
cout << sum;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int f, t, next, kind, id;
} e[200005 * 2];
int ecnt, head[200005];
int rv[4] = {0, 2, 1, 3};
void addedge(int f, int t, int kind, int id) {
e[++ecnt] = (edge){f, t, head[f], kind, id};
head[f] = ecnt;
e[++ecnt] = (edge){t, f, head[t], rv[kind], id};
head[t] = ecnt;
}
vector<int> con[200005], f[200005];
int bcj[200005], belong[200005], ok[200005], del[200005], bol[200005];
int ff(int x) { return bcj[x] == x ? bcj[x] : bcj[x] = ff(bcj[x]); }
int gety(int x) {
int t1 = f[x][0] == -1 ? 1 : 0;
int t2 = f[x][1] == -1 ? 1 : 0;
return (t1 << 1) | t2;
}
void connect(int id) {
if (con[id].size() == 0) return;
if (con[id].size() == 1) {
ok[ff(con[id][0])] = id;
} else {
ff(con[id][0]), ff(con[id][1]);
if ((f[id][0] ^ f[id][1]) == 0) {
bcj[bcj[con[id][0]]] = bcj[con[id][1]];
ok[ff(con[id][1])] = id;
} else if (bcj[con[id][0]] == bcj[con[id][1]]) {
ok[ff(con[id][0])] = id;
} else {
ok[bcj[con[id][1]]] = max(ok[bcj[con[id][1]]], ok[bcj[con[id][0]]]);
bcj[bcj[con[id][0]]] = bcj[con[id][1]];
}
}
}
int n, m;
int check[200005], color[200005];
void DFS(int u, int fr) {
check[u] = 1;
color[u] = 1;
for (int i = head[u]; i; i = e[i].next) {
if (e[i].t == fr || check[e[i].t] == 1) continue;
bol[e[i].id] = (e[i].kind & 1) == 0 ? 1 : -1;
DFS(e[i].t, u);
}
}
int main() {
ecnt = 1;
scanf("%d%d", &n, &m);
for (int i = 1, t = 0; i <= n; i++) {
scanf("%d", &t);
for (int j = 1, p = 0; j <= t; j++) {
scanf("%d", &p);
con[abs(p)].push_back(i);
f[abs(p)].push_back(p / abs(p));
}
}
for (int i = 1; i <= n; i++) bcj[i] = i;
for (int i = 1; i <= m; i++) connect(i);
for (int i = 1; i <= n; i++) {
if (ok[ff(i)] == 0) return puts("NO"), 0;
}
puts("YES");
for (int i = 1; i <= n; i++) {
if (i == ff(i) && f[ok[i]].size() == 1) {
del[ok[i]] = 1;
color[con[ok[i]][0]] = 1;
bol[ok[i]] = f[ok[i]][0];
} else if (i == ff(i)) {
del[ok[i]] = 1;
color[con[ok[i]][0]] = color[con[ok[i]][1]] = 1;
bol[ok[i]] = f[ok[i]][0];
}
}
for (int i = 1; i <= m; i++) {
if (del[i] == 0) {
if (con[i].size() == 0)
continue;
else if (con[i].size() == 1)
bol[i] = 1;
else
addedge(con[i][0], con[i][1], gety(i), i);
}
}
for (int i = 1; i <= n; i++) {
if (color[i] == 1 && check[i] == 0) DFS(i, 0);
}
for (int i = 1; i <= m; i++) putchar(bol[i] == 1 ? '1' : '0');
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e5 + 5;
const long long inf = 1e15 + 5;
struct point {
long long x, y;
};
bool operator<(const point A, const point B) {
if (A.x != B.x) return A.x < B.x;
return A.y < B.y;
}
bool operator==(const point A, const point B) {
if (A.x != B.x) return false;
if (A.y != B.y) return false;
return true;
}
long long calcDist(point A, point B) { return abs(A.x - B.x) + abs(A.y - B.y); }
int n;
point a[MAXN];
vector<point> v;
long long maxX, minX, maxY, minY;
long long answer1 = 0, answer2 = 0;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i].x >> a[i].y;
if (i != 0) answer2 += calcDist(a[i - 1], a[i]);
}
answer2 += calcDist(a[0], a[n - 1]);
maxX = a[0].x;
minX = a[0].x;
minY = a[0].y;
maxY = a[0].y;
for (int i = 1; i < n; i++) {
maxX = max(maxX, a[i].x);
maxY = max(maxY, a[i].y);
minX = min(minX, a[i].x);
minY = min(minY, a[i].y);
}
for (int i = 0; i < n; i++) {
if (a[i].x == maxX) {
v.push_back(a[i]);
} else if (a[i].x == minX) {
v.push_back(a[i]);
} else if (a[i].y == maxY) {
v.push_back(a[i]);
} else if (a[i].y == minY) {
v.push_back(a[i]);
}
}
for (int i = 0; i < v.size(); i++) {
for (int j = i + 1; j < v.size(); j++) {
for (int k = 0; k < n; k++) {
if (a[k] == v[i] || a[k] == v[j]) continue;
answer1 = max(answer1, calcDist(v[i], v[j]) + calcDist(v[i], a[k]) +
calcDist(v[j], a[k]));
}
}
}
cout << answer1;
for (int i = 4; i <= n; i++) cout << " " << answer2;
cout << '\n';
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int i, s = 0, a[10003], h[100003] = {0};
for (i = 0; i < 5; i++) cin >> a[i], s += a[i], h[a[i]]++;
long long int ma = INT_MAX;
for (i = 0; i <= 100; i++) {
if (h[i] >= 2) {
ma = min(ma, s - min(h[i], 3ll) * i);
}
}
if (ma == INT_MAX)
cout << s << endl;
else
cout << ma << endl;
}
| 1 |
#include <cstdio>
#define ll long long
ll mod = 1000000007;
ll big(ll b, ll p){
if (p == 1) return b;
ll h = big(b, p / 2);
ll res = (h * h) % mod;
if (p % 2 == 1) res = (res * b) % mod;
return res;
}
int main(){
ll n, k;
scanf("%lld %lld", &n, &k);
ll a[k + 1], ans = 0;
for (int i = k; i >= 1; i--){
a[i] = big(k / i, n);
for (int j = 2; i * j <= k; j++){
(a[i] += mod - a[i * j]) %= mod;
}
}
for (int i = 1; i <= k; i++){
(ans += (i * a[i]) % mod) %= mod;
}
printf("%lld\n", ans);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int r, s, p, da, keo, bao, sum, daconlai, keoconlai, baoconlai;
double dp[101][101][101], res;
int main() {
cin >> da >> keo >> bao;
dp[0][0][0] = 1.0;
for (int r = 0; r <= da; r++)
for (int s = 0; s <= keo; s++)
for (int p = 0; p <= bao; p++) {
if (r == 0 && s == 0 && p == 0) continue;
daconlai = da - r;
keoconlai = keo - s;
baoconlai = bao - p;
if (r > 0) {
sum = (daconlai + 1) * keoconlai + keoconlai * baoconlai +
baoconlai * (daconlai + 1);
if (sum > 0)
dp[r][s][p] += dp[r - 1][s][p] * baoconlai * (daconlai + 1) / sum;
}
if (s > 0) {
sum = daconlai * (keoconlai + 1) + (keoconlai + 1) * baoconlai +
baoconlai * daconlai;
if (sum > 0)
dp[r][s][p] += dp[r][s - 1][p] * daconlai * (keoconlai + 1) / sum;
}
if (p > 0) {
sum = daconlai * keoconlai + keoconlai * (baoconlai + 1) +
(baoconlai + 1) * daconlai;
if (sum > 0)
dp[r][s][p] += dp[r][s][p - 1] * keoconlai * (baoconlai + 1) / sum;
}
}
res = 0;
for (int i = 0; i < da; i++) res += dp[i][keo][bao];
printf("%.12f ", res);
res = 0;
for (int i = 0; i < keo; i++) res += dp[da][i][bao];
printf("%.12f ", res);
res = 0;
for (int i = 0; i < bao; i++) res += dp[da][keo][i];
printf("%.12f ", res);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, c, d, a, b, ans, cmax, dmax;
char type;
vector<pair<int, int> > coin_list, diamond_list;
void calc(vector<pair<int, int> > x, int avail) {
int sz = x.size();
if (sz < 2) return;
vector<int> vect(100007);
vect[0] = x[0].second;
for (int i = 1; i < sz; i++) vect[i] = max(vect[i - 1], x[i].second);
for (int i = sz - 1; i > 0; i--) {
int j;
for (j = 0; j < i; j++)
if (x[i].first + x[j].first > avail) break;
j -= 1;
if (j - 1 == i) break;
if (j >= 0) ans = max(ans, x[i].second + vect[j]);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> c >> d;
while (n--) {
cin >> a >> b >> type;
if (type == 'C') {
if (b > c) continue;
coin_list.push_back(make_pair(b, a));
cmax = max(cmax, a);
} else {
if (b > d) continue;
diamond_list.push_back(make_pair(b, a));
dmax = max(dmax, a);
}
}
sort(coin_list.begin(), coin_list.end());
sort(diamond_list.begin(), diamond_list.end());
calc(coin_list, c);
calc(diamond_list, d);
if (diamond_list.size() && coin_list.size()) ans = max(ans, cmax + dmax);
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010;
map<int, int> mp;
map<int, int> id;
vector<pair<int, int> > a;
vector<int> b;
int n;
long long v[N];
void init() { memset(v, 0, sizeof v); }
int lowbit(int x) { return x & -x; }
void update(int pos, long long key) {
while (pos && pos < N) {
v[pos] += key;
pos += lowbit(pos);
}
}
long long query(int pos) {
long long ans = 0;
while (pos > 0) {
ans += v[pos];
pos -= lowbit(pos);
}
return ans;
}
int Run() {
while (cin >> n) {
mp.clear(), a.clear(), b.clear();
for (int i = 0; i < n; ++i) {
int x, y;
cin >> x >> y;
int px = mp[x], py = mp[y];
if (!px) px = x;
if (!py) py = y;
mp[x] = py;
mp[y] = px;
}
map<int, int>::iterator it = mp.begin();
for (int c = 0, last = -1; it != mp.end(); ++it) {
if (last != -1 && last + 1 != it->first) {
a.push_back(pair<int, int>(it->first - 1, it->first - last - 1));
b.push_back(it->first - 1);
}
a.push_back(pair<int, int>(it->second, 1));
b.push_back(it->second);
last = it->first;
}
sort(b.begin(), b.end());
for (int i = 0; i < b.size(); ++i) id[b[i]] = i + 1;
init();
long long ans = 0;
for (int i = a.size() - 1; i >= 0; --i) {
ans += a[i].second * query(id[a[i].first] - 1);
update(id[a[i].first], a[i].second);
}
cout << ans << endl;
}
return 0;
}
int main() {
ios::sync_with_stdio(0);
return Run();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long arr1[26], arr2[26][26];
int main() {
string str;
cin >> str;
int len = str.length();
for (int i = 0; i < len; i++) {
int c = str[i] - 'a';
for (int j = 0; j < 26; j++) arr2[j][c] += arr1[j];
arr1[c]++;
}
long long ans = 0;
for (int i = 0; i < 26; i++) ans = (arr1[i] > ans) ? arr1[i] : ans;
for (int i = 0; i < 26; i++)
for (int j = 0; j < 26; j++) ans = (arr2[i][j] > ans) ? arr2[i][j] : ans;
cout << ans;
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
#define ls p<<1
#define rs p<<1|1
typedef long long ll;
const int N=35005;
ll mx[N<<2],tag[N<<2];
void add(int p,int v){
mx[p]+=v,tag[p]+=v;
}
void pushup(int p){
mx[p]=min(mx[ls],mx[rs]);
}
void pushdown(int p){
if(tag[p]) add(ls,tag[p]),add(rs,tag[p]),tag[p]=0;
}
void upt(int p,int l,int r,int ql,int qr,int v){
if(ql<=l&&r<=qr) return add(p,v);
int mid=(l+r)>>1;
pushdown(p);
if(ql<=mid) upt(ls,l,mid,ql,qr,v);
if(mid<qr) upt(rs,mid+1,r,ql,qr,v);
pushup(p);
}
ll f[N][105];int las[N],a[N];
void build(int p,int l,int r,int k){
tag[p]=0;
if(l==r) return (void)(mx[p]=f[l-1][k]);
int mid=(l+r)>>1;
build(ls,l,mid,k),build(rs,mid+1,r,k);
mx[p]=min(mx[ls],mx[rs]);
}
ll query(int p,int l,int r,int ql,int qr){
if(ql<=l&&r<=qr) return mx[p];
int mid=(l+r)>>1;long long res=1e18;
if(ql<=mid) res=min(res,query(ls,l,mid,ql,qr));
if(mid<qr) res=min(res,query(rs,mid+1,r,ql,qr));
return res;
}
signed main(){
int n,k;
cin>>n>>k;
for(int i=1;i<=n;++i)
cin>>a[i];
for(int i=1;i<=n;++i) f[i][0]=1e18;
for(int j=1;j<=k;++j){
build(1,1,n,j-1);
for(int i=1;i<=n;++i){
int pos=las[a[i]];
if(pos) upt(1,1,n,1,pos,i-pos);
f[i][j]=query(1,1,n,1,i);
las[a[i]]=i;
}
for(int i=1;i<=n;++i) las[i]=0;
// for(int i=1;i<=n;++i)
// cout<<f[i][j]<<" ";cout<<"\n";
}
cout<<f[n][k];
return 0;
}
| 5 |
#include<iostream>
using namespace std;
int main(){
string s,t;
cin>>s;
cin>>t;
int ans = 0;
for(int i=0;i<s.size();i++){
if(s[i]!=t[i])ans++;
}
cout<<ans<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(){
char s;
cin>>s;
if(65<=s& s<=90){
cout<<'A';
}
else{
cout<<"a";
}
} | 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("avx")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
using namespace std;
int main() {
string s;
cin >> s;
long long p, l = 0, r = 0;
for (int i = 0; i < (int)(s.length()); ++i) {
if (s[i] == '^') p = i;
}
for (int i = 0; s[i] != '^'; i++) {
if (s[i] >= '1' && s[i] <= '9') {
l += (s[i] - 48) * (p - i);
}
}
for (int i = p; i < s.length(); i++) {
if (s[i] >= '1' && s[i] <= '9') {
r += (s[i] - 48) * (i - p);
}
}
if (l == r)
cout << "balance";
else if (l > r)
cout << "left";
else
cout << "right";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef double f64;
const int MAX_N = 100000 + 5;
int n, a[MAX_N], l[MAX_N], r[MAX_N];
void solve() {
scanf("%d", &n);
for (int i = 1; i <= n; i ++) scanf("%d", a + i);
for (int i = l[1] = 1; ++ i <= n; )
if (a[i - 1] < a[i]) l[i] = l[i - 1] + 1;
else l[i] = 1;
r[n] = 1;
for (int i = n - 1; i > 0; i --)
if (a[i + 1] < a[i]) r[i] = r[i + 1] + 1;
else r[i] = 1;
int cnt = 0, len = 0;
for (int i = 1; i <= n; i ++) {
if (l[i] > len) {
len = l[i]; cnt = 1;
}else cnt += l[i] == len;
if (r[i] > len) {
len = r[i]; cnt = 1;
}else cnt += r[i] == len;
}
int ans = 0;
if (cnt != 2 || (~ len & 1)) {
printf("0\n"); return ;
}
for (int i = 1; i <= n; i ++)
if (l[i] == len && r[i] == len) ans ++;
printf("%d\n", ans);
}
int main() {
int T;
T = 1;
// scanf("%d", &T);
while (T --) solve();
return 0;
} | 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300005;
int a[maxn], n, m, k;
long long calc(int p) {
long long res = 0, sum = 0, mn = 0;
for (int i = 1; i <= n; i++) {
sum += a[i];
mn = min(mn, sum);
if ((i - p) % m == 0) res = max(res, sum - mn);
}
return res;
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
long long res = 0;
for (int i = 1; i <= m; i++) {
for (int j = i; j <= n; j += m) a[j] -= k;
res = max(res, calc(i));
for (int j = i; j <= n; j += m) a[j] += k;
}
printf("%lld\n", res);
return 0;
}
| 4 |
#include <iostream>
#include <algorithm>
#include <stdio.h>
using namespace std;
double e[1001][51001];
double optimalBST(double p[],double q[],int n){
double w[1001][1001];
for(int i=1;i<=n+1;i++){
e[i][i-1]=q[i-1];
w[i][i-1]=q[i-1];
}
for(int l=1;l<=n;l++){
for(int i=1;i<=n-l+1;i++){
int j=i+l-1;
e[i][j]=1000.0;
w[i][j]=w[i][j-1]+p[j]+q[j];
for(int r=i;r<=j;r++){
double t=e[i][r-1]+e[r+1][j]+w[i][j];
if(t<e[i][j]){
e[i][j]=t;
}
}
}
}
return e[1][n];
}
int main(){
int n;
double p[1001],q[1001];
cin>>n;
for(int i=1;i<=n;i++){
cin>>p[i];
}
for(int i=0;i<=n;i++){
cin>>q[i];
}
printf("%.8lf\n", optimalBST(p,q,n));
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
ostream& operator<<(ostream& stream, const vector<T> v) {
stream << "[ ";
for (int i = 0; i < (int)v.size(); i++) stream << v[i] << " ";
stream << "]";
return stream;
}
long long fpow(long long x, long long p, long long m) {
long long r = 1;
for (; p; p >>= 1) {
if (p & 1) r = r * x % m;
x = x * x % m;
}
return r;
}
long long inv(long long a, long long b) {
return a < 2 ? a : ((a - inv(b % a, a)) * b + 1) / a % b;
}
int gcd(int a, int b) {
if (!b) return a;
return gcd(b, a % b);
}
long long gcd(long long a, long long b) {
if (!b) return a;
return gcd(b, a % b);
}
long long N, K;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> N >> K;
cout << (K + N - 1) / N << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
void __print(int x) { cout << x; }
void __print(long x) { cout << x; }
void __print(long long x) { cout << x; }
void __print(unsigned x) { cout << x; }
void __print(unsigned long x) { cout << x; }
void __print(unsigned long long x) { cout << x; }
void __print(float x) { cout << x; }
void __print(double x) { cout << x; }
void __print(long double x) { cout << x; }
void __print(char x) { cout << '\'' << x << '\''; }
void __print(const char *x) { cout << '\"' << x << '\"'; }
void __print(const string &x) { cout << '\"' << x << '\"'; }
void __print(bool x) { cout << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cout << '{';
__print(x.first);
cout << ',';
__print(x.second);
cout << '}';
}
template <typename T>
void __print(const T &x) {
int first = 0;
cout << '{';
for (auto &i : x) cout << (first++ ? "," : ""), __print(i);
cout << "}";
}
void _print() { cout << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cout << ", ";
_print(v...);
}
template <class T>
void remdup(vector<T> &v) {
sort((v).begin(), (v).end());
v.erase(unique((v).begin(), (v).end()), end(v));
}
template <typename T>
struct cmp {
bool operator()(const T &p1, const T &p2) {}
};
const long long N = 2e5 + 100;
const long long mod = 1e9 + 7;
const long long X = 2e5 + 100;
vector<pair<long long, long long>> dire = {{-1, 0}, {1, 0}, {0, 1}, {0, -1}};
long long r, c;
string s[1002];
long long check[1005][10005];
pair<long long, long long> start, endd;
vector<pair<long long, long long>> fight;
long long dist;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
;
cin >> r >> c;
for (long long i = (0); i < (r); ++i) cin >> s[i];
for (long long i = (0); i < (r); ++i)
for (long long j = (0); j < (c); ++j) {
if (s[i][j] == 'S') {
start = {i, j};
check[i][j] = 0;
} else if (s[i][j] == 'E') {
endd = {i, j};
check[i][j] = 0;
} else if (s[i][j] == 'T')
check[i][j] = -1;
else
check[i][j] = (s[i][j] - '0');
}
queue<pair<pair<long long, long long>, long long>> qq;
qq.push({endd, 0});
check[endd.first][endd.second] = -1;
while (((long long)(qq.size())) != 0) {
pair<pair<long long, long long>, long long> x;
x = qq.front();
qq.pop();
if (x.first == start) dist = x.second;
for (long long i = (0); i < (((long long)(dire.size()))); ++i) {
long long f1 = x.first.first + dire[i].first;
long long f2 = x.first.second + dire[i].second;
if (f1 < 0 || f1 >= r || f2 < 0 || f2 >= c) continue;
if (check[f1][f2] == -1) continue;
if (check[f1][f2] > 0) fight.push_back({check[f1][f2], x.second + 1});
check[f1][f2] = -1;
qq.push({{f1, f2}, x.second + 1});
}
}
long long ans = 0;
for (long long i = (0); i < (((long long)(fight.size()))); ++i)
if (fight[i].second <= dist) ans += fight[i].first;
cout << ans << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
using ld = long double;
const ld eps = 1e-9;
vector<int> memo;
int kk = -1;
int dfs(const int now, const int from, const vector<vector<int>>& edges) {
int a = 0;
int b = 0;
int c = 0;
for (auto e : edges[now]) {
if (e == from)
continue;
else {
int sta = dfs(e, now, edges);
if (sta == 0)
c++;
else if (sta == 1) {
b++;
} else if (sta == 2) {
a++;
} else if (sta == 3) {
kk = e;
throw(false);
}
}
}
if (a == 0 && b == 0 && c <= 1) {
return memo[now] = 0;
} else if (a == 0 && b == 0 && c == 2) {
return memo[now] = 1;
} else if (a <= 1) {
return memo[now] = 2;
} else if (a == 2) {
return memo[now] = 3;
} else {
throw(false);
}
}
int main() {
int N;
cin >> N;
memo.resize(N);
vector<vector<int>> edges(N, vector<int>());
for (int i = 0; i < N - 1; ++i) {
int a, b;
cin >> a >> b;
a--;
b--;
edges[a].push_back(b);
edges[b].push_back(a);
}
bool ok = true;
try {
dfs(0, -1, edges);
} catch (...) {
ok = false;
}
if (kk != -1) {
ok = true;
try {
dfs(kk, -1, edges);
} catch (...) {
ok = false;
}
}
if (ok)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int mod = 1000000007;
int n;
cin >> n;
long long a = 1, b = 1;
for (int i = 2; i <= n; i++) {
a = (a * i) % mod;
b = (b * 2) % mod;
}
cout << (a - b + mod) % mod << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[300010];
bool vst[300010];
int dp[300010][2];
int root[300010];
int cnt[300010];
int dst[300010];
int find_root(int u) {
if (root[u] == u) return u;
return root[u] = find_root(root[u]);
}
void reunion(int u, int v) {
u = find_root(u);
v = find_root(v);
if (u == v) return;
if (cnt[u] < cnt[v]) swap(u, v);
cnt[u] += cnt[v];
root[v] = u;
dst[u] = max(dst[u], (dst[u] + 1) / 2 + (dst[v] + 1) / 2 + 1);
dst[u] = max(dst[u], dst[v]);
}
int val;
void dfs(int u, int fa = 0) {
vst[u] = 1;
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (v == fa) continue;
dfs(v, u);
}
vector<int> vt;
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (v == fa) continue;
vt.push_back(dp[v][0]);
}
sort(vt.begin(), vt.end());
reverse(vt.begin(), vt.end());
if (vt.size()) dp[u][0] = vt[0] + 1;
if (vt.size() > 1) dp[u][1] = vt[1] + 1;
val = max(val, dp[u][0] + dp[u][1]);
}
int main() {
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i++) root[i] = i;
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
reunion(u, v);
}
for (int i = 1; i <= n; i++) {
if (!vst[i]) {
val = 0;
dfs(i);
int fa = find_root(i);
dst[fa] = val;
}
}
while (q--) {
int ok;
scanf("%d", &ok);
if (ok == 2) {
int u, v;
scanf("%d%d", &u, &v);
reunion(u, v);
} else {
int u;
scanf("%d", &u);
u = find_root(u);
printf("%d\n", dst[u]);
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long int N = 3e5 + 5;
long long int tot[N], ending[N], ans, last, can[N];
vector<pair<long long int, pair<long long int, long long int>>> v;
vector<pair<long long int, long long int>> store;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int n, m;
cin >> n >> m;
long long int i, j, x, y, z;
for (i = 0; i < m; i++) {
cin >> x >> y >> z;
v.push_back({z, {x, y}});
}
sort(v.begin(), v.end());
for (i = 0; i < v.size(); i++) {
x = v[i].second.first;
y = v[i].second.second;
z = v[i].first;
if (last != z) {
for (j = 0; j < store.size(); j++) {
can[store[j].first] = tot[store[j].first];
can[store[j].second] = tot[store[j].second];
}
for (j = 0; j < store.size(); j++) {
tot[store[j].second] =
max(tot[store[j].second], can[store[j].first] + 1);
}
store.clear();
last = z;
}
store.push_back({x, y});
}
for (j = 0; j < store.size(); j++) {
can[store[j].first] = tot[store[j].first];
can[store[j].second] = tot[store[j].second];
}
for (j = 0; j < store.size(); j++) {
tot[store[j].second] = max(tot[store[j].second], can[store[j].first] + 1);
}
for (i = 1; i <= n; i++) ans = max(ans, tot[i]);
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
char s[2000005];
vector<int> a[2000005];
vector<int> cf[2000005], cf2[2000005];
int check(int ans) {
for (int i = 0; i <= n + 1; i++) {
for (int j = 0; j <= m + 1; j++) {
cf[i][j] = cf2[i][j] = 0;
}
}
for (int i = 0; i <= n + 1; i++) {
for (int j = 0; j <= m + 1; j++) {
if (a[i][j] == 1) continue;
cf[max(1, i - ans)][max(1, j - ans)]++;
cf[max(1, i - ans)][min(m, j + ans) + 1]--;
cf[min(n, i + ans) + 1][max(1, j - ans)]--;
cf[min(n, i + ans) + 1][min(m, j + ans) + 1]++;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cf[i][j] = cf[i - 1][j] + cf[i][j - 1] + cf[i][j] - cf[i - 1][j - 1];
if (cf[i][j] == 0) {
cf2[max(1, i - ans)][max(1, j - ans)]++;
cf2[max(1, i - ans)][min(m, j + ans) + 1]--;
cf2[min(n, i + ans) + 1][max(1, j - ans)]--;
cf2[min(n, i + ans) + 1][min(m, j + ans) + 1]++;
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cf2[i][j] = cf2[i - 1][j] + cf2[i][j - 1] + cf2[i][j] - cf2[i - 1][j - 1];
if (cf2[i][j] == 0 && a[i][j]) return 0;
}
}
return 1;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m + 2; i++) {
cf[0].push_back(0);
a[0].push_back(0);
cf2[0].push_back(0);
}
for (int i = 1; i <= n; i++) {
scanf("%s", s + 1);
a[i].push_back(0);
cf[i].push_back(0);
cf2[i].push_back(0);
for (int j = 1; j <= m; j++) {
if (s[j] == 'X')
a[i].push_back(1);
else
a[i].push_back(0);
cf[i].push_back(0);
cf2[i].push_back(0);
}
a[i].push_back(0);
cf[i].push_back(0);
cf2[i].push_back(0);
}
for (int i = 1; i <= m + 2; i++) {
cf[n + 1].push_back(0);
cf2[n + 1].push_back(0);
a[n + 1].push_back(0);
}
int l = 0, r = min(n - 1, m - 1) / 2, mid;
while (l < r) {
mid = (l + r + 1) >> 1;
if (check(mid))
l = mid;
else
r = mid - 1;
}
printf("%d\n", l);
check(l);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (cf[i][j] == 0)
printf("X");
else
printf(".");
}
printf("\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, k, num, cnt;
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> k;
for (int i = 1; i <= k; i++) {
vector<int> v;
int t;
cin >> t;
for (int j = 1; j <= t; j++) {
int x;
cin >> x;
v.push_back(x);
}
if (v[0] == 1) {
int pos = 0;
for (int j = 1; j < v.size(); j++) {
if (v[j] == v[j - 1] + 1)
pos++;
else
break;
}
num += (int)v.size() - pos - 1;
cnt = pos;
} else {
num += (int)v.size() - 1;
}
}
cout << num + n - 1 - cnt << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
int colors1[150], colors2[150];
int main() {
int i, n1, n2, count = 0;
char owns[1005], needs[1005];
scanf("%s", owns);
scanf("%s", needs);
n1 = strlen(owns);
n2 = strlen(needs);
for (i = 0; i < n1; i++) {
colors1[owns[i]]++;
}
for (i = 0; i < n2; i++) {
colors2[needs[i]]++;
}
for (i = 'a'; i <= 'z'; i++) {
if (colors2[i]) {
if (colors1[i] == 0) {
printf("-1\n");
return 0;
} else if (colors1[i] < colors2[i]) {
count += colors1[i];
} else {
count += colors2[i];
}
}
}
printf("%d\n", count);
return 0;
}
| 2 |
#include <stdio.h>
#include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits.h>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <time.h>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#pragma warning(disable:4996)
#pragma comment(linker, "/STACK:336777216")
using namespace std;
#define mp make_pair
#define all(x) (x).begin(), (x).end()
#define ldb ldouble
typedef tuple<int, int, int> t3;
typedef long long ll;
typedef unsigned long long ull;
typedef double db;
typedef long double ldb;
typedef pair <int, int> pii;
typedef pair <ll, ll> pll;
typedef pair <ll, int> pli;
typedef pair <db, db> pdd;
int IT_MAX = 1 << 16;
const ll MOD = 998244353;
const int INF = 0x3f3f3f3f;
const ll LL_INF = 0x3f3f3f3f3f3f3f3f;
const db PI = acos(-1);
const db ERR = 1e-10;
#define szz(x) (int)(x).size()
#define rep(i, n) for(int i=0;i<n;i++)
#define Se second
#define Fi first
vector <int> in[8];
bool dchk[26];
char u[4050];
vector<int> readvec() {
scanf("%s", u);
vector <int> rv;
for (int i = 0; u[i] != 0; i++) rv.push_back(u[i] - '0');
reverse(all(rv));
return rv;
}
bool cmp(vector<int> &a, vector<int> &b) {
if (a.size() != b.size()) return a.size() < b.size();
for (int i = a.size() - 1; i >= 0; i--) if (a[i] != b[i]) return a[i] < b[i];
return false;
}
int main() {
int N, i, j;
scanf("%d", &N);
for (i = 0; i <= N; i++) in[i] = readvec();
while(1) {
int c = 0;
int mx = 7;
for (j = 1; j <= N; j++) {
if (dchk[j]) continue;
c++;
if (cmp(in[mx], in[j])) mx = j;
}
if (c == 1) {
swap(in[1], in[mx]);
break;
}
int t;
for (j = 1; j <= N; j++) {
if (dchk[j] || j == mx) continue;
t = j;
}
int L1 = in[mx].size(), L2 = in[t].size();
for (i = 0; i < L2; i++) in[mx][i + L1 - L2] ^= in[t][i];
while (!in[mx].empty() && !in[mx].back()) in[mx].pop_back();
if (in[mx].empty()) {
dchk[mx] = true;
continue;
}
for (i = 1; i <= N; i++) {
if (dchk[i] || i == mx) continue;
if (in[i] == in[mx]) dchk[mx] = true;
}
}
ll ans = 0;
int L1 = in[0].size(), L2 = in[1].size();
for (i = L1 - 1; i >= L2 - 1; i--) ans = (ans * 2 + in[0][i]) % MOD;
in[2].resize(L1);
for (i = 0; i < L1; i++) in[2][i] = 0;
for (i = L1 - 1; i >= L2 - 1; i--) {
if (in[0][i] != in[2][i]) {
int t = i - (L2 - 1);
for (j = L2 - 1; j >= 0; j--) in[2][t + j] ^= in[1][j];
}
}
bool chk = true;
for (i = L2 - 2; i >= 0; i--) {
if (in[0][i] == in[2][i]) continue;
if (in[0][i] < in[2][i]) chk = false;
break;
}
if (chk) ans = (ans + 1) % MOD;
return !printf("%lld\n", ans);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int arraysize, numberOfSubarrays, firstIndex, lastIndex, cntr = 0;
cin >> arraysize >> numberOfSubarrays;
int theFinalArray[arraysize], mexs[numberOfSubarrays];
for (int i = 0; i < numberOfSubarrays; i++) {
cin >> firstIndex >> lastIndex;
mexs[i] = lastIndex - firstIndex;
}
sort(mexs, mexs + numberOfSubarrays);
cout << mexs[0] + 1 << endl;
for (int i = 0; i < arraysize; i++) {
theFinalArray[i] = cntr;
cntr++;
if (cntr > mexs[0]) cntr = 0;
cout << theFinalArray[i] << " ";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n;
int ans = 0, cnt = 0, divisor[1000006];
bool check(long long a, long long b, long long c) {
if (a + b <= c || a + c <= b || b + c <= a) return false;
if (((a + b - c) & 1) || ((a + c - b) & 1) || ((b + c - a) & 1)) return false;
return true;
}
int main() {
cin >> n;
if (n % 3 != 0) {
puts("0");
return 0;
}
n /= 3;
for (int i = 1; (long long)i * i <= n; ++i)
if (n % i == 0) divisor[++cnt] = i;
for (int i = 1; i <= cnt; ++i) {
long long rest = n / divisor[i];
for (int j = 1; j <= cnt; ++j)
if (rest < divisor[j])
break;
else if (rest % divisor[j] == 0) {
long long c = rest / divisor[j];
if ((long long)c * c <= n && check(divisor[i], divisor[j], c)) ++ans;
}
}
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template <typename T>
using vec = vector<T>;
template <typename K, typename V>
using umap = unordered_map<K, V>;
template <typename K>
using uset = unordered_set<K>;
using vi = vec<int>;
using vl = vec<ll>;
using vpi = vec<pii>;
using vpl = vec<pll>;
using int128 = __int128_t;
using uint128 = __uint128_t;
template <typename I>
string intStr(I x) {
string ret;
while (x > 0) {
ret += (x % 10) + '0';
x /= 10;
}
reverse(ret.begin(), ret.end());
return ret;
}
template <typename T>
inline void maxa(T& st, T v) {
st = max(st, v);
}
template <typename T>
inline void mina(T& st, T v) {
st = min(st, v);
}
inline void setprec(ostream& out, int prec) {
out << setprecision(prec) << fixed;
}
template <typename T>
ostream& operator<<(ostream& out, vector<T> iter) {
out << "[";
for (auto t : iter) {
out << t << ", ";
}
out << "]";
return out;
}
template <typename T>
string arrayStr(T* arr, int sz) {
string ret = "[";
for (int i = 0; i < sz; i++) {
ret += to_string(arr[i]) + ", ";
}
return ret + "]";
}
template <typename T>
void printArray(T* arr, int sz) {
for (int i = 0; i < sz; i++) {
cout << arr[i] << " ";
}
cout << "\n";
}
inline void scan() {}
template <typename F, typename... R>
inline void scan(F& f, R&... r) {
cin >> f;
scan(r...);
}
template <typename F>
inline void println(F t) {
cout << t << '\n';
}
template <typename F, typename... R>
inline void println(F f, R... r) {
cout << f << " ";
println(r...);
}
inline void print() {}
template <typename F, typename... R>
inline void print(F f, R... r) {
cout << f;
print(r...);
}
const int MN = 1e5 + 1;
int n, r, loc[MN];
void solve() {
sort(loc, loc + n);
n = unique(loc, loc + n) - loc;
reverse(loc, loc + n);
int req = 0, sub = 0;
for (__typeof(0) i = 0; i < n; i++) {
if (loc[i] - sub > 0) {
sub += r;
req++;
}
}
println(req);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int T;
scan(T);
while (T--) {
scan(n, r);
for (__typeof(0) i = 0; i < n; i++) {
scan(loc[i]);
}
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int v;
struct edge *next;
edge() {}
edge(int _v, edge *_next) : v(_v), next(_next) {}
};
edge *d[100005];
int init[100005], goal[100005];
int level[100005], sta[100005], pre[100005];
int que[100005], acc[100005];
void insert_edge(int u, int v) {
d[u] = new edge(v, d[u]);
d[v] = new edge(u, d[v]);
}
int calc(int v) {
acc[v] = 0;
acc[v] ^= acc[pre[pre[v]]];
int tmp = acc[v] ^ init[v] ^ goal[v];
acc[v] ^= tmp;
return tmp;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n - 1; ++i) {
int a, b;
scanf("%d%d", &a, &b);
insert_edge(a, b);
}
for (int i = 1; i <= n; ++i) scanf("%d", init + i);
for (int i = 1; i <= n; ++i) scanf("%d", goal + i);
que[0] = 1;
level[1] = 1;
vector<int> ans;
sta[1] = calc(1);
if (sta[1]) ans.push_back(1);
for (int head = 0, tail = 1; head < tail; ++head) {
int v = que[head];
for (edge *p = d[v]; p; p = p->next)
if (!level[p->v]) {
level[p->v] = level[v] + 1;
pre[p->v] = v;
sta[p->v] = calc(p->v);
if (sta[p->v]) ans.push_back(p->v);
que[tail++] = p->v;
}
}
sort(ans.begin(), ans.end());
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); ++i) printf("%d\n", ans[i]);
return 0;
}
| 3 |
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n, m;
while (cin >> n >> m, m) {
vector<int> seq(n);
for (int i = 0; i < n; ++i)
seq[i] = i + 1;
while (seq.size() > 1) {
rotate(seq.begin(), seq.begin() + (m - 1) % seq.size(), seq.end());
seq.erase(seq.begin());
}
cout << seq[0] << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int Inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3fll;
template <int jt>
struct ModInt {
int x;
ModInt(int v = 0) {
x = v;
if (x >= jt || x < 0) {
x %= jt;
if (x < 0) x += jt;
}
}
ModInt(long long v) {
x = v % jt;
if (x < 0) x += jt;
}
operator int() const { return x; }
friend inline ModInt &operator+=(ModInt &a, const ModInt &b) {
a.x += b.x;
if (a.x >= jt) a.x -= jt;
return a;
}
friend inline ModInt operator+(ModInt a, const ModInt &b) { return a += b; }
friend inline ModInt operator+(ModInt a, int b) { return a += ModInt(b); }
friend inline ModInt operator+(int a, ModInt b) { return b += ModInt(a); }
friend inline ModInt &operator++(ModInt &a) { return a += 1; }
friend inline ModInt &operator-=(ModInt &a, const ModInt &b) {
a.x -= b.x;
if (a.x < 0) a.x += jt;
return a;
}
friend inline ModInt operator-(ModInt a, const ModInt &b) { return a -= b; }
friend inline ModInt operator-(ModInt a, int b) { return a -= ModInt(b); }
friend inline ModInt operator-(int a, ModInt b) { return ModInt(a) - b; }
friend inline ModInt &operator--(ModInt &a) { return a -= 1; }
friend inline ModInt &operator*=(ModInt &a, const ModInt &b) {
a.x = (long long)a.x * b.x % jt;
return a;
}
friend inline ModInt operator*(ModInt a, const ModInt &b) { return a *= b; }
friend inline ModInt operator*(ModInt a, int b) { return a *= ModInt(b); }
friend inline ModInt operator*(int a, ModInt b) { return b *= ModInt(a); }
static inline void exgcd(long long a, long long b, long long &x,
long long &y) {
b ? (exgcd(b, a % b, y, x), y -= a / b * x) : (x = 1, y = 0);
}
friend inline ModInt inv(const ModInt &a) {
long long x, y;
exgcd(a, jt, x, y);
return x;
}
friend inline ModInt operator/(const ModInt &a, const ModInt &b) {
return a * inv(b);
}
friend inline ModInt operator/(ModInt a, int b) { return a * inv(ModInt(b)); }
friend inline ModInt operator/(int a, ModInt b) { return ModInt(a) * inv(b); }
friend inline ModInt operator/=(ModInt &a, const ModInt &b) {
return a = a / b;
}
};
const int jt = 1000000007;
int n;
char l[1 << 17], r[1 << 17];
ModInt<jt> m2[1 << 17], m10[1 << 17], ii[1 << 17];
ModInt<jt> dp[1 << 17];
ModInt<jt> asms(int i, ModInt<jt> pre) {
if (i <= 0) return 0;
ModInt<jt> c0 = dp[i];
if (!pre) return c0;
ModInt<jt> c1 = (m2[i] - 1) * 11 * ii[i];
ModInt<jt> c2 = m2[i] - 1;
return c0 + (c1 + c2 * pre) * pre;
}
void init() {
m2[0] = 1;
for (int i = 1; i <= (n); ++i) m2[i] = m2[i - 1] * 2;
m10[0] = 1;
for (int i = 1; i <= (n); ++i) m10[i] = m10[i - 1] * 10;
ii[0] = 0;
for (int i = 1; i <= (n); ++i) ii[i] = ii[i - 1] * 10 + 1;
dp[0] = 0;
for (int i = 1; i <= (n); ++i) {
ModInt<jt> l = asms(i - 1, 4 * m10[i - 1]);
ModInt<jt> r = asms(i - 1, 7 * m10[i - 1]);
ModInt<jt> lr = 4 * m10[i - 1] + 7 * ii[i - 1];
ModInt<jt> rl = 7 * m10[i - 1] + 4 * ii[i - 1];
dp[i] = l + r + lr * rl;
}
}
ModInt<jt> solve(char r[]) {
ModInt<jt> ans = 0;
for (int i = 1; i <= (n - 1); ++i) {
ans += asms(i, 0);
ans += ii[i] * 7 * ii[i + 1] * 4;
}
ModInt<jt> pf = 0;
for (int i = (n - 1); ((-1) > 0 ? i <= (0) : i >= (0)); i += (-1)) {
if (r[n - i - 1] == '4') {
pf += m10[i] * 4;
} else {
ans += asms(i, pf + 4 * m10[i]);
ModInt<jt> lr = pf + 4 * m10[i] + 7 * ii[i];
ModInt<jt> rl = pf + 7 * m10[i] + 4 * ii[i];
ans += lr * rl;
pf += m10[i] * 7;
}
}
return ans;
}
int main() {
scanf("%s", l);
scanf("%s", r);
n = strlen(r);
init();
printf("%d\n", int(solve(r) - solve(l)));
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, count = 0;
cin >> n;
long long int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
long long int mx = a[n - 1];
long long int mn = a[0];
for (int i = 1; i < n - 1; i++)
if (a[i] != mx && a[i] != mn) count++;
cout << count;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
long long a[n];
long long dmg = 0, cnt = 1, sum = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
dmg += a[i];
}
string s;
cin >> s;
for (int i = 0, j; i < n; i++) {
for (j = i + 1; j < n; j++)
if (s[i] == s[j])
cnt++;
else
break;
if (cnt > k) {
sort(a + i, a + j);
for (int t = i; t < i + cnt - k; t++) {
sum += a[t];
}
}
cnt = 1;
i = j - 1;
}
cout << dmg - sum;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const int INF = 1000 * 1000 * 1000 + 7;
const long long LINF = (long long)INF * INF;
int cnt[26];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n, k;
string S;
cin >> n >> k >> S;
for (int i = (0); i < (n); ++i) {
cnt[S[i] - 'A']++;
}
int ans = INF;
for (int i = (0); i < (k); ++i) ans = min(ans, cnt[i]);
cout << ans * k;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (!a) return b;
return gcd(b % a, a);
}
long long mexp(long long a, long long b) {
long long ans = 1;
a %= 1000000007;
while (b) {
if (b & 1) ans = ans * a % 1000000007;
b >>= 1;
a = a * a % 1000000007;
}
return ans;
}
const int N = 100005;
int a[N];
vector<long long> g[N];
long long dp[N][2];
long long ans;
void dfs(int u, int p, int pos) {
int x = (a[u] >> pos) & 1;
dp[u][x] = 1;
dp[u][x ^ 1] = 0;
long long d = 0;
for (int v : g[u]) {
if (v != p) {
dfs(v, u, pos);
d += dp[u][0] * dp[v][1] + dp[u][1] * dp[v][0];
dp[u][x ^ 0] += dp[v][0];
dp[u][x ^ 1] += dp[v][1];
}
}
ans += d << pos;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (long long i = 1; i < n + 1; ++i) {
cin >> a[i];
ans += a[i];
}
for (long long i = 1; i < n; ++i) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
for (long long i = 0; i < 21; ++i) {
dfs(1, 0, i);
}
cout << ans;
cerr << 1.0 * clock() / CLOCKS_PER_SEC << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool isvis[1000005] = {0};
vector<int> link[1000005];
vector<long long int> vec;
void dfs(int n, int d) {
bool islf = true;
isvis[n] = true;
for (int i = 0; i < link[n].size(); i++) {
if (!isvis[link[n][i]]) {
islf = false;
dfs(link[n][i], d + 1);
}
}
if (islf) {
vec.push_back(d);
}
return;
}
int main() {
int n, n1, n2;
cin.tie(NULL);
cin.sync_with_stdio(false);
cin >> n;
for (int i = 1; i < n; i++) {
cin >> n1 >> n2;
link[n1].push_back(n2);
link[n2].push_back(n1);
}
isvis[1] = true;
long long int ans = numeric_limits<int>::min();
for (int i = 0; i < link[1].size(); i++) {
vec.clear();
dfs(link[1][i], 0);
sort(vec.begin(), vec.end());
long long int btime = numeric_limits<int>::min();
for (int j = 0; j < vec.size(); j++) {
btime = max(btime + 1, vec[j]);
}
ans = max(ans, btime + 1);
}
cout << ans << endl;
return 0;
}
| 5 |
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main(){
int n,m;
while(cin >> n >> m , n + m){
vector<int> v;
int a;
for(int i = 0 ; i < n ; i++){
cin >> a;
v.push_back(a);
}
int size = v.size();
for(int i = 0 ; i < size ; i++){
for(int j = 0 ; j < size ; j++){
v.push_back(v[i]+v[j]);
}
}
sort(v.begin(),v.end());
int ans = 0;
for(int i = 0 ; i < v.size() ; i++){
int want = m - v[i];
int l = 0,r = v.size()-1;
if(want < 0) continue;
while(r - l > 1){
int mid = (l+r) /2;
if(v[mid] >= want){
r = mid;
}
else{
l = mid;
}
if(v[l] + v[i] <= m){
ans = max(ans,v[l]+v[i]);
}
}
}
cout << ans << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int tests;
cin >> tests;
while (tests--) {
int n;
cin >> n;
vector<vector<char>> t(n);
char c;
for (auto& i : t) {
for (int j = 0; j < n; ++j) {
cin >> c;
i.push_back(c);
}
}
vector<pair<int, int>> ans;
char right_s = t[0][1];
char down_s = t[1][0];
char left_f = t[n - 1][n - 2];
char up_f = t[n - 2][n - 1];
if (right_s == down_s) {
if (right_s == '0')
c = '1';
else
c = '0';
if (left_f != c) ans.push_back(make_pair(n, n - 1));
if (up_f != c) ans.push_back(make_pair(n - 1, n));
} else if (left_f == up_f) {
if (left_f == '0')
c = '1';
else
c = '0';
if (right_s != c) ans.push_back(make_pair(1, 2));
if (down_s != c) ans.push_back(make_pair(2, 1));
} else {
c = right_s;
ans.push_back(make_pair(1, 2));
if (left_f != c) ans.push_back(make_pair(n, n - 1));
if (up_f != c) ans.push_back(make_pair(n - 1, n));
}
cout << ans.size() << '\n';
for (auto i : ans) {
cout << i.first << ' ' << i.second << '\n';
}
}
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,k;cin>>n>>k;
vector<int >iis(k,0);
for(int i=0;i<n;i++){
int l;cin>>l;
for(int j=0,a;j<l;j++){
cin>>a;iis[a-1]++;
}
}
int tot=0;
for(int i=0;i<k;i++)if(iis[i]==n)tot++;
cout<<tot;
} | 0 |
#include <iostream>
#include <queue>
#include <climits>
using namespace std;
#define MOD 100000007
typedef pair<int,int> P;
int h, w;
int sx, sy, gx, gy;
int closed[1002][1002];
int minDist[1002][1002];
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
int main(){
while(cin >> h >> w >> sy >> sx >> gy >> gx){
queue<P> open;
open.push(P(sx, sy));
for(int i = 0; i < h; i++){
for(int j = 0; j < w; j++){
minDist[i][j] = INT_MAX;
closed[i][j] = 0;
}
}
closed[sy][sx] = 1;
minDist[sy][sx] = 0;
while(!open.empty()){
P p = open.front();
open.pop();
if(p.first == gx && p.second == gy){
break;
}
int ncost = minDist[p.second][p.first] + 1;
for(int i = 0; i < 4; i++){
int nx = (p.first + dx[i] + w) % w;
int ny = (p.second + dy[i] + h) % h;
if(minDist[ny][nx] < ncost) continue;
if(minDist[ny][nx] > ncost) open.push(P(nx, ny));
closed[ny][nx] += closed[p.second][p.first];
closed[ny][nx] %= MOD;
minDist[ny][nx] = ncost;
}
}
cout << closed[gy][gx] << endl;
}
} | 0 |
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
while(1) {
bool end = false;
int n;
cin >> n;
if(n == 0) return 0;
int w[n];
for(int i = 0; i < n; i++) {
string s;
cin >> s;
w[i] = s.size();
}
// for(int i = 0; i < n; i++) cout << w[i] << " ";
// cout << endl;
int tanku[5] = {5, 7, 5, 7, 7};
for(int i = 0; i < n; i++) {
if(end) break;
int k = 0;
for(int j = 0; j < 5; j++) {
if(end) break;
int sum = 0;
while(sum < tanku[j]) {
sum += w[i+k];
k++;
}
// cout << sum << " :" << j << " ";
if(sum != tanku[j]) break;
if(j == 4) {
cout << i+1 << endl;
end = true;
}
}
}
}
}
| 0 |
#include <bits/stdc++.h>
int main() {
int n;
int i;
scanf("%d", &n);
if (n == 1) {
putchar('a');
return 0;
}
putchar('a');
putchar('a');
if (n == 2) return 0;
char prePrev = 'a';
char prev = 'a';
for (i = 3; i <= n; i++) {
if (prePrev == 'a') {
prePrev = prev;
prev = 'b';
putchar(prev);
} else if (prePrev == 'b') {
prePrev = prev;
prev = 'a';
putchar(prev);
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int loop_times, candy_number;
cin >> loop_times;
while (loop_times--) {
cin >> candy_number;
int x[candy_number + 1];
int f[candy_number + 1];
for (int i = 1; i <= candy_number; ++i) {
cin >> x[i];
}
f[0] = 0;
f[1] = x[1];
f[2] = min((f[1] + x[2]), f[1]);
f[3] = min(min(f[2] + x[3], f[1] + x[2]), x[1]);
f[4] = min(min(f[3] + x[4], f[2] + x[3]), min(f[1] + x[2], x[1] + x[2]));
for (int i = 5; i <= candy_number; ++i) {
f[i] = min(min(f[i - 1] + x[i], f[i - 2] + x[i - 1]),
min(f[i - 3] + x[i - 2], f[i - 4] + x[i - 3] + x[i - 2]));
}
cout << f[candy_number] << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int64_t mod = 1e9 + 7;
int64_t Prime[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29,
31, 37, 41, 43, 47, 53, 59, 61, 67};
int64_t n, res = 0, Pre[70], ff[16][16];
vector<int64_t> V[20], f[16][2][16];
void Init() {
Pre[1] = 0;
int64_t Count = 0;
for (int64_t i = 4; i <= 18; i++) Pre[Prime[i]] = ++Count;
}
int main() {
ios_base::sync_with_stdio(false);
Init();
cin >> n;
int64_t x;
for (int64_t i = 1; i <= n; i++) {
cin >> x;
int64_t sum = 0;
for (int64_t j = 0; j <= 3; j++) {
int64_t Count = 0;
while (x % Prime[j] == 0) {
Count ^= 1;
x /= Prime[j];
}
sum += Count * (1 << j);
}
V[Pre[x]].push_back(sum);
}
for (int64_t pos = 0; pos <= 15; pos++)
for (int64_t j = 0; j <= 15; j++) {
f[pos][0][j].resize(V[pos].size() + 5);
f[pos][1][j].resize(V[pos].size() + 5);
}
if (V[0].size() > 0) {
f[0][0][0][0]++;
f[0][0][V[0][0]][0]++;
for (int64_t i = 1; i < V[0].size(); i++)
for (int64_t j = 0; j <= 15; j++)
f[0][0][j][i] = (f[0][0][j][i - 1] + f[0][0][j ^ V[0][i]][i - 1]) % mod;
}
for (int64_t pos = 1; pos <= 15; pos++)
if (V[pos].size() > 0) {
f[pos][0][0][0]++;
f[pos][1][V[pos][0]][0]++;
for (int64_t i = 1; i < V[pos].size(); i++)
for (int64_t j = 0; j <= 15; j++) {
f[pos][0][j][i] =
(f[pos][0][j][i - 1] + f[pos][1][j ^ V[pos][i]][i - 1]) % mod;
f[pos][1][j][i] =
(f[pos][1][j][i - 1] + f[pos][0][j ^ V[pos][i]][i - 1]) % mod;
}
}
if (V[0].size() > 0)
for (int64_t i = 0; i <= 15; i++) ff[0][i] = f[0][0][i][V[0].size() - 1];
else
ff[0][0] = 1;
for (int64_t pos = 1; pos <= 15; pos++)
for (int64_t i = 0; i <= 15; i++) {
if (V[pos].size() > 0)
for (int64_t t = 0; t <= 15; t++)
ff[pos][i] = (ff[pos][i] +
ff[pos - 1][t] * f[pos][0][i ^ t][V[pos].size() - 1]) %
mod;
else
ff[pos][i] = ff[pos - 1][i];
}
cout << (ff[15][0] - 1 + mod) % mod;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int s[100010];
int a[100010];
map<int, int> mx, my;
int main(void) {
int N, i;
cin >> N;
for ((i) = 0; (i) < (int)(N); (i)++) scanf("%d", &s[i]);
cout << "YES" << endl;
if (N == 1) {
cout << s[0] << endl << 0 << endl;
return 0;
}
for ((i) = 0; (i) < (int)(N); (i)++) a[i] = s[i];
sort(a, a + N);
int X = (N + 2) / 3;
int Y = N - X - X;
for ((i) = 0; (i) < (int)(N); (i)++) {
if (i < X) {
mx[a[i]] = 0;
my[a[i]] = a[i];
} else if (i < X + X) {
mx[a[i]] = a[i];
my[a[i]] = 0;
} else {
mx[a[i]] = N - 1 - i;
my[a[i]] = a[i] - (N - 1 - i);
}
}
for ((i) = 0; (i) < (int)(N); (i)++) {
printf("%d", mx[s[i]]);
if (i == N - 1)
printf("\n");
else
printf(" ");
}
for ((i) = 0; (i) < (int)(N); (i)++) {
printf("%d", my[s[i]]);
if (i == N - 1)
printf("\n");
else
printf(" ");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct p {
int u, v, w;
p() {}
p(int u, int v, int w) : u(u), v(v), w(w) {}
bool operator<(const p &right) { return this->w < right.w; }
};
int n;
string s1, s2;
map<pair<char, char>, int> M;
map<char, int> S;
int l, r;
int main() {
vector<int> ans;
string s;
cin >> s;
vector<int> dp(s.size() + 1, 0);
s = s + "(";
for (int i = s.size() - 3; i >= 0; --i)
if (s[i] == '(' && s[i + dp[i + 1] + 1] == ')')
dp[i] = dp[i + 1] + dp[i + dp[i + 1] + 2] + 2;
int maxn = *max_element(dp.begin(), dp.end());
if (maxn == 0)
cout << "0 1" << endl;
else {
cout << maxn << " ";
cout << count(dp.begin(), dp.end(), maxn);
}
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-variable"
#pragma GCC diagnostic ignored "-Wc++11-extensions"
#pragma GCC diagnostic ignored "-Wunused-const-variable"
using namespace std;
void ain(vector<long long>& a) {
for (long long i = 0; i < (long long)a.size(); i++) cin >> a[i];
}
void print(vector<long long>& a, char c = ' ') {
for (long long i = 0; i < a.size(); i++) cout << a[i] << c;
}
long long max(vector<long long>& a) {
long long Max = a[0];
for (long long i = 1; i < a.size(); i++) Max = max(Max, a[i]);
return Max;
}
long long min(vector<long long>& a) {
long long Min = a[0];
for (long long i = 1; i < a.size(); i++) Min = min(Min, a[i]);
return Min;
}
long long max(long long a, long long b) { return (a > b) ? a : b; }
long long min(long long a, long long b) { return (a > b) ? b : a; }
long long Ceil(double x) {
return (((long long)x == x) ? x : (long long)x + 1);
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
long long n;
vector<long long> a;
long long f(long long l, long long r) {
if (l > r) return 0;
if (l == r) return a[l] == 0 ? 0 : 1;
long long Mini = l;
for (long long i = l; i <= r; i++) {
if (a[i] < a[Mini]) Mini = i;
}
long long Min = a[Mini];
for (long long i = l; i <= r; i++) {
a[i] -= Min;
}
return min(r - l + 1, f(l, Mini - 1) + f(Mini + 1, r) + Min);
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
a.assign(n, 0);
ain(a);
cout << f(0, n - 1) << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
int n, mid;
int a[30], b[30], c[30];
map<pair<int, long long>, pair<int, long long> > h;
pair<int, long long> ans;
void dfs1(int step, long long sta, int A, int B, int C) {
if (step == mid + 1) {
pair<int, long long> tmp;
tmp = h[pair<int, long long>(A - B, B - C)];
if (tmp.second == 0)
h[pair<int, long long>(A - B, B - C)] = {A, sta};
else
h[pair<int, long long>(A - B, B - C)] =
max(tmp, pair<int, long long>(A, sta));
return;
}
dfs1(step + 1, sta << 2 | 1, A, B + b[step], C + c[step]);
dfs1(step + 1, sta << 2 | 2, A + a[step], B, C + c[step]);
dfs1(step + 1, sta << 2 | 3, A + a[step], B + b[step], C);
}
void dfs2(int step, long long sta, int A, int B, int C) {
if (step == n + 1) {
pair<int, long long> tmp = h[pair<int, long long>(B - A, C - B)];
if (tmp.second == 0) return;
ans = max(ans, pair<int, long long>(A + tmp.first,
tmp.second << (n - mid << 1) | sta));
return;
}
dfs2(step + 1, sta << 2 | 1, A, B + b[step], C + c[step]);
dfs2(step + 1, sta << 2 | 2, A + a[step], B, C + c[step]);
dfs2(step + 1, sta << 2 | 3, A + a[step], B + b[step], C);
}
int main() {
ans.first = -INF;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d%d%d", &a[i], &b[i], &c[i]);
mid = (n + 1) / 2;
dfs1(1, 0, 0, 0, 0);
dfs2(mid + 1, 0, 0, 0, 0);
if (ans.first == -INF) return puts("Impossible");
vector<int> res;
for (int i = 1; i <= n; i++) {
res.push_back(ans.second & 3);
ans.second >>= 2;
}
for (int i = res.size() - 1; i >= 0; i--) {
if (res[i] == 3)
puts("LM");
else if (res[i] == 2)
puts("LW");
else
puts("MW");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string ans = "";
while(n != 0){
int t = n%(-2);
if(t == -1) t = 1;
ans.push_back('0'+t);
n = (n-t)/(-2);
}
if(ans.size() == 0) ans = "0";
reverse(ans.begin(),ans.end());
cout << ans << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
cin >> t;
while (t--) {
double n;
cin >> n;
double angle = 3.141592653589793238;
angle /= n;
angle /= 2;
double ans = tan(angle);
ans = 1 / ans;
cout << setprecision(15) << ans << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x * f;
}
int n, m, a[210][210], cnt[210][210], ax = 1, ay = 1;
int main() {
n = read(), m = read();
for (int i = 1; i <= n + m; ++i)
for (int j = 1; j <= n + m; ++j) a[i][j] = 1;
for (int i = 1; i <= n; ++i) {
char s[110];
cin >> s;
for (int j = 1; j <= n; ++j) a[i][j] = (s[j - 1] == '#');
}
if (m == 1) {
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
if (!a[i][j]) {
cout << i << " " << j << endl;
return 0;
}
cout << 1 << " " << 1 << endl;
return 0;
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) {
bool flag = 0;
for (int k = 0; k < m; ++k)
if (a[i + k][j]) flag = 1;
if (!flag)
for (int k = 0; k < m; ++k) cnt[i + k][j]++;
flag = 0;
for (int k = 0; k < m; ++k)
if (a[i][j + k]) flag = 1;
if (!flag)
for (int k = 0; k < m; ++k) cnt[i][j + k]++;
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
if (cnt[ay][ax] < cnt[i][j]) ay = i, ax = j;
}
}
cout << ay << " " << ax << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops")
#pragma GCC optimize("no-stack-protector,fast-math")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const long long N = 2e6 + 100, OO = 1e7 + 7, M = 1e9 + 7, P = 49157, sq = 360,
lg = 30;
long long f[N], is[5][N], hs[N], pw[N], ht[N];
void kmp(string s, string t, long long x) {
s = t + (char)(127) + s;
long long n = (long long)s.size(), j = 0, m = (long long)t.size() + 1;
f[1] = 0;
for (long long i = 2; i <= n; i++) {
while (s[i - 1] != s[j] && j) j = f[j];
if (s[i - 1] == s[j]) j++;
f[i] = j;
if (i > m) is[x][i - m] = j;
}
}
int32_t main() {
string s, t;
getline(cin, s);
getline(cin, t);
long long n = (long long)s.size(), m = (long long)t.size();
if (n != m) return cout << "-1 -1" << endl, 0;
pw[0] = 1;
for (long long i = 1; i <= n; i++) pw[i] = (pw[i - 1] * P);
for (long long i = 1; i <= n; i++)
hs[i] = (hs[i - 1] * P + (long long)(s[i - 1]) + 1);
for (long long i = 1; i <= n; i++)
ht[i] = (ht[i - 1] * P + (long long)(t[i - 1]) + 1);
for (long long i = 1; i <= n; i++) {
long long l = 0, r = n - i + 2;
while (l < r) {
long long mid = (l + r) / 2;
long long j = i + mid - 1;
long long t = hs[j] - hs[i - 1] * pw[mid];
if (mid == 0 || t == ht[mid])
l = mid + 1;
else
r = mid;
}
is[1][i] = l - 1;
if (is[1][i] + i - 1 == n) is[1][i]--;
}
reverse(s.begin(), s.end());
kmp(t, s, 2);
reverse(s.begin(), s.end());
reverse(t.begin(), t.end());
kmp(s, t, 3);
reverse(t.begin(), t.end());
vector<pair<long long, long long> > v;
for (long long i = 1; i < n; i++) {
if (is[3][i] != i) continue;
if (is[2][(n - i)] < (n - i)) continue;
v.push_back({i - 1, -i});
}
for (long long i = 2; i < n; i++) {
long long j = i + is[1][i] - 1;
if (is[3][i - 1] != i - 1) continue;
if (is[2][(n - i + 1)] < (n - j)) continue;
long long t = n - is[2][n - i + 1];
v.push_back({i - 2, -max(i - 1, t)});
}
sort(v.begin(), v.end());
if (v.size() == 0) {
cout << "-1 -1" << endl;
return 0;
}
cout << v.back().first << " " << -1 * v.back().second << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 2 * acos(0.0);
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
mt19937_64 rng_64(chrono::steady_clock::now().time_since_epoch().count());
const string DIGITS = "0123456789";
const string ALPH = "abcdefghijklmnopqrstuvwxyz";
template <class T0, class T1>
inline ostream &operator<<(ostream &out, pair<T0, T1> &a) {
return out << "{" << a.first << ", " << a.second << "}";
}
template <class T0, class T1, class T2>
inline ostream &operator<<(ostream &out, tuple<T0, T1, T2> &a) {
return out << "{" << get<0>(a) << ", " << get<1>(a) << ", " << get<2>(a)
<< "}";
}
template <class T0, class T1, class T2, class T3>
inline ostream &operator<<(ostream &out, tuple<T0, T1, T2, T3> &a) {
return out << "{" << get<0>(a) << ", " << get<1>(a) << ", " << get<2>(a)
<< ", " << get<3>(a) << "}";
}
template <class T>
inline ostream &operator<<(ostream &out, vector<T> &a) {
out << "[";
for (int i = 0; i < int(a.size()); ++i)
out << a[i] << vector<string>{", ", "] "}[i + 1 == a.size()];
return out;
}
void smain();
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << setprecision(12) << fixed;
smain();
return 0;
}
const int N = 3e6 + 100;
pair<int, pair<bool, bool>> t[N << 2];
const long long oo = 1e18;
int a[N];
pair<int, pair<bool, bool>> trans(pair<int, pair<bool, bool>> a,
pair<int, pair<bool, bool>> b) {
int cnt = a.first + b.first;
if (b.second.first && a.second.second) cnt--;
return {cnt, {a.second.first, b.second.second}};
}
void build(int v, int tl, int tr) {
if (tl == tr) {
if (a[tl] == 1) {
t[v] = {1, {1, 1}};
} else {
t[v] = {0, {0, 0}};
}
return;
}
int tm = tl + tr >> 1;
build(v << 1, tl, tm);
build(v << 1 | 1, tm + 1, tr);
t[v] = trans(t[v << 1], t[v << 1 | 1]);
}
pair<int, pair<bool, bool>> get(int v, int tl, int tr, int l, int r) {
assert(l <= r);
if (tl == l && tr == r) return t[v];
int tm = tl + tr >> 1;
if (l <= tm && r > tm)
return trans(get(v << 1, tl, tm, l, min(tm, r)),
get(v << 1 | 1, tm + 1, tr, max(tm + 1, l), r));
if (l <= tm) return get(v << 1, tl, tm, l, min(tm, r));
return get(v << 1 | 1, tm + 1, tr, max(tm + 1, l), r);
}
int p[N];
void solve() {
int n;
cin >> n;
vector<pair<long long, long long>> segs(n);
vector<long long> points;
for (int i = 0; i < int(n); ++i) {
cin >> segs[i].first >> segs[i].second;
segs[i].first *= 2, segs[i].second *= 2;
for (int dif = -1; dif <= 1; ++dif) {
points.push_back(segs[i].first + dif);
points.push_back(segs[i].second + dif);
}
}
points.push_back(-oo);
sort(points.begin(), points.end());
points.resize(unique(points.begin(), points.end()) - points.begin());
int NN = 0;
for (int i = 0; i < int(n); ++i) {
segs[i].first = lower_bound(points.begin(), points.end(), segs[i].first) -
points.begin();
segs[i].second = lower_bound(points.begin(), points.end(), segs[i].second) -
points.begin();
NN = max(NN, ((int)segs[i].second + 10));
}
for (int i = 0; i < int(NN); ++i) a[i] = 0;
for (int i = 0; i < int(n); ++i) {
a[segs[i].first]++;
a[segs[i].second + 1]--;
}
int all = 0;
p[0] = a[0];
for (int i = 1; i < NN; ++i) {
a[i] += a[i - 1];
p[i] = a[i] + p[i - 1];
if (a[i - 1] == 0 && a[i]) all++;
}
build(1, 0, NN - 1);
int ans = 0;
for (int i = 0; i < int(n); ++i) {
pair<int, pair<bool, bool>> res =
get(1, 0, NN - 1, segs[i].first, segs[i].second);
int cur = res.first;
if (res.second.first && a[segs[i].first - 1] == 0) {
cur--;
}
if (res.second.second && a[segs[i].second + 1] == 0) {
cur--;
}
if (p[segs[i].second] - p[segs[i].first - 1] ==
segs[i].second - segs[i].first + 1)
cur = -1;
ans = max(ans, (all + cur));
}
cout << ans << '\n';
}
void smain() {
int t;
cin >> t;
while (t--) {
solve();
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
string s;
int main() {
int x = 0, y = 0;
cin >> s;
for (int i = 0; i < s.length(); i++) {
if (s[i] == '0') x++;
if (s[i] == '1') y++;
}
char c = s[s.length() - 1];
if (y < (s.length() + 1) / 2) cout << "00" << endl;
if ((y <= (s.length() + 1) / 2) && (x <= s.length() / 2)) {
if ((y < (s.length() + 1) / 2) && (c != '0')) cout << "01" << endl;
if ((y == (s.length() + 1) / 2) && (c == '1')) cout << "01" << endl;
if ((x < s.length() / 2) && (c != '1')) cout << "10" << endl;
if ((x == s.length() / 2) && (c == '0')) cout << "10" << endl;
}
if (x < s.length() / 2) cout << "11" << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 7;
int n;
int N;
int a[maxn];
long long ans;
int dfs(int rt) {
int rc = rt << 1, lc = rt << 1 | 1;
int v1, v2;
if (rc > N) return a[rt];
v1 = dfs(rc);
v2 = dfs(lc);
ans += abs(v1 - v2);
return a[rt] + max(v1, v2);
}
int main() {
while (~scanf("%d", &n)) {
N = (1 << (n + 1)) - 1;
for (int i = 2; i < int(N + 1); i++) scanf("%d", &a[i]);
dfs(1);
cout << ans << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string str, s1, s2 = "<";
stack<char> delm;
vector<string> re;
getline(cin, str);
for (int i = 0; i < str.size(); i++) {
if (str[i] == '"' && delm.empty()) {
s1 = "<";
delm.push(str[i]);
} else if (!delm.empty()) {
char ch = delm.top();
if (ch == str[i]) {
s1 += "*>";
re.push_back(s1);
delm.pop();
} else
s1 += str[i];
} else if (delm.empty()) {
if (str[i] == ' ' && s2.size() > 1) {
s2 += "*>";
re.push_back(s2);
s2 = "<";
} else if (str[i] != ' ') {
s2 += str[i];
}
if (i == str.size() - 1 && str[str.size() - 1] != ' ') {
s2 += "*>";
re.push_back(s2);
s2 = "<";
continue;
}
}
}
for (int i = 0; i < re.size(); i++) {
bool flag = false;
for (int j = 1; j < re[i].size() - 1; j++)
if (re[i][j] != ' ' || re[i][re[i].size() - 1] == '*') {
flag = true;
re[i] =
re[i].substr(0, re[i].size() - 2) + re[i].substr(re[i].size() - 1);
break;
}
if (flag) cout << re[i] << endl;
}
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 2e5 + 50;
ll d[maxn << 2];
int lowbit(int x){
return x & (-x);
}
void update(int x, ll v){
for(int i = x;i < maxn;i += lowbit(i)){
d[i] += v;
}
}
ll query(ll x){
ll ans = 0;
for(int i = x; i;i -= lowbit(i)){
ans += d[i];
}
return ans;
}
ll c[maxn];
int main()
{
std::ios::sync_with_stdio(false);
int n, t, k;
cin >> n >> t;
for(int i = 1;i <= n;i++) c[i] = -1;
while(t--){
cin >> k;
int l = 1, r = n;
int ans = 0;
while(l <= r){
int mid = (l + r) >> 1;
int sum;
if(c[mid] != -1){
sum = c[mid] + query(mid);
}
else{
cout << "? " << 1 << " " << mid << endl;
cin >> sum;
c[mid] = sum - query(mid);
}
if(mid - sum >= k) r = mid - 1, ans = mid;
else l = mid + 1;
}
cout << "! " << ans << endl;
update(ans, 1);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9 + 7;
const int N = (int)2e5 + 4;
const int K = 21;
struct point {
int x, y;
point() { x = 0, y = 0; }
~point() {}
point(int x, int y) : x(x), y(y) {}
bool operator<(const point &a) const {
if (x == a.x) {
return y < a.y;
}
return x < a.x;
}
};
int a[N];
int firsts[N], seconds[N], firstx[N], secondx[N];
void upd_values(int d, int i) {
if (firsts[d] == -1) {
firsts[d] = i;
} else if (seconds[d] == -1) {
seconds[d] = i;
firstx[d] = firsts[d];
secondx[d] = seconds[d];
} else {
firstx[d] = secondx[d];
secondx[d] = i;
}
}
int n;
long long sum;
set<point> points;
void upd_points(int x, int y) {
if (x >= n) {
return;
}
set<point>::iterator it = points.upper_bound(point(x, inf));
--it;
if (it->y >= y) {
return;
}
vector<point> to_del;
if (it->x == x) {
to_del.push_back(point(it->x, it->y));
}
int old_x = x;
int last = it->y;
++it;
sum += (y - last) * 1LL * (it->x - x);
x = it->x;
for (; it->y < y;) {
to_del.push_back(point(it->x, it->y));
last = it->y;
++it;
sum += (y - last) * 1LL * (it->x - x);
x = it->x;
}
for (point &del : to_del) {
points.erase(del);
}
points.insert(point(old_x, y));
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
}
for (int i = 1; i < N; ++i) {
firsts[i] = seconds[i] = -1;
firstx[i] = secondx[i] = -1;
}
for (int i = 0; i < n; ++i) {
for (int d = 1; d * d <= a[i]; ++d) {
if (a[i] % d == 0) {
upd_values(d, i);
if (d * d != a[i]) {
upd_values(a[i] / d, i);
}
}
}
}
long long ans = (N - 1) * 1LL * n * (n + 1) / 2;
for (int i = 0; i < n; ++i) {
points.insert(point(i, i));
}
points.insert(point(n, inf));
sum = n * 1LL * (n - 1) / 2;
for (int d = N - 1; d >= 1; --d) {
if (seconds[d] != -1) {
if (seconds[d] <= firstx[d]) {
upd_points(0, firstx[d]);
upd_points(seconds[d] + 1, n);
}
upd_points(0, firsts[d]);
upd_points(firsts[d] + 1, secondx[d]);
upd_points(secondx[d] + 1, n);
}
ans -= n * 1LL * n - sum;
}
printf("%lld", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n;
long long ans;
long long d[107];
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
ans = (long long)-1e18;
for (long long i = 0; i < n; i++) {
for (long long j = i + 1; j <= n; j++) {
for (long long k = i + 1; k <= j; k++) {
d[k]++;
}
}
}
for (long long i = 0; i <= n; i++) {
ans = max(ans, d[i]);
}
cout << ans << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<int> mp[200005];
set<pair<int, int> > aa;
int a[200005], v[200005], b[200005];
int n, s, t, w, k;
int find(int x, int y) {
int k = mp[y].size(), m = mp[y][k - 1], r = mp[x].size() - 1;
int l = 0;
while (l < r) {
int mid = (l + r) >> 1;
if (mp[x][mid] <= m)
l = mid + 1;
else
r = mid;
}
return mp[x][r];
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d %d", &s, &w);
a[i] = s;
mp[s].push_back(w);
}
for (int i = n; i >= 1; i--)
if (!v[a[i]]) {
aa.insert(make_pair(-i, a[i]));
v[a[i]] = i;
}
set<pair<int, int> >::iterator it;
scanf("%d", &t);
while (t--) {
scanf("%d", &k);
for (int i = 1; i <= k; i++) {
scanf("%d", &w);
b[i] = w;
if (v[w] == 0) continue;
aa.erase(make_pair(-v[w], w));
}
if (aa.size() == 0)
printf("0 0\n");
else if (aa.size() == 1) {
int x = aa.begin()->second;
printf("%d %d\n", x, mp[x][0]);
} else {
int x = aa.begin()->second;
int y = (++aa.begin())->second;
printf("%d %d\n", x, find(x, y));
}
for (int i = 1; i <= k; i++)
if (v[b[i]]) aa.insert(make_pair(-v[b[i]], b[i]));
}
return 0;
}
| 4 |
#include <cstdio>
char ps[23];
int main()
{
scanf("%s",ps);
if(ps[2]==ps[3]&&ps[4]==ps[5]) printf("Yes");
else printf("No");
return 0;
} | 0 |
#include <stdio.h>
#include <cmath>
#include <algorithm>
#include <cfloat>
#include <stack>
#include <queue>
#include <vector>
#include <string>
#include <iostream>
#include <set>
#include <map>
#include <time.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;
enum Type{
IN_KADO,
IN_HEN,
IN_NAIBU,
};
struct Info{
void set(Type arg_type){
type = arg_type;
}
Type type;
};
int main(){
int N;
scanf("%d",&N);
int* in_num = new int[N*N];
bool* used = new bool[N*N];
Info* loc = (Info*)malloc(sizeof(Info)*(N*N));
for(int i = 0; i < N*N; i++){
in_num[i] = 0;
used[i] = false;
}
vector<int> ADJ[N*N];
int a,b,limit = 2*N*N-2*N;
for(int loop = 0; loop < limit; loop++){
scanf("%d %d",&a,&b);
a--;
b--;
in_num[a]++;
in_num[b]++;
ADJ[a].push_back(b);
ADJ[b].push_back(a);
}
vector<int> KADO;
for(int i = 0; i < N*N; i++){
if(in_num[i] == 2){
KADO.push_back(i);
loc[i].set(IN_KADO);
}else if(in_num[i] == 3){
loc[i].set(IN_HEN);
}else{
loc[i].set(IN_NAIBU);
}
}
int** ans_table = new int*[N];
for(int row = 0; row < N; row++){
ans_table[row] = new int[N];
}
ans_table[0][0] = KADO[0];
used[KADO[0]] = true;
int tmp_num;
for(int row = 1; row <= N-2; row++){
for(int i = 0; i < ADJ[ans_table[row-1][0]].size(); i++){
tmp_num = ADJ[ans_table[row-1][0]][i];
if(loc[tmp_num].type == IN_HEN && used[tmp_num] == false){
ans_table[row][0] = tmp_num;
used[tmp_num] = true;
break;
}
}
}
for(int i = 0; i < ADJ[ans_table[N-2][0]].size(); i++){
tmp_num = ADJ[ans_table[N-2][0]][i];
if(loc[tmp_num].type == IN_KADO && used[tmp_num] == false){
ans_table[N-1][0] = tmp_num;
used[tmp_num] = true;
break;
}
}
bool FLG;
for(int col = 1; col <= N-2; col++){
for(int i = 0; i < ADJ[ans_table[0][col-1]].size(); i++){
tmp_num = ADJ[ans_table[0][col-1]][i];
if(loc[tmp_num].type == IN_HEN && used[tmp_num] == false){
ans_table[0][col] = tmp_num;
used[tmp_num] = true;
break;
}
}
for(int row = 1; row <= N-2; row++){
for(int i = 0; i < ADJ[ans_table[row-1][col]].size(); i++){
tmp_num = ADJ[ans_table[row-1][col]][i];
if(loc[tmp_num].type != IN_NAIBU || used[tmp_num] == true)continue;
FLG = false;
for(int k = 0; k < ADJ[ans_table[row][col-1]].size(); k++){
if(tmp_num == ADJ[ans_table[row][col-1]][k]){
FLG = true;
break;
}
}
if(FLG){
ans_table[row][col] = tmp_num;
used[tmp_num] = true;
break;
}
}
}
for(int i = 0; i < ADJ[ans_table[N-1][col-1]].size(); i++){
tmp_num = ADJ[ans_table[N-1][col-1]][i];
if(loc[tmp_num].type == IN_HEN && used[tmp_num] == false){
ans_table[N-1][col] = tmp_num;
used[tmp_num] = true;
break;
}
}
}
for(int i = 0; i < ADJ[ans_table[0][N-2]].size(); i++){
tmp_num = ADJ[ans_table[0][N-2]][i];
if(loc[tmp_num].type == IN_KADO && used[tmp_num] == false){
ans_table[0][N-1] = tmp_num;
used[tmp_num] = true;
break;
}
}
for(int row = 1; row <= N-2; row++){
for(int i = 0; i < ADJ[ans_table[row-1][N-1]].size(); i++){
tmp_num = ADJ[ans_table[row-1][N-1]][i];
if(loc[tmp_num].type == IN_HEN && used[tmp_num] == false){
ans_table[row][N-1] = tmp_num;
used[tmp_num] = true;
break;
}
}
}
for(int i = 0; i < ADJ[ans_table[N-1][N-2]].size(); i++){
tmp_num = ADJ[ans_table[N-1][N-2]][i];
if(loc[tmp_num].type == IN_KADO && used[tmp_num] == false){
ans_table[N-1][N-1] = tmp_num;
break;
}
}
for(int row = 0; row <= N-1; row++){
printf("%d",ans_table[row][0]+1);
for(int col = 1; col <= N-1; col++){
printf(" %d",ans_table[row][col]+1);
}
printf("\n");
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v;
vector<int>::iterator it;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
v.push_back(x);
}
vector<int> seq;
seq.push_back(-1);
string ans;
while (1) {
if (v.back() <= seq.back() && v[0] <= seq.back()) break;
if (v.empty()) break;
if (v.size() == 1 && v[0] > seq.back()) {
ans += 'R';
break;
}
if (v.back() < v[0] && seq.back() < v.back()) {
seq.push_back(v.back());
ans += 'R';
it = v.end();
it--;
v.erase(it);
} else if (v[0] < v.back() && seq.back() < v[0]) {
seq.push_back(v[0]);
ans += 'L';
v.erase(v.begin());
} else if (v[0] == v.back()) {
int cnt_lft = 0, cnt_rit = 0;
for (int i = 1; v[i] > v[i - 1]; i++) cnt_lft++;
for (int i = v.size() - 2; v[i] > v[i + 1]; i--) cnt_rit++;
if (cnt_lft > cnt_rit) {
ans += 'L';
for (int i = 1; v[i] > v[i - 1]; i++) ans += 'L';
break;
} else {
ans += 'R';
for (int i = v.size() - 2; v[i] > v[i + 1]; i--) ans += 'R';
break;
}
} else if (v[0] > seq.back()) {
seq.push_back(v[0]);
ans += 'L';
v.erase(v.begin());
} else if (v.back() > seq.back()) {
seq.push_back(v.back());
ans += 'R';
it = v.end();
it--;
v.erase(it);
}
if (v.back() <= seq.back() && v[0] <= seq.back()) break;
if (v.empty()) break;
if (v.size() == 1 && v[0] > seq.back()) {
ans += 'R';
break;
}
}
cout << ans.size() << endl << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long a = (n * (n + 1) / 2);
cout << (a * 6) + 1;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string in, ans;
cin >> in;
int f = 0;
for (unsigned i = 0; i < in.length(); i++) {
ans += in[i];
f++;
i += f;
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[100][30010];
int n, s, j, k, v, t, maxn, ans, x;
int main() {
scanf("%d%d", &n, &s);
for (int i = 0; i < n; i++) {
scanf("%d", &k);
x = 0;
while (k--) {
scanf("%d%d", &v, &t);
while (t--) a[i][++x] = a[i][x - 1] + v;
}
if (x > maxn) maxn = x;
}
for (int i = 2; i <= maxn; i++)
for (int j = 0; j < n - 1; j++) {
if (a[j][i] == 0) continue;
for (k = j + 1; k < n; k++) {
if (a[k][i] == 0) continue;
if (a[j][i] == a[k][i]) {
if (a[j][i - 1] < a[k][i - 1] && a[j][i + 1] > a[k][i + 1]) ans++;
if (a[j][i - 1] > a[k][i - 1] && a[j][i + 1] < a[k][i + 1]) ans++;
} else {
if (a[j][i - 1] < a[k][i - 1] && a[j][i] > a[k][i]) ans++;
if (a[j][i - 1] > a[k][i - 1] && a[j][i] < a[k][i]) ans++;
}
}
}
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2000 + 100;
int n;
char s[maxn][maxn];
char r1[maxn], c1[maxn];
char r2[maxn], c2[maxn];
int ans;
int main() {
scanf("%d ", &n);
for (int i = 0, _n = (int)(n); i < _n; i++) gets(s[i]);
for (int i = 0, _n = (int)(n); i < _n; i++)
for (int j = 0, _n = (int)(n); j < _n; j++) s[i][j] -= '0';
for (int i = 0, _n = (int)(n); i < _n; i++)
for (int j = (int)(n), _x = (int)(i + 1); j-- > _x;)
if (r1[i] ^ c1[j] ^ s[i][j]) ans++, r1[i] ^= 1, c1[j] ^= 1;
for (int i = (int)(n), _x = (int)(0); i-- > _x;)
for (int j = 0, _n = (int)(i); j < _n; j++)
if (r2[i] ^ c2[j] ^ s[i][j]) ans++, r2[i] ^= 1, c2[j] ^= 1;
for (int i = 0, _n = (int)(n); i < _n; i++)
if (r1[i] ^ c1[i] ^ r2[i] ^ c2[i] ^ s[i][i]) ans++;
printf("%d\n", ans);
{
int _;
cin >> _;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
ifstream fin("template.in");
ofstream fout("template.out");
int main() {
int n, m;
cin >> n >> m;
string ar1[n], ar2[m];
for (long long i = 0; i < n; i++) {
cin >> ar1[i];
}
for (long long i = 0; i < m; i++) {
cin >> ar2[i];
}
int q;
cin >> q;
int in;
for (int i = 0; i < q; i++) {
cin >> in;
in--;
cout << ar1[in % n] << ar2[in % m] << endl;
}
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int main(void){
int n;
while(cin >> n,n){
int k,s = 0,f = 0;
for(int i = 0; i < n; i ++){
cin >> k;
if(k >= 1) s++;
if(k > 1) f=1;
}
if(!f)cout << "NA" << endl;
else cout << s+1 << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b;
cin >> a >> b;
if (a == b)
cout << -1;
else
cout << max(a.length(), b.length());
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:102400000,102400000")
const int maxn = 1e5 + 5;
int n, f;
int k[maxn], l[maxn];
long long ans = 0;
vector<int> ve;
void solve() {
sort(ve.begin(), ve.end());
reverse(ve.begin(), ve.end());
for (int i = 0; i < ve.size(); i++) {
if (!f) break;
f--;
ans += ve[i];
}
cout << ans << endl;
}
int main() {
cin >> n >> f;
for (int i = 1; i <= n; i++) {
scanf("%d%d", k + i, l + i);
if (k[i] >= l[i])
ans = ans + l[i];
else {
ans = ans + k[i];
if (k[i]) ve.push_back(min(k[i], l[i] - k[i]));
}
}
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
int n, a, b;
int p[MAXN];
map<int, int> rp;
bool in_vec(int x, vector<int> &vec) {
for (int c : vec) {
if (x == c) return true;
}
return false;
}
struct TwoSAT {
int n;
vector<int> G[MAXN * 2];
int pre[MAXN * 2], lowlink[MAXN * 2], sccno[MAXN * 2], dfs_clock, scc_cnt;
stack<int> S;
void dfs(int u) {
pre[u] = lowlink[u] = ++dfs_clock;
S.push(u);
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
if (!pre[v]) {
dfs(v);
lowlink[u] = min(lowlink[u], lowlink[v]);
} else if (!sccno[v]) {
lowlink[u] = min(lowlink[u], pre[v]);
}
}
if (lowlink[u] == pre[u]) {
scc_cnt++;
for (;;) {
int x = S.top();
S.pop();
sccno[x] = scc_cnt;
if (x == u) break;
}
}
}
void find_scc() {
dfs_clock = scc_cnt = 0;
memset(sccno, 0, sizeof(sccno));
memset(pre, 0, sizeof(pre));
for (int i = 0; i < n * 2; i++)
if (!pre[i]) dfs(i);
}
void init(int n) {
this->n = n;
for (int i = 0; i < n * 2; i++) G[i].clear();
}
void add_clause(int x, int xval, int y, int yval) {
x = x * 2 + xval;
y = y * 2 + yval;
if (!in_vec(y, G[x])) {
G[x].push_back(y);
}
}
bool solve() {
for (int i = 0; i < n * 2; i += 2) {
if (sccno[i] == sccno[i + 1]) return false;
}
return true;
}
} solver;
int main() {
scanf("%d%d%d", &n, &a, &b);
solver.init(n);
for (int i = 0; i < n; i++) {
scanf("%d", &p[i]);
rp[p[i]] = i;
}
for (int i = 0; i < n; i++) {
if (rp.count(a - p[i])) {
if (p[i] != a - p[i]) {
solver.add_clause(rp[p[i]], 0, rp[a - p[i]], 0);
solver.add_clause(rp[p[i]], 1, rp[a - p[i]], 1);
}
} else
solver.add_clause(rp[p[i]], 0, rp[p[i]], 1);
if (rp.count(b - p[i])) {
if (p[i] != b - p[i]) {
solver.add_clause(rp[p[i]], 1, rp[b - p[i]], 1);
solver.add_clause(rp[p[i]], 0, rp[b - p[i]], 0);
}
} else
solver.add_clause(rp[p[i]], 1, rp[p[i]], 0);
}
solver.find_scc();
bool res = solver.solve();
if (res) {
printf("YES\n");
for (int i = 0; i < n * 2; i += 2) {
if (solver.sccno[i] < solver.sccno[i + 1])
printf("0 ");
else
printf("1 ");
}
printf("\n");
} else
printf("NO\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
int fa[10000000 + 10];
inline long long gcd(long long a, long long b) {
while (a > 0) {
long long tmp = a;
a = b % a;
b = tmp;
}
return b;
}
inline int getfa(int a) { return (fa[a] == a) ? a : fa[a] = getfa(fa[a]); }
int n;
inline void m(long long a, long long b) {
if (fa[a] == 0 || fa[b] == 0) return;
int faa = getfa(a), fbb = getfa(b);
if (faa == fbb) return;
fa[faa] = fbb;
n--;
}
int main() {
scanf("%d", &n);
int mx = 0;
for (int i = 0; i < n; i++) {
int tmp;
scanf("%d", &tmp);
fa[tmp] = tmp;
if (mx < tmp) mx = tmp;
}
for (long long i = 2; i * i <= 2 * mx; i += 2)
for (long long j = i + 1, a = i / 2 * (j + 1), b = j, c = i / 2 * i + j;
a <= mx && b <= mx; j += 2, a += i, b += j, c += j) {
if (gcd(a, b) > 1) continue;
m(a, b);
if (c <= mx) {
m(b, c);
m(c, a);
}
}
printf("%d\n", n);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long sum[100005];
long long a[100005], b[100005];
int main() {
long long n, m, c;
while (cin >> n >> m >> c) {
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= m; i++) cin >> b[i];
sum[0] = 0;
for (int i = 1; i <= m; i++) sum[i] = sum[i - 1] + b[i];
int te = n - m + 1;
int t = m - 1;
if (te < m) {
for (int i = 1; i < te; i++) {
a[i] += sum[i];
a[n - i + 1] += (sum[m] - sum[m - i]);
}
for (int i = te; i <= n - te + 1; i++) {
a[i] += (sum[i] - sum[i - te]);
}
} else {
for (int i = 1; i <= t; i++) {
a[i] += sum[i];
a[n - i + 1] += (sum[m] - sum[m - i]);
}
for (int i = t + 1; i <= n - t; i++) {
a[i] += sum[m];
}
}
for (int i = 1; i <= n; i++) a[i] %= c;
for (int i = 1; i <= n; i++) {
printf("%I64d ", a[i]);
}
puts("");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> a;
int n;
cin >> n;
for (int i = 0; i < n; i++) {
bool f;
f = 0;
for (int j = 0; j < n; j++) {
int x;
cin >> x;
if (j != i && (x == -1 || x == 1 || x == 3)) f = 1;
}
if (!f) a.push_back(i + 1);
}
cout << a.size() << endl;
for (int i = 0; i < a.size(); i++) cout << a[i] << " ";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int LIM_N = 1e5 + 5;
int cnts[LIM_N];
const int inf = 1e9;
struct Node {
Node *l = 0, *r = 0;
int lo, hi, mset = inf, madd = 0, val = -inf;
Node(int lo, int hi) : lo(lo), hi(hi) {}
Node(vector<int>& v, int lo, int hi) : lo(lo), hi(hi) {
if (lo + 1 < hi) {
int mid = lo + (hi - lo) / 2;
l = new Node(v, lo, mid);
r = new Node(v, mid, hi);
val = max(l->val, r->val);
} else
val = v[lo];
}
int query(int L, int R) {
if (R <= lo || hi <= L) return -inf;
if (L <= lo && hi <= R) return val;
push();
return max(l->query(L, R), r->query(L, R));
}
void set(int L, int R, int x) {
if (R <= lo || hi <= L) return;
if (L <= lo && hi <= R)
mset = val = x, madd = 0;
else {
push(), l->set(L, R, x), r->set(L, R, x);
val = max(l->val, r->val);
}
}
void add(int L, int R, int x) {
if (R <= lo || hi <= L) return;
if (L <= lo && hi <= R) {
if (mset != inf)
mset += x;
else
madd += x;
val += x;
} else {
push(), l->add(L, R, x), r->add(L, R, x);
val = max(l->val, r->val);
}
}
void push() {
if (!l) {
int mid = lo + (hi - lo) / 2;
l = new Node(lo, mid);
r = new Node(mid, hi);
}
if (mset != inf)
l->set(lo, hi, mset), r->set(lo, hi, mset), mset = inf;
else if (madd)
l->add(lo, hi, madd), r->add(lo, hi, madd), madd = 0;
}
};
int N;
int vals[LIM_N];
int ps[LIM_N], ts[LIM_N], xs[LIM_N];
Node* st;
int getNm() {
int ini = 0, fin = N;
while (ini < fin) {
int piv = (ini + fin) / 2 + 1;
if (st->query(piv, N + 1) <= 0)
fin = piv - 1;
else
ini = piv;
}
return ini == 0 ? -1 : vals[ini];
}
int main() {
vector<int> _vk;
scanf("%d", &N);
_vk.resize(N + 1, 0);
st = new Node(_vk, 0, N + 1);
for (int i = 0; i < N; i++) {
scanf("%d%d", &ps[i], &ts[i]);
if (ts[i]) {
scanf("%d", &xs[i]);
vals[ps[i]] = xs[i];
}
st->add(0, ps[i] + 1, ts[i] ? 1 : -1);
}
for (int i = N - 1; i >= 0; i--) {
xs[i] = getNm();
st->add(0, ps[i] + 1, ts[i] ? -1 : 1);
}
for (int i = 0; i < N; i++) printf("%d\n", xs[i]);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int serial, sucess, fail;
int result1 = 0, result2 = 0;
while (cin >> serial >> sucess >> fail) {
if (serial == 1) {
result1 += sucess - fail;
} else {
result2 += sucess - fail;
}
}
result1 >= 0 ? cout << "LIVE" << endl : cout << "DEAD" << endl;
result2 >= 0 ? cout << "LIVE" << endl : cout << "DEAD" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int toInt(string s) {
int r = 0;
istringstream sin(s);
sin >> r;
return r;
}
long long int a[200005], l[200005], r[200005];
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
;
long long int n;
cin >> n;
for (long long int i = 0; i <= n - 1; i++) {
cin >> a[i];
l[i] = -1;
r[i] = n;
}
stack<long long int> s, s2;
for (long long int i = 0; i <= n - 1; i++) {
if (s.size()) {
while (s.size() && ((a[s.top()] | a[i]) == a[i])) {
if (a[s.top()] == a[i]) break;
s.pop();
}
if (s.size()) l[i] = s.top();
}
s.push(i);
}
long long int ans = n * (n + 1) / 2;
for (long long int i = n - 1; i >= 0; i--) {
if (s2.size()) {
while (s2.size() && ((a[s2.top()] | a[i]) == a[i])) s2.pop();
if (s2.size()) r[i] = s2.top();
}
s2.push(i);
ans -= (i - l[i]) * (r[i] - i);
}
cout << ans << endl;
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
using ll=long long;
constexpr ll mod=1000000007;
ll N;
map<ll,int>mp;
int res;
int main(){
cin>>N;
for(ll i=2;i*i<=N;i++){
while(N%i==0){
N/=i;
mp[i]++;
}
}
if(N!=1)mp[N]++;
for(pair<ll,int>p:mp){
for(int i=1;i<=p.second;i++){
res++;
p.second-=i;
}
}
cout<<res<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a[(int)(1e5) + 10];
bool cmp(string a, string b) {
if (a == "rock" and b == "scissors") return true;
if (a == "scissors" and b == "paper") return true;
if (a == "paper" and b == "rock")
return true;
else
return false;
}
int main() {
int n;
string sF, sM, sS;
getline(cin, sF);
getline(cin, sM);
getline(cin, sS);
if (sF == sM and sM == sS)
puts("?");
else {
if (cmp(sF, sM) == true and cmp(sF, sS) == true)
puts("F");
else if (cmp(sM, sF) == true and cmp(sM, sS) == true)
puts("M");
else if (cmp(sS, sF) == true and cmp(sS, sM) == true)
puts("S");
else
puts("?");
}
return 0;
}
| 1 |
#include<iostream>
#include<string>
using namespace std;
int main()
{
string str;
for(int k=0;k<5;k++){
int a=0,b=0;
cin >> str;
if(str=="EOF") break;
for(int i=0;i<(int)str.size()-2;i++){
if(str[i+1]=='O'&&str[i+2]=='I'){
if(str[i]=='J') a++;
else if(str[i]=='I') b++;
}
}
cout << a << endl;
cout << b << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n;
long long getSum(long long n) { return !n ? 0 : (n % 10) + getSum(n / 10); }
bool is(long long n) { return (getSum(n) % 4) ? false : true; }
int main() {
ios_base::sync_with_stdio();
cin.tie(0);
cout.tie(0);
cin >> n;
if (is(n)) return cout << n << endl, 0;
while (++n)
if (is(n)) return cout << n << endl, 0;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
while (t--) {
string s;
cin >> s;
long long int flag = 0, ans = 0;
for (long long int i = s.find('1'); i < s.find_last_of('1'); i++) {
if (s[i] == '0') ans++;
}
cout << ans << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int dx[8] = {-1, -1, -1, 0, 1, 1, 1, 0};
int dy[8] = {-1, 0, 1, 1, 1, 0, -1, -1};
const int N = 100005;
struct mes {
char c;
int id;
};
int n, m;
bool no[N];
mes all[N];
int p[N];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
cin >> all[i].c >> all[i].id;
}
int on = 0;
for (int i = 0; i < m; i++) {
if (all[i].c == '+') {
p[all[i].id] = 1;
}
if (all[i].c == '-' && !p[all[i].id]) {
p[all[i].id] = 0;
on++;
}
}
for (int i = 0; i < m; i++) {
if (all[i].c == '+' && (on || (i > 0 && all[i - 1].id != all[i].id))) {
no[all[i].id] = 1;
}
if (all[i].c == '+') {
on++;
}
if (all[i].c == '-') {
on--;
}
if (all[i].c == '-' &&
(on || (i + 1 < m && (all[i + 1].id != all[i].id)))) {
no[all[i].id] = 1;
}
}
int k = 0;
for (int i = 1; i <= n; i++) {
k += 1 - no[i];
}
cout << k << endl;
for (int i = 1; i <= n; i++) {
if (!no[i]) {
cout << i << " ";
}
}
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int ucln(int a, int b) {
int r;
while (b > 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
int main() {
int x, y, a, b, bc;
cin >> x >> y >> a >> b;
bc = x * y / ucln(x, y);
int l = a, r = b;
while (l % bc != 0) l++;
while (r % bc != 0) r--;
cout << (r - l) / bc + 1;
}
| 1 |
#include <bits/stdc++.h>
const int inf = 0xfffffff;
const long long INF = 1ll << 61;
using namespace std;
vector<int> G[100000 + 55];
int n;
int ans;
void init() {
for (int i = 0; i < 100000 + 55; i++) G[i].clear();
}
bool input() {
while (scanf("%d", &n) == 1) {
for (int i = 0; i < n; i++) {
int x, y;
scanf("%d %d", &x, &y);
G[x].push_back(y);
}
return false;
}
return true;
}
bool find(int x, int y) {
if (x >= 100000 + 55) return false;
return binary_search(G[x].begin(), G[x].end(), y);
}
void cal() {
for (int i = 0; i < 100000 + 55; i++) sort(G[i].begin(), G[i].end());
int sq = sqrt(n * 1.00);
ans = 0;
for (int i = 0; i < 100000 + 55; i++) {
int len = G[i].size();
if (!len) continue;
if (len < sq) {
for (int j = 0; j < len; j++) {
for (int k = j + 1; k < len; k++) {
int d = G[i][k] - G[i][j];
if (find(i + d, G[i][j]) && find(i + d, G[i][k])) ans++;
}
}
} else {
for (int j = i + 1; j < 100000 + 55; j++) {
for (int k = 0; k < G[j].size(); k++) {
int d = j - i;
if (find(i, G[j][k]) && find(j, G[j][k] + d) && find(i, G[j][k] + d))
ans++;
}
}
}
}
}
void output() { printf("%d\n", ans); }
int main() {
while (true) {
init();
if (input()) return 0;
cal();
output();
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int fun(int x) { return (x * (x - 1)) / 2; }
int main() {
int n, i, a[26], res, x, y;
string st;
for (i = 0; i < 26; i++) a[i] = 0;
cin >> n;
for (i = 0; i < n; i++) {
cin >> st;
a[st[0] - 97]++;
}
res = 0;
for (i = 0; i < 26; i++) {
if (a[i]) {
x = a[i] / 2;
y = a[i] - x;
res += fun(x) + fun(y);
}
}
cout << res << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1e9 + 7;
const int N = 5001;
int dp[N][26][26];
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
string s;
cin >> s;
int n = s.length();
for (int i = (int)(0); i < (int)(n); i++) {
int ch = s[i] - 'a';
for (int j = (int)(0); j < (int)(n); j++) {
int dh = s[(i + j) % n] - 'a';
dp[j][ch][dh] += 1;
}
}
int cnt = 0;
for (int j = (int)(0); j < (int)(26); j++) {
int ma = 0;
for (int i = (int)(1); i < (int)(n); i++) {
int uq = 0;
for (int k = (int)(0); k < (int)(26); k++) {
if (dp[i][j][k] == 1) {
uq++;
}
}
ma = max(ma, uq);
}
cnt += ma;
}
cout << setprecision(15) << ((double)cnt / (double)n) << "\n";
}
| 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.