solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
long long sum(long long n) { return (n * (n + 1)) / 2; }
long long ds(long long s, long long e) {
if (s <= 1) return sum(e);
return sum(e) - sum(s - 1);
}
long long bs(long long n, long long k) {
long long st = 1, en = k;
while (st < en) {
long long mid = (st + en) / 2;
long long sub = ds(mid, k);
if (sub == n)
return k - mid + 1;
else if (sub > n)
st = mid + 1;
else
en = mid;
}
return k - st + 2;
}
int main() {
long long n, k;
cin >> n >> k;
if (n == 1)
cout << "0" << endl;
else if (n <= k)
cout << "1";
else {
k--;
n--;
if (sum(k) < n)
cout << "-1" << endl;
else
cout << bs(n, k);
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long a[n];
bool pos, neg;
pos = neg = false;
for (long long i = 0; i < n; i++) {
cin >> a[i];
if (a[i] >= 0) pos = true;
if (a[i] < 0) neg = true;
}
if (n == 1) {
cout << a[0] << endl;
return 0;
}
if (pos && neg) {
long long sum = 0;
for (long long i = 0; i < n; i++) {
sum += abs(a[i]);
}
cout << sum << endl;
return 0;
}
if (!pos) {
sort(a, a + n);
long long sum = 0;
for (long long i = 0; i < n - 1; i++) {
sum += a[i];
}
cout << (a[n - 1] - sum) << endl;
return 0;
}
sort(a, a + n);
long long sum = 0;
for (long long i = 1; i < n; i++) {
sum += a[i];
}
cout << sum - a[0] << endl;
return 0;
}
| 4 |
#include <iostream>
#include <algorithm>
#define int long long
using namespace std;
int n;
int x[200000];
int s[200000];
int rs[200001]; //rs[i] = s[0] + … + s[i - 1]
signed main()
{
int i;
cin >> n;
for (i = 0; i < n; i++) cin >> x[i] >> s[i];
for (i = 1; i <= n; i++) rs[i] = rs[i - 1] + s[i - 1];
int maxR = rs[n] - x[n - 1];
int ans = 0;
for (int l = n - 1; l >= 0; l--) {
int L = x[l] - rs[l];
ans = max(ans, maxR + L);
if (l > 0) maxR = max(maxR, rs[l] - x[l - 1]);
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, a, b;
cin >> n >> k;
if (k == 1 || k == n)
cout << 6 + (n - 2) * 3;
else {
a = max(n - k, k - 1), b = min(n - k, k - 1);
cout << 6 + (b - 1) * 3 + b + a * 3;
}
}
| 2 |
#include <iostream>
#include <algorithm>
#include <vector>
#include <set>
#include <math.h>
using namespace std;
typedef long long int ll;
int main(){
int n; cin >> n;
vector<int> p(n);
int ra[n+1];
for(int i=0;i<n;i++){
cin >> p[i];
ra[p[i]]=i;
}
ll ans=0;
set<int> S;
S.insert(-1); S.insert(n);
for(ll d=1;d<=n;d++){
int i=ra[d];
auto it=S.lower_bound(i);
int r=*it;
it--;
int l=*it;
ans+=d*(i-l)*(r-i);
S.insert(i);
}
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int a, b, n;
long long int binsearch(long long int x, long long int start,
long long int sz) {
long long int lbound = start, ubound = sz, mid = (lbound + ubound) / 2,
comp = 0, te = 0;
while (lbound <= ubound) {
mid = (lbound + ubound) / 2;
comp = ((mid - start + 1) * (2 * a + (mid + start - 2) * b)) / 2;
te = (((mid + 1) - start + 1) * (2 * a + ((mid + 1) + start - 2) * b)) / 2;
if (comp > x)
ubound = mid - 1;
else if (comp < x) {
if (te > x || mid + 1 > sz)
return mid;
else
lbound = mid + 1;
} else if (comp == x)
return mid;
}
return -1;
}
int main() {
cin >> a >> b >> n;
while (n-- > 0) {
long long int l, t, m;
cin >> l >> t >> m;
if ((a + (l - 1) * b) > t) {
cout << -1 << endl;
continue;
}
int x = (t - a + b) / b;
long long int ans = binsearch(t * m, l, x);
cout << ans << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-6;
const long double PI = acos(-1.0);
struct PT {
long double x, y;
PT(long double x = 0.0, long double y = 0.0) : x(x), y(y) {}
PT(const PT &p) : x(p.x), y(p.y) {}
inline PT operator+(const PT &p) const { return PT(x + p.x, y + p.y); }
inline PT operator-(const PT &p) const { return PT(x - p.x, y - p.y); }
inline PT operator*(const long double &c) const { return PT(x * c, y * c); }
inline PT operator/(const long double &c) const { return PT(x / c, y / c); }
};
inline istream &operator>>(istream &is, PT &p) { return is >> p.x >> p.y; }
long double dot(PT p, PT q) { return p.x * q.x + p.y * q.y; }
long double dist2(PT p, PT q) { return dot(p - q, p - q); }
long double dist(PT p, PT q) { return sqrt(dist2(p, q)); }
long double GetSegmentArea(long double r1, long double r2, long double d) {
long double deg = acos(((d * d + r2 * r2) - r1 * r1) / (2.0 * r2 * d)) * 2.0;
long double sector = deg * r2 * r2 / 2.0;
long double tri = r2 * r2 * sin(deg) / 2.0;
return sector - tri;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
cout << fixed << setprecision(20);
PT c1, c2;
long double d, r1, r2;
cin >> c1 >> r1;
cin >> c2 >> r2;
if (r1 < r2) {
swap(r1, r2);
swap(c1, c2);
}
d = dist(c1, c2);
if (d + EPS >= r1 + r2) {
cout << 0 << '\n';
return 0;
}
if (d + r2 <= r1 + EPS) {
cout << PI * r2 * r2 << '\n';
return 0;
}
cout << (GetSegmentArea(r1, r2, d) + GetSegmentArea(r2, r1, d)) << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
string s;
int main() {
cin >> n >> s;
if (s == "1") {
cout << "YES";
return 0;
}
if (s == "0") {
cout << "NO";
return 0;
}
if (s.find("000") != -1 || s.find("00") == 0) {
cout << "NO";
return 0;
}
if (s[n - 1] == '0' && s[n - 2] == '0') {
cout << "NO";
return 0;
}
for (int i = 0; i <= n - 2; i++)
if (int(s[i] - '0') + int(s[i + 1] - '0') > 1) {
cout << "NO";
return 0;
}
cout << "YES";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n, p;
cin >> t;
for (int g = 0; g < t; g++) {
cin >> n >> p;
int m = 2 * n + p;
int a = 1;
while (m) {
for (int j = a + 1; j <= n && m; j++) {
if (j > n || a > n) {
break;
}
cout << a << " " << j << endl;
m--;
}
a++;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b, m, s;
int i, j, g, l, k, f, n, d;
cin >> n;
for (d = 0; d < n; d++) {
cin >> a;
cin >> b;
sort(a.begin(), a.end());
k = a.size();
l = b.size();
g = 0;
if (l < k) {
cout << "NO" << endl;
continue;
} else {
if ((l - k) == 0) {
f = 1;
} else {
f = (l - k) + 1;
}
for (i = 0; i < f; i++) {
s = b.substr(i, k);
sort(s.begin(), s.end());
if (s == a) {
g = g + 1;
break;
}
}
}
if (g == 1) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
}
| 1 |
#include<iostream>
using namespace std;
int main(){
string a;
cin>>a;
for(int i=0;i<a.length()-8;i++)cout<<a[i];
cout<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 10;
const int MAX_LOG = 20;
vector<int> e[MAXN];
vector<int> fen[MAXN];
vector<int> vertex[MAXN];
vector<pair<int, pair<int, int> > > d[MAXN];
int f[MAXN][MAX_LOG];
int par[MAXN][MAX_LOG];
int x[MAXN];
int y[MAXN];
int b[MAXN];
int st[MAXN];
int ft[MAXN];
int ans[MAXN];
int t = 0;
bool is_par(int v, int u) { return (st[v] <= st[u] && ft[v] >= ft[u]); }
int lca(int v, int u) {
for (int i = MAX_LOG - 1; i >= 0; i--) {
if (!is_par(par[v][i], u)) {
v = par[v][i];
}
}
return (is_par(v, u) ? v : par[v][0]);
}
pair<int, int> mbtlca(int v, int u) {
int res = 0;
for (int i = MAX_LOG - 1; i >= 0; i--) {
if (!is_par(f[v][i], u)) {
v = f[v][i];
res += (1 << i);
}
}
return make_pair(v, res);
}
void update(int id, int p) {
for (; p < fen[id].size(); p += ((p) & -(p))) {
fen[id][p]++;
}
}
int get_sum(int id, int p) {
int sum = 0;
for (; p > 0; p -= ((p) & -(p))) {
sum += fen[id][p];
}
return sum;
}
void set_dfs(int v) {
st[v] = ++t;
for (int i = 0; i < vertex[v].size(); i++) {
par[vertex[v][i]][0] = v;
set_dfs(vertex[v][i]);
}
ft[v] = t;
}
void f_dfs(int v) {
for (int i = 0; i < vertex[v].size(); i++) {
f_dfs(vertex[v][i]);
if (st[f[vertex[v][i]][0]] < st[f[v][0]]) {
f[v][0] = f[vertex[v][i]][0];
}
}
}
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = 2; i <= n; i++) {
int p;
cin >> p;
vertex[p].push_back(i);
}
for (int i = 1; i <= n; i++) {
f[i][0] = i;
}
set_dfs(1);
par[1][0] = 1;
for (int i = 1; i < MAX_LOG; i++) {
for (int j = 1; j <= n; j++) {
par[j][i] = par[par[j][i - 1]][i - 1];
}
}
int m;
cin >> m;
for (int i = 1; i <= m; i++) {
int v, u;
cin >> v >> u;
if (st[v] > st[u]) {
swap(v, u);
}
int w = lca(v, u);
e[w].push_back(st[v]);
d[w].push_back(make_pair(st[u], make_pair(0, st[v])));
if (st[w] < st[f[v][0]]) {
f[v][0] = w;
}
if (st[w] < st[f[u][0]]) {
f[u][0] = w;
}
}
f_dfs(1);
for (int i = 1; i < MAX_LOG; i++) {
for (int j = 1; j <= n; j++) {
f[j][i] = f[f[j][i - 1]][i - 1];
}
}
int q;
cin >> q;
for (int i = 1; i <= q; i++) {
cin >> x[i] >> y[i];
if (st[x[i]] > st[y[i]]) {
swap(x[i], y[i]);
}
if (is_par(x[i], y[i])) {
pair<int, int> z = mbtlca(y[i], x[i]);
if (is_par(f[z.first][0], x[i])) {
ans[i] = z.second + 1;
} else {
ans[i] = -1;
}
} else {
pair<int, int> zy = mbtlca(y[i], x[i]), zx = mbtlca(x[i], y[i]);
if (is_par(f[zy.first][0], x[i]) && is_par(f[zx.first][0], y[i])) {
ans[i] = zy.second + zx.second + 2;
x[i] = zx.first;
y[i] = zy.first;
int w = lca(x[i], y[i]);
d[w].push_back(make_pair(ft[y[i]], make_pair(i, 1)));
d[w].push_back(make_pair(st[y[i]] - 1, make_pair(i, -1)));
} else {
ans[i] = -1;
}
}
}
for (int i = 1; i <= n; i++) {
sort(e[i].begin(), e[i].end());
e[i].resize(unique(e[i].begin(), e[i].end()) - e[i].begin());
fen[i].resize((int)(e[i].size()) + 10);
for (int j = 0; j < (int)(e[i].size()) + 10; j++) {
fen[i].push_back(0);
}
sort(d[i].begin(), d[i].end());
for (int j = 0; j < d[i].size(); j++) {
if (d[i][j].second.first == 0) {
int p = lower_bound(e[i].begin(), e[i].end(), d[i][j].second.second) -
e[i].begin() + 1;
update(i, p);
} else {
int l = lower_bound(e[i].begin(), e[i].end(),
st[x[d[i][j].second.first]]) -
e[i].begin(),
r = upper_bound(e[i].begin(), e[i].end(),
ft[x[d[i][j].second.first]]) -
e[i].begin();
b[d[i][j].second.first] +=
d[i][j].second.second * (get_sum(i, r) - get_sum(i, l));
}
}
}
for (int i = 1; i <= q; i++) {
cout << ans[i] - (b[i] > 0) << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 10;
int n, m, dp[maxn][maxn];
char a[maxn], b[maxn];
int main() {
double h, l;
scanf("%lf%lf", &h, &l);
double r = (h * h + l * l) / (2 * h);
printf("%.13lf\n", r - h);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100;
bool u[N];
vector<int> g[N], st;
int deg[N], cnt[N];
inline bool check(int v, int k, int p = 0) {
if (k == 0) {
return g[v].size() == 1;
}
int wow = 0;
for (auto to : g[v]) {
if (to == p) continue;
if (check(to, k - 1, v)) {
++wow;
} else {
return 0;
}
}
return wow >= 3;
}
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
int n, k;
cin >> n >> k;
for (int i = 1; i < n; ++i) {
int x, y;
cin >> x >> y;
g[x].emplace_back(y);
g[y].emplace_back(x);
}
for (int i = 1; i <= n; ++i) deg[i] = -10000;
for (int i = 1; i <= n; ++i) {
if (g[i].size() == 1) {
deg[i] = 0;
st.emplace_back(i);
}
}
int alreadyYes = 0;
int it = 0;
while (it != st.size()) {
int v = st[it++];
int parent = 0;
if (deg[v] > k) {
cout << "No\n";
return 0;
}
for (auto to : g[v]) {
if (deg[to] + 1 == deg[v]) continue;
if (deg[to] == -10000 || deg[to] == deg[v] + 1) {
deg[to] = deg[v] + 1;
++parent;
if (++cnt[to] == 3) {
st.emplace_back(to);
}
} else {
cout << "No\n";
return 0;
}
}
if (parent == 0) {
if (deg[v] == k && cnt[v] >= 3) {
if (alreadyYes) {
cout << "No\n";
return 0;
}
alreadyYes = v;
} else {
cout << "No\n";
return 0;
}
}
if (parent > 1) {
cout << "No\n";
return 0;
}
}
if (alreadyYes && check(alreadyYes, k)) {
cout << "Yes\n";
} else {
cout << "No\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, n;
cin >> n >> a >> b;
string s;
cin >> s;
int len = s.length();
if ((n * b < len) || (n * a > len)) return cout << "No solution", 0;
int k = 0;
for (int i = 0; i < n - 1; ++i) {
for (int j = 0; j < len / n; ++j) {
cout << s[k++];
}
cout << "\n";
}
for (int i = k; i < len; ++i) cout << s[i];
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
const int inf = 1e9 + 7;
char a[2000];
int main() {
int t;
scanf("%d", &t);
while (t--) {
scanf("%s", a + 1);
int n = strlen(a + 1);
if (a[n] == 'o' && a[n - 1] == 'p') {
cout << "FILIPINO" << endl;
} else if ((a[n] == 'u' && a[n - 1] == 's' && a[n - 2] == 'e' &&
a[n - 3] == 'd') ||
(a[n] == 'u' && a[n - 1] == 's' && a[n - 2] == 'a' &&
a[n - 3] == 'm')) {
cout << "JAPANESE" << endl;
} else if (a[n] == 'a' && a[n - 1] == 'd' && a[n - 2] == 'i' &&
a[n - 3] == 'n' && a[n - 4] == 'm') {
cout << "KOREAN" << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
if (n <= 10 || n > 21) {
printf("0\n");
} else {
n = n - 10;
if (n == 10)
printf("15\n");
else
printf("4\n");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int a, b, d, i, j, k = 0, l, s = 0, s1, s2;
cin >> a >> b;
long long int aro[a][b];
for (i = 0; i < a; i++) {
for (j = 0; j < b; j++) {
cin >> aro[i][j];
}
}
long long int n = a;
long long int m = b;
for (i = 0; i < n / 2; i++) {
for (j = 0; j < m / 2; j++) {
vector<int> tem;
s2 = -1;
tem.push_back(aro[i][j]);
tem.push_back(aro[i][m - j - 1]);
tem.push_back(aro[n - i - 1][j]);
tem.push_back(aro[n - i - 1][m - j - 1]);
for (k = 0; k < 4; k++) {
s1 = abs(tem[k] - aro[i][j]) + abs(tem[k] - aro[i][m - j - 1]) +
abs(tem[k] - aro[n - i - 1][j]) +
abs(tem[k] - aro[n - i - 1][m - j - 1]);
if (s2 == -1) s2 = s1;
if (s2 > s1) s2 = s1;
}
s = s + s2;
}
}
if (n % 2 == 1) {
k = n / 2;
for (j = 0; j < m / 2; j++) {
s = s + abs(aro[k][j] - aro[k][m - j - 1]);
}
}
if (m % 2 == 1) {
k = m / 2;
for (j = 0; j < n / 2; j++) {
s = s + abs(aro[j][k] - aro[n - j - 1][k]);
}
}
cout << s << endl;
}
int main() {
int c;
cin >> c;
while (c--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, t, b, s, nol = 1e18, p;
vector<long long> tb, stb;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
cin >> n >> b;
t = 1;
while (t < b) {
t++;
if (t * t > b) t = b;
if (b % t == 0) {
tb.push_back(t);
s = 0;
while (b % t == 0) b = b / t, s++;
stb.push_back(s);
}
}
for (t = 0; t <= tb.size() - 1; t++) {
s = 0;
p = 1;
while (p <= n / tb.at(t)) {
p = p * tb.at(t);
s = s + n / p;
}
s = s / stb.at(t);
nol = min(nol, s);
}
cout << nol;
return 0;
}
| 3 |
#include <iostream>
#include <string>
#include <vector>
#include <set>
#include <algorithm>
using namespace std;
const int INF = 1 << 28;
int dp[1 << 20][20], rec[1 << 20][20], board[20][20];
// generate binary string (not less than k-digit)
string to_binString(int n, int k) {
string ret = "";
while(n) ret += ('0' + (n&1)), n >>= 1;
while(ret.length() < k) ret += '0';
// reverse(ret.begin(), ret.end());
return ret;
}
int main() {
while(1) {
int N; cin >> N;
if(!N) break;
vector<string> vs(N);
for(int i=0; i<N; i++) {
cin >> vs[i];
}
// init
for(int bit=0; bit<(1<<N); bit++) {
fill(dp[bit], dp[bit]+N, INF);
fill(rec[bit], rec[bit]+N, 0);
}
for(int i=0; i<N; i++) {
dp[1 << i][i] = vs[i].length();
for(int j=0; j<N; j++) {
board[i][j] = 0;
}
}
vector< set<string> > S(N);
for(int i=0; i<N; i++) {
int M = vs[i].length();
for(int j=1; j<=M; j++) {
for(int k=0; k<M-j+1; k++) {
S[i].insert(vs[i].substr(k, j));
}
}
}
for(int i=0; i<N; i++) {
for(int j=0; j<N; j++) {
if(i == j) continue;
int lenI = vs[i].length(), lenJ = vs[j].length();
int M = min(lenI, lenJ);
int cnt = 0;
for(int k=1; k<=M; k++) {
string tmpI = vs[i].substr(lenI - k);
string tmpJ = vs[j].substr(0, k);
if(tmpI == tmpJ) cnt = k;
}
board[i][j] = cnt;
}
}
for(int bit=1; bit<(1<<N); bit++) {
for(int i=0; i<N; i++) {
if(bit >> i & 1) continue;
for(int k=0; k<N; k++) {
if(bit >> k & 1) {
if(S[k].count(vs[i])) {
rec[bit][i] = vs[i].size();
}
}
}
}
}
for(int bit=1; bit<(1<<N); bit++) {
for(int i=0; i<N; i++) {
for(int j=0; j<N; j++) {
if(!(bit >> i & 1) || bit >> j & 1) continue;
int nbit = bit ^ (1 << j);
int sub, nj;
if(rec[bit][j]) {
nj = i, sub = rec[bit][j];
dp[nbit][nj] = min(dp[nbit][nj], dp[bit][i] + (int)vs[j].length() - sub);
}
nj = j, sub = board[i][j];
dp[nbit][nj] = min(dp[nbit][nj], dp[bit][i] + (int)vs[j].length() - sub);
// printf("bit = %s, i = %d, j = %d, sub = %d\n", to_binString(bit, N).c_str(), i+1, j+1, sub);
// printf("dp[%s][%d] = %d\n", to_binString(nbit, N).c_str(), j+1, dp[nbit][j]);
}
}
}
int ans = INF;
for(int i=0; i<N; i++) {
ans = min(ans, dp[(1<<N)-1][i]);
}
cout << ans << endl;
}
return 0;
}
| 0 |
#include <stdio.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
bool leap(int y) {
if (y%4) return false;
if (y%400==0) return true;
return y%100;
}
int main() {
for (int _q = 0;; _q++) {
int a, b;
scanf("%d%d", &a, &b);
if (a == 0 && b == 0) return 0;
if (_q) puts("");
int c = 0;
for (int i = a; i <= b; i++) if (leap(i)) {
printf("%d\n", i);
c++;
}
if (c == 0) puts("NA");
}
return 0;
}
| 0 |
#include<iostream>
#include<string>
#include<queue>
#include<algorithm>
#include<map>
#include<set>
#include<vector>
#include<math.h>
using namespace std;
#define INF 1000000007
#define LINF (1LL << 62)
typedef long long i64;
typedef pair<i64,i64> P;
i64 T, n, m, to[10101];
vector<i64> v[404];
vector<P> G[404];
vector<vector<int>> dist(404, vector<int>(404, INF));
vector<int> route[404][404];
i64 now = 1, next_t = 0;
i64 have[404] = {0};
vector<i64> result;
int finished[404];
i64 o[100][10001];
int Times = 0;
i64 para[2] = {180, 16};
void floyd(){
for(int i = 1; i <= n; i++){
for(int j = 1; j <= n; j++){
for(int k = 1; k <= n; k++){
if(dist[j][k] > dist[j][i] + dist[i][k]){
//route[j][k] = route[j][i]+route[i][k];
route[j][k] = route[j][i];
route[j][k].insert(route[j][k].end(),route[i][k].begin(),route[i][k].end());
dist[j][k] = dist[j][i] + dist[i][k];
}
}
}
}
}
P choice_next(int start, i64 t){
i64 ma = -1, k = -1;
for(int i = 2; i <= n; i++){
if(!have[i]) continue;
if(dist[start][i] >= T-t) continue;
i64 cnt = 0;
for(int j = 0; j < route[start][i].size(); j++){
cnt += have[route[start][i][j]];
}
if(ma < cnt * para[0] / (dist[start][i])){
ma = cnt * para[0] / (dist[start][i]);
k = i;
}
}
return P(ma, k);
}
int Move(int start, i64 next_t){
P choice = choice_next(start, next_t);
i64 ma = choice.first, k = choice.second;
if(ma >= para[1]){
int npos = route[start][k][0];
for(int i = 0; i < dist[now][npos]; i++){
if(next_t >= T) break;
//cout << npos << endl;
o[Times][next_t] = npos;
next_t++;
}
now = npos;
for(int i = 0; i < have[now]; i++){
result[Times] += T*T - (next_t - v[now][finished[now]])*(next_t - v[now][finished[now]]);
finished[now]++;
}
have[now] = 0;
next_t = Move(now, next_t);
return next_t;
}
for(int i = route[1][now].size()-2; i >= -1; i = route[1][now].size()-2){
int npos;
if(i == -1) npos = 1;
else npos = route[1][now][i];
for(int j = 0; j < dist[now][npos]; j++){
if(next_t >= T) break;
//cout << npos << endl;
o[Times][next_t] = npos;
next_t++;
}
now = npos;
}
return next_t;
}
int main(){
cin >> n >> m;
for(int i = 0; i <= n; i++){
dist[i][i] = 0;
}
for(int i = 0; i < m; i++){
int a,b,c;
cin >> a >> b >> c;
G[a].push_back(P(b,c));
G[b].push_back(P(a,c));
dist[a][b] = c;
dist[b][a] = c;
route[a][b].push_back(b);
route[b][a].push_back(a);
}
cin >> T;
for(int i = 0; i < T; i++){
int a,b,c;
cin >> a;
if(a){
cin >> b >> c;
v[c].push_back(i);
to[i] = c;
}
}
floyd();
for(int para1 = 1; para1 <= 512; para1*=2) for(int para2 = 1; para2 <= 128; para2*=2){
para[0] = para1; para[1] = para2;
result.push_back(0);
for(int i = 0; i <= n; i++){
have[i] = 0;
finished[i] = 0;
}
now = 1; next_t = 0;
for(i64 t = 0; t < T; t++){
if(now == 1) have[to[t]]++;
if(next_t > t) continue;
next_t = Move(1, t);
if(next_t == t){
//cout << -1 << endl;
o[Times][next_t] = -1;
}
}
Times++;
}
i64 ans_cnt = 0, ans_time = 0;
for(int i = 0; i < Times; i++){
if(ans_cnt < result[i]){
ans_cnt = result[i];
ans_time = i;
}
}
for(int i = 0; i < T; i++){
cout << o[ans_time][i] << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned int uint;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<pii> vpii;
#define FOR(i, a, b) for (int i = a; i <= (b); i++)
#define F0R(i, a) for (int i = 0; i < (a); i++)
#define FORd(i, a, b) for (int i = (b); i >= a; i--)
#define F0Rd(i, a) for (int i = (a)-1; i >= 0; i--)
#define trav(a, x) for (auto &a : x)
#define sz(x) (int)(x).size()
#define popcnt(x) __builtin_popcount(x)
#define low_bo(a, x) (lower_bound(a.begin(), a.end(), x) - a.begin())
#define up_bo(a, x) (upper_bound(a.begin(), a.end(), x) - a.begin())
#define unique(a) a.resize(unique(a.begin(), a.end()) - a.begin())
#define shuffle(a) shuffle(a.begin(), a.end(), rnd)
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define f first
#define s second
#define lb lower_bound
#define ub upper_bound
#define all(x) x.begin(), x.end()
#define ins insert
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int MOD = 1000000007;
const char nl = '\n';
const int MX = 150001; //check the limits, dummy
void solve(int t) {
int n;
cin >> n;
vi arr(n);
int cnt = 0;
vi neg, pos;
F0R(i, n) {
cin >> arr[i];
if (arr[i] <= 0)
cnt++, neg.pb(arr[i]);
else
pos.pb(arr[i]);
}
if (sz(neg) > 1 && sz(pos) > 0) {
sort(all(neg));
sort(all(pos));
int mn = neg[1] - neg[0];
F0R(i, sz(neg) - 1) {
mn = min(mn, neg[i+1] - neg[i]);
}
if (mn >= pos[0]) {
cnt++;
}
} else if(sz(pos)>0) {
cnt++;
}
cout << cnt << nl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.precision(20);
cout << fixed;
int T = 1;
cin >> T;
F0R(i, T) {
solve(i + 1);
}
}
// read the question correctly (ll vs int)
// template by bqi343
| 2 |
#include<iostream>
#include<queue>
using namespace std;
int n, a[300], m; bool u1[300], u2[300];
int main() {
while (true) {
cin >> m; if (m == 0)break; cin >> n;
for (int i = 0; i < 300; i++)a[i] = 0;
for (int i = 1; i <= n; i++)cin >> a[i];
for (int i = 0; i < 300; i++)u1[i] = false; u1[0] = true;
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= n; j++) {
if (u1[j] == false)continue;
for (int k = 1; k <= m; k++) {
int G = j + k; if (G > n)G = n + 1;
G += a[G]; if (G < 0)G = 0; if (G > n)G = n + 1; u1[G] = true;
}
}
}
bool flag = false;
for (int i = 0; i <= n; i++) {
if (u1[i] == false)continue;
for (int j = 0; j < 300; j++)u2[j] = false; u2[i] = true;
queue<int>Q; Q.push(i);
while (!Q.empty()) {
int a1 = Q.front(); Q.pop();
for (int j = 1; j <= m; j++) {
int G = a1 + j; if (G > n)G = n + 1;
G += a[G]; if (G < 0)G = 0; if (G > n)G = n + 1;
if (u2[G] == false) { u2[G] = true; Q.push(G); }
}
}
if (u2[n + 1] == false) { cout << "NG" << endl; flag = true; break; }
}
if (flag == false)cout << "OK" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << '[';
string sep;
for (const auto &x : v) os << sep << x, sep = ", ";
return os << ']';
}
template <typename T, size_t size>
ostream &operator<<(ostream &os, const array<T, size> &arr) {
os << '{';
string sep;
for (const auto &x : arr) os << sep << x, sep = ", ";
return os << '}';
}
template <typename A, typename B>
ostream &operator<<(ostream &os, const pair<A, B> &p) {
return os << '{' << p.first << ", " << p.second << '}';
}
template <typename T>
ostream &operator<<(ostream &os, const set<T> &s) {
os << '{';
string sep;
for (const auto &x : s) os << sep << x, sep = ", ";
return os << '}';
}
template <typename A, typename B>
ostream &operator<<(ostream &os, const map<A, B> &mp) {
os << '[';
string sep;
for (const auto &x : mp) os << sep << x, sep = ", ";
return os << ']';
}
template <typename T>
ostream &operator<<(ostream &os, const multiset<T> &s) {
os << '{';
string sep;
for (const auto &x : s) os << sep << x, sep = ", ";
return os << '}';
}
void dbg_out() { cerr << endl; }
template <typename Head, typename... Tail>
void dbg_out(Head H, Tail... T) {
cerr << ' ' << H;
dbg_out(T...);
}
long long N, K, A, B;
vector<long long> v;
long long f(long long l, long long r) {
long long rrvalue = upper_bound(v.begin(), v.end(), r) - v.begin();
long long llvalue = lower_bound(v.begin(), v.end(), l) - v.begin();
long long smm = rrvalue - llvalue;
if (!smm) return A;
if (l == r) {
long long rvalue = upper_bound(v.begin(), v.end(), r) - v.begin();
long long lvalue = lower_bound(v.begin(), v.end(), l) - v.begin();
long long sm = rvalue - lvalue;
if (!sm) return A;
return sm * B;
}
long long rvalue = upper_bound(v.begin(), v.end(), r) - v.begin();
long long lvalue = lower_bound(v.begin(), v.end(), l) - v.begin();
long long sm = rvalue - lvalue;
long long ans1 = (sm == 0LL ? A : sm * B * (r - l + 1LL));
long long mid = l + (r - l) / 2;
long long ans2 = f(l, mid) + f(mid + 1LL, r);
return min(ans1, ans2);
}
void solve() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> N >> K >> A >> B;
for (long long i = 0; i < K; i++) {
long long x;
cin >> x;
v.push_back(x);
}
sort(v.begin(), v.end());
long long ans = f(1LL, 1LL << N);
cout << ans << '\n';
}
int32_t main() {
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e4 + 10;
int a[MAXN];
int main() {
int n, t;
cin >> n >> t;
for (int i = 1; i < n; i++) cin >> a[i];
int q = 1;
while (q <= t) {
if (q == t) {
cout << "YES";
return 0;
}
q += a[q];
}
cout << "NO";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int space = 0;
string a;
cin >> a;
for (int i = 0; i < a.length(); i++) {
if (a[i] == '>' || (a[i] >= 'a' && a[i] <= 'z') || a[i] == '/') {
cout << a[i];
} else {
if (a[i + 1] == '/') {
space -= 2;
}
if (i) {
cout << "\n";
}
if (i)
for (int j = 0; j < space; j++) {
cout << " ";
}
if (a[i + 1] != '/') {
space += 2;
}
cout << "<";
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int al, ar, bl, br;
scanf("%d%d%d%d", &al, &ar, &bl, &br);
if ((br >= al - 1 && br <= 2 * (al + 1)) ||
(bl >= ar - 1 && bl <= 2 * (ar + 1)))
puts("YES");
else
puts("NO");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long n, s, x;
cin >> n >> s;
vector<long long> v(n);
for (long long i = 0; i < n; i++) cin >> v[i];
sort(v.begin(), v.end());
long long key = v[n / 2];
long long sum = 0;
if (key == s) {
cout << 0;
return 0;
} else if (key < s) {
for (long long i = n / 2; i < n; i++) {
if (v[i] <= s)
sum = sum + s - v[i];
else
break;
}
} else {
for (long long i = n / 2; i >= 0; i--) {
if (v[i] >= s)
sum = sum + v[i] - s;
else
break;
}
}
cout << sum;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll n, m;
int main()
{
cin >> n >> m;
if (n > m) swap(n, m);
if (n == 1 && m == 1) cout << 1 << endl;
else if (n == 1) cout << m-2 << endl;
else cout << (n-2)*(m-2) << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x1 = 0, y1 = 0, x2 = 0, y2 = 0;
int n;
cin >> n;
int s;
for (int i = 0; i < n; i++) {
cin >> s;
int x, y;
cin >> x >> y;
if (s == 1) {
x1 += x;
y1 += y;
} else {
x2 += x;
y2 += y;
}
}
if (x1 >= y1)
cout << "LIVE" << endl;
else
cout << "DEAD" << endl;
if (x2 >= y2)
cout << "LIVE";
else
cout << "DEAD";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long dp[101][10010];
int MOD = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<int> a(n + 1);
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
vector<int> cnt(110, 0);
int dif = 0;
for (int i : a) {
if (i && !cnt[i]) {
dif++;
}
cnt[i]++;
}
if (dif <= 2) {
cout << n;
return 0;
}
dp[0][0] = 1;
for (int i = 1; i <= 100; i++) {
for (int k = n; k >= 1; k--) {
for (int w = 10000; w >= 1; w--) {
for (int f = 1; f <= min(k, cnt[i]) && f * i <= w; f++) {
dp[k][w] += dp[k - f][w - i * f];
}
}
}
}
int ans = 0;
for (int i = 1; i <= 100; i++) {
for (int j = 1; j <= cnt[i]; j++) {
if (dp[j][j * i] == 1) {
ans = max(ans, j);
}
}
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100100;
vector<int> g, sta;
int n, a[maxn], b[maxn], c[maxn], d[maxn], e[maxn], que[maxn], vis[maxn], l, r,
pre[maxn];
set<pair<int, int> > cc[maxn * 2];
void modify(int x, pair<int, int> v) {
for (; x <= 2 * n; x += x & (-x)) {
cc[x].insert(v);
}
}
void ask(int x, pair<int, int> v) {
for (; x; x -= x & (-x)) {
set<pair<int, int> >::iterator it = cc[x].lower_bound(v);
while (it != cc[x].end()) {
sta.push_back((*it).second);
cc[x].erase(it);
it = cc[x].lower_bound(v);
}
}
}
void work(int ll, int rr) {
for (int i = ll; i <= rr; i++) {
sta.clear();
ask(e[que[i]], make_pair(b[que[i]], 0));
for (int j = 0; j < (int)sta.size(); j++) {
if (vis[sta[j]]) continue;
vis[sta[j]] = 1;
pre[sta[j]] = que[i];
que[++r] = sta[j];
if (a[sta[j]] == 0 && b[sta[j]] == 0) {
l = r + 1;
return;
}
}
}
l = rr + 1;
}
void print(int x) {
printf("%d ", x);
if (pre[x]) print(pre[x]);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d%d%d", a + i, b + i, c + i, d + i);
g.push_back(a[i]), g.push_back(c[i]);
}
sort(g.begin(), g.end());
for (int i = 1; i <= n; i++) {
e[i] = 2 * n - (lower_bound(g.begin(), g.end(), a[i]) - g.begin());
c[i] = 2 * n - (lower_bound(g.begin(), g.end(), c[i]) - g.begin());
modify(c[i], make_pair(d[i], i));
}
que[l = r = 1] = n;
vis[n] = 1;
int step = 0;
if (n != 1 && !(a[n] == 0 && b[n] == 0))
while (l <= r) work(l, r), step++;
if (a[que[r]] != 0 || b[que[r]] != 0)
printf("-1\n");
else {
printf("%d\n", step + 1);
print(que[r]);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
std::ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
ll cnt = 0;
cin >> n;
for (int x = 0; x < 9; x++) {
for (int v = 0; v < 9; v++) {
if (x >= 5 && v >= 1) continue;
cnt += max<ll>((n - x - v + 1LL), 0LL);
}
}
cout << cnt << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000007;
int k, n, m, ans;
string s[10][10];
void dfs(int x, int y, int z) {
if (x < 0 || x > n - 1 || y < 0 || y > m - 1 || z < 0 || z > k - 1 ||
s[z][x][y] == '#')
return;
ans++;
s[z][x][y] = '#';
dfs(x, y, z + 1);
dfs(x, y, z - 1);
dfs(x + 1, y, z);
dfs(x - 1, y, z);
dfs(x, y + 1, z);
dfs(x, y - 1, z);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> k >> n >> m;
for (int i = 0; i < k; i++)
for (int j = 0; j < n; j++) cin >> s[i][j];
int x, y;
cin >> x >> y;
dfs(x - 1, y - 1, 0);
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
while (t--) {
long long n;
cin >> n;
long long arr[n];
long long ans = 0;
for (int i = 0; i < n; i++) {
cin >> arr[i];
ans += arr[i];
}
int q;
cin >> q;
map<pair<long long, long long>, long long> mp;
long long mrk[n];
memset(mrk, 0, sizeof(mrk));
for (int i = 0; i < q; i++) {
long long x, y, z;
cin >> x >> y >> z;
z--;
int t = mp[{x, y}];
if (t != 0) {
t--;
ans += min(arr[t], mrk[t]);
mrk[t]--;
ans -= min(arr[t], mrk[t]);
}
mp[{x, y}] = z + 1;
if (z != -1) {
ans += min(arr[z], mrk[z]);
mrk[z]++;
ans -= min(arr[z], mrk[z]);
}
cout << ans << endl;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int sym(int a[][111], int sz, int m) {
int i, j;
if (sz % 2 == 1) return 0;
for (i = 1; i <= sz / 2; i++) {
for (j = 1; j <= m; j++) {
if (a[i][j] == a[sz - i + 1][j])
;
else
return 0;
}
}
return 1;
}
int main() {
int i, j, n, m;
int a[111][111];
cin >> n >> m;
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) cin >> a[i][j];
while (3) {
if (sym(a, n, m) == 1) {
n = n / 2;
} else
break;
}
cout << n << endl;
}
| 2 |
#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<map>
#include<set>
#include<utility>
#include<cmath>
#include<cstring>
#include<queue>
#include<cstdio>
#include<sstream>
#include<iomanip>
#define loop(i,a,b) for(int i=a;i<b;i++)
#define rep(i,a) loop(i,0,a)
#define pb push_back
#define mp make_pair
#define all(in) in.begin(),in.end()
#define shosu(x) fixed<<setprecision(x)
using namespace std;
//kaewasuretyuui
typedef long long ll;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<pii> vp;
typedef vector<vp> vvp;
typedef pair<int,pii> pip;
typedef vector<pip>vip;
const double PI=acos(-1);
const double EPS=1e-8;
const int inf=1e8;
class LCA{
public:
int N,root,max_log;
vvi G,parent;
vi depth;
LCA(int size){
N=size;
G=vvi(size);
max_log=20;
depth=vi(size);
parent=vvi(max_log,vi(size));
}
void add_edge(int a,int b){
G[a].pb(b);
G[b].pb(a);
}
void dfs(int v,int p,int d){
parent[0][v]=p;
depth[v]=d;
rep(i,G[v].size())if(G[v][i]!=p)dfs(G[v][i],v,d+1);
}
void init(){
root=0;
dfs(root,-1,0);
for(int k=0;k+1<max_log;k++){//doubling
for(int v=0;v<N;v++){
if(parent[k][v]<0)parent[k+1][v]=-1;
else parent[k+1][v]=parent[k][parent[k][v]];
}
}
}
int lca(int u,int v){
if(depth[u]>depth[v])swap(u,v);
rep(k,max_log)if((depth[v]-depth[u])>>k&1)v=parent[k][v];
if(u==v)return u;
for(int k=max_log-1;k>=0;k--){
if(parent[k][u]!=parent[k][v]){
u=parent[k][u];
v=parent[k][v];
}
}
return parent[0][u];
}
};
int main(){
int n;
cin>>n;
LCA lca(n);
rep(i,n){
int k;
cin>>k;
rep(j,k){
int a;
cin>>a;
lca.add_edge(i,a);
}
}
lca.init();
int q;
cin>>q;
while(q--){
int a,b;
cin>>a>>b;
int k=lca.lca(a,b);
cout<<k<<endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
int main() {
int n, k;
cin >> n >> k;
if (k / n > 2)
cout << "0\n";
else
cout << n - (k % n) << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int t, i, j, k, n, m, a, b, c;
cin >> n;
for (i = 0; i < n; i++) {
cin >> j;
while (j % 2 == 0) j /= 2;
while (j % 3 == 0) j /= 3;
if (i == 0) c = j;
if (j != c) break;
}
if (j != c)
cout << "No" << endl;
else
cout << "Yes" << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
;
int t;
cin >> t;
while (t--) {
long long one = 0, zero = 0;
long long n = 0;
long long q;
cin >> q;
for (int i = 0; i < q; i++) {
string s;
cin >> s;
if (s.size() % 2 != 0) n++;
for (int j = 0; j < s.size(); j++) {
if (s[j] == '1')
one++;
else
zero++;
}
}
if (n == 0 && one % 2 == 1) {
cout << q - 1 << "\n";
} else
cout << q << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long int a, b, c, d;
cin >> a >> b >> c >> d;
long long int p = (a / b) - (d / b) + (c - 1) / b;
cout << p << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
s += "b";
for (int i = 0; i < s.size() - 1; i++) {
if (s[i] != s[i + 1])
cout << "1 ";
else
cout << "0 ";
}
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
#define N 5000050
#define M 200020
const int mod=1e9+7;
typedef long long ll;
inline ll read(){
ll x=0,f=1;
char c=getchar();
while(c<'0'||c>'9'){
if(c=='-')f=-1;
c=getchar();
}
while(c>='0'&&c<='9'){
x=(x<<1)+(x<<3)+c-'0';
c=getchar();
}
return x*f;
}
int n,a[N],ans[N],m;
bool t[N];
int p[M],k[M],b[M],w[M];
int seed,base;
inline int rnd(){
int tmp=seed;
seed=(1LL*seed*base+233)%mod;
return tmp;
}
int main(){
n=read(),m=read();
for(int i=1;i<=m;++i){
p[i]=read(),k[i]=read(),b[i]=read(),w[i]=read();
}
for(int i=1;i<=m;++i){
seed=b[i],base=w[i];
for(int j=p[i-1]+1;j<=p[i];++j){
t[j]=(rnd()&1);
a[j]=(rnd()%k[i])+1;
}
}
if(t[1]){
for(int i=1;i<=n;++i)t[i]^=1;
}
ll s0=0,s1=0;
for(int i=1;i<=n;++i){
if(t[i])s1+=a[i];
else s0+=a[i];
}
//cerr<<" ?? "<<s0<<" "<<s1<<endl;
if(s0<=s1){
for(int i=1,j=1;i<=n;++i){
if(!t[i]){
ans[i]=a[i];
if(j<i)j=i;
int res=a[i];
while(res){
if(!t[(j-1)%n+1]){
++j;
continue;
}
int u=(j-1)%n+1;
if(res<=a[u]-ans[u]){
ans[u]+=res;
res=0;
}
else{
res-=a[u]-ans[u];
ans[u]=a[u];
++j;
}
}
}
}
}
else{
ans[1]=1;
for(int i=1,j=1;i<=n;++i){
if(t[i]){
ans[i]=a[i];
if(j<i)j=i;
int res=a[i];
while(res){
if(t[(j-1)%n+1]){
++j;
continue;
}
int u=(j-1)%n+1;
if(res<=a[u]-ans[u]){
ans[u]+=res;
res=0;
}
else{
res-=a[u]-ans[u];
ans[u]=a[u];
++j;
}
}
}
}
}
int zyk=1;
ll qwq=0;
for(int i=1;i<=n;++i){
zyk=1LL*zyk*(((ans[i]^(1LL*i*i))+1)%mod)%mod;
}
printf("%d\n",zyk);
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
const double eps = 1e-7;
const int maxn = 1e6 + 9;
const double pi = acos(-1.0);
const long long inf = 1e17;
const long long mod = 10007;
int main() {
ios::sync_with_stdio(false);
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
set<int> pq;
for (int i = 0; i < n; ++i) {
int tmp;
cin >> tmp;
pq.insert(tmp);
}
int jk = pq.size();
if (k == 1) {
if (jk > k)
cout << "-1\n";
else
cout << "1\n";
} else {
if (jk <= k)
cout << "1\n";
else {
int tmp = jk - k;
int kl = 1 + tmp / (k - 1);
if (tmp % (k - 1)) ++kl;
cout << kl << "\n";
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long exgcd(long long a, long long b, long long &x, long long &y) {
if (!b) {
x = 1;
y = 0;
return a;
}
long long ans = exgcd(b, a % b, x, y), temp = x;
x = y;
y = temp - a / b * y;
return ans;
}
int main() {
long long a, b, c, d, x, y;
cin >> a >> b >> c;
d = exgcd(a, b, x, y);
if (c % d)
cout << -1 << endl;
else
cout << -x * (c / d) << " " << -y * (c / d) << endl;
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
int main(){
double A, B, H, M;
cin >> A >> B >> H >> M;
double si=abs(30*H+M/2-6*M);
si=min(si, 360-si);
double P=3.14159265358979;
double c=A*A+B*B-2*A*B*cos(si*2*P/360);
cout << setprecision(15) << pow(c, 0.5) << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100005;
int n, k;
int a[MAX_N];
int cnt[MAX_N];
int main() {
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
int l = 1;
int res = 1e9;
int L = -1;
int R = -1;
int CNT = 0;
for (int r = 1; r <= n; r++) {
cnt[a[r]]++;
if (cnt[a[r]] == 1) ++CNT;
if (CNT < k) continue;
while (CNT > k && l <= r) {
cnt[a[l]]--;
if (cnt[a[l]] == 0) CNT--;
l++;
}
while (CNT == k && l <= r) {
if (cnt[a[l]] == 1) break;
cnt[a[l]]--;
l++;
}
cout << l << ' ' << r;
return 0;
}
cout << -1 << ' ' << -1;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 60;
const long long MOD = 1000000007;
int m, k;
long long n;
struct Matrix {
long long m[N][N];
};
Matrix matrix;
Matrix matrix_multi(Matrix& a, Matrix& b) {
Matrix c;
for (int i = 0; i < m; i++)
for (int j = 0; j < m; j++) {
long long sum = 0;
for (int k = 0; k < m; k++) {
sum += a.m[i][k] * b.m[k][j];
sum %= MOD;
}
c.m[i][j] = sum;
}
return c;
}
long long matrix_pow() {
long long k = n;
Matrix ans;
for (int i = 0; i < m; i++)
for (int j = 0; j < m; j++) ans.m[i][j] = i == j;
for (; k; k >>= 1) {
if (k & 1) {
ans = matrix_multi(ans, matrix);
}
matrix = matrix_multi(matrix, matrix);
}
long long cnt = 0;
for (int i = 0; i < m; i++)
for (int j = 0; j < m; j++) cnt = (cnt + ans.m[i][j]) % MOD;
return cnt;
}
int change(char c) {
if (c >= 'a' && c <= 'z') return c - 'a';
return c - 'A' + 26;
}
int main() {
char a, b;
while (cin >> n >> m >> k) {
for (int i = 0; i < m; i++)
for (int j = 0; j < m; j++) matrix.m[i][j] = 1;
for (int i = 0; i < k; i++) {
cin >> a >> b;
matrix.m[change(a)][change(b)] = 0;
}
n--;
cout << matrix_pow() << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int n, m, k;
cin >> n >> m >> k;
if (n % 2 == 1 and m % 2 == 0) {
int q = m / 2;
if (k < q) {
cout << "NO" << '\n';
} else {
int d = k - q;
if (d % 2 == 0) {
cout << "YES" << '\n';
} else {
cout << "NO" << '\n';
}
}
} else if (n % 2 == 0 and m % 2 == 1) {
int q = n / 2;
k = n * m / 2 - k;
if (k < q) {
cout << "NO" << '\n';
} else {
int d = k - q;
if (d % 2 == 0) {
cout << "YES" << '\n';
} else {
cout << "NO" << '\n';
}
}
} else {
if (k % 2 == 0)
cout << "YES" << '\n';
else
cout << "NO" << '\n';
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
bool vis[N] = {false};
bool vs[N] = {false};
vector<int> g[N];
vector<int> edge[N];
vector<int> ans;
int n, k, d, a, u, v;
queue<int> q;
void bfs() {
int now;
int nxt;
while (!q.empty()) {
now = q.front();
q.pop();
for (int i = 0; i < g[now].size(); i++) {
if (!vis[g[now][i]])
vis[g[now][i]] = true, vs[edge[now][i]] = true, q.push(g[now][i]);
else if (!vs[edge[now][i]])
ans.push_back(edge[now][i]);
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k >> d;
for (int i = 0; i < k; i++) cin >> a, vis[a] = true;
for (int i = 0; i < n - 1; i++)
cin >> u >> v, g[u].push_back(v), g[v].push_back(u),
edge[v].push_back(i + 1), edge[u].push_back(i + 1);
for (int i = 1; i <= n; i++)
if (vis[i]) q.push(i);
bfs();
sort(ans.begin(), ans.end());
ans.erase(unique(ans.begin(), ans.end()), ans.end());
cout << ans.size() << '\n';
for (int i = 0; i < ans.size(); i++) cout << ans[i] << ' ';
cout << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
int a[5] = {2, 3, 1, 2, 1};
int main() {
int x;
scanf("%d", &x);
printf("%d", a[x - 1]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double pi = 3.141592653589793;
const double tau = 6.283185307179586;
const double epsilon = 1e-6;
using namespace std;
double X, Y;
int N;
double target;
int main(int argc, const char* argv[]) {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cin >> X >> Y >> N;
target = X / Y;
pair<double, double> closest_fraction = pair<double, double>(-INFINITY, 1.0);
for (int i = 1; i <= N; i++) {
double denom = i;
int low_bound = max(denom / Y * X - 1, 0.0);
int high_bound = denom / Y * X + 1.0;
for (int j = low_bound; j <= high_bound; j++) {
double numer = j;
if (abs(numer / denom - target) <
abs(closest_fraction.first / closest_fraction.second - target))
closest_fraction = pair<double, double>(numer, denom);
}
}
cout << closest_fraction.first << '/' << closest_fraction.second << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int c[2000 + 5], r[2000 + 5], n;
vector<int> X;
struct node {
int l, r;
} T[2000 + 5];
bool cmp(const struct node &ta, const struct node &tb) {
return ta.l < tb.l || (ta.l == tb.l && ta.r < tb.r);
}
int dp[4000 + 5][4000 + 5];
bool flag[4000 + 5][4000 + 5];
vector<int> ans;
vector<int> g[4000 + 5], f[4000 + 5];
void dfs(int l, int r) {
if (l == r) return;
if (flag[l][r - 1]) {
for (int i = 0; i < n; i++) {
if (T[i].l == l && T[i].r + 1 == r) {
ans.push_back(i);
}
}
dp[r - l][l]--;
}
int k = r - l;
if (dp[k - 1][l + 1] == dp[k][l])
dfs(l + 1, r);
else if (dp[k - 1][l] == dp[k][l])
dfs(l, r - 1);
else {
for (int i = 0; i < n; i++) {
if (T[i].l == l && T[i].r < r) {
int t1 = T[i].r - T[i].l + 1, t2 = r - T[i].r;
if (dp[t1][T[i].l] + dp[t2][T[i].r] == dp[r - l][l]) {
dfs(T[i].l, T[i].r + 1);
dfs(T[i].r, r);
return;
}
}
}
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d %d", &r[i], &c[i]);
for (int i = 0; i < n; i++) {
X.push_back(r[i] - c[i]);
X.push_back(r[i] + c[i]);
}
sort(X.begin(), X.end());
X.erase(unique(X.begin(), X.end()), X.end());
for (int i = 0; i < n; i++) {
T[i].l = lower_bound(X.begin(), X.end(), r[i] - c[i]) - X.begin();
T[i].r = lower_bound(X.begin(), X.end(), r[i] + c[i]) - X.begin();
flag[T[i].l][T[i].r] = 1;
int l = T[i].l, r = T[i].r;
g[l].push_back(i);
f[r].push_back(i);
}
for (int i = 1; i <= X.size(); i++) {
for (int j = 0, k = 0; j + i <= X.size(); j++) {
dp[i][j] = max(dp[i - 1][j], dp[i - 1][j + 1]);
for (int ll = 0; ll < g[j].size(); ll++) {
k = g[j][ll];
if (T[k].r < j + i) {
int x = T[k].r - T[k].l + 1;
int t = dp[x][j] + dp[i - x + 1][j + x - 1];
if (t > dp[i][j]) dp[i][j] = t;
}
}
if (flag[j][j + i - 1] == 1) dp[i][j]++;
}
}
dfs(0, X.size());
printf("%d\n", ans.size());
sort(ans.begin(), ans.end());
for (int i = 0; i < ans.size(); i++) printf("%d ", ans[i] + 1);
printf("\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 300005;
int n, m;
vector<int> graph[MAXN];
char c[MAXN];
void check(int node) {
int s = 0;
for (auto i : graph[node]) {
if (c[i] == c[node]) s++;
}
if (s > 1) {
if (c[node] == '0')
c[node] = '1';
else
c[node] = '0';
for (auto i : graph[node]) {
check(i);
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; ++i) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
graph[a].push_back(b);
graph[b].push_back(a);
}
for (int i = 0; i < n; ++i) c[i] = '0';
for (int i = 0; i < n; ++i) {
check(i);
}
puts(c);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define endl '\n'
int main() {
string s;
cin >> s;
set<char> a;
for (auto c : s) {
a.insert(c);
}
cout << (a.size() == 2 ? "Yes" : "No") << endl;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
using ll = int64_t;
signed main(){
ll x,k,d;
cin>>x>>k>>d;
x = abs(x);
__int128_t _x=x,_k=k,_d=d;
if(_x>_k*_d){
cout<< x-k*d <<endl;
}
else{
k -= x/d;
x -= x/d*d;
cout<<(k&1?abs(x-d):x)<<endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long quantidade;
long long menor, maior;
long long contMenor, contMaior;
cin >> quantidade;
cin >> menor;
maior = menor;
contMenor = contMaior = 1;
for (long long i = 0; i < quantidade - 1; i++) {
long long num;
cin >> num;
if (num == menor || num == maior) {
contMenor += (num == menor);
contMaior += (num == maior);
}
if (num < menor) {
menor = num;
contMenor = 1;
}
if (num > maior) {
maior = num;
contMaior = 1;
}
}
if (menor == maior)
cout << 0 << " " << (quantidade * (quantidade - 1)) / 2 << endl;
else
cout << maior - menor << " " << contMaior * contMenor << endl;
return 0;
}
| 2 |
#include<bits/stdc++.h>
#include<iomanip>
#include<numeric>
using namespace std;
using ll = long long;
constexpr int mo = 1e9+7;
constexpr int mod = mo;
constexpr int inf = 1<<30;
int main(){
int n,c;
cin>>n>>c;
vector<int> imos(100050);
for(int i=0;i<n;++i){
int s,t,c;
cin>>s>>t>>c;
imos[s]++;
imos[t+1]--;
}
for(int i=0;i<100000;++i)imos[i+1] += imos[i];
int ret = 0;
for(int i=1;i<=100000;++i){
ret = max(ret,imos[i]);
}
ret = min(ret,c);
cout << ret << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int m, n, d[100005], trace[100005], r[100005], nu[100005], k[100005];
vector<int> ke[100005], keC[100005];
set<pair<int, pair<int, int> > > q;
vector<pair<int, pair<int, int> > > listc, ans;
set<pair<int, int> > path;
int findx(int l, int r, int u, int v) {
int midu, midv, res;
while (l <= r) {
midu = listc[(l + r) / 2].first;
midv = (listc[(l + r) / 2].second).first;
if (u >= midu && v >= midv) {
res = (l + r) / 2;
l = (l + r) / 2 + 1;
} else
r = (l + r) / 2 - 1;
}
return res;
}
void solve() {
for (int i = (1), _b = (n); i <= _b; i++) {
d[i] = 1000000000;
r[i] = -1;
nu[i] = m + 1;
}
nu[1] = 0;
d[1] = 0;
q.insert(make_pair(0, make_pair(d[1], 1)));
while (!q.empty()) {
pair<int, pair<int, int> > top = *q.begin();
q.erase(q.begin());
int u = (top.second).second;
if (u == n) break;
for (int i = 0, _n = (ke[u].size()); i < _n; i++) {
int v = ke[u][i];
if (nu[v] > nu[u] + 1 ||
(nu[v] == nu[u] + 1 && d[v] > keC[u][i] + d[u])) {
q.erase(make_pair(nu[v], make_pair(d[v], v)));
d[v] = d[u] + keC[u][i];
nu[v] = nu[u] + 1;
trace[v] = u;
r[v] = keC[u][i];
q.insert(make_pair(nu[v], make_pair(d[v], v)));
}
}
}
int t = n;
while (trace[t] > 0) {
path.insert(min(make_pair(t, trace[t]), make_pair(trace[t], t)));
t = trace[t];
}
for (int i = (1), _b = (n); i <= _b; i++)
for (int j = 0, _n = (ke[i].size()); j < _n; j++)
if (ke[i][j] > i) {
pair<int, int> tmp = make_pair(i, ke[i][j]);
if ((path.count(tmp) > 0 && keC[i][j] == 1) ||
(path.count(tmp) == 0 && keC[i][j] == 0))
ans.push_back(make_pair(i, make_pair(ke[i][j], keC[i][j])));
}
printf("%d\n", ans.size());
for (int i = 0, _n = (ans.size()); i < _n; i++)
printf("%d %d %d\n", ans[i].first, (ans[i].second).first,
(ans[i].second).second);
}
int main() {
scanf("%d%d", &n, &m);
int tmp = 0;
for (int i = 0, _n = (m); i < _n; i++) {
int u, v, z;
scanf("%d%d%d", &u, &v, &z);
z = 1 - z;
listc.push_back(make_pair(u, make_pair(v, z)));
listc.push_back(make_pair(v, make_pair(u, z)));
tmp += 2;
ke[u].push_back(v);
keC[u].push_back(z);
ke[v].push_back(u);
keC[v].push_back(z);
}
sort(listc.begin(), listc.end());
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool comp(pair<int, int> x, pair<int, int> y) {
return x.first + x.second <= y.first + y.second;
}
void solve() {
int n;
cin >> n;
string s = "", b;
int r = n, c = n;
vector<pair<int, int>> v;
v.push_back({n, n});
v.push_back({1, 1});
while (abs(r - 1) + abs(c - 1) >= n) {
if (r > 1) {
r--;
cout << "? " << 1 << " " << 1 << " " << r << " " << c << endl;
cin >> b;
if (b == "YES") {
v.push_back({r, c});
continue;
}
r++;
}
c--;
cout << "? " << 1 << " " << 1 << " " << r << " " << c << endl;
cin >> b;
v.push_back({r, c});
}
r = 1;
c = 1;
while (abs(r - n) + abs(c - n) > n) {
if (c < n) {
c++;
cout << "? " << r << " " << c << " " << n << " " << n << endl;
cin >> b;
if (b == "BAD") return;
if (b == "YES") {
v.push_back({r, c});
continue;
}
c--;
}
r++;
cout << "? " << r << " " << c << " " << n << " " << n << endl;
cin >> b;
if (b == "BAD") return;
v.push_back({r, c});
}
cout << "! ";
sort(v.begin(), v.end(), comp);
for (int i = 0; i < (v.size() - 1); ++i) {
if (v[i].first == v[i + 1].first)
cout << 'R';
else
cout << 'D';
}
cout << endl;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
t = 1;
while (t--) {
solve();
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[501]={},s=0,n;
int main(){
cin>>n;
for (int i=1;i<=2*n;i++)cin>>a[i];
sort(a+1,a+2*n+1);
for (int i=1;i<=2*n;i++)
if (i%2==1) s+=a[i];
cout<<s;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vi> vvi;
typedef vector<vll> vvll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<pii> vpii;
typedef vector<pll> vpll;
typedef vector<vpii> vvpii;
typedef vector<vpll> vvpll;
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define sz(x) (int)(x).size()
#define fi first
#define se second
template<class T> bool ckmin(T &a, const T &b) {return a > b ? a = b, 1 : 0;}
template<class T> bool ckmax(T &a, const T &b) {return a < b ? a = b, 1 : 0;}
void __print(int x) {cerr << x;}
void __print(long long x) {cerr << x;}
void __print(double x) {cerr << x;}
void __print(long double x) {cerr << x;}
void __print(char x) {cerr << '\'' << x << '\'';}
void __print(const string &x) {cerr << '\"' << x << '\"';}
void __print(bool x) {cerr << (x ? "true" : "false");}
template<typename T, typename V>
void __print(const pair<T, V> &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';}
template<typename T>
void __print(const T &x) {int f = 0; cerr << '{'; for(auto z : x) cerr << (f++ ? "," : ""), __print(z); cerr << "}";}
void _print() {cerr << "]\n";}
template <typename T, typename... V>
void _print(T t, V... v) {__print(t); if(sizeof...(v)) cerr << ", "; _print(v...);}
#ifdef ljuba
#define dbg(x...) cerr << "LINE(" << __LINE__ << ") -> " << "[" << #x << "] = ["; _print(x)
#else
#define dbg(x...)
#endif
const char nl = '\n';
inline ll sqr(ll x) {
return x * x;
}
inline ll dist(pll a, pll b) {
return sqr(a.fi-b.fi) + sqr(a.se-b.se);
}
void solve() {
int n;
cin >> n;
vpll v(n);
for(auto &[a, b] : v)
cin >> a >> b;
vi ans{0};
vector<bool> marked(n);
marked[0] = 1;
for(int i = 0; i < n-1; ++i) {
int tren = -1;
ll raz = 0;
int prosli = ans.back();
for(int j = 0; j < n; ++j) {
if(marked[j])
continue;
if(tren == -1) {
tren = j;
raz = dist(v[prosli], v[j]);
continue;
}
if(ckmax(raz, dist(v[prosli], v[j]))) {
tren = j;
}
}
ans.pb(tren);
marked[tren] = 1;
}
for(auto z : ans)
cout << z+1 << " ";
cout << nl;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int testCases = 1;
//cin >> testCases;
while(testCases--)
solve();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int num = 0, sign = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') sign = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
num = num * 10 + ch - '0';
ch = getchar();
}
return num * sign;
}
int main() {
int T = read();
while (T--) printf("%d\n", read());
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int t, m;
int vis[111];
int cnt;
bool exist[111];
void init() {
memset(vis, 0, sizeof(vis));
memset(exist, 0, sizeof(exist));
cnt = 0;
}
int alloc(int x) {
int i;
int res = 0;
for (i = 0; i < m; i++) {
if (vis[i] == 0) {
res = 0;
while (vis[i] == 0 && i < m) {
res++;
i++;
if (res == x) break;
}
}
if (res == x) {
break;
}
}
if (res == x) {
cnt++;
for (int j = i - res; j < i; j++) vis[j] = cnt;
exist[cnt] = 1;
return cnt;
} else
return -1;
}
int erases(int x) {
if (exist[x] == 0)
return -1;
else {
for (int i = 0; i < m; i++)
if (vis[i] == x) vis[i] = 0;
exist[x] = 0;
return 1;
}
}
void defragment() {
int xx[111];
int res = 0;
for (int i = 0; i < m; i++) {
if (vis[i]) {
xx[res++] = vis[i];
}
}
for (int i = 0; i < res; i++) vis[i] = xx[i];
for (int i = res; i < m; i++) vis[i] = 0;
}
int main() {
scanf("%d %d", &t, &m);
char op[22];
int a;
init();
for (int i = 0; i < t; i++) {
scanf("%s", op);
if (op[0] == 'd') {
defragment();
} else {
scanf("%d", &a);
if (op[0] == 'a') {
if (a < 0) {
printf("NULL\n");
continue;
}
int xx = alloc(a);
if (xx == -1)
printf("NULL\n");
else
printf("%d\n", xx);
} else if (op[0] == 'e') {
if (a < 0 || a > t) {
printf("ILLEGAL_ERASE_ARGUMENT\n");
continue;
}
int xx = erases(a);
if (xx == -1) printf("ILLEGAL_ERASE_ARGUMENT\n");
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long INF = 1e9 + 7;
long long MOD = 998244353;
int main(void) {
ios_base::sync_with_stdio(0);
cin.tie(0);
string s;
cin >> s;
for (long long x = 0; x < 10; x++) {
for (long long y = 0; y < 10; y++) {
long long ans = 0;
long long dist[10][10];
for (long long i = 0; i < 10; i++) {
for (long long j = 0; j < 10; j++) {
dist[i][j] = INF;
}
}
for (long long i = 0; i < 10; i++) {
dist[i][(i + x) % 10] = 1;
dist[i][(i + y) % 10] = 1;
}
for (long long k = 0; k < 10; k++) {
for (long long i = 0; i < 10; i++) {
for (long long j = 0; j < 10; j++) {
dist[i][j] = min(dist[i][k] + dist[k][j], dist[i][j]);
}
}
}
for (long long i = 0; i < s.size() - 1; i++) {
ans += dist[s[i] - '0'][s[i + 1] - '0'] - 1;
}
if (ans >= INF - 1) {
ans = -1;
}
cout << ans << " ";
}
cout << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9 + 123, MAXN = 2e5 + 47;
template <class T>
istream& operator>>(istream& in, vector<T>& a) {
for (auto& i : a) in >> i;
return in;
}
template <class T>
ostream& operator<<(ostream& out, vector<T>& a) {
for (auto& i : a) out << i << " ";
return out;
}
template <class T, class D>
istream& operator>>(istream& in, vector<pair<T, D>>& a) {
for (auto& i : a) in >> i.first >> i.second;
return in;
}
template <class T, class D>
ostream& operator<<(ostream& out, vector<pair<T, D>>& a) {
for (auto& i : a) out << i.first << " " << i.second << endl;
return out;
}
signed main() {
setlocale(LC_ALL, "rus");
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, m, k;
cin >> n >> m >> k;
vector<long long> a(n), b(m);
cin >> a >> b;
vector<long long> dp1(n + 1), dp2(m + 1);
long long cnt = 0;
for (long long i = 0; i < n; ++i)
if (a[i])
dp1[++cnt]++;
else
cnt = 0;
cnt = 0;
for (long long i = 0; i < m; ++i)
if (b[i])
dp2[++cnt]++;
else
cnt = 0;
for (long long i = n - 1; i >= 1; --i) dp1[i] += dp1[i + 1];
for (long long i = m - 1; i >= 1; --i) dp2[i] += dp2[i + 1];
long long ans = 0;
for (long long i = 1; i * i <= k; ++i)
if (k % i == 0) {
long long f = i, f2 = k / i;
if (f <= n && f2 <= m) ans += dp1[f] * dp2[f2];
swap(f, f2);
if (f == f2) continue;
if (f <= n && f2 <= m) ans += dp1[f] * dp2[f2];
}
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<pair<int, int> > v[100002];
int ind[100002], dp[100002];
int dfs(int i) {
if (dp[i]) return dp[i];
dp[i] = 1;
for (int j = 0; j < v[i].size(); j++) {
if (dfs(v[i][j].first) + 1 > dp[i]) {
dp[i] = dp[v[i][j].first] + 1;
ind[i] = max(ind[v[i][j].first], v[i][j].second);
}
}
return dp[i];
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> m;
int a, b;
for (int i = 1; i <= m; i++) {
cin >> a >> b;
v[a].push_back(make_pair(b, i));
}
for (int i = 1; i <= n; i++) {
if (dfs(i) == n) {
cout << ind[i] << "\n";
return 0;
}
}
cout << "-1";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 4 * atan(1);
int T, N;
long long X[100013], Y[100013], Z[100013];
long long ansx, ansy, ansz;
inline bool is(long long x, int p) { return (((x % 2) + 2) % 2) == p; }
bool go(long long d) {
long long xmi = -8.1e18, xma = 8.1e18, ymi = -8.1e18, yma = 8.1e18,
zmi = -8.1e18, zma = 8.1e18, smi = -8.1e18, sma = 8.1e18;
for (int i = 0; i < N; i++) {
xmi = max(xmi, Y[i] + Z[i] - X[i] - d);
xma = min(xma, Y[i] + Z[i] - X[i] + d);
ymi = max(ymi, -Y[i] + Z[i] + X[i] - d);
yma = min(yma, -Y[i] + Z[i] + X[i] + d);
zmi = max(zmi, Y[i] - Z[i] + X[i] - d);
zma = min(zma, Y[i] - Z[i] + X[i] + d);
smi = max(smi, Y[i] + Z[i] + X[i] - d);
sma = min(sma, Y[i] + Z[i] + X[i] + d);
}
for (int p = 0; p < 2; p++) {
long long xmi2 = xmi + is(xmi, !p);
long long ymi2 = ymi + is(ymi, !p);
long long zmi2 = zmi + is(zmi, !p);
long long xma2 = xma - is(xma, !p);
long long yma2 = yma - is(yma, !p);
long long zma2 = zma - is(zma, !p);
long long smi2 = smi + is(smi, !p);
long long sma2 = sma - is(sma, !p);
if (smi2 > sma2 || xmi2 > xma2 || ymi2 > yma2 || zmi2 > zma2) continue;
long long qmi = xmi2 + ymi2 + zmi2, qma = xma2 + yma2 + zma2;
if (qmi <= sma2 && qma >= smi2) {
if (xma2 + ymi2 + zmi2 < smi2) {
if (xma2 + yma2 + zmi2 < smi2) {
ansx = xma2;
ansy = yma2;
ansz = smi2 - ansx - ansy;
} else {
ansx = xma2;
ansz = zmi2;
ansy = smi2 - ansx - ansz;
}
} else {
ansy = ymi2;
ansz = zmi2;
ansx = max(xmi2, smi2 - ansy - ansz);
}
return true;
}
}
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> T;
while (T--) {
cin >> N;
for (int i = 0; i < N; i++) {
cin >> X[i] >> Y[i] >> Z[i];
}
long long lo = 0;
long long hi = 3.1e18;
while (lo != hi) {
long long mid = (lo + hi) / 2;
if (go(mid)) {
hi = mid;
} else {
lo = mid + 1;
}
}
go(lo);
cout << (ansy + ansz) / 2 << ' ' << (ansx + ansz) / 2 << ' '
<< (ansx + ansy) / 2 << '\n';
}
cout.flush();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, x[5555], a[5555], b[5555], c[5555], d[5555], st, en;
long long dp[2][5551][2][2];
const long long inf = 1e18;
map<int, int> hs;
int main() {
scanf("%d%d%d", &n, &st, &en);
int tst = 0;
{
st--;
en--;
int i, j, s, p, q, flag;
hs.clear();
for (i = 0; i < n; i++) {
scanf("%d", &x[i]);
}
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
for (i = 0; i < n; i++) {
scanf("%d", &b[i]);
}
for (i = 0; i < n; i++) {
scanf("%d", &c[i]);
}
for (i = 0; i < n; i++) {
scanf("%d", &d[i]);
}
for (i = 0; i < 2; i++)
for (j = 0; j <= n; j++)
for (s = 0; s < 2; s++)
for (p = 0; p < 2; p++) dp[i][j][s][p] = inf;
dp[0][0][0][0] = 0;
flag = 0;
int fs = 0;
for (i = 0; i < n; i++) {
for (j = 0; j <= n; j++)
for (s = 0; s < 2; s++)
for (p = 0; p < 2; p++) dp[1 - flag][j][s][p] = inf;
for (j = 0; j <= n; j++)
for (s = 0; s < 2; s++)
for (p = 0; p < 2; p++) {
if (dp[flag][j][s][p] == inf) continue;
if (fs && s == 0 && p == 0) continue;
if (i != st && i != en) {
dp[1 - flag][j + 1][s][p] =
min(dp[1 - flag][j + 1][s][p],
dp[flag][j][s][p] + d[i] - x[i] + b[i] - x[i]);
if (j + s + p >= 2)
dp[1 - flag][j - 1][s][p] =
min(dp[1 - flag][j - 1][s][p],
dp[flag][j][s][p] + (long long)c[i] + (long long)x[i] +
(long long)a[i] + (long long)x[i]);
if (j) {
dp[1 - flag][j][s][p] =
min(dp[1 - flag][j][s][p], dp[flag][j][s][p] + a[i] + d[i]);
dp[1 - flag][j][s][p] =
min(dp[1 - flag][j][s][p], dp[flag][j][s][p] + c[i] + b[i]);
}
if (s)
dp[1 - flag][j][s][p] =
min(dp[1 - flag][j][s][p], dp[flag][j][s][p] + a[i] + d[i]);
if (p)
dp[1 - flag][j][s][p] =
min(dp[1 - flag][j][s][p], dp[flag][j][s][p] + c[i] + b[i]);
if (s > 0 && p > 0)
dp[1 - flag][j][s - 1][p - 1] =
min(dp[1 - flag][j][s - 1][p - 1],
dp[flag][j][s][p] + (long long)c[i] + (long long)x[i] +
(long long)a[i] + (long long)x[i]);
} else if (i == st) {
dp[1 - flag][j][s + 1][p] = min(dp[1 - flag][j][s + 1][p],
dp[flag][j][s][p] + d[i] - x[i]);
if (j)
dp[1 - flag][j - 1][s + 1][p] =
min(dp[1 - flag][j - 1][s + 1][p],
dp[flag][j][s][p] + c[i] + x[i]);
if (p)
dp[1 - flag][j][s][p - 1] = min(
dp[1 - flag][j][s][p - 1], dp[flag][j][s][p] + c[i] + x[i]);
} else if (i == en) {
dp[1 - flag][j][s][p + 1] = min(dp[1 - flag][j][s][p + 1],
dp[flag][j][s][p] + b[i] - x[i]);
if (j)
dp[1 - flag][j - 1][s][p + 1] =
min(dp[1 - flag][j - 1][s][p + 1],
dp[flag][j][s][p] + a[i] + x[i]);
if (s)
dp[1 - flag][j][s - 1][p] = min(
dp[1 - flag][j][s - 1][p], dp[flag][j][s][p] + a[i] + x[i]);
}
}
if (i == st) fs |= 1;
if (i == en) fs |= 2;
flag = 1 - flag;
}
printf("%I64d\n", dp[flag][0][0][0]);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int size = 1e5 + 10;
char mas[size];
int main() {
scanf("%s", mas);
int len = (int)strlen(mas);
stack<char> st;
st.push(mas[0]);
for (int i = 1; i < len; ++i) {
if (st.empty() || st.top() != mas[i]) {
st.push(mas[i]);
} else {
st.pop();
}
}
if (st.empty()) {
printf("Yes");
} else {
printf("No");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
constexpr int d = 60;
int t;
cin >> t;
for (int i = 0; i < t; i++) {
int n, ans = 0;
cin >> n;
vector<uint64_t> a(n), w(d);
for (int j = 0; j < n; j++) {
cin >> a.at(j);
}
string s;
cin >> s;
for (int j = n - 1; j >= 0; j--) {
if (s.at(j) == '1') {
uint64_t m = a.at(j);
for (int k = 0; k < d; k++) {
if ((m >> k) & 1ul) m ^= w.at(k);
}
if (m) {
ans = 1;
}
} else {
uint64_t m = a.at(j);
for (int k = 0; k < d; k++) {
if ((m >> k) & 1ul) {
if (w.at(k) == 0) {
w.at(k) = m;
}
m ^= w.at(k);
}
}
}
}
cout << ans << "\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, x, y;
cin >> n >> x >> y;
if ((y - (n - 1)) * (y - (n - 1)) + n - 1 >= x && (y - (n - 1)) > 0) {
for (int i = 1; i <= n - 1; i++) cout << 1 << "\n";
cout << (y - (n - 1));
} else
cout << -1;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int mOdd = 0, mEven = 0;
int n;
cin >> n;
int inp[n + 1];
for (int i = 0; i < n; i++) {
cin >> inp[i];
if (i % 2 == 0) {
if (inp[i] % 2 != 0) mEven++;
} else if (i % 2 == 1) {
if (inp[i] % 2 != 1) mOdd++;
}
}
if (mOdd == mEven)
cout << mEven << endl;
else
cout << -1 << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[100010];
int main()
{
int n, x;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &x);
a[x + 1]++;
}
int ans = 0;
for (int i = 0; i <= 100000; i++) {
ans = max(ans, a[i] + a[i + 1] + a[i + 2]);
}
printf("%d\n", ans);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int n, m, A[100000], B[100000];
long long int f(int x) {
long long int ans = 0;
for (int i = 0; i < n; ++i) {
if (A[i] < x) {
ans += (x - A[i]);
} else
break;
}
for (int i = m - 1; i >= 0; --i) {
if (B[i] > x) {
ans += (B[i] - x);
} else
break;
}
return ans;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; ++i) {
cin >> A[i];
}
for (int i = 0; i < m; ++i) {
cin >> B[i];
}
sort(A, A + n);
sort(B, B + m);
int m1, m2, l = 1, r = 1000000000;
while (r - l >= 3) {
m1 = l + (r - l) / 3;
m2 = r - (r - l) / 3;
if (f(m1) > f(m2))
l = m1;
else
r = m2;
}
long long int ans = f(l);
for (int i = l + 1; i <= r; ++i) {
ans = min(ans, f(i));
}
cout << ans << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int MN = 1.5e5 + 100;
using ll = long long;
int N, NN, a[MN], b[MN];
ll fans[MN];
ll ans;
struct BIT {
public:
int a[MN];
void reset() { memset(a, 0, sizeof(a)); }
void upd(int x, int v) {
assert(x >= 0);
for (++x; x <= N + 10; x += -x & x) a[x - 1] += v;
}
int qry(int x) {
assert(x >= 0);
int r = 0;
for (++x; x; x -= -x & x) r += a[x - 1];
return r;
}
};
BIT vals, cnts;
struct segtree {
public:
int m[1 << 19], m2[1 << 19], c[1 << 19], z[1 << 19];
void reset() {
memset(m2, -1, sizeof(m2));
memset(z, -1, sizeof(z));
memset(c, 0, sizeof(c));
memset(m, -1, sizeof(m));
}
void down(int n) {
if (!~z[n]) return;
for (int x : {n << 1, n << 1 | 1})
if (m[x] > z[n]) z[x] = m[x] = z[n];
z[n] = -1;
}
void up(int n) {
if (m[n << 1] > m[n << 1 | 1])
m[n] = m[n << 1], c[n] = c[n << 1],
m2[n] = std::max(m2[n << 1], m[n << 1 | 1]);
else if (m[n << 1] < m[n << 1 | 1])
m[n] = m[n << 1 | 1], c[n] = c[n << 1 | 1],
m2[n] = std::max(m2[n << 1 | 1], m[n << 1]);
else
m[n] = m[n << 1], c[n] = c[n << 1] + c[n << 1 | 1],
m2[n] = std::max(m2[n << 1], m2[n << 1 | 1]);
}
void set(int n, int l, int r, int x, int v) {
if (r - l > 1) {
int m = l + (r - l) / 2;
down(n);
if (x < m)
set(n << 1, l, m, x, v);
else
set(n << 1 | 1, m, r, x, v);
up(n);
} else {
if (c[n]) cnts.upd(m[n], -1), ans -= vals.qry(m[n]);
m[n] = v, c[n] = 1;
cnts.upd(m[n], 1);
ans += vals.qry(m[n]);
}
}
void upd(int n, int l, int r, int ql, int qr, int v) {
if (v >= m[n]) return;
if (v > m2[n] && ql <= l && r <= qr) {
cnts.upd(m[n], -c[n]);
ans -= static_cast<ll>(c[n]) * vals.qry(m[n]);
m[n] = v;
z[n] = v;
cnts.upd(m[n], c[n]);
ans += static_cast<ll>(c[n]) * vals.qry(m[n]);
return;
}
assert(r - l > 1);
int m = l + (r - l) / 2;
down(n);
if (ql < m) upd(n << 1, l, m, ql, qr, v);
if (m < qr) upd(n << 1 | 1, m, r, ql, qr, v);
up(n);
}
};
segtree st;
std::set<int> use;
bool start[MN];
void solve() {
st.reset();
vals.reset();
cnts.reset();
use.clear();
memset(start, 0, sizeof(start));
ans = 0LL;
for (int i = 0, x; i < N; ++i) {
st.upd(1, 0, NN, 0, b[i], b[i] - 1);
std::set<int>::iterator it = use.upper_bound(b[i]);
if (it != use.end()) {
st.set(1, 0, NN, *it, N);
if (!start[*it])
cnts.upd(*it - 1, -1), start[*it] = 1, ans -= vals.qry(*it - 1);
}
use.insert(b[i]);
st.set(1, 0, NN, *use.begin(), N);
if (!start[*use.begin()])
cnts.upd(*use.begin() - 1, -1), start[*use.begin()] = 1,
ans -= vals.qry(*use.begin() - 1);
vals.upd(b[i], 1);
ans += cnts.qry(N) - cnts.qry(b[i] - 1);
fans[i] += ans;
}
}
int main(void) {
scanf("%d", &N);
NN = 1 << 18;
for (int i = 0; i < N; ++i) scanf("%d", a + i), b[a[i] - 1] = i + 1;
solve();
for (int i = 0; i < N; ++i) b[i] = N + 1 - b[i];
solve();
for (int i = 0; i < N; ++i) printf("%lld\n", fans[i] - i - 1);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, q;
vector<int> a, k;
int count_le(int x) {
int cnt = 0;
for (auto y : a)
if (y <= x) cnt++;
for (auto y : k) {
if (y > 0 && y <= x) cnt++;
if (y < 0 && abs(y) <= cnt) cnt--;
}
return cnt;
}
int main() {
scanf("%d %d", &n, &q);
a.resize(n);
k.resize(q);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < q; i++) scanf("%d", &k[i]);
if (count_le(int(1e9)) == 0) {
puts("0");
return 0;
}
int lf = 0;
int rg = int(1e6) + 1;
while (rg - lf > 1) {
int mid = (lf + rg) / 2;
if (count_le(mid) > 0)
rg = mid;
else
lf = mid;
}
printf("%d\n", rg);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long a[200010];
map<long long, long long> m, vis;
vector<long long> v;
int main() {
long long t, n, i, j, k, l, mn = 0, num = 0, mx = 0;
scanf("%lld", &n);
m.clear();
for (i = 0; i < n; i++) {
scanf("%lld", &a[i]);
m[a[i]]++;
if (m[a[i]] > mx) {
mx = m[a[i]];
num = a[i];
}
}
for (i = 0; i < n; i++) {
if (a[i] == num) {
v.push_back(i), vis[i] = 1;
}
}
if (v.size() == n)
cout << 0 << "\n";
else
cout << n - v.size() << "\n";
if (v[0] > 0) {
long long p = v[0] - 1;
for (j = p; j >= 0; j--) {
if (a[j] > num)
cout << 2 << " " << j + 1 << " " << j + 2 << "\n";
else
cout << 1 << " " << j + 1 << " " << j + 2 << "\n";
}
}
long long pp = 0;
for (i = v[0]; i < n; i++) {
if (vis[i] == 0) {
if (a[i] > num)
cout << 2 << " " << i + 1 << " " << i << "\n";
else
cout << 1 << " " << i + 1 << " " << i << "\n";
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int ans = 0;
for (auto c : s)
if (c == '1')
++ans;
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void solve();
mt19937 rnd(2007);
signed main() {
mt19937 rrnd(
std::chrono::high_resolution_clock::now().time_since_epoch().count());
swap(rrnd, rnd);
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
solve();
}
const long long mod = (long long)1e9 + 7;
const long long maxn = (long long)1e6 + 7;
long long fact0[maxn], fact_[maxn], pwn[maxn], pwm[maxn];
long long C(long long n, long long k) {
return ((fact0[n] * fact_[k]) % mod * fact_[n - k]) % mod;
}
long long binpow(long long a, long long n) {
long long res = 1;
while (n) {
if (n & 1) {
res *= a;
res %= mod;
}
a *= a;
a %= mod;
n >>= 1;
}
return res;
}
void solve() {
long long n, m;
cin >> n >> m;
fact0[0] = 1;
for (long long(i) = 0; (i) < (maxn - 1); ++(i))
fact0[i + 1] = (fact0[i] * (i + 1)) % mod;
for (long long(i) = 0; (i) < (maxn); ++(i))
fact_[i] = binpow(fact0[i], mod - 2);
pwn[0] = 1;
for (long long(i) = 0; (i) < (maxn - 1); ++(i))
pwn[i + 1] = (pwn[i] * n) % mod;
pwm[0] = 1;
for (long long(i) = 0; (i) < (maxn - 1); ++(i))
pwm[i + 1] = (pwm[i] * m) % mod;
long long ans = 0;
for (long long l = 1; l < n; ++l) {
if (l > m) break;
long long cur = 1;
long long cnt_trees;
if (n - l - 2 == -1)
cnt_trees = ((l + 1) * binpow(n, mod - 2)) % mod;
else {
cnt_trees = ((l + 1) * pwn[(n - l - 2)]) % mod;
}
cur *= C(m - 1, l - 1);
cur %= mod;
cur *= pwm[n - 1 - l];
cur %= mod;
cur *= cnt_trees;
cur %= mod;
cur *= fact0[n - 2];
cur %= mod;
cur *= fact_[n - 1 - l];
cur %= mod;
ans += cur;
ans %= mod;
}
cout << ans << '\n';
}
| 4 |
#include <iostream>
#define ll long long
using namespace std;
ll mod=998244353;
const int arm=310000;
ll fac[arm], finv[arm], inv[arm];
void COMinit(ll m){
fac[0]=fac[1]=1;
finv[0]=finv[1]=1;
inv[1]=1;
for (int i=2; i<arm; ++i){
fac[i]=(fac[i-1]*i)%m;
inv[i]=m-(inv[m%i]*(m/i))%m;
finv[i]=(finv[i-1]*inv[i])%m;
}
}
ll COM(ll n, ll k, ll m){
if(n<k) return 0;
if(n<0 || k<0) return 0;
return (fac[n]*((finv[k]*finv[n-k])%m))%m;
}
int main() {
ll N, A, B, K;
cin >> N >> A >> B >> K;
ll ans=0;
COMinit(mod);
for(ll i=0; i<=N && i*A<=K; ++i){
ll j=(K-i*A)/B;
if(i*A+j*B==K && j<=N){
ans=(ans+(COM(N, i, mod)*COM(N, j, mod))%mod)%mod;
}
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long i, j, fldgjdflgjhrthrl, fldggfhfghjdflgjl, fldgjdflgrtyrtyjl,
ffgfldgjdflgjl, n, k, k1, k2, m, y, x;
long long dp[3][5005];
pair<long long, string> a[100500];
vector<pair<long long, string> > f, g;
string s;
long long Abs(long long x) {
if (x < 0) return -x;
return x;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
cin >> n;
for (i = 0; i < n; i++) cin >> a[i].second >> a[i].first;
sort(a, a + n);
for (i = 0; i < n; i++) {
x = a[i].first;
if (x > f.size()) {
cout << -1 << endl;
return 0;
}
for (j = 0; j < x; j++) g.push_back(f[j]);
g.push_back(a[i]);
for (j = x; j < f.size(); j++) g.push_back(f[j]);
f.clear();
for (j = 0; j < g.size(); j++) f.push_back(g[j]);
g.clear();
}
for (i = 0; i < f.size(); i++)
cout << f[i].second << " " << 10000 - f[i].first << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100010;
inline int Read() {
char c = getchar();
int f = 1, x = 0;
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') x = (x << 3) + (x << 1) + c - '0', c = getchar();
return f * x;
}
struct Node {
int sum, rmx;
} f[MAXN << 2];
inline void Up(int rt) {
f[rt].sum = f[rt << 1].sum + f[rt << 1 | 1].sum;
f[rt].rmx = max(f[rt << 1 | 1].rmx, f[rt << 1].rmx + f[rt << 1 | 1].sum);
}
int pos, val;
void Turn(int rt, int l, int r) {
if (l == r) {
f[rt].sum = f[rt].rmx = val;
return;
}
int mid = l + r >> 1;
if (pos <= mid)
Turn(rt << 1, l, mid);
else
Turn(rt << 1 | 1, mid + 1, r);
Up(rt);
return;
}
int n;
int query() {
int nw = 1, l = 1, r = n, sum = 0;
if (f[nw].rmx <= 0) return -1;
while (l != r) {
int mid = l + r >> 1;
if (sum + f[nw << 1 | 1].rmx > 0) {
nw = nw << 1 | 1;
l = mid + 1;
} else {
sum += f[nw << 1 | 1].sum;
nw = nw << 1;
r = mid;
}
}
return l;
}
int a[MAXN];
int main() {
n = Read();
int opt;
for (int i = 1; i <= n; ++i) {
pos = Read();
opt = Read();
if (opt == 0) {
val = -1;
Turn(1, 1, n);
} else {
val = 1;
a[pos] = Read();
Turn(1, 1, n);
}
int Ans = query();
if (Ans == -1)
puts("-1");
else
printf("%d\n", a[Ans]);
}
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
const ll infll = (ll)1e18;
const int N = (int)505;
int n;
ll p_sum_pos[N][N], p_sum_neg[N][N], f[N][N], ans = infll;
ll get_p_sum_pos (int x_1, int x_2, int y_1, int y_2) { return p_sum_pos[x_2][y_2] + p_sum_pos[x_1 - 1][y_1 - 1]
- p_sum_pos[x_2][y_1 - 1] - p_sum_pos[x_1 - 1][y_2]; }
ll get_p_sum_neg (int x_1, int x_2, int y_1, int y_2) { return p_sum_neg[x_2][y_2] + p_sum_neg[x_1 - 1][y_1 - 1]
- p_sum_neg[x_2][y_1 - 1] - p_sum_neg[x_1 - 1][y_2]; }
int main () {
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
// freopen("test.INP", "r", stdin);
cin >> n;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j < i; ++j) cin >> p_sum_pos[i][j];
for (int j = i + 1; j <= n; ++j) cin >> p_sum_neg[i][j];
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
p_sum_neg[i][j] += p_sum_neg[i - 1][j] + p_sum_neg[i][j - 1] - p_sum_neg[i - 1][j - 1];
p_sum_pos[i][j] += p_sum_pos[i - 1][j] + p_sum_pos[i][j - 1] - p_sum_pos[i - 1][j - 1];
}
}
for (int i = 1; i < n; ++i) ans = min(ans, get_p_sum_neg(1, i, 1, i) + get_p_sum_neg(i + 1, n, i + 1, n) );
for (int i = 1; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
f[i][j] = get_p_sum_pos(j + 1, n, 1, i) + get_p_sum_neg(i + 1, j, i + 1, j) + get_p_sum_neg(1, i, 1, i);
}
}
for (int k = 1; k < n; ++k) {
for (int i = k + 1; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
f[i][j] = min(f[i][j], f[k][i] + get_p_sum_pos(j + 1, n, k + 1, i) + get_p_sum_neg(i + 1, j, i + 1, j) );
}
}
}
for (int i = 1; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
ans = min(ans, f[i][j] + get_p_sum_neg(j + 1, n, j + 1, n) );
}
}
cout << ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define int long long int
#define pb emplace_back
#define mp make_pair
#define fi first
#define se second
#define all(v) v.begin(),v.end()
#define run ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);cerr.tie(0);
#define mod 1000000007
#define decimal(n,k) cout<<fixed<<setprecision(k)<<n<<endl
#define LL_MAX LLONG_MAX
#define yes cout<<"YES"<<endl
#define no cout<<"NO"<<endl
#define maxa(v) *max_element(v, v + v.size())
#define mina(v) *min_element(v, v + v.size())
int exp(int x,int y){int res=1;x=x%mod;while(y>0){if(y&1)res=(res*x)%mod;y=y>>1;x=(x*x)%mod;}return res;}
int modinv(int x){return exp(x,mod-2);}
int add(int a,int b){a%=mod,b%=mod;a=((a+b)%mod+mod)%mod;return a;}
int sub(int a,int b){a%=mod,b%=mod;a=((a-b)%mod+mod)%mod;return a;}
int mul(int a,int b){a%=mod,b%=mod;a=((a*b)%mod+mod)%mod;return a;}
int gcd(int a, int b){if (b == 0)return a; return gcd(b, a % b);}
int Log2n( int n){ return (n > 1) ? 1 + Log2n(n / 2) : 0;}
int fac[100009];int ncr_mod(int n,int k){int ans=fac[n];ans*=modinv(fac[k]);ans%=mod;ans*=modinv(fac[n-k]);ans%=mod;return ans;}
vector<int>v_prime;void Sieve(int n){bool prime[n + 1];memset(prime,true,sizeof(prime));for (int p = 2; p*p <=n;p++){if(prime[p] ==true) {for(int i = p*p; i<= n; i += p)prime[i]=false;}}for(int p = 2;p<= n;p++)if (prime[p])v_prime.pb(p);}
vector<int>v_factor;void factors(int n){ for (int i=1; i<=sqrt(n); i++) {if (n%i == 0) {if (n/i == i) v_factor.pb(i);else { v_factor.pb(i),v_factor.pb(n/i);};} } sort(all(v_factor)); }
void out(vector<int>&a){for(int i=0;i<a.size();i++) cout<<a[i]<<" "; cout<<endl;}
// s.top().second;
signed main()
{
run;
/*
open for mod factorial
fac[0]=1;
for(int i=1;i<100009;i++)
{
fac[i]=fac[i-1]*i;
fac[i]%=mod;
}
*/
/*
for sieve open this and use v_prime
int pp=pow(10,6)+100000;
Sieve(pp);
*/
// USE v_factor For calculating factors
int t=1;
cin>>t;
while(t--)
{
// vector< pair <int,int> > vp;
// map<int,int>mp; // x.second-->frequency
// set<int>st;
int n,i,x,y,ok=0,sum=0,ans=0,j,k,cnt=0,m,c=0;
int h[100009]={0};
cin>>n;
string s;
//cin>>s;
vector<int>a(n,0),v,b(n,0),tt(n,0),stand(n,0);
for(i=0;i<n;i++)
{
cin>>a[i]>>b[i];
stand[i]=(b[i]-a[i])/2;
if((b[i]-a[i])%2!=0)
stand[i]++;
}
for(i=0;i<n;i++)
cin>>tt[i];
int fi=tt[0]+a[0];
if(n==1)
{
cout<<fi<<endl;
continue;
}
else
{
int dep=0,fi,pp=a[0];
for(i=0;i<n-1;i++)
{
fi=tt[i]+pp+dep;
x=fi+stand[i];
dep=max(b[i],x);
pp=abs(a[i+1]-b[i]);
}
fi=tt[n-1]+pp+dep;
cout<<fi<<endl;
}
}
}
| 1 |
#include <bits/stdc++.h>
const double eps = 1e-8;
const double PI = acos(-1.0);
using namespace std;
int main() {
int n;
cin >> n;
if (n <= 5)
puts("-1");
else {
for (int i = 2; i <= 4; i++) {
cout << 1 << " " << i << endl;
}
for (int i = 5; i <= n; i++) {
cout << 2 << " " << i << endl;
}
}
for (int i = 2; i <= n; i++) {
cout << 1 << " " << i << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int H1,M1,H2,M2,K;
cin>>H1>>M1>>H2>>M2>>K;
cout<<H2*60+M2-(H1*60+M1)-K<<endl;
}
| 0 |
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main(void) {
int D[1001][1001] = {};
string s1, s2;
cin >> s1 >> s2;
for (int i = 0; i <= s1.length(); i++)
D[i][0] = i;
for (int i = 0; i <= s2.length(); i++)
D[0][i] = i;
for (int i = 1; i <= s1.length(); i++) {
for (int j = 1; j <= s2.length(); j++) {
D[i][j] = min(D[i - 1][j - 1] + ((s1.at(i - 1) != s2.at(j - 1)) ? 1 : 0),
min(D[i - 1][j] + 1, D[i][j - 1] + 1));
}
}
cout << D[s1.length()][s2.length()] << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000;
struct Ans {
int u, v, w;
Ans(int u = 0, int v = 0, int w = 0) : u(u), v(v), w(w) {}
};
int n, m;
vector<int> G[maxn + 5];
int vis[maxn + 5];
vector<Ans> ans;
int dfs(int u, int fa) {
vis[u] = vis[fa] + 1;
vector<int> P;
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
if (vis[v]) {
if (vis[u] < vis[v]) P.push_back(v);
continue;
}
int temp = dfs(v, u);
if (temp)
ans.push_back(Ans(u, v, temp));
else
P.push_back(v);
}
int i;
for (i = 0; i < (int)P.size() - 1; i += 2)
ans.push_back(Ans(P[i], u, P[i + 1]));
if (i == (int)P.size() - 1) return P[(int)P.size() - 1];
return 0;
}
int main() {
while (cin >> n >> m) {
for (int i = 1; i <= n; i++) G[i].clear();
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
ans.clear();
int rest = dfs(1, 0);
if (rest)
printf("No solution\n");
else {
for (int i = 0; i < ans.size(); i++)
printf("%d %d %d\n", ans[i].u, ans[i].v, ans[i].w);
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char ch = getchar();
int res = 0, flag = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') flag = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
res = res * 10 + ch - '0';
ch = getchar();
}
return res * flag;
}
int T, n;
char a[101], b[101];
int main() {
T = read();
while (T--) {
n = read();
scanf("%s%s", a + 1, b + 1);
for (register int i = 1; i <= n; ++i)
if (a[i] == '1' && b[i] == '1') {
puts("NO");
goto over;
}
puts("YES");
over:;
}
return 0;
}
| 1 |
#include <iostream>
#include <string>
using namespace std;
int main(void){
string taro,hanako;
while( cin >> taro >> hanako ){
if( taro == hanako && taro == "0" )break;
int hit = 0;
int blow = 0;
for( int i = 0 ; i < 4 ; i++ ){
for( int j = 0 ; j < 4 ; j++ ){
if( i != j && taro[i] == hanako[j] ){
hit++;
}
if( i == j && taro[i] == hanako[j] ){
blow++;
}
}
}
cout << blow << " " << hit << endl;
}
return 0;
}
| 0 |
#include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
int b = 0, cnt = 0;
for (int i = 0; i < n; ++i) {
int h;
cin >> h;
if (b <= h) cnt++;
b = max(b, h);
}
cout << cnt << endl;
}
| 0 |
#include <bits/stdc++.h>
#define double long double
using namespace std;
const double EPS = 1e-8;
const double INF = 1e9;
struct p3{
double x,y,z,r;
p3(){x=y=z=r=0;}
p3(double x,double y,double z):x(x),y(y),z(z){};
p3(double x,double y,double z,double r):x(x),y(y),z(z),r(r){};
p3 operator + (const p3 a)const {return p3(x+a.x,y+a.y,z+a.z,r);}
p3 operator - (const p3 a)const {return p3(x-a.x,y-a.y,z-a.z,r);}
p3 operator * (const double a)const{return p3(x*a,y*a,z*a,r);}
p3 operator / (const double a)const{return p3(x/a,y/a,z/a,r);}
bool operator == (const p3 a)const {return abs(x-a.x)<EPS&&abs(y-a.y)<EPS&&abs(z-a.z)<EPS;}
double Abs()const{return sqrt(x*x+y*y+z*z);}
double dis(const p3 a)const{return sqrt((a.x-x)*(a.x-x)+(a.y-y)*(a.y-y)+(a.z-z)*(a.z-z));}
};
double dot(p3 a,p3 b){return a.x*b.x+a.y*b.y+a.z*b.z;}
struct L3{
p3 s,t;
L3(){s=t=p3();}
L3(p3 s,p3 t):s(s),t(t){};
bool operator == (const L3 a)const{return s==a.s&&t==a.t;}
};
L3 getRay(L3 a,p3 b){//???b??¨????????????a??????????°????????????????????????????
a.t = a.t-a.s;
b = b-a.s;
p3 e = a.t / a.t.Abs();
p3 s = e*dot(e,b);
double d = s.dis(b);
if(dot(e,b)<EPS||d>b.r+EPS)return L3();
s = e * (s.Abs()-sqrt(b.r*b.r-d*d));
p3 n = (b-s)/(b-s).Abs(); //??????????????????
n = n*dot(a.t*(-1),n)*2;
p3 t = a.t+n+s;
return L3(s+a.s,t+a.s);
}
int n;
vector<p3> A;
p3 calc(L3 ray){
while(1){
double mn = INF;
L3 nray;
for(int i=0;i<n;i++){
L3 res = getRay(ray,A[i]);
if(res==L3())continue;
if(mn>ray.s.dis(res.s)) mn=ray.s.dis(res.s),nray = res;
}
if(mn==INF) return ray.s;
ray = nray;
}
}
int main(){
while(cin>>n,n){
L3 start;
cin>>start.t.x>>start.t.y>>start.t.z;
A.resize(n);
for(int i=0;i<n;i++)cin>>A[i].x>>A[i].y>>A[i].z>>A[i].r;
p3 ans = calc(start);
printf("%Lf %Lf %Lf\n",ans.x,ans.y,ans.z);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 1e5 + 5;
bool mark[MAX_N];
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n - 1; i++) {
int a;
cin >> a;
mark[a - 1] = true;
}
for (int i = 0; i < n; i++)
if (!mark[i]) cout << i + 1;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int d, n, m;
long long res = 0, cur = 0, qe;
pair<int, int> *vp;
int *lix, *q;
scanf("%d %d %d", &d, &n, &m);
vp = new pair<int, int>[m + 2];
for (auto i = 0; i < m; i++) {
scanf("%d %d", &vp[i].first, &vp[i].second);
}
cur = n;
vp[m] = pair<int, int>(d, 0);
vp[m + 1] = pair<int, int>(0, 0);
lix = new int[m + 2]();
q = new int[m + 1]();
qe = 0;
q[qe++] = m + 1;
sort(vp, vp + m + 2);
for (int i = m; i >= 0; i--) {
while (qe && vp[i].second < vp[q[qe - 1]].second) qe--;
lix[i] = q[qe - 1];
q[qe++] = i;
}
for (int i = 1; i < m + 2; i++) {
cur -= vp[i].first - vp[i - 1].first;
if (cur < 0) {
res = -1;
break;
}
if (i < m + 1) {
qe = min(n - cur, vp[lix[i]].first - vp[i].first - cur);
if (qe > 0) {
res += qe * vp[i].second;
cur += qe;
}
}
}
cout << res << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
char a;
cin>>a;
if(a=='a'||a=='e'||a=='i'||a=='o'||a=='u')cout<<"vowel\n";
else cout<<"consonant\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll inf = 1e18;
const int N = 2 * 1e5 + 10;
ll n;
ll res;
ll a[N];
bool ok(ll m) {
ll prev = -inf;
ll can = (1LL << m) - 1;
for (int i = 0; i < n; ++i) {
if (prev > a[i]) {
if (a[i] + can < prev) return 0;
}
prev = max(a[i], prev);
}
return 1;
}
void solve() {
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
ll lo = -1, hi = 40;
while (lo + 1 < hi) {
ll m = lo + hi >> 1LL;
if (ok(m))
hi = m;
else
lo = m;
}
cout << hi << "\n";
}
int main(int argc, char const *argv[]) {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
ll t = 1;
cin >> t;
while (t--) {
solve();
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int num[110];
int main() {
string str;
while (~scanf("%d%d", &n, &k)) {
for (int i = 0; i < n; i++) {
scanf("%d", &num[i]);
}
sort(num, num + n);
printf("%d\n", num[n - k]);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<long long> v(n);
long long sum = 0ll;
for (int i = 0; i < n; i++) {
cin >> v[i];
sum += v[i];
}
long long N = (n * (n + 1)) / 2;
if (sum % N != 0) {
cout << "NO\n";
} else {
vector<long long> ans(n);
sum /= N;
bool flag = true;
for (int i = 1; i < n; i++) {
long long val = v[i - 1] - v[i];
val += sum;
if (val % n == 0 && val > 0)
ans[i] = val / n;
else {
flag = false;
break;
}
}
long long val = 0ll;
for (int i = 1; i < n; i++) val += ans[i];
if ((sum - val) > 0)
ans[0] = (sum - val);
else
flag = false;
if (!flag)
cout << "NO\n";
else {
cout << "YES\n";
for (auto &u : ans) cout << u << " ";
cout << "\n";
}
}
}
return 0;
}
| 5 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.