solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, d;
cin >> n >> d;
vector<std::pair<int, int> > v;
long long m, s;
for (int i = 0; i < (n); ++i) {
cin >> m >> s;
v.push_back(make_pair(m, s));
}
sort(v.begin(), v.end());
long long maxm = v[0].second, sum = 0, prev = v[0].first, index = 0;
for (int i = 1; i <= (n - 1); ++i) {
if (i == 1 && v[i].first - prev < d) {
sum += v[i - 1].second;
maxm = max(sum, maxm);
}
if (v[i].first - prev < d) {
sum += v[i].second;
maxm = max(sum, maxm);
} else {
sum -= v[index].second;
maxm = max(sum, maxm);
index++;
prev = v[index].first;
i--;
}
}
cout << maxm;
}
int main() {
std::ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
t = 1;
while (t--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline long long in() {
long long ret = 0, c = getchar(), b = 1;
while (!isdigit(c)) {
b = c == '-' ? -1 : 1, c = getchar();
}
while (isdigit(c)) {
ret = ret * 10 + c - '0', c = getchar();
}
return ret * b;
}
long long n, p[300005], L[300005], R[300005], cnt[300005], minn[300005],
maxx[300005], ans;
void work(long long *a, long long *b) {
long long la = a[0], lb = b[0], mini = n + 1, maxi = 0;
minn[0] = n + 1;
maxx[0] = 0;
for (long long i = 1; i <= lb; i++) {
minn[i] = min(minn[i - 1], b[i]);
maxx[i] = max(maxx[i - 1], b[i]);
}
long long nl = 1, nr = 1;
for (long long i = 1; i <= la; i++) {
mini = min(mini, a[i]);
maxi = max(maxi, a[i]);
long long len = maxi - mini + 1;
if (len > i && len - i <= lb && minn[len - i] > mini &&
maxx[len - i] < maxi) {
ans++;
}
while (nr <= lb && minn[nr] > mini) {
cnt[maxx[nr] - nr + 1]++;
nr++;
}
while (nl < nr && maxx[nl] < maxi) {
cnt[maxx[nl] - nl + 1]--;
nl++;
}
ans += cnt[i + mini];
}
for (long long i = 1; i <= lb; i++) {
cnt[maxx[i] - i + 1] = 0;
}
}
void erfen(long long l, long long r) {
if (l == r) {
ans++;
return;
}
long long mid = (l + r) >> 1;
L[0] = R[0] = 0;
for (long long i = mid; i >= l; i--) {
L[++L[0]] = p[i];
}
for (long long i = mid + 1; i <= r; i++) {
R[++R[0]] = p[i];
}
work(L, R);
work(R, L);
erfen(l, mid);
erfen(mid + 1, r);
}
signed main() {
n = in();
for (long long i = 1; i <= n; i++) {
long long x = in(), y = in();
p[x] = y;
}
erfen(1, n);
printf("%lld\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<pair<long double, int>> points;
points.reserve(n);
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
long double angle = atan2(y, x);
points.push_back({angle, i});
}
sort(points.begin(), points.end());
long double minAngle = 5;
int a, b;
for (int i = 0; i < n; i++) {
pair<long double, int> p1 = points[i];
pair<long double, int> p2 = points[(i + 1) % n];
long double angle = p2.first - p1.first;
angle = fabs(angle);
if (angle > acos(-1)) {
angle = 2 * acos(-1) - angle;
}
if (angle < minAngle) {
minAngle = angle;
a = p1.second;
b = p2.second;
}
}
cout << a + 1 << " " << b + 1 << '\n';
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline void pisz(int n) { printf("%d\n", n); }
template <typename T, typename TT>
ostream &operator<<(ostream &s, pair<T, TT> t) {
return s << "(" << t.first << "," << t.second << ")";
}
template <typename T>
ostream &operator<<(ostream &s, vector<T> t) {
for (int i = 0; i < ((int)((t).size())); i++) s << t[i] << " ";
return s;
}
int gcd(int a, int b) { return a ? gcd(b % a, a) : b; }
long long gcd(long long a, long long b) { return a ? gcd(b % a, a) : b; }
long long powmod(long long a, long long p, long long m) {
long long r = 1;
while (p) {
if (p & 1) r = r * a % m;
p >>= 1;
a = a * a % m;
}
return r;
}
const int fx[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
int main(int argc, char *argv[]) {
int(n), (k);
scanf("%d %d", &(n), &(k));
;
if (k * n > (n - 1) * n / 2) {
printf("-1\n");
} else {
printf("%d\n", n * k);
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= i + k; j++) {
if (j <= n)
printf("%d %d\n", i, j);
else
printf("%d %d\n", i, j - n);
}
}
}
return EXIT_SUCCESS;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[300005];
int ans[300005];
vector<pair<int, int> > v;
int last = 0;
int n;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
v.push_back(make_pair(a[i], i));
}
sort(v.begin(), v.end());
for (int i = 0; i < n; i++) {
if (v[i].first <= last) {
ans[v[i].second] = last + 1;
last++;
} else {
ans[v[i].second] = v[i].first;
last = v[i].first;
}
}
printf("%d", ans[0]);
for (int i = 1; i < n; i++) printf(" %d", ans[i]);
puts("");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 102, M = 5107;
int p[N], f1[N][M], f2[N][M];
inline void solve(int l, int r, int ql, int qr, int a, int b, bool rev) {
if (l == r) {
p[ql] = l;
return;
}
if (f2[a][b] == 1) {
int g[N];
g[0] = 0;
if (rev == 0)
for (int i = 1; i <= f1[a][b]; i++) g[++g[0]] = i;
if (rev == 1)
for (int i = 1; i <= f1[a][b]; i++) g[++g[0]] = f1[a][b] - i + 1;
int x = a - f1[a][b] + 1, v = l + x - 1;
for (int i = 1; i <= g[0]; i++) {
if (g[i] == 1)
solve(l, v, ql, ql + x - 1, x, b - f1[a][b] * (f1[a][b] + 1) / 2 + 1,
rev ^ 1),
ql += x;
else
solve(v + g[i] - 1, v + g[i] - 1, ql, ql, 1, 0, rev), ql++;
}
}
if (f2[a][b] == 2) {
int g[N];
g[0] = 0;
int x = a - f1[a][b] + 1, v = l + x - 1;
for (int i = 2; i <= f1[a][b]; i += 2) g[++g[0]] = i;
for (int i = 1; i <= f1[a][b]; i += 2) g[++g[0]] = i;
if (g[0] % 2 == 1) swap(g[g[0]], g[g[0] - 1]);
if (rev) {
for (int i = 1; i <= g[0]; i++) g[i] = g[0] - g[i] + 1;
}
for (int i = 1; i <= g[0]; i++) {
if (g[i] == 1)
solve(l, v, ql, ql + x - 1, x, b - f1[a][b], rev ^ 1), ql += x;
else
solve(v + g[i] - 1, v + g[i] - 1, ql, ql, 1, 0, rev), ql++;
}
}
}
int main() {
f1[1][1] = -1;
for (int i = 1; i <= 100; i++)
for (int j = 1; j <= i * (i + 1) / 2; j++)
if (f1[i][j]) {
for (int k = 2; k + i <= 101; k++)
f1[i + k - 1][j + k * (k + 1) / 2 - 1] = k,
f2[i + k - 1]
[j + k * (k + 1) / 2 - 1] = 1;
for (int k = 4; k + i <= 101; k++)
f1[i + k - 1][j + k] = k, f2[i + k - 1][j + k] = 2;
}
int n, m, t;
cin >> t;
while (t--) {
cin >> n >> m;
if (f1[n][m]) {
puts("YES");
solve(1, n, 1, n, n, m, 0);
for (int i = 1; i <= n; i++) printf("%d ", p[i]);
cout << endl;
} else
puts("NO");
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class T1>
void deb(T1 e1) {
cout << e1 << endl;
}
template <class T1, class T2>
void deb(T1 e1, T2 e2) {
cout << e1 << " " << e2 << endl;
}
template <class T1, class T2, class T3>
void deb(T1 e1, T2 e2, T3 e3) {
cout << e1 << " " << e2 << " " << e3 << endl;
}
void check_time() {}
const int res = 2e5 + 10;
const long long int mod = 1e9 + 7;
int main() {
string s, x;
int n, sum = 0, ans = 0;
cin >> s;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
cin >> x;
if (x == s) {
deb("YES");
return 0;
}
if (s[1] == x[0]) {
sum = 1;
}
if (s[0] == x[1]) {
ans = 1;
}
}
cout << ((sum == 1 and ans == 1) ? "YES\n" : "NO\n") << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int dp[(1<<13)+5][2],X,Y,x,o,te;
int C(int x,int y) {return ((x>>y)&1);}
int dq(int tt,int o)
{
if ((tt&X)==X) return 1;
if ((tt&Y)==Y) return 0;
if (dp[tt][o]>-1) return dp[tt][o];
if (o==0)
{
bool kt=false;int kq=0;
for (int i=0;i<13;++i)
if (C(tt,i)==0)
{
if (i<12 && C(tt,i+1) && C(X,i))
{
kt=true;
kq=max(kq,dq(tt+(1<<i),1));
}
if (i>0 && C(tt,i-1) && C(X,i))
{
kt=true;
kq=max(kq,dq(tt+(1<<i),1));
}
}
if (!kt) kq=dq(tt,1);
return dp[tt][o]=kq;
}
else
{
bool kt=false;int kq=1;
for (int i=0;i<13;++i)
if (C(tt,i)==0)
{
if (i<12 && C(tt,i+1) && C(Y,i))
{
kt=true;
kq=min(kq,dq(tt+(1<<i),0));
}
if (i>0 && C(tt,i-1) && C(Y,i))
{
kt=true;
kq=min(kq,dq(tt+(1<<i),0));
}
}
if (!kt) kq=dq(tt,0);
return dp[tt][o]=kq;
}
}
int main()
{
ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
cin>>te;
while (te--)
{
X=0;
memset(dp,-1,sizeof(dp));
for (int i=1;i<=6;++i)
{
cin>>x;
x--;
X+=(1<<x);
}
Y=(1<<13)-1-(1<<6)-X;
if (dq(1<<6,0)==1) cout<<"yes";else cout<<"no";
cout<<'\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:64000000")
using namespace std;
const int INF = ((1 << 31) - 1);
const long long LLINF = (((1LL << 63) - 1LL));
const double eps = 1e-9;
const double PI = 3.14159265358979323846;
const int maxN = 201;
double max_sum[maxN][maxN][maxN];
double calc[maxN][maxN][maxN];
int n;
double p[maxN];
double getMaxSum(int one_year, int len, int ends_with) {
if (one_year > 2 * n) return getMaxSum(2 * n, len, ends_with);
if (len == 0) {
if (one_year == ends_with) return 0.0;
return -1e30;
}
if (calc[one_year][len][ends_with]) return max_sum[one_year][len][ends_with];
double res = -1.0;
for (int to_second_use = 0; to_second_use <= one_year && to_second_use <= n;
++to_second_use) {
res = max(res, p[to_second_use] +
getMaxSum(one_year - to_second_use + (n - to_second_use),
len - 1, ends_with));
}
calc[one_year][len][ends_with] = true;
return max_sum[one_year][len][ends_with] = res;
}
int main() {
cin >> n;
for (int i = 0; i <= n; ++i) scanf("%lf", &p[i]);
double res = 0.0;
for (int len = 1; len <= 2 * n; ++len) {
for (int one_year = 0; one_year <= n; ++one_year) {
res = max(res, getMaxSum(n, len, n) / len);
}
}
printf("%0.18lf\n", res);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 7;
int le[N], ri[N];
long long n, k;
char s[N];
int main() {
scanf("%lld%lld", &n, &k);
scanf("%s", s + 1);
le[1] = s[1] - '0';
for (int i = 2; i <= n; i++) {
if (le[i - 1] != s[i] - '0')
le[i] = 2;
else
le[i] = le[i - 1];
}
ri[n] = s[n] - '0';
for (int i = n - 1; i >= 1; i--) {
if (ri[i + 1] != s[i] - '0')
ri[i] = 2;
else
ri[i] = ri[i + 1];
}
if (n == k || ri[k + 1] != 2 || le[n - k] != 2) {
printf("tokitsukaze\n");
return 0;
}
bool flag = false;
for (int i = 2; i + k <= n; i++) {
if (le[i - 1] == ri[i + k] && le[i - 1] != 2) {
printf("tokitsukaze\n");
return 0;
}
if (le[i - 1] == 2 || ri[i + k] == 2) {
flag = true;
} else if (i - 1 > k || n - (i + k) + 1 > k) {
flag = true;
}
}
if (flag)
printf("once again\n");
else
printf("quailty\n");
}
| 3 |
#include <stdio.h>
#include <algorithm>
using namespace std;
int main(void)
{
char c[5];
int i, j;
int sum[14];
int max, max2;
while (scanf("%d, %d, %d, %d, %d", &c[0], &c[1], &c[2], &c[3], &c[4]) != EOF){
for (i = 0; i < 14; i++){
sum[i] = 0;
}
for (i = 0; i < 5; i++){
sum[c[i]-1]++;
}
max = 0;
max2 = 0;
for (i = 0; i < 14; i++){
if (max < sum[i]){
max = sum[i];
}
else if (max2 < sum[i]){
max2 = sum[i];
}
}
int ch;
for (i = 0; i < 10; i++){
ch = 0;
for (j = 0; j < 5; j++){
if (sum[(i + j) % 13] == 1){
ch++;
}
}
if (ch == 5){
break;
}
}
if (max == 4){
printf("four card\n");
}
else if (max == 3 && max2 == 2){
printf("full house\n");
}
else if (ch == 5){
printf("straight\n");
}
else if (max == 3){
printf("three card\n");
}
else if (max == 2 && max2 == 2){
printf("two pair\n");
}
else if (max == 2){
printf("one pair\n");
}
else {
printf("null\n");
}
}
return (0);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n, s[2000100];
bool vis[2000100];
char t[2000100];
int sa[2000100], rnk[2000100], tmp[2000100], cnt[2000100];
void build(char *s) {
int n = strlen(s) + 1, m = 256;
int *x = rnk, *y = tmp, *z;
for (int i = 0; i < m; i++) cnt[i] = 0;
for (int i = 0; i < n; i++) cnt[x[i] = s[i]]++;
for (int i = 1; i < m; i++) cnt[i] += cnt[i - 1];
for (int i = n - 1; i >= 0; i--) sa[--cnt[x[i]]] = i;
for (int j = 1, p = 1; p < n; j <<= 1, m = p) {
p = 0;
for (int i = n - j; i < n; i++) y[p++] = i;
for (int i = 0; i < n; i++)
if (sa[i] >= j) y[p++] = sa[i] - j;
for (int i = 0; i < m; i++) cnt[i] = 0;
for (int i = 0; i < n; i++) cnt[x[i]]++;
for (int i = 1; i < m; i++) cnt[i] += cnt[i - 1];
for (int i = n - 1; i >= 0; i--) sa[--cnt[x[y[i]]]] = y[i];
z = x, x = y, y = z;
x[sa[0]] = 0, p = 1;
for (int i = 1; i < n; i++)
x[sa[i]] = (y[sa[i]] == y[sa[i - 1]] && y[sa[i] + j] == y[sa[i - 1] + j])
? p - 1
: p++;
}
for (int i = 0; i < n; i++) rnk[sa[i]] = i;
}
int main() {
scanf("%s", t + 1);
n = strlen(t + 1);
int mn = 0;
for (int i = 1; i <= n; i++) {
s[i] = s[i - 1];
if (t[i] == '(')
s[i]++;
else
s[i]--;
mn = min(mn, s[i]);
}
for (int i = 1; i <= n; i++) t[n + i] = t[i], s[i + n] = s[i] + s[n];
int dn = 0;
if (s[n] < 0) dn = -s[n];
build(t + 1);
multiset<int> S;
for (int i = n + 1; i <= 2 * n; i++) S.insert(s[i]);
int k, p = 1e9;
for (int i = n; i >= 0; i--) {
int t = *S.begin();
S.erase(S.find(s[i + n]));
if (t - s[i] + dn >= 0) {
if (rnk[i] < p) p = rnk[i], k = i + 1;
}
S.insert(s[i]);
}
int sum = s[n];
if (sum < 0)
for (int i = sum; i < 0; i++) putchar('(');
for (int i = 0; i < n; i++) putchar(t[k + i]);
if (sum > 0)
for (int i = 0; i < sum; i++) putchar(')');
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 9;
const int MOD = 1e9 + 7;
int R, n, m;
pair<int, int> head[205], tail[205];
int dis[205][205];
int dp[205][205];
int mark[205][205];
bool cycle;
queue<pair<int, int> > q;
int dfs(pair<int, int> v) {
int vh = v.first;
int vt = v.second;
if (vh + vt > R) return 0;
if (mark[vh][vt] == 1) {
cycle = true;
return 0;
}
if (mark[vh][vt] == 2) return dp[vh][vt];
mark[vh][vt] = 1;
for (int i = 1; i <= min(n, vh); i++) {
int ph, pt;
ph = vh - i + head[i].first;
pt = vt + head[i].second;
dp[vh][vt] = max(dp[vh][vt], dfs({ph, pt}) + 1);
}
for (int i = 1; i <= min(m, vt); i++) {
int ph, pt;
ph = vh + tail[i].first;
pt = vt - i + tail[i].second;
dp[vh][vt] = max(dp[vh][vt], dfs({ph, pt}) + 1);
}
mark[vh][vt] = 2;
return dp[vh][vt];
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
memset(dis, -1, sizeof(dis));
int h, t;
cin >> h >> t >> R;
cin >> n;
for (int i = 1; i <= n; i++) cin >> head[i].first >> head[i].second;
cin >> m;
for (int i = 1; i <= m; i++) cin >> tail[i].first >> tail[i].second;
q.push({h, t});
dis[h][t] = 0;
while (!q.empty()) {
int ch = q.front().first, ct = q.front().second;
q.pop();
int cd = dis[ch][ct];
for (int i = 1; i <= min(n, ch); i++) {
int ph, pt;
ph = ch - i + head[i].first;
pt = ct + head[i].second;
if (ph + pt <= R && dis[ph][pt] == -1) {
dis[ph][pt] = cd + 1;
q.push({ph, pt});
}
}
for (int i = 1; i <= min(m, ct); i++) {
int ph, pt;
ph = ch + tail[i].first;
pt = ct - i + tail[i].second;
if (ph + pt <= R && dis[ph][pt] == -1) {
dis[ph][pt] = cd + 1;
q.push({ph, pt});
}
}
}
if (dis[0][0] != -1) return cout << "Ivan\n" << dis[0][0] << "\n", 0;
dfs({h, t});
if (cycle) return cout << "Draw\n", 0;
cout << "Zmey\n" << dp[h][t] << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
int mod = 998244353;
long long fac[2123456], ifac[2123456];
long long powermod(long long a, long long b) {
if (b == 0) return 1;
long long t = powermod(a, b / 2);
t = (t * t) % mod;
if (b % 2 == 1) t = (t * a) % mod;
return t;
}
void prepare() {
fac[0] = 1;
for (int i = 1; i <= 2123456 - 1; ++i) fac[i] = (fac[i - 1] * i) % mod;
ifac[2123456 - 1] = powermod(fac[2123456 - 1], mod - 2);
for (int i = 2123456 - 2; i >= 0; --i)
ifac[i] = (ifac[i + 1] * (i + 1)) % mod;
}
long long cal(int n, int k) {
long long rs = fac[n];
rs = (rs * ifac[k]) % mod;
rs = (rs * ifac[n - k]) % mod;
return rs;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
prepare();
long long rs = fac[n];
for (int i = 1; i <= n - 1; ++i) {
long long x = (cal(n, n - i) * fac[n - i]) % mod;
x = (x * (fac[i] - 1 + mod) % mod) % mod;
rs = (rs + x) % mod;
}
cout << rs;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
int a[600], st;
cin >> n >> k;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
int ans = a[0];
st = 0;
for (int i = 1; i < n; i++) {
if (st >= k) {
cout << ans << endl;
return 0;
}
if (ans > a[i]) {
st++;
} else {
st = 1;
ans = a[i];
}
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0;
char ch = getchar();
bool d = 1;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') d = 0;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
return d ? x : -x;
}
inline void write(long long x) {
if (x < 0) x = -x, putchar('-');
if (x >= 10) write(x / 10);
putchar('0' + x % 10);
}
inline void writeln(long long x) {
write(x);
puts("");
}
inline void writep(long long x) {
write(x);
putchar(' ');
}
inline unsigned long long rnd() {
return ((unsigned long long)rand() << 30 ^ rand()) << 4 | rand() % 4;
}
const int N = 2e5 + 5;
int n, m, head[N], opt;
struct info {
int to, nxt;
} e[N];
vector<long long> v[N];
void add(int x, int y) {
v[y].push_back(x);
e[++opt] = (info){y, head[x]};
head[x] = opt;
}
int q[N], tot, dis[N];
void bfs(int s) {
memset(dis, -1, sizeof(dis));
q[tot = 1] = s;
dis[s] = 0;
for (int o = (int)(1); o <= (int)(tot); o++) {
int u = q[o];
for (int i = head[u]; i; i = e[i].nxt) {
int k = e[i].to;
if (dis[k] == -1) dis[k] = dis[u] + 1, q[++tot] = k;
}
}
}
int a[N];
int main() {
n = read();
m = read();
for (int i = (int)(1); i <= (int)(m); i++) add(read(), read());
int k = read();
for (int i = (int)(1); i <= (int)(k); i++) a[i] = read();
bfs(a[k]);
int mn = 0, mx = 0;
for (int i = (int)(1); i <= (int)(k - 1); i++) {
if (dis[a[i]] == dis[a[i + 1]] + 1) {
int sum = 0;
for (auto x : v[a[i]]) {
if (dis[x] + 1 == dis[a[i]]) {
sum++;
if (sum > 1) break;
}
}
if (sum > 1) mx++;
} else
mn++, mx++;
}
cout << mn << " " << mx;
}
| 2 |
#include <iostream>
#include <algorithm>
#include <vector>
#include <map>
#include <cmath>
using namespace std;
const int N = 50;
const double EPS = 1e-8;
int n;
vector<pair<double, int> > data;
bool equals(double a, double b){ return abs(a - b) < EPS; }
int solve(){
pair<double, double> dist[N];
int round[N], res;
for(int i=0;i<n;i++){
dist[i] = make_pair(0.0, 0.0);
round[i] = 1;
}
for(res=0;;res++){
for(int i=0;i<n;i++) if(data[i].second) goto CONT; break;
CONT:
for(int i=0;i<n;i++){
if(data[i].second == 0) continue;
dist[i] = make_pair(dist[i].second, dist[i].second + data[i].first);
for(int j=0;j<i;j++){
if(data[j].second == 0) continue;
if(round[i] != round[j]) continue;
if(equals(dist[i].first, 0.0) && equals(dist[j].first, 0.0)) continue;
if(!equals(dist[j].first, dist[i].first) && dist[j].first < dist[i].first) continue;
if(!equals(dist[i].first, dist[j].second) && dist[i].first < dist[j].second) dist[i].second = min(dist[i].second, dist[j].second);
}
dist[i].second = min(dist[i].second, 1.0);
if(equals(dist[i].second, 1.0)){
dist[i].second = 0.0;
if(round[i] == 0) data[i].second--;
round[i] = 1 - round[i];
}
}
}
return res;
}
int main(){
while(cin >> n && n){
data.clear();
for(int i=0;i<n;i++){
int a, b;
cin >> a >> b;
data.push_back(make_pair(1.0 / a, b));
}
sort(data.begin(), data.end());
cout << solve() << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long strtoint(string str);
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long b, n = 0, k;
cin >> b >> k;
b %= 2;
for (auto i = 0; i < k; ++i) {
long long x;
cin >> x;
long long tmp = x * pow(b, k - 1 - i);
tmp %= 2;
n += tmp;
}
(n % 2 == 0) ? cout << "even\n" : cout << "odd\n";
return 0;
}
long long strtoint(string str) {
long long x = 0;
stringstream ss;
ss << str;
ss >> x;
return x;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int x,y;cin>>x>>y;
if(x*2<=y && x*4>=y && y%2==0)cout<<"Yes";
else cout<<"No";
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
struct task {
int t, k, d;
int id;
bool operator<(const task& b) const { return t < b.t; }
} p[maxn];
struct sever {
int id, t;
bool operator<(const sever& b) const { return t > b.t; }
sever(int _id, int _t) : id(_id), t(_t) {}
};
struct severv {
int id;
bool operator<(const severv& b) const { return id > b.id; }
severv(int _id) : id(_id) {}
};
int res[maxn];
int main() {
priority_queue<sever> sev;
priority_queue<severv> que;
int n;
scanf("%d", &n);
for (int i = (1); i < (n + 1); i++) que.push(severv(i));
int q;
scanf("%d", &q);
for (int i = (0); i < (q); i++) {
scanf("%d%d%d", &p[i].t, &p[i].k, &p[i].d);
p[i].id = i;
}
sort(p, p + q);
for (int i = (0); i < (q); i++) {
while (!sev.empty()) {
if (sev.top().t < p[i].t) {
que.push(severv(sev.top().id));
sev.pop();
} else
break;
}
if (que.size() >= p[i].k) {
int ans = 0;
for (int j = (0); j < (p[i].k); j++) {
sev.push(sever(que.top().id, p[i].t + p[i].d - 1));
ans += que.top().id;
que.pop();
}
res[p[i].id] = ans;
} else {
res[p[i].id] = -1;
}
}
for (int i = (0); i < (q); i++) printf("%d\n", res[i]);
return 0;
}
| 3 |
#include <iostream>
#include <cstdio>
#include <iomanip>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <bitset>
#include <stack>
#include <utility>
#include <numeric>
#include <algorithm>
#include <functional>
#include <cctype>
#include <complex>
#include <string>
#include <sstream>
#include <fstream>
#include <cassert>
using namespace std;
//common
typedef int i32;
typedef long long i64,ll;
typedef long double ld;
#define BR "\n"
#define ALL(c) (c).begin(),(c).end()
#define REP(i,n) for(int i=0;i<(int)(n);++i)
#define FOR(i,l,r) for(int i=(int)l;i<(int)(r);++i)
#define EACH(it,o) for(auto it = (o).begin(); it != (o).end(); ++it)
#define IN(l,v,r) ((l)<=(v) && (v)<(r))
//config
//#define NDEBUG
//#define INF 1<<30
//#define EPS 1e-8
//const ll MOD =100000007;
//debug
#ifdef NDEBUG
#define DUMP(x)
#define DUMPLN(x)
#define DEBUG(x)
#define DEBUGLN(x)
#define LINE()
#define LINELN()
#define CHECK(exp,act)
#define STOP(e)
#else
#define DUMP(x) cerr << #x << " = " << (x)
#define DUMPLN(x) DUMP(x) <<endl
#define DEBUG(x) DUMP(x) << LINE() << " " << __FILE__
#define DEBUGLN(x) DEBUG(x)<<endl
#define LINE() cerr<< " (L" << __LINE__ << ")"
#define LINELN() LINE()<<endl
#define CHECK(exp,act) if(exp!=act){DUMPLN(exp);DEBUGLN(act);}
#define STOP(e) CHECK(e,true);if(!(e)) exit(1);
#endif
template<class T> inline string toString(const vector<T>& x) {
stringstream ss;
REP(i,x.size()){
if(i!=0)ss<<" ";
ss<< x[i];
}
return ss.str();
}
template<class T> inline string toString(const vector<vector<T> >& map) {
stringstream ss;
REP(i,map.size()){
if(i!=0)ss<<BR;
ss<< toString(map[i]);
}
return ss.str();
}
template<class K,class V> string toString(map<K,V>& x) {
string res;stringstream ss;
for(auto& p:x)ss<< p.first<<":" << p.second<<" ";
return ss.str();
}
string BITtoString(int bit){
stringstream ss;
while(bit!=0){ss<<(bit%2);bit/=2;}
string res=ss.str();reverse(ALL(res));
return res;
}
template<typename T> inline T pmod(T v,T MOD){
return (v%MOD+MOD)%MOD;
}
#define nextInt(n) scanf("%d",&n)
#define defInt(n) int n;nextInt(n)
#define nextLong(n) scanf("%lld",&n)
#define defLong(n) ll n;nextLong(n)
#define nextDouble(n) scanf("%lf",&n)
class Main{
public:
int N;
bool input(){
// ifstream cin("in");
// ofstream cout( "out" );
cin >> N;
return true;
}
void run(){
input();
string pc=")";ll rest=0;
REP(i,N){
string c;ll len;cin >> c >> len;
if(pc=="("){
if(c=="("){
rest+=len;
}else if( c==")"){
rest-=len;
}
}else if(pc==")"){
if(c=="("){
rest+=len;
}else if(c==")"){
rest-=len;
}
}
if(rest<0){
cout <<"NO"<<endl;
return;
}
pc=c;
}
if(rest!=0 || pc!=")"){
cout <<"NO"<<endl;
return;
}
cout <<"YES"<<endl;
}
};
int main(){
//cout <<fixed<<setprecision(3);
//ios::sync_with_stdio(false);
Main().run();
return 0;
} | 0 |
//Try until you reach your goal
#include <bits/stdc++.h>
using namespace std;
# define ll long long
# define endl "\n"
# define str string
# define vll vector<ll>
# define pb push_back
# define mll map<ll,ll>
# define mp make_pair
# define ff first
# define ss second
# define pll pair<ll,ll>
# define f(x,y) for(int x=0;x<y;x++)
int main(){
ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
priority_queue<int,vector<int>,greater<int>>q;
ll x;
cin>>x;
ll a[x];
f(i,x){
cin>>a[i];
}
ll sum=0;
for(ll i=0;i<x;i++){
sum=sum+a[i];
q.push(a[i]);
while(sum<0){
sum-=q.top();
q.pop();
}
}
cout<<q.size();
} | 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int c, v0, v1, a, l;
while (cin >> c >> v0 >> v1 >> a >> l) {
int k = 0, sum = 0, inc = v0;
while (true) {
k++, sum += inc;
if (sum >= c) break;
sum -= l;
inc += a;
if (inc >= v1) inc = v1;
}
cout << k << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long x, long long y) { return y ? gcd(y, x % y) : x; }
int n;
long long p, q, b;
int main() {
scanf("%d", &n);
while (n--) {
scanf("%I64d%I64d%I64d", &p, &q, &b);
q /= gcd(p, q);
while (true) {
b = gcd(q, b);
if (b == 1) {
if (q == 1)
puts("Finite");
else
puts("Infinite");
break;
}
while (q % b == 0) q /= b;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int dap = 0;
int a[200010];
int dp[100010], dp1[100010];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) {
dp[i] = min(dp[i - 1] + 1, a[i]);
}
for (int i = n; i >= 1; i--) dp1[i] = min(dp1[i + 1] + 1, a[i]);
for (int i = 1; i <= n; i++) dap = max(dap, min(dp[i], dp1[i]));
printf("%d", dap);
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
const int N=1e6+5;
int a[N],vis[N];
int main()
{
int n,x;scanf("%d%d",&n,&x);
if(x==1||x==2*n-1){printf("No\n");return 0;}
printf("Yes\n");
if(n==2){printf("1\n2\n3\n");return 0;}
if(x==2*n-2)a[n-1]=x-2,a[n]=x,a[n+1]=x+1,a[n+2]=x-1,vis[x-2]=1;
else a[n-1]=x+2,a[n]=x,a[n+1]=x-1,a[n+2]=x+1,vis[x+2]=1;
vis[x]=vis[x+1]=vis[x-1]=1;
int k=1;
for(int i=1;i<=2*n-1;i++)
{
if(a[i])continue;
while(vis[k])k++;a[i]=k;vis[k]=1;
}
for(int i=1;i<=2*n-1;i++)printf("%d\n",a[i]);
}
| 0 |
#include<cstdio>
#include<vector>
#include<algorithm>
#include<utility>
#include<numeric>
#include<iostream>
#include<array>
#include<string>
#include<sstream>
#include<stack>
#include<queue>
#include<list>
#include<functional>
#define _USE_MATH_DEFINES
#include<math.h>
#include<map>
#define SENTINEL 1000000001
#define min(a,b) ((a)>(b)?(b):(a))
#define max(a,b) ((a)>(b)?(a):(b))
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pll;
bool coverd[5000][5000];
int main() {
vector<int> xl,yl,xs, xe, ys, ye;
xl.reserve(5000);
yl.reserve(5000);
xs.reserve(3000);
xe.reserve(3000);
ys.reserve(3000);
ye.reserve(3000);
int N;
scanf("%d", &N);
for (int i = 0; i < N; i++)
{
int x1, x2, y1, y2;
scanf("%d %d %d %d", &x1, &y1, &x2, &y2);
xl.push_back(x1 + 1000000000);
xl.push_back(x2 + 1000000000);
yl.push_back(y1 + 1000000000);
yl.push_back(y2 + 1000000000);
xs.push_back(x1 + 1000000000);
xe.push_back(x2 + 1000000000);
ys.push_back(y1 + 1000000000);
ye.push_back(y2 + 1000000000);
}
sort(xl.begin(), xl.end());
sort(yl.begin(), yl.end());
xl.erase(unique(xl.begin(), xl.end()), xl.end());
yl.erase(unique(yl.begin(), yl.end()), yl.end());
for (int i = 0; i < N; i++)
{
xs[i] = lower_bound(xl.begin(), xl.end(), xs[i]) - xl.begin();
xe[i] = lower_bound(xl.begin(), xl.end(), xe[i]) - xl.begin();
ys[i] = lower_bound(yl.begin(), yl.end(), ys[i]) - yl.begin();
ye[i] = lower_bound(yl.begin(), yl.end(), ye[i]) - yl.begin();
}
for (int k = 0; k < N; k++)
{
for (int i = xs[k]; i < xe[k]; i++)
{
for (int j = ys[k]; j < ye[k]; j++)
{
coverd[i][j] = true;
}
}
}
ll area = 0;
for (int i = 0; i != (xl.size() - 1); i++)
{
for (int j = 0; j != (yl.size() - 1); j++)
{
if (coverd[i][j])
{
ll x1, x2, y1, y2;
x1 = xl[i + 1]; x2 = xl[i];
y1 = yl[j + 1]; y2 = yl[j];
area += (x1 - x2)*(y1 - y2);
}
}
}
cout << area << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
const long long INF = 1000000000;
int main() {
long long t;
cin >> t;
while (t--) {
long long n, m;
cin >> n >> m;
long long mx = m, mn = m, prev = 0;
bool flag = true;
while (n--) {
long long low, up, k;
cin >> k >> low >> up;
mx += k - prev;
mn -= k - prev;
if (mx < low || mn > up) {
flag = flag && false;
}
mx = min(mx, up);
mn = max(mn, low);
prev = k;
}
if (flag)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MAXN=2e5+10;
int ti[MAXN];
int main(){
int n,t;
while(cin>>n>>t){
for(int i=1;i<=n;i++) cin>>ti[i];
ll sum=0;
sum+=t;
for(int i=2;i<=n;i++){
sum+=min(t,ti[i]-ti[i-1]);
}
cout<<sum<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long fact[20], n, k, anss;
vector<int> vec, vec2;
long long num(int a) {
int j = 0;
for (int i = 31; i >= 0; i--)
if ((a >> i) & 1) {
j = i;
break;
}
long long ans = 0;
for (int i = j - 1; i >= 0; i--) {
ans *= 10;
if ((a >> i) & 1)
ans += 7;
else
ans += 4;
}
return ans;
}
bool lucky(int a) {
while (a > 0) {
if (a % 10 != 4 && a % 10 != 7) return false;
a /= 10;
}
return true;
}
int main() {
fact[0] = 1;
for (long long i = 1; i < 14; i++) fact[i] = fact[i - 1] * i;
cin >> n >> k;
if (n < 14 && k > fact[n]) {
cout << -1 << endl;
return 0;
}
k--;
int j = 1;
while (fact[j] <= k) j++;
j = n - j + 1;
for (int i = j; i <= n; i++) vec.push_back(i);
int Max = n + 1;
for (int i = j; i <= n; i++)
if (lucky(i)) {
Max = i;
break;
}
for (int i = j; i <= n; i++) {
int num = k / fact[n - i];
if (lucky(vec[num]) && lucky(i)) anss++;
k -= num * fact[n - i];
vec2.clear();
for (int i = 0; i < num; i++) vec2.push_back(vec[i]);
for (int i = num + 1; i < (int)vec.size(); i++) vec2.push_back(vec[i]);
vec.clear();
for (int i = 0; i < (int)vec2.size(); i++) vec.push_back(vec2[i]);
}
int a = 2;
while (num(a) < Max) {
anss++;
a++;
}
cout << anss << endl;
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
int n,nw,ans,a[100005];
int main(){
cin>>n;
for(int i=1;i<=n;i++){
cin>>a[i];
if(i>1 && a[i]>a[i-1]){
ans=max(ans,nw);
nw=0;
}
nw++;
}
ans=max(ans,nw);
cout<<ans-1;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
template <class T>
int size(T &&a) {
return (int)(a.size());
}
ostream &operator<<(ostream &os, string str) {
for (char c : str) os << c;
return os;
}
template <class A, class B>
ostream &operator<<(ostream &os, const pair<A, B> &p) {
return os << '(' << p.first << "," << p.second << ')';
}
template <class T>
auto operator<<(ostream &os, T &&x) -> decltype(x.begin(), os) {
os << '{';
for (auto it = x.begin(); it != x.end(); ++it)
os << *it << (it == prev(x.end()) ? "" : " ");
return os << '}';
}
template <class T>
ostream &operator<<(ostream &os, vector<vector<T>> vec) {
for (auto x : vec) os << "\n " << x;
return os;
}
void dump() {}
template <class T, class... Args>
void dump(T &&x, Args... args) {
cerr << x << "; ";
dump(args...);
}
struct Trie {
vector<int> val;
vector<array<int, 2>> nxt;
Trie() {
val.emplace_back(0);
nxt.push_back({-1, -1});
}
void insert(int x) {
int v = 0;
for (int i = 30; i >= 0; --i) {
int b = bool(x & (1 << i));
if (nxt[v][b] == -1) {
nxt[v][b] = size(val);
val.emplace_back(0);
nxt.push_back({-1, -1});
}
v = nxt[v][b];
++val[v];
}
}
int answer(int v = 0) {
if (nxt[v][0] == -1 and nxt[v][1] == -1) return val[v];
array<int, 2> sons;
for (int b = 0; b < (2); ++b) {
if (nxt[v][b] != -1)
sons[b] = answer(nxt[v][b]);
else
sons[b] = 0;
}
return max(sons[0] + min(1, sons[1]), sons[1] + min(1, sons[0]));
}
} trie;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < (n); ++i) {
int a;
cin >> a;
trie.insert(a);
}
cout << n - trie.answer();
}
| 5 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
const long double pi = 3.14159265358979323846;
const long long int inf = (long long int)1ll << 50;
const int ss = (int)1e6 + 3;
const long long int base = inf;
bool pred(const pair<int, int>& i, const pair<int, int>& j) {
if (i.first == j.first) {
return i.second > j.second;
} else {
return i.first > j.first;
}
}
bool pred1(const string& i, const string& j) { return i.size() > j.size(); }
long long int res = 1ll << 62;
int l, r, n, ql, qr;
int w[100005];
int suml[100005];
int sumr[100005];
int main() {
cin >> n >> l >> r >> ql >> qr;
int all = 0;
for (int i = 0; i < n; ++i) {
scanf("%d", &w[i]);
suml[i + 1] = w[i] + suml[i];
all += w[i];
}
for (int i = 0; i <= n; ++i) {
sumr[i] = all - suml[i];
}
for (int i = 0; i <= n; ++i) {
int koll = i;
int kolr = n - i;
long long int now = suml[koll] * 1ll * l + sumr[koll] * 1ll * r;
int kolp = max(abs(koll - kolr) - 1, 0);
if (koll > kolr) {
now += kolp * 1ll * ql;
} else {
now += kolp * 1ll * qr;
}
res = min(res, now);
}
cout << res;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[100010];
int s[100010];
int query(int l, int r) { return s[r] - s[l - 1]; }
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
s[i] = a[i] + s[i - 1];
}
int ans = 0;
for (int i = 1; i < n; i++) {
if (query(1, i) == query(i + 1, n)) {
ans++;
}
}
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f, mod = 1000000007;
const double pi = 3.1415926535897932, eps = 1e-6;
int T, n, k, a[200005], ans, p;
void solve() {
scanf("%d%d", &n, &k);
for (int(i) = (1); (i) <= (n); (i)++) scanf("%d", a + i);
ans = inf;
for (int(i) = (1); (i) <= (n - k); (i)++)
if (ans > a[i + k] - a[i]) ans = a[i + k] - a[i], p = (a[i] + a[i + k]) / 2;
printf("%d\n", p);
}
int main() {
scanf("%d", &T);
while (T--) solve();
return 0;
}
| 3 |
// #pragma GCC optimize("Ofast,unroll-loops")
// #pragma GCC target("avx,avx2,fma")
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ull unsigned long long
#define dd double
#define ld long double
#define sl(n) scanf("%lld", &n)
#define si(n) scanf("%d", &n)
#define sd(n) scanf("%lf", &n)
#define pll pair <ll, ll>
#define pii pair <int, int>
#define mp make_pair
#define pb push_back
#define all(v) v.begin(), v.end()
#define inf (1LL << 61)
#define loop(i, start, stop, inc) for(ll i = start; i <= stop; i += inc)
#define for1(i, stop) for(ll i = 1; i <= stop; ++i)
#define for0(i, stop) for(ll i = 0; i < stop; ++i)
#define rep1(i, start) for(ll i = start; i >= 1; --i)
#define rep0(i, start) for(ll i = (start-1); i >= 0; --i)
#define ms(n, i) memset(n, i, sizeof(n))
#define casep(n) printf("Case %lld:", ++n)
#define pn printf("\n")
#define pf printf
#define EL '\n'
#define fastio std::ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
const ll sz = 2e5 + 10;
vector <int> g[sz];
ll ans;
ll dfs(ll u, ll p)
{
if(g[u].size() == 1 && u != 1)
return 1;
vector <int> cst;
for(int &v : g[u]) {
if(v == p)
continue;
ll ret = dfs(v, u);
cst.pb(ret);
}
sort(all(cst));
ans = max(ans, (ll)cst[0]);
if(cst.size() > 1) {
if(u != 1)
ans = max(ans, cst.back()+1LL);
else
ans = max({ans, (ll)cst.back(), (ll)cst[cst.size()-2]+1});
}
return cst[0] + 1;
}
int main()
{
ll t;
cin >> t;
while(t--) {
ll n; sl(n);
for1(i, n) g[i].clear();
for(ll i = 1; i < n; i++) {
ll u, v;
sl(u), sl(v);
g[u].pb(v);
g[v].pb(u);
}
ans = 0;
dfs(1, -1);
pf("%lld\n", ans);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
//#define DEBUG 1
#define pii pair<int,int>
#define ff first
#define ss second
#define pb push_back
const int N = 2e3+100;
const int D = 10;
char mat[N][N];
int minH[D][N],maxH[D][N],minV[D][N],maxV[D][N];
int64_t ans[D];
int n;
int main(){
ios::sync_with_stdio(false);
int t=1;cin>>t;
while(t--){
cin>>n;
for(int i=0;i<n;i++)
for(int j=0;j<n;j++)
cin>>mat[i][j];
for(int i=0;i<n;i++)
for(int j=0;j<D;j++)
minH[j][i] = maxH[j][i] = minV[j][i] = maxV[j][i] = -1;
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
int d = mat[i][j]-'0';
// cout<<d;
minH[d][i] = ( minH[d][i] == -1 || minH[d][i] > j ) ? j : minH[d][i] ;
maxH[d][i] = ( maxH[d][i] == -1 || maxH[d][i] < j ) ? j : maxH[d][i] ;
minV[d][j] = ( minV[d][j] == -1 || minV[d][j] > i ) ? i : minV[d][j] ;
maxV[d][j] = ( maxV[d][j] == -1 || maxV[d][j] < i ) ? i : maxV[d][j] ;
}
// cout<<endl;
}
for(int i=0;i<D;i++)
ans[i] = 0;
for(int d=0;d<D;d++){
for(int i1=0;i1<n;i1++){
if( maxH[d][i1] == -1 )
continue;
for(int i2=i1+1;i2<n;i2++){
if( maxH[d][i2] == -1 ) continue;
int64_t h = i2-i1;
int64_t dd = max( n-1-min(minH[d][i1],minH[d][i2]), max(maxH[d][i2],maxH[d][i1] )) ;
ans[d] = max(ans[d],h*dd);
}
}
for(int j1=0;j1<n;j1++){
if( maxV[d][j1] == -1 ) continue;
for(int j2=j1+1;j2<n;j2++){
if( maxV[d][j2] == -1 ) continue;
int64_t h = j2-j1;
int64_t dd = max( n-1-min(minV[d][j1],minV[d][j2]), max(maxV[d][j2],maxV[d][j1] )) ;
ans[d] = max(ans[d],h*dd);
}
}
}
for(int d=0;d<D;d++)
cout<<ans[d]<<" " ; cout<<endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct Point {
int x, w;
Point() {}
Point(int _x, int _w) { x = _x, w = _w; }
bool operator<(const Point& other) const { return x - w < other.x - other.w; }
};
Point p[200005];
int dp[200005];
int main() {
int n;
int x, w;
while (cin >> n) {
for (int i = 0; i < n; i++) {
cin >> p[i].x >> p[i].w;
}
sort(p, p + n);
dp[n - 1] = 1;
int ans = 1;
for (int i = n - 2; i >= 0; i--) {
dp[i] = 1;
int j_s = lower_bound(p, p + n, Point(p[i].x + p[i].w, 0)) - p;
dp[i] = max(dp[i], dp[j_s] + 1);
dp[i] = max(dp[i], dp[i + 1]);
}
cout << dp[0] << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300004;
const int maxx = 30 * maxn;
int sz;
int trie[maxx][2], s[maxx];
int a[maxn], p[maxn];
void insert(int n) {
int v = 0;
for (int i = 29; i >= 0; i--) {
int val = (n >> i) & 1;
if (!trie[v][val]) trie[v][val] = ++sz;
v = trie[v][val];
++s[v];
}
}
int query(int n) {
int v = 0;
int res = 0;
for (int i = 29; i >= 0; i--) {
int val = (n >> i) & 1;
if (!s[trie[v][val]]) val ^= 1;
v = trie[v][val];
--s[v];
res = (res << 1) | val;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
for (int i = 0; i < n; ++i) {
cin >> p[i];
insert(p[i]);
}
for (int i = 0; i < n; i++) {
cout << (query(a[i]) ^ a[i]) << ' ';
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 5e3 + 10, mod = 998244353;
long long n;
long long fac[N], ifac[N], a[N], lim[N], dp[N];
inline long long pw(long long x, long long y) {
long long res = 1;
for (; y; x = x * x % mod, y >>= 1)
if (y & 1) res = res * x % mod;
return res;
}
void init() {
fac[0] = 1;
for (long long i = 1; i <= n; i++) fac[i] = fac[i - 1] * i % mod;
ifac[n] = pw(fac[n], mod - 2);
for (long long i = n - 1; i >= 0; i--) ifac[i] = ifac[i + 1] * (i + 1) % mod;
}
long long A(long long x, long long y) {
if (x < 0 || y < 0 || x < y) return 0;
return fac[x] * ifac[x - y] % mod;
}
inline void add(long long &x, long long y) {
x += y;
if (x >= mod) x -= mod;
}
signed main() {
scanf("%lld", &n);
init();
for (long long i = 1; i <= n; i++) scanf("%lld", &a[i]);
sort(a + 1, a + n + 1);
long long ps = 0;
for (long long i = 1; i <= n; i++) {
while (ps + 1 < i && 2 * a[ps + 1] <= a[i]) ps++;
lim[i] = ps;
}
dp[0] = 1, lim[0] = -1;
for (long long i = 1; i <= n; i++) {
for (long long j = 0; j < i; j++)
if (2 * a[j] <= a[i])
add(dp[i], dp[j] * A(n - lim[j] - 2, lim[i] - lim[j] - 1) % mod);
}
if (lim[n] == n - 1)
printf("%lld", dp[n]);
else
printf("0");
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> P;
#define rep(i, n) for (int i = 0; i < n; i++)
#define int long long
signed main(signed argc, char* argv[]) {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n,q;
cin>>n>>q;
vector<int> a(n);
rep(i,n)cin>>a[i];
sort(a.begin(),a.end());
rep(i,q){
int l,r;
cin>>l>>r;
cout<<upper_bound(a.begin(),a.end(),r)-lower_bound(a.begin(),a.end(),l)<<endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double pi = 2 * acos(0);
const long long N = 1e9 + 5;
long long j, t, i, n, x, y;
int main() {
cin >> x;
vector<long long> v(x);
for (int i = 0; i < x; i++) {
cin >> v[i];
}
if (is_sorted(v.begin(), v.end())) {
cout << "yes"
<< "\n"
<< 1 << " " << 1;
return 0;
}
n = 0;
t = 0;
for (int i = 0; i < x; i++) {
if (v[i] > v[i + 1] && t == 0) {
n = i;
t = 1;
} else if ((v[i] < v[i + 1] || i == x - 1) && t == 1) {
y = i;
break;
}
}
sort(v.begin() + n, v.begin() + y + 1);
if (is_sorted(v.begin(), v.end())) {
cout << "yes"
<< "\n"
<< n + 1 << " " << y + 1;
return 0;
}
cout << "no";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename TH>
void _dbg(const char* sdbg, TH h) {
cerr << sdbg << "=" << h << "\n";
}
template <typename TH, typename... TA>
void _dbg(const char* sdbg, TH h, TA... t) {
while (*sdbg != ',') cerr << *sdbg++;
cerr << "=" << h << ",";
_dbg(sdbg + 1, t...);
}
const int maxn = 2e5 + 5;
const int inf = 1e9 + 5;
const int logn = 18;
struct edge {
int u, v, c, id;
} e[maxn];
int res[maxn], n, m, id[maxn];
int lab[maxn];
int finds(int u) { return lab[u] < 0 ? u : lab[u] = finds(lab[u]); }
bool Merge(int u, int v) {
u = finds(u);
v = finds(v);
if (u == v) return 0;
if (lab[u] > lab[v]) swap(u, v);
lab[u] += lab[v];
lab[v] = u;
return 1;
}
void enter() {
cin >> n >> m;
for (int i = 1; i <= m; ++i) {
cin >> e[i].u >> e[i].v >> e[i].c;
e[i].id = i;
}
sort(e + 1, e + m + 1,
[](const edge& x, const edge& y) { return x.c < y.c; });
}
bool inMST[maxn];
vector<int> adj[maxn];
int P[maxn][logn], Max[maxn][logn];
int Min[maxn][logn], h[maxn];
void dfs(int u, int par) {
for (int c : adj[u]) {
int next = e[c].u + e[c].v - u;
if (next == par) continue;
P[next][0] = u;
for (int i = 1; i < logn; ++i) P[next][i] = P[P[next][i - 1]][i - 1];
Max[next][0] = e[c].c;
for (int i = 1; i < logn; ++i) {
Max[next][i] = max(Max[next][i - 1], Max[P[next][i - 1]][i - 1]);
}
h[next] = h[u] + 1;
id[next] = e[c].id;
dfs(next, u);
}
}
int lca(int u, int v) {
if (h[u] < h[v]) swap(u, v);
int k = h[u] - h[v];
for (int i = 0; i < logn; ++i)
if ((k >> i) & 1) u = P[u][i];
if (u == v) return u;
for (int i = logn - 1; i >= 0; --i)
if (P[u][i] != P[v][i]) u = P[u][i], v = P[v][i];
return P[u][0];
}
int queryMax(int u, int v) {
int res = 0;
if (h[u] < h[v]) swap(u, v);
int k = h[u] - h[v];
for (int i = 0; i < logn; ++i)
if ((k >> i) & 1) res = max(res, Max[u][i]), u = P[u][i];
if (u == v) return res;
for (int i = logn - 1; i >= 0; --i)
if (P[u][i] != P[v][i])
res = max(res, Max[u][i]), res = max(res, Max[v][i]), u = P[u][i],
v = P[v][i];
res = max(res, Max[u][0]);
res = max(res, Max[v][0]);
return res;
}
void update(int u, int v, int val) {
int k = h[u] - h[v];
for (int i = 0; i < logn; ++i) {
if ((k >> i) & 1) {
Min[u][i] = min(Min[u][i], val);
u = P[u][i];
}
}
}
void solve() {
fill_n(lab, maxn, -1);
for (int i = 1; i <= m; ++i) {
if (Merge(e[i].u, e[i].v)) {
adj[e[i].u].push_back(i);
adj[e[i].v].push_back(i);
(e[i].u, e[i].v, e[i].c);
inMST[i] = 1;
}
}
dfs(1, -1);
fill_n(&Min[0][0], maxn * logn, inf);
for (int i = 1; i <= m; ++i) {
if (inMST[i] == 0) {
res[e[i].id] = queryMax(e[i].u, e[i].v) - 1;
int LCA = lca(e[i].u, e[i].v);
update(e[i].u, LCA, e[i].c);
update(e[i].v, LCA, e[i].c);
} else
(e[i].id);
}
for (int i = logn - 1; i > 0; --i) {
for (int j = 1; j <= n; ++j) {
Min[j][i - 1] = min(Min[j][i], Min[j][i - 1]);
Min[P[j][i - 1]][i - 1] = min(Min[j][i], Min[P[j][i - 1]][i - 1]);
}
}
for (int j = 2; j <= n; ++j) {
res[id[j]] = Min[j][0] - 1;
}
for (int i = 1; i <= m; ++i) {
if (res[i] > 1e9)
cout << -1 << " ";
else
cout << res[i] << " ";
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
enter();
solve();
}
| 4 |
#include <cstdlib>
#include <cmath>
#include <climits>
#include <cfloat>
#include <map>
#include <utility>
#include <set>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <sstream>
#include <deque>
#include <complex>
#include <stack>
#include <queue>
#include <cstdio>
#include <cctype>
#include <cstring>
#include <ctime>
#include <iterator>
#include <bitset>
#include <numeric>
#include <list>
#include <iomanip>
using namespace std;
typedef long long LL;
typedef pair<int,int> pii;
typedef pair<LL,LL> pll;
typedef vector<int> vint;
typedef vector<vector<int> > vvint;
typedef vector<long long> vll, vLL;
typedef vector<vector<long long> > vvll, vvLL;
#define VV(T) vector<vector< T > >
template <class T>
void initvv(vector<vector<T> > &v, int a, int b, const T &t = T()){
v.assign(a, vector<T>(b, t));
}
template <class F, class T>
void convert(const F &f, T &t){
stringstream ss;
ss << f;
ss >> t;
}
#define REP(i,n) for(int i=0;i<int(n);++i)
#define ALL(v) (v).begin(),(v).end()
#define RALL(v) (v).rbegin(),(v).rend()
#define PB push_back
#define ITR ::iterator
#define MOD 1000000009LL
#define EPS 1e-8
typedef double D;
typedef complex<D> P;
typedef const P &rP;
typedef vector<P> polygon;
typedef const polygon &rpolygon;
typedef pair<D,int> pdi;
inline D dot(rP a, rP b){
return real(a) * real(b) + imag(a) * imag(b);
}
inline D cross(rP a, rP b){
return real(a) * imag(b) - imag(a) * real(b);
}
inline int ccw(rP a, P b, P c) {
b -= a;
c -= a;
D cr = cross(b, c);
if (cr > EPS){ return +1; } // counter clockwise
if (cr < -EPS){ return -1; } // clockwise
if (dot(b, c) < -EPS){ return +2; } // c--a--b on line
if (abs(b) + EPS < abs(c)){ return -2; } // a--b--c on line
return 0;
}
D distanceLP(rP a, rP b, rP c){
return abs(cross(b - a, c - a)) / abs(b - a);
}
D distanceLsP(rP a, rP b, rP c){
if( dot(b - a, c - a) <= 0.0 ) return abs(c - a);
if( dot(a - b, c - b) <= 0.0 ) return abs(c - b);
return distanceLP(a, b, c);
}
bool containsPlgP(rpolygon plg, rP pt){
int cnt = 0;
D y = imag(pt);
for(int i = 0; i < plg.size(); ++i){
int j = (i + 1 == plg.size() ? 0: i + 1);
if( distanceLsP(plg[i], plg[j], pt) <= EPS ){
return true;
}
D dyi = imag(plg[i]) - y;
D dyj = y - imag(plg[j]);
D tx = (dyi * real(plg[j]) + dyj * real(plg[i])) / (dyi + dyj);
if(imag(plg[i]) >= y && imag(plg[j]) < y){
if( tx < real(pt) ) ++cnt;
}
else if(imag(plg[i]) < y && imag(plg[j]) >= y){
if( tx < real(pt) ) ++cnt;
}
}
return (cnt % 2 != 0);
}
D divrat(rP pa1, rP pa2, rP pb1, rP pb2){
P da12 = pa2 - pa1;
P db21 = pb1 - pb2;
P dab1 = pb1 - pa1;
D d = cross(da12, db21);
if(abs(d) > EPS){
D t = cross(dab1, db21) / d;
D s = cross(da12, dab1) / d;
if((-EPS < t && t < 1.0 + EPS) && (-EPS < s && s < 1.0 + EPS)){
return t; //前半は交点が線分1に含まれるか、後半は線分2に含まれるかどうか
}
}
return DBL_MAX;
}
bool containsPlgS(rpolygon plg, rP a, rP b){
int n = plg.size();
vector<D> r(2);
r[1] = 1.0;
P dif = b - a;
for(int i = 0; i < n; ++i){
D t = divrat(a, b, plg[i], plg[(i + 1) % n]);
if(t < DBL_MAX){ r.push_back(t); }
}
sort(ALL(r));
for(int i = 1; i < r.size(); ++i){
if(!containsPlgP(plg, a + 0.5 * (r[i] + r[i - 1]) * dif)){
return false;
}
}
return true;
}
P input(){
D x, y;
scanf("%lf%lf", &x, &y);
return P(x, y);
}
void mirror(rP pl1, rP pl2, P &p){
P d = pl2 - pl1;
d /= abs(d);
P a = pl1 - p;
a -= dot(a, d) * d;
p += 2.0 * a;
}
D solve(int n){
int m;
P ps, pg, pl1, pl2;
vector<polygon> blds(n), plgs;
plgs.reserve(5);
for(int i = 0; i < n; ++i){
scanf("%d", &m);
blds[i].resize(m);
for(int j = 0; j < m; ++j){
blds[i][j] = input();
}
}
ps = input();
pg = input();
pl1 = input();
pl2 = input();
if(ccw(pl1, pl2, ps) == -1){
swap(pl1, pl2);
}
for(int i = 0; i < n; ++i){
if(ccw(pl1, pl2, blds[i][0]) == -1){
for(int j = 0; j < blds[i].size(); ++j){
mirror(pl1, pl2, blds[i][j]);
}
}
if(containsPlgP(blds[i], ps) || containsPlgP(blds[i], pg)){
plgs.push_back(blds[i]);
}
}
if(plgs.size() != 2){ return DBL_MAX; }
vector<P> pts;
pts.push_back(ps);
pts.push_back(pg);
for(int i = 0; i < 2; ++i){
pts.insert(pts.end(), ALL(plgs[i]));
}
vector<vector<pdi> > G(pts.size());
for(int i = 1; i < pts.size(); ++i)
for(int j = 0; j < i; ++j){
bool ok = true;
for(int k = 0; k < 2; ++k){
if(!containsPlgS(plgs[k], pts[i], pts[j])){
ok = false;
break;
}
}
if(ok){
D ds = abs(pts[i] - pts[j]);
G[i].push_back(pdi(ds, j));
G[j].push_back(pdi(ds, i));
}
}
vector<D> d(pts.size(), DBL_MAX);
d[0] = 0.0;
priority_queue<pdi,vector<pdi>,greater<pdi> > pq;
pq.push(pdi());
while(!pq.empty()){
D a = pq.top().first;
int u = pq.top().second;
pq.pop();
if(d[u] != a){ continue; }
for(int i = 0; i < G[u].size(); ++i){
D b = a + G[u][i].first;
int v = G[u][i].second;
if(d[v] > b){
d[v] = b;
pq.push(pdi(b, v));
}
}
}
return d[1];
}
int main(){
int n;
while(scanf("%d", &n), n){
D ans = solve(n);
if(ans < DBL_MAX){
printf("%.15f\n", ans);
}
else{
puts("impossible");
}
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using P = pair<int, int>;
const double eps = 1e-8;
const ll MOD = 1000000007;
const int INF = INT_MAX / 2;
const ll LINF = LLONG_MAX / 2;
template<typename T1, typename T2>
bool chmax(T1 &a, const T2 &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template<typename T1, typename T2>
bool chmin(T1 &a, const T2 &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template<typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> p) {
os << p.first << ":" << p.second;
return os;
}
template<class T>
ostream &operator<<(ostream &os, const vector<T> &v) {
for(int i=0;i<((int)(v.size()));++i) {
if (i) os << " ";
os << v[i];
}
return os;
}
struct Point {
double x, y, z;
Point(double x, double y, double z): x(x), y(y), z(z) {}
};
double operator*(const Point &p1, const Point &p2) {
return p1.x * p2.x + p1.y * p2.y + p1.z * p2.z;
}
Point operator+(const Point &p1, const Point &p2) {
return Point(p1.x + p2.x, p1.y + p2.y, p1.z + p2.z);
}
Point operator-(const Point &p1, const Point &p2) {
return Point(p1.x - p2.x, p1.y - p2.y, p1.z - p2.z);
}
Point operator*(const double &k, const Point &p) {
return Point(k * p.x, k * p.y, k * p.z);
}
double dist2(const Point &p1, const Point &p2) {
return (p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y) + (p1.z - p2.z) * (p1.z - p2.z);
}
bool solve() {
int n, m, R;
cin >> n >> m >> R;
if (n == 0) return false;
vector<Point> s;
vector<double> r(n);
for(int i=0;i<(n);++i) {
double x, y, z, nr; cin >> x >> y >> z >> nr;
s.emplace_back(Point(x, y, z));
r[i] = nr;
}
vector<Point> t;
vector<double> b(m);
for(int i=0;i<(m);++i) {
double x, y, z, nb; cin >> x >> y >> z >> nb;
t.emplace_back(Point(x, y, z));
b[i] = nb;
}
Point e(0, 0, 0);
cin >> e.x >> e.y >> e.z;
vector<bitset<2000>> need(m);
for(int i=0;i<(m);++i) {
for(int j=0;j<(n);++j) {
Point d = t[i] - e;
double k = ((s[j] * d) - (e * d)) / (d * d);
Point x = e + k * d;
bool ok = true;
if(0 < k && k < 1 && dist2(e, s[j]) > r[j] * r[j] && dist2(t[i], s[j]) > r[j] * r[j]) ok &= dist2(x, s[j]) > r[j] * r[j];
ok &= (dist2(e, s[j]) > r[j] * r[j]) == (dist2(t[i], s[j]) > r[j] * r[j]);
need[i][j] = !ok;
}
}
double ma = 0;
for(int i=0;i<(1<<m);++i) {
bitset<2000> now;
for(int j=0;j<(m);++j) {
if((i>>j)&1) now |= need[j];
}
if(now.count() > R) continue;
double val = 0;
for(int j=0;j<(m);++j) {
if((i>>j)&1) {
val += b[j] / dist2(t[j], e);
}
}
chmax(ma, val);
}
cout << ma << endl;
return true;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
while (solve()) {}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long suf(long long a) { return (a * (a + 1)) / 2; }
int dx[]{1, -1, 0, 0};
int dy[]{0, 0, 1, -1};
int dx8[]{1, -1, 0, 0, 1, -1, 1, -1};
int dy8[]{0, 0, 1, -1, 1, -1, -1, 1};
const long long OO = 1e9 + 7;
int main() {
int n;
cin >> n;
string s, ans = "";
cin >> s;
vector<string> v;
int l = 0;
while (l <= 9) {
for (int i = 0; i < s.size(); i++) s[i] = (((s[i] - '0') + 1) % 10 + '0');
string L = "", R = "";
char last = '!';
for (int i = 0; i < s.size(); i++) {
if (s[i] == '0' && last != '0') {
R = s.substr(0, i);
L = s.substr(i, s.size());
L.append(R);
if (ans > L || ans == "") ans = L;
}
last = s[i];
}
l++;
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
#define fastIO ios_base::sync_with_stdio(false); cout.tie(0)
#define endl '\n'
#define FORI(start, end) for(int i = start; i < end; i++)
#define FORJ(start, end) for(int j = start; j < end; j++)
#define FORK(start, end) for(int k = start; k < end; k++)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
void solve(){
int n, m;
cin >> n >> m;
if(n <= m){
cout << "YES"<< endl;
return;
}
string s;
while(n > 0){
string newChar = to_string(n % m);
if(s.find(newChar) != -1){
cout << "NO"<<endl;
return;
}
s += newChar;
n /= m;
}
cout << "YES";
}
int main(){
fastIO;
int t;
// cin >> t;
t = 1;
while(t--){
solve();
}
return 0;
} | 4 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
const int N = 2e5 + 5;
int t, n, k, a[N], b[N], posA[N], posB[N];
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; ++i) {
posA[i] = 0;
posB[i] = 0;
scanf("%d", &a[i]);
}
a[0] = a[n + 1] = 0;
posB[0] = 1e9;
for (int i = 1; i <= n; ++i) posA[a[i]] = i;
for (int i = 1; i <= k; ++i) {
scanf("%d", &b[i]);
posB[b[i]] = i;
}
int ans = 1;
for (int i = 1; i <= k; ++i) {
int j = posA[b[i]];
int c = (posB[a[j - 1]] <= i) + (posB[a[j + 1]] <= i);
ans = (long long)ans * c % mod;
}
printf("%d\n", ans);
}
return 0;
}
| 2 |
#include<iostream>
#include<algorithm>
using namespace std;
#define rep(i,n) for(int i=0; i<n; i++)
int main(){
int N;
while( cin >> N, N ){
int pos[200][2] = {};
for(int i=1; i<N; i++){
int n, d;
cin >> n >> d;
pos[i][0] = pos[n][0];
pos[i][1] = pos[n][1];
pos[i][d%2] += (d<2 ? -1 : 1);
}
int minX=0, maxX=0, minY=0, maxY=0;
for(int i=1; i<N; i++){
if( pos[i][0] > maxX ) maxX = pos[i][0];
if( pos[i][0] < minX ) minX = pos[i][0];
if( pos[i][1] > maxY ) maxY = pos[i][1];
if( pos[i][1] < minY ) minY = pos[i][1];
}
cout << (maxX-minX+1) << " " << (maxY-minY+1) << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int a[5004];
int main() {
ios ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i <= n; i++) {
if (a[a[a[i]]] == i) {
cout << "YES" << endl;
return 0;
}
}
cout << "NO" << endl;
return 0;
}
| 1 |
#include <iostream>
#include <vector>
#include <queue>
using namespace std;
const int MAXN = 2e5 + 10;
bool a[MAXN], dl[MAXN];
int n, m, deg[MAXN][2];
vector<int> Mat[MAXN];
queue<int> del;
void ers(int v) {
for (int i = 0; i < Mat[v].size(); i++) {
if (dl[Mat[v][i]])
continue;
deg[Mat[v][i]][a[v]]--;
if (deg[Mat[v][i]][0] == 0 || deg[Mat[v][i]][1] == 0)
del.push(Mat[v][i]), dl[Mat[v][i]] = true;
}
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
char tmp;
cin >> tmp;
a[i] = (tmp == 'A');
}
for (int i = 0; i < m; i++) {
int v, u;
cin >> v >> u;
Mat[u].push_back(v);
Mat[v].push_back(u);
deg[u][a[v]]++;
deg[v][a[u]]++;
}
for (int i = 1; i <= n; i++)
if (deg[i][0] == 0 || deg[i][1] == 0)
del.push(i), dl[i] = true;
while (!del.empty()) {
ers(del.front());
del.pop();
}
int ans = 0;
for (int i = 1; i <= n; i++)
ans += !dl[i];
if (ans)
cout << "Yes";
else
cout << "No";
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int y, c = 1;
vector<int> a;
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> y;
a.push_back(y);
}
sort(a.begin(), a.end());
for (int i = 0; i < n - 1; i++) {
if (a[i + 1] > a[i] && a[i] != 0) {
c++;
}
}
cout << c;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long int inf = 1e15;
const long long int mod = 1000000007;
const int infInt = 1e9;
const double PI = acos(-1.00);
const double eps = 1e-6;
long long int nCars, nGas, len, Time;
pair<long long int, long long int> cars[200010];
long long int stations[200010];
long long int bb(long long int ini, long long int fin, long long int fuel) {
long long int ans = -1;
long long int dist = fin;
while (ini <= fin) {
long long int mid = (ini + fin) / 2;
if (2LL * mid + (dist - mid) <= fuel) {
ans = mid;
ini = mid + 1;
} else {
fin = mid - 1;
}
}
return ans;
}
bool can(long long int fuel) {
long long int timeSpend = 0;
long long int ant = 0;
for (int i = 0; i < nGas; i++) {
long long int dist = stations[i] - ant;
ant = stations[i];
if (2LL * dist <= fuel) {
timeSpend += dist;
continue;
}
if (dist > fuel) return false;
long long int bestAcc = bb(0, dist, fuel);
timeSpend += bestAcc + 2 * (dist - bestAcc);
}
return (timeSpend <= Time);
}
int main() {
cin.sync_with_stdio(false);
cin.tie(NULL);
long long int maxi = -inf;
cin >> nCars >> nGas >> len >> Time;
for (int i = 0; i < nCars; i++) {
cin >> cars[i].first >> cars[i].second;
maxi = max(maxi, cars[i].second);
}
for (int i = 0; i < nGas; i++) {
cin >> stations[i];
}
sort(stations, stations + nGas);
stations[nGas++] = len;
long long int ini = 0, fin = maxi;
long long int bestFuel = -1;
while (ini <= fin) {
long long int mid = (ini + fin) / 2;
if (can(mid)) {
bestFuel = mid;
fin = mid - 1;
} else {
ini = mid + 1;
}
}
if (bestFuel == -1)
cout << -1 << "\n";
else {
long long int best = inf;
for (int i = 0; i < nCars; i++) {
if (cars[i].second >= bestFuel) {
best = min(best, cars[i].first);
}
}
cout << best << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
#define REP(i, a, n) for (ll i = ((ll) a); i < ((ll) n); i++)
using namespace std;
typedef long long ll;
const ll INF = 1LL << 60;
struct state {
ll v, z, d;
bool operator<(const state &s) const {
return d > s.d;
}
};
int main(void) {
for (ll N, M, C; cin >> N >> M >> C, N && M && C;) {
vector<vector<pair<ll, ll>>> E(N);
REP(i, 0, M) {
ll f, t, c;
cin >> f >> t >> c, f--, t--;
E[f].push_back(make_pair(t, c));
}
vector<vector<ll>> dp(N, vector<ll>(M + 1, INF));
priority_queue<state> q;
q.push((state) { 0, 0, 0 });
while (!q.empty()) {
assert(q.size() > 0);
ll v = q.top().v, z = q.top().z, d = q.top().d;
q.pop();
if (dp[v][z] <= d) continue;
dp[v][z] = d;
REP(i, 0, E[v].size()) {
ll u = E[v][i].first, c = E[v][i].second;
if (d + c < dp[u][z]) {
q.push((state) { u, z, d + c });
}
if (z + 1 <= M && d < dp[u][z + 1]) {
q.push((state) { u, z + 1, d });
}
}
}
ll ans = INF;
REP(i, 0, M + 1) {
if (dp[N - 1][i] <= C) {
ans = min(ans, i);
}
}
cout << ans << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long A[2][2];
long long C[2];
char out[2000000];
int main() {
for (int i = 0; i < (2); ++i)
for (int j = 0; j < (2); ++j) cin >> A[i][j];
for (int i = 0; i < (2); ++i)
while (C[i] * (C[i] - 1) / 2 < A[i][i]) ++C[i];
bool ok = true;
for (int i = 0; i < (2); ++i)
if (C[i] * (C[i] - 1) / 2 != A[i][i]) ok = false;
if (A[0][1] || A[1][0]) {
C[0] = max(C[0], 1LL);
C[1] = max(C[1], 1LL);
}
if (C[0] == 0 && C[1] == 0) C[0] = 1;
if (A[0][1] + A[1][0] != C[0] * C[1]) ok = false;
if (!ok) {
printf("Impossible\n");
return 0;
}
int c = 0;
while (C[0] || C[1]) {
if (!C[0] || A[0][1] < C[1]) {
--C[1];
out[c++] = '1';
continue;
} else {
--C[0];
A[0][1] -= C[1];
out[c++] = '0';
}
}
printf("%s\n", out);
}
| 2 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000000")
using namespace std;
int64_t n, m, k;
int32_t q;
int main() {
scanf("%d\n", &q);
for (int32_t i = (0); i < (q); ++i) {
cin >> n >> m >> k;
auto mn = min(n, m);
auto mx = max(n, m);
if (mx > k) {
printf("%d", -1);
} else if ((mx - mn) % 2 == 0 && mx % 2 != k % 2) {
cout << k - 2;
} else if ((mx - mn) % 2ll == 0) {
cout << k;
} else {
cout << k - 1ll;
}
printf("\n");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> ans;
int idx = 1;
while (n >= idx) {
ans.push_back(idx);
n -= idx;
idx++;
}
ans[ans.size() - 1] += n;
n = 0;
cout << ans.size() << endl;
for (auto x : ans) cout << x << " ";
}
| 1 |
//
// main.cpp
// OrangeMadness
//
// Created by Panagiotis Chadjicostas on 2021/01/2021
// Copyright © 2021 Panagiotis Hadjicostas. All rights reserved.
//
#include <iostream>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <fstream>
#include <iomanip>
#include <iterator>
#include <limits>
#include <list>
#include <cstring>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#include <unordered_map>
using namespace std;
typedef long long ll;
#define fo(i,a,b) for(int i = a; i<=b; i++)
#define f(i,b) for(int i=0;i<b;i++)
#define F first
#define S second
const ll MOD=ll(1e9)+7;
void solve(){
ll w,h,n;cin>>w>>h>>n;
//n--;
ll ans=1;
while(h%2==0){
//n--;
h/=2;
ans*=2;
if(ans>=n){
cout<<"YES"<<endl;
return;
}
}
while (w%2==0)
{
w/=2;
ans*=2;
//n--;
if(ans>=n){
cout<<"YES"<<endl;
return;
}
}
if(ans==n){
cout<<"YES"<<endl;
return;
}
cout<<"NO"<<endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll t;cin>>t;
while (t--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int k;
char M[5][7];
int C[256];
int main() {
scanf("%d", &k);
for (int i = (0); i < (5); ++i) {
scanf("%s", &M[i]);
for (int j = (0); j < (5); ++j) C[M[i][j]]++;
}
for (int i = ('1'); i < ('9' + 1); ++i)
if (C[i] > 2 * k) {
printf("NO\n");
return 0;
}
printf("YES\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[666666];
int n, h, ans = 0;
void upd(int x) {
if (adj[x].size() || ans) return;
printf("? %d\n", x);
fflush(stdout);
int k;
scanf("%d", &k);
if (k == 2) ans = x;
adj[x].resize(k);
for (int i = 0; i < k; i++) scanf("%d", &adj[x][i]);
}
void prt(int x = ans) {
printf("! %d\n", x);
fflush(stdout);
}
int dis[666666], dir[666666], fa[666666];
bool leaf[666666];
int qs[666666];
int fa_1() {
upd(1);
if (adj[1].size() == 2) return 0;
if (adj[1].size() == 1) return adj[1][0];
int l = 1, r = 1, tot = 0;
qs[r++] = 1;
while (l ^ r) {
int x = qs[l++];
if (leaf[dir[x]]) continue;
upd(x);
for (int b : adj[x]) {
if (b == fa[x]) continue;
fa[b] = x;
dis[b] = dis[x] + 1;
if (x == 1)
dir[b] = b;
else
dir[b] = dir[x];
if (!leaf[dir[b]]) {
upd(b);
if (ans) return 233;
if (adj[b].size() == 1) leaf[dir[b]] = 1, ++tot;
if (dis[b] < 3) qs[r++] = b;
}
}
if (tot == 2) break;
}
for (int a : adj[1]) {
if (!leaf[a]) return a;
}
return 0;
}
bool chk(int x, int f, int z) {
upd(x);
if (adj[x].size() == 1) return 0;
if (!z) return 1;
for (int b : adj[x]) {
if (b != f) return chk(b, x, z - 1);
}
}
int ss[666666], sn = 0;
void push(int x, int f, int dep) {
if (!dep) {
ss[++sn] = x;
return;
}
upd(x);
for (auto b : adj[x])
if (b != f) push(b, x, dep - 1);
}
void sol() {
scanf("%d", &h);
n = (1 << h);
ans = 0;
for (int i = 1; i <= n; i++) adj[i].clear();
memset(dis, 0, sizeof(dis));
memset(fa, 0, sizeof(fa));
memset(leaf, 0, sizeof(leaf));
memset(dir, 0, sizeof(dir));
int fa1 = fa_1();
if (ans) {
prt();
return;
}
int dep = 0;
for (int i = 1; i <= n; i++)
if (leaf[dir[i]]) dep = max(dep, dis[i]);
dep = h - dep;
int cur = 1, bk = 1;
if (dep > 3) {
cur = fa1;
while (--dep > 3) {
upd(cur);
vector<int> tmp = adj[cur];
tmp.erase(find(tmp.begin(), tmp.end(), bk));
int fa = tmp[0];
if (!chk(fa, cur, h - dep - 1)) fa = tmp[1];
bk = cur;
cur = fa;
}
}
sn = 0;
push(cur, bk, 2);
for (int i = 1; i < sn; i++) upd(ss[i]);
if (!ans) ans = ss[sn];
prt();
}
int main() {
int T;
scanf("%d", &T);
while (T--) sol();
}
| 6 |
#include<iostream>
#include<cmath>
using namespace std;
int main(){
int A,B,C;
cin>>A>>B>>C;
int K;
cin>>K;
cout<<A+B+C-max(A,max(B,C))+max(A,max(B,C))*pow(2,K);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef struct _Bus {
double v, t;
_Bus(double v, double t) {
this->v = v;
this->t = t;
}
_Bus() {}
} Bus;
int n;
double a, d;
Bus bus[100100];
double getMaxSpeedWhen(Bus b) { return b.v / a; }
double lengthWhenMaxSpeed(Bus b) {
double t = getMaxSpeedWhen(b);
return 0.5f * a * t * t;
}
double timeToArrive(Bus b) {
double t = getMaxSpeedWhen(b);
double length = d - lengthWhenMaxSpeed(b);
if (length <= 0) return sqrt(2.0f * d / a) + b.t;
return length / b.v + t + b.t;
}
int main() {
scanf("%d %lf %lf", &n, &a, &d);
for (int(i) = (0), _n = (n - 1); (i) <= _n; (i)++) {
double v, t;
scanf("%lf %lf", &t, &v);
bus[i] = Bus(v, t);
}
double prevAns = timeToArrive(bus[0]);
for (int(i) = (0), _n = (n - 1); (i) <= _n; (i)++) {
double ans = timeToArrive(bus[i]);
if (prevAns >= ans)
ans = prevAns;
else
prevAns = ans;
printf("%.11lf\n", ans);
}
return 0;
}
| 3 |
#include <cstdio>
#define N 100001
using namespace std;
int a[N], p[N], n, m, r = 0;
int f(int x) { return p[x] = p[x] == x ? x : f(p[x]); }
void u(int x, int y) { p[f(x)] = f(y); }
int main() {
scanf("%d%d", &n, &m);
for(int i = 1; i <= n; i++)
scanf("%d", a + i), p[i] = i;
for(int i = 1, x, y; i <= m; i++)
scanf("%d%d", &x, &y), u(x, y);
for(int i = 1; i <= n; i++)
r += f(i) == f(a[i]);
printf("%d", r);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 3e5 + 5;
long long n, m, arr[N][9], Mask[1 << 8];
pair<long long, long long> ans;
bool cool(long long x) {
memset(Mask, -1, sizeof(Mask));
for (long long i = 0; i < n; i++) {
long long mask = 0;
for (long long w = 0; w < m; w++) {
if (arr[i][w] >= x) {
mask |= (1LL << w);
}
}
Mask[mask] = i;
}
for (long long i = 0; i < (1LL << m); i++) {
for (long long w = 0; w < (1LL << m); w++) {
if (Mask[i] != -1 && Mask[w] != -1) {
long long k = i | w;
if (k == (1LL << m) - 1) {
ans = make_pair(Mask[i] + 1, Mask[w] + 1);
return true;
}
}
}
}
return false;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
for (long long i = 0; i < n; i++) {
for (long long w = 0; w < m; w++) cin >> arr[i][w];
}
long long lo = 0, hi = 1e9, mid;
while (lo <= hi) {
mid = (lo + hi) / 2;
if (cool(mid)) {
lo = mid + 1;
} else
hi = mid - 1;
}
if (ans.first > ans.second) swap(ans.first, ans.second);
cout << (long long)ans.first << " " << (long long)ans.second;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MN = 101010, MVAL = 1010101010;
int dp[MN];
int t[MN];
int main() {
int n, pre, cost, i;
scanf("%d", &n);
for (i = 0; i < n; ++i) scanf("%d", t + i);
for (i = 0; i < n; ++i) dp[i] = MVAL;
for (i = 0; i < n; ++i) {
cost = 20;
if (i != 0) cost += dp[i - 1];
dp[i] = min(dp[i], cost);
pre = lower_bound(t, t + n, t[i] - 90 + 1) - t;
cost = 50;
if (pre != 0) cost += dp[pre - 1];
dp[i] = min(dp[i], cost);
pre = lower_bound(t, t + n, t[i] - 1440 + 1) - t;
cost = 120;
if (pre != 0) cost += dp[pre - 1];
dp[i] = min(dp[i], cost);
}
printf("%d\n", dp[0]);
for (i = 1; i < n; ++i) printf("%d\n", dp[i] - dp[i - 1]);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int a,b,h,m;
cin>>a>>b>>h>>m;
float hour=30.0*h+(m/2.0);
float min=m*6;
float diff=min-hour;
//cout<<diff<<"\n";
cout<<setprecision(12)<<sqrt(a*a+b*b-2*a*b*cos((M_PI*diff)/180.0));
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string x, y, z;
cin >> x;
cin >> z;
for (int i = 0; i < x.size(); ++i) {
if (x[i] == z[i])
y.push_back(x[i]);
else if (z[i] > x[i]) {
cout << -1 << endl;
return 0;
} else
y.push_back(z[i]);
}
cout << y << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int p, n, m, x, y, res = 1, plates[12][12][12];
int solve(int a, int b, int c) {
if (plates[a][b][c] != -2) {
if (plates[a - 1][b][c] == 1) {
res++;
plates[a - 1][b][c] = -1;
}
if (plates[a + 1][b][c] == 1) {
res++;
plates[a + 1][b][c] = -1;
}
if (plates[a][b - 1][c] == 1) {
res++;
plates[a][b - 1][c] = -1;
}
if (plates[a][b + 1][c] == 1) {
res++;
plates[a][b + 1][c] = -1;
}
if (plates[a][b][c - 1] == 1) {
res++;
plates[a][b][c - 1] = -1;
}
if (plates[a][b][c + 1] == 1) {
res++;
plates[a][b][c + 1] = -1;
}
plates[a][b][c] = -2;
if (plates[a - 1][b][c] == -1) solve(a - 1, b, c);
if (plates[a + 1][b][c] == -1) solve(a + 1, b, c);
if (plates[a][b - 1][c] == -1) solve(a, b - 1, c);
if (plates[a][b + 1][c] == -1) solve(a, b + 1, c);
if (plates[a][b][c - 1] == -1) solve(a, b, c - 1);
if (plates[a][b][c + 1] == -1) solve(a, b, c + 1);
return res;
}
}
int main(void) {
char ch;
cin >> p >> n >> m;
for (int i = 1; i <= p; i++)
for (int j = 1; j <= n; j++)
for (int k = 1; k <= m; k++) {
cin >> ch;
(ch == '.') ? plates[i][j][k] = 1 : plates[i][j][k] = 0;
}
cin >> x >> y;
cout << solve(1, x, y) << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
void solve() {
long long n;
cin >> n;
string s;
cin >> s;
long long i = 0, j = n - 1;
long long ans = LLONG_MAX;
bool flag = false;
char x;
while (i < j) {
if (s[i] == s[j]) {
i++;
j--;
continue;
} else {
break;
}
}
if (i >= j) {
cout << 0 << "\n";
return;
}
x = s[i];
long long c = 0;
long long a = i, b = j;
while (i < j) {
if (s[i] == s[j]) {
i++;
j--;
continue;
} else {
if (s[i] == x) {
i++;
c++;
} else if (s[j] == x) {
j--;
c++;
} else {
flag = true;
break;
}
}
}
if (flag) {
ans = -1;
} else {
ans = min(ans, c);
}
i = a;
j = b;
x = s[j];
c = 0;
flag = false;
while (i < j) {
if (s[i] == s[j]) {
i++;
j--;
continue;
} else {
if (s[i] == x) {
i++;
c++;
} else if (s[j] == x) {
j--;
c++;
} else {
flag = true;
break;
}
}
}
if (!flag) {
if (ans == -1) {
ans = c;
} else
ans = min(ans, c);
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 5, maxlen = 5e5 + 5;
const int inf = 3e6 + 5;
int n, x[maxn], y[maxn];
char s[maxlen];
int ansb, ansn;
bool check(int mid, int ty) {
int xmin = 0, xmax = inf, ymin = 0, ymax = inf, dmin = -inf, dmax = inf;
for (int i = 1; i <= n; i++) {
xmin = max(xmin, x[i] - mid);
xmax = min(xmax, x[i] + mid);
ymin = max(ymin, y[i] - mid);
ymax = min(ymax, y[i] + mid);
dmin = max(dmin, x[i] - y[i] - mid);
dmax = min(dmax, x[i] - y[i] + mid);
}
if (xmin > xmax || ymin > ymax || dmin > dmax) return 0;
ymin = max(ymin, xmin - dmax);
ymax = min(ymax, xmax - dmin);
if (ymin > ymax) return 0;
if (ty) {
for (int x = xmin; x <= xmax; x++) {
int rymin = max(ymin, x - dmax), rymax = min(ymax, x - dmin);
if (rymin <= rymax && (x > 0 || rymax > 0)) {
ansb = x, ansn = (x == 0) ? rymax : rymin;
break;
}
}
}
return 1;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%s", s + 1);
int len = strlen(s + 1);
for (int j = 1; j <= len; j++)
if (s[j] == 'B')
x[i]++;
else
y[i]++;
}
int l = 0, r = 2e6;
while (l <= r) {
int mid = (l + r) >> 1;
if (check(mid, 0))
r = mid - 1;
else
l = mid + 1;
}
printf("%d\n", ++r);
check(r, 1);
for (int i = 1; i <= ansb; i++) putchar('B');
for (int i = 1; i <= ansn; i++) putchar('N');
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 1;
void solve() {
int n;
cin >> n;
int l[n], r[n];
int mil = INF, mar = -INF;
for (int i = 0; i < n; i++) {
cin >> l[i] >> r[i];
if (mil > r[i]) mil = r[i];
if (mar < l[i]) mar = l[i];
}
if (mar < mil)
cout << 0;
else
cout << mar - mil;
}
int main() {
int t;
cin >> t;
while (t--) {
solve();
cout << '\n';
}
}
| 1 |
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#define pb push_back
#define rep(i,a,b) for(i=a;i<=b;i++)
using namespace std;
const int N=100010;
int a[N];
int n,K;
int ans;
int dep[N];
vector<int> vec[N];
void dfs(int x){
int i,y;
rep(i,0,(int)vec[x].size()-1){
y=vec[x][i];
dfs(y);
if(dep[y]==K-1&&x!=1) ans++;
else dep[x]=max(dep[x],dep[y]+1);
}
}
int main(){
// freopen("a.in","r",stdin);
// freopen("a.out","w",stdout);
int i;
scanf("%d%d",&n,&K);
rep(i,1,n) scanf("%d",&a[i]);
if(a[1]!=1) ans++;
a[1]=1;
rep(i,2,n) vec[a[i]].pb(i);
dfs(1);
printf("%d",ans);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int tilecnt[1111111];
int dp[2][9][9];
int main(void) {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
int x = 0;
cin >> x;
tilecnt[x]++;
}
int ans = 0;
for (int i = 1; i <= m; i++) {
while (tilecnt[i] > 8) {
ans++;
tilecnt[i] -= 3;
}
}
memset(dp, 0xC0, sizeof(dp));
dp[0][0][0] = 0;
for (int i = 1; i <= m; i++) {
int cur = i % 2;
int last = (i - 1) % 2;
memset(&dp[cur], 0xC0, sizeof(dp[cur]));
for (int l1 = 0; l1 < 9; l1++) {
for (int l2 = 0; l2 < 9; l2++) {
if (dp[last][l1][l2] < 0) continue;
for (int self_consume = 0; self_consume <= tilecnt[i] / 3;
self_consume++) {
int conslim = min({l1, l2, tilecnt[i] - self_consume * 3});
for (int use = 0; use <= conslim; use++) {
int& target =
dp[cur][l2 - use][tilecnt[i] - self_consume * 3 - use];
target = max(target, dp[last][l1][l2] + self_consume + use);
}
}
}
}
}
int maxv = INT32_MIN;
for (int l1 = 0; l1 < 9; l1++) {
for (int l2 = 0; l2 < 9; l2++) {
maxv = max(maxv, dp[m % 2][l1][l2]);
}
}
cout << maxv + ans << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
char A[105][105], str[105];
int n;
void swapp(int a, int b) {
char t[105];
strcpy(t, A[a]);
strcpy(A[a], A[b]);
strcpy(A[b], t);
}
bool isMax(int a, int b) { return (strcmp(A[a], A[b]) > 0); }
void sort() {
int i, j;
for (i = 0; i < n; i++) {
for (j = 0; j < n - i - 1; j++) {
if (isMax(j, j + 1)) swapp(j, j + 1);
}
}
}
int main() {
int i, len;
char t;
scanf(" %s", str);
scanf(" %d", &n);
for (i = 0; i < n; i++) scanf(" %s", A[i]);
sort();
len = strlen(str);
for (i = 0; i < n; i++) {
t = A[i][len];
A[i][len] = '\0';
if (!strcmp(str, A[i])) {
A[i][len] = t;
puts(A[i]);
return 0;
}
}
puts(str);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int N;
vector<int> L, T, R, B;
vector<int> X, Y;
vector<vector<ll>> field;
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
void compress(vector<int> &X){
sort(X.begin(), X.end());
X.erase(unique(X.begin(), X.end()), X.end());
}
void dfs(int x, int y){
ll val = field[x][y];
field[x][y] = -1;
for(int i=0; i<4; i++){
int nx = x + dx[i];
int ny = y + dy[i];
if(0<=nx && nx<X.size() && 0<=ny && ny<Y.size() && field[nx][ny] == val){
dfs(nx, ny);
}
}
}
int main(){
while(cin >> N, N){
L.resize(N); T.resize(N); R.resize(N); B.resize(N);
X.clear(); Y.clear();
for(int i=0; i<N; i++){
cin >> L[i] >> T[i] >> R[i] >> B[i];
for(int j=-1; j<=1; j++){
X.push_back(L[i] + j);
X.push_back(R[i] + j);
Y.push_back(T[i] + j);
Y.push_back(B[i] + j);
}
}
compress(X); compress(Y);
field = vector<vector<ll>>(X.size(), vector<ll>(Y.size()));
for(int i=0; i<X.size(); i++){
for(int j=0; j<Y.size(); j++){
ll t = 0;
for(int k=0; k<N; k++){
if(L[k]<=X[i] && X[i]<R[k] && B[k]<=Y[j] && Y[j]<T[k])
t |= 1LL<<k;
}
field[i][j] = t;
}
}
int ans = 0;
for(int i=0; i<X.size(); i++){
for(int j=0; j<Y.size(); j++) if(field[i][j] >= 0){
dfs(i, j);
ans++;
}
}
cout << ans << endl;
}
return 0;
} | 0 |
#include <iostream>
using namespace std;
int card[50];
int buffer[50];
int main()
{
int n,r;
while(cin>>n>>r,n!=0){
for(int i=0;i<n;i++)card[i]=n-i;
for(int i=0;i<r;i++){
int p,c;
cin>>p>>c;
for(int j=0;j<p-1;j++)
buffer[j]=card[j];
for(int j=0;j<c;j++)
card[j]=card[j+p-1];
for(int j=0;j<p-1;j++)
card[j+c]=buffer[j];
}
cout<<card[0]<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n, k, maxx, idx, max1, s;
int main(int argc, char *argv[]) {
pair<int, int> a[10000];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i].first;
a[i].second = 0;
}
maxx = 0;
max1 = 0;
for (int i = 0; i < n; i++) {
if (a[i].first > maxx) {
max1 = maxx;
maxx = a[i].first;
idx = i;
} else if (max1 < a[i].first)
max1 = a[i].first;
}
cout << idx + 1 << " " << max1 << endl;
return EXIT_SUCCESS;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
#define int long long
int n,m,f[100100],val[100100],s[100100],a,b,ff[100100],d[100100],cnt;
vector<int>v[100100];
inline int sf(int x){return f[x]==x?x:f[x]=sf(f[x]);}
inline void dfs(int x,int fa,int wh){
s[x]=val[x]=wh;ff[x]=fa;
for(int i=0;i<v[x].size();i++)
if(v[x][i]!=fa)dfs(v[x][i],x,-wh),s[x]+=s[v[x][i]];
}
signed main(){
int i,j,k,ans=0;
scanf("%lld%lld",&n,&m);
for(i=1;i<=n;i++)f[i]=i;
for(i=1;i<=m;i++){
int x,y;
scanf("%lld%lld",&x,&y);
if(sf(x)==sf(y))a=x,b=y;
else f[sf(x)]=sf(y),v[x].push_back(y),v[y].push_back(x);
}
if(!a)a=1;dfs(a,0,1);
if(!b){
if(s[a]){puts("-1");return 0;}
for(i=1;i<=n;i++)ans+=abs(s[i]);
printf("%lld\n",ans);return 0;
}
if(val[a]==val[b]){
if(s[a]%2!=0){puts("-1");return 0;}
k=s[a]/2;for(i=b;i;i=ff[i])s[i]-=k;ans=abs(k);
s[a]=0;for(i=1;i<=n;i++)ans+=abs(s[i]);
printf("%lld\n",ans);return 0;
}
if(s[a]){puts("-1");return 0;}
for(i=1;i<=n;i++)ans+=abs(s[i]);
d[++cnt]=0;
for(i=b;i!=a;i=ff[i])d[++cnt]=s[i],ans-=abs(s[i]);
sort(d+1,d+cnt+1);
for(i=1;i<=cnt;i++)ans+=abs(d[i]-d[(cnt+1)/2]);
printf("%lld\n",ans);return 0;
}
| 0 |
#include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
#define lol(i,n) for(int i=0;i<n;i++)
#define mod 1000000007
typedef long long ll;
using namespace std;
ll Pmod(ll n,ll k){
ll r=k,ret=1;
while(true){
if(n==0)break;
if(n%2==1){
ret=ret*r%mod;
}
n/=2;
r=r*r%mod;
}
return ret;
}
vector<pair<ll,ll> > v;
int main(){
ll n,k;
cin>>n>>k;
for(ll i=1;i*i<=n;i++){
if(n%i==0){
v.push_back(make_pair(i,-1));
if(i!=n/i)v.push_back(make_pair(n/i,-1));
}
}
sort(v.begin(),v.end());
ll ans[2]={0,0};
for(int i=0;i<v.size();i++){
ll x=v[i].first;
ll tmp=Pmod((x+1)/2,k);
for(int j=0;j<i;j++){
if(x%v[j].first==0){
tmp=(mod+tmp-v[j].second)%mod;
}
}
v[i].second=tmp;
ans[x%2]+=tmp*x%(mod*(ll)10);
}
//cout<<ans[0]<<" "<<ans[1]<<endl;
cout<<(ans[0]/2+ans[1])%mod<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a[200], b, kol, j, ost, vid;
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d", &b);
if (a[b - 1] == 0) {
vid++;
}
a[b - 1]++;
j++;
}
for (int i = 0; i < 101; i++) {
for (int j = 0; j < 101; j++) {
if (a[j] > a[j + 1]) {
swap(a[j], a[j + 1]);
}
}
}
if (a[101] % m > 0) {
ost = 1;
}
kol = vid * (a[101] / m + ost) * m;
printf("%d", kol - j);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void solve(void) {
int n;
cin >> n;
vector<pair<int, string>> ps(n), ans;
for (auto &p : ps) {
cin >> p.second >> p.first;
}
sort(ps.begin(), ps.end());
int h = 3000;
for (const auto &p : ps) {
auto pos = ans.begin() + p.first;
if (pos > ans.end()) {
cout << -1 << endl;
return;
}
ans.insert(pos, {h--, p.second});
}
for (auto a : ans) {
cout << a.second << ' ' << a.first << '\n';
}
}
int main() {
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long powm(long long base, long long exp, long long mod = 1000000007) {
base %= mod;
long long ans = 1;
while (exp) {
if (exp & 1LL) ans = (ans * base) % mod;
exp >>= 1LL, base = (base * base) % mod;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
int n = s.size();
int z = 0, o = 0, q = 0;
for (auto it : s)
if (it == '0')
z++;
else if (it == '1')
o++;
else
q++;
if (o + 1 <= z + q) cout << "00" << '\n';
if (n % 2 == 0 && o <= n / 2 && z <= n / 2 && s[n - 1] != '0') {
if (s[n - 1] == '1' || o < n / 2) cout << "01" << '\n';
}
if (n % 2 == 1 && o <= (n + 1) / 2 && z <= n / 2 && s[n - 1] != '0') {
if (s[n - 1] == '1' || o < (n + 1) / 2) cout << "01" << '\n';
}
if (n % 2 == 0 && o <= n / 2 && z <= n / 2 && s[n - 1] != '1') {
if (s[n - 1] == '0' || z < n / 2) cout << "10" << '\n';
}
if (n % 2 == 1 && o <= (n + 1) / 2 && z <= n / 2 && s[n - 1] != '1') {
if (s[n - 1] == '0' || z < n / 2) cout << "10" << '\n';
}
if (o + q >= z + 2) cout << "11" << '\n';
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a[100010], i, x, val;
cin >> n >> x;
int cnt[100010] = {0};
int cnt2[100010] = {0};
for (i = 0; i < n; i++) {
cin >> a[i];
cnt[a[i]]++;
}
for (i = 0; i < 100010; i++) {
if (cnt[i] > 1) {
cout << "0\n";
return 0;
}
}
for (i = 0; i < n; i++) {
val = a[i] & x;
if (cnt[val] > 0 && val != a[i]) {
cout << "1\n";
return 0;
}
}
for (i = 0; i < n; i++) {
val = a[i] & x;
cnt2[val]++;
}
for (i = 0; i < 100010; i++) {
if (cnt2[i] > 1) {
cout << "2\n";
return 0;
}
}
cout << "-1\n";
return 0;
}
| 2 |
#define NDEBUG
#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
#include <map>
#include <queue>
#include <set>
#include <tuple>
#include <cassert>
using namespace std;
typedef long long ll;
struct LCTree {
typedef int D;
static const int INF = 1LL<<25;
static const int DF = 1LL<<25;
struct Node;
typedef Node* NP;
static Node last_d;
static NP last;
struct Node {
NP p, l, r;
int sz;
int v, sm, lz;
int lsm, rsm, ma, mv;
bool rev;
Node(D v) :p(NULL), l(last), r(last), sz(1),
v(v), sm(v), lz(DF), rev(false),
lsm(max(v, 0)), rsm(max(v, 0)), ma(max(v, 0)), mv(v) {}
Node(string s) : l(NULL), r(NULL), sz(0), v(-INF), mv(-INF) {}
inline int pos() {
if (p) {
if (p->l == this) return -1;
if (p->r == this) return 1;
}
return 0;
}
void rot() {
NP q = p, qq = q->p;
int qp = q->pos();
if (q->l == this) {
q->l = r; r->p = q;
r = q; q->p = this;
} else {
q->r = l; l->p = q;
l = q; q->p = this;
}
q->update(); update();
p = qq;
if (!qp) return;
if (qp == -1) {
qq->l = this;
} else {
qq->r = this;
}
qq->update();
}
void splay() {
assert(this != last);
supush();
int ps;
while ((ps = pos())) {
int pps = p->pos();
int u = ps*p->pos();
if (!pps) {
rot();
} else if (ps == pps) {
p->rot(); rot();
} else {
rot(); rot();
}
}
}
void expose() {
assert(this != last);
NP u = this;
do {
u->splay();
} while ((u = u->p));
u = last;
u->p = this;
do {
u->p->r = u;
u->p->update();
u = u->p;
} while (u->p);
splay();
}
void push() {
if (rev) {
if (l->sz) {
l->revdata();
}
if (r->sz) {
r->revdata();
}
rev = false;
}
if (lz != DF) {
if (l->sz) {
l->lzdata(lz);
}
if (r->sz) {
r->lzdata(lz);
}
lz = DF;
}
}
void supush() {
if (pos()) {
p->supush();
}
push();
}
void revdata() {
swap(l, r);
swap(lsm, rsm);
rev ^= true;
}
void lzdata(D d) {
v = d;
sm = sz*d;
lsm = rsm = ma = max(0, sm);
mv = d;
lz = d;
}
NP update() {
assert(this != last);
sz = 1+l->sz+r->sz;
sm = v + l->sm + r->sm;
lsm = max(l->lsm, l->sm+v+r->lsm);
rsm = max(r->rsm, r->sm+v+l->rsm);
ma = max(l->ma, r->ma);
ma = max(ma, l->rsm+v+r->lsm);
mv = max(l->mv, r->mv);
mv = max(mv, v);
return this;
}
} *n;
LCTree() : n(last) {}
LCTree(NP n) : n(n) {}
LCTree(D id, D d) : n(new Node(d)) {}
int sz() {
return n->sz;
}
void event() {
n->expose();
n->revdata();
}
void link(LCTree r) {
event();
r.n->expose();
n->p = r.n;
}
void set(int x) {
n->expose();
n->lzdata(x);
}
int get() {
n->expose();
if (n->mv < 0) return n->mv;
return n->ma;
}
};
LCTree::Node LCTree::last_d = LCTree::Node("last");
LCTree::NP LCTree::last = &last_d;
const int MN = 201000;
LCTree tr[MN];
int main() {
int n, q;
scanf("%d %d", &n, &q);
for (int i = 0; i < n; i++) {
int w;
scanf("%d", &w);
tr[i] = LCTree(i, w);
}
for (int i = 0; i < n-1; i++) {
int s, e;
scanf("%d %d", &s, &e); s--; e--;
tr[s].link(tr[e]);
}
for (int i = 0; i < q; i++) {
int t, a, b, c;
scanf("%d %d %d %d", &t, &a, &b, &c); a--; b--;
if (t == 1) {
tr[a].event();
tr[b].set(c);
} else {
tr[a].event();
printf("%d\n", tr[b].get());
}
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 50005;
long long one[19] = {0, 1};
void init() {
for (int i = (2); i <= (16); i++) one[i] = one[i - 1] * 10 + 1;
}
long long dfs(long long sum, long long n) {
if (n == 1) return sum;
long long k1 = sum / one[n];
long long k2 = k1 + 1;
long long r1 = dfs(sum - k1 * one[n], n - 1),
r2 = dfs(k2 * one[n] - sum, n - 1);
return min(k1 * n + r1, k2 * n + r2);
}
long long get(long long n) {
long long ret = 0;
while (n) {
ret++;
n /= 10;
}
return ret;
}
int main() {
init();
long long n;
scanf("%I64d", &n);
printf("%I64d\n", dfs(n, get(n) + 1));
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
bool transp = false;
if (n > m) {
transp = true;
swap(n, m);
}
if (m == 2 or (n != 3 and m == 3))
cout << "NO" << endl;
else {
cout << "YES" << endl;
vector<vector<int> > v(n, vector<int>(m));
if (n == 1 and m != 4) {
for (int i = 1; i <= m; i += 2) v[0][i / 2] = i;
for (int i = 2; i <= m; i += 2) v[0][(m - 1) / 2 + i / 2] = i;
} else {
if (n == 3 and m == 3) {
v[0][0] = 5;
v[0][1] = 3;
v[0][2] = 7;
v[1][0] = 9;
v[1][1] = 4;
v[1][2] = 2;
v[2][0] = 1;
v[2][1] = 6;
v[2][2] = 8;
} else {
if (m == 4 and n == 1) {
v[0][0] = 3;
v[0][1] = 1;
v[0][2] = 4;
v[0][3] = 2;
} else {
if (transp) {
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
v[i][j] = j * n + i + 1;
if (i % 2 == 0) {
v[i][j] += 2 * n;
if (j >= m - 2) v[i][j] -= n * m;
}
}
}
for (int j = 0; j < m; j += 2) {
int a = v[0][j];
for (int i = 0; i < n - 1; ++i) {
v[i][j] = v[i + 1][j];
}
v[n - 1][j] = a;
}
} else {
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
v[i][j] = i * m + j + 1;
if (i % 2 == 0) {
v[i][j] += 2;
if (v[i][j] > i * m + m) v[i][j] -= m;
}
}
}
for (int j = 0; j < m; j += 2) {
int a = v[0][j];
for (int i = 0; i < n - 1; ++i) {
v[i][j] = v[i + 1][j];
}
v[n - 1][j] = a;
}
}
}
}
}
if (transp) {
for (int j = 0; j < m; ++j) {
for (int i = 0; i < n; ++i) {
cout << v[i][j] << " ";
}
cout << endl;
}
} else {
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cout << v[i][j] << " ";
}
cout << endl;
}
}
}
}
| 2 |
#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <cmath>
using namespace std;
inline int read()
{
int f = 1, x = 0;
char ch;
do{
ch = getchar();
if (ch == '-')
f = -1;
}while(ch < '0' || ch > '9');
do{
x = x * 10 + ch - '0';
ch = getchar();
}while(ch >= '0' && ch <= '9');
return f * x;
}
const int N = 100;
const int M = 2e5;
const int mod = 1e9 + 7;
int n, q;
int b[N + 1], c[N + 1], sumc[N + 1];
int f[N + 1][N * N + 1], g[N * N + 1], ans[M + 1];
int sum = 1, l = M / 2, r = M / 2;
inline int dp(int x)
{
memset(f, 0, sizeof(int) * (N + 1));
f[0][0] = 1;
for (int i = 0; i <= N * N; i++)
g[i] = 1;
for (int i = 1; i <= n; i++) {
for (int j = sumc[i]; j >= 0; j--)
f[i][j] = (g[j] - ((j - c[i] > 0)?g[j - c[i] - 1]:0) + mod) % mod;
for (int j = 0; j < x * i + b[i - 1]; j++)
f[i][j] = 0;
g[0] = f[i][0];
for (int j = 1; j <= N * N; j++)
g[j] = (g[j - 1] + f[i][j]) % mod;
}
return g[sumc[n]];
}
int main()
{
n = read();
for (int i = 1; i <= n; i++) {
c[i] = read();
sumc[i] = sumc[i - 1] + c[i];
sum = 1ll * sum * (c[i] + 1) % mod;
}
for (int i = 1; i < n; i++)
b[i] = b[i - 1] + read();
for (int i = 1; i < n; i++)
b[i] += b[i - 1];
q = read();
for (int i = 1; i <= n; i++) {
l = min(l, (int)ceil(-b[i - 1] / i));
r = min(r, (int)floor((sumc[i] - b[i - 1]) / i));
}
l = max(l, -M / 2);
for (int i = l; i <= r; i++)
ans[i + M / 2] = dp(i);
for (int i = 1; i <= q; i++) {
int x = read();
printf("%d\n", x < l?sum:(x > r?0:ans[x + M / 2]));
}
return 0;
}
| 3 |
#include "bits/stdc++.h"
using namespace std;
#define long int64_t
struct Solver {
void solve() {
unsigned x;
cin >> x;
bitset<32> b( x );
cout << b << '\n'
<< ~b << '\n'
<< (b << 1) << '\n'
<< (b >> 1) << endl;
}
};
int main() {
ios::sync_with_stdio( false );
cout << fixed << setprecision( 10 );
Solver().solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
const long long MAXN = 2e5 + 100;
const long long MOD = 1000000007;
struct ele {
long long pos, ty;
bool operator<(const ele &a) const { return pos < a.pos; }
} ax[MAXN];
int main(int argc, char const *argv[]) {
long long a[2], b[2], c[2];
a[0] = b[0] = c[0] = INF * 1;
a[1] = b[1] = c[1] = INF * -1;
long long n, idx = 0;
scanf("%lld", &n);
for (int i = 0; i < n; ++i) {
char type[3];
long long pos;
scanf("%lld %s", &pos, type);
ax[idx].pos = pos;
if (type[0] == 'B') {
a[0] = min(a[0], pos);
a[1] = max(a[1], pos);
ax[idx++].ty = 0;
} else if (type[0] == 'R') {
b[0] = min(b[0], pos);
b[1] = max(b[1], pos);
ax[idx++].ty = 1;
} else {
c[0] = min(c[0], pos);
c[1] = max(c[1], pos);
ax[idx++].ty = 2;
}
}
long long ans = 0;
bool sp = 0;
if (c[0] == INF) {
sp = 1;
ans = max(0ll, a[1] - a[0ll]) + max(0ll, b[1] - b[0ll]);
}
if (sp) {
cout << ans << endl;
return 0;
}
ans += max(0ll, c[0ll] - a[0ll]) + max(0ll, c[0ll] - b[0ll]) +
max(0ll, a[1] - c[1]) + max(0ll, b[1] - c[1]);
long long last[2];
long long lastc;
long long bg[2];
sort(ax, ax + n);
for (int i = 0; i < n; ++i) {
if (ax[i].pos < c[0]) continue;
if (ax[i].pos > c[1]) {
break;
}
if (ax[i].pos == c[0]) {
last[0] = last[1] = lastc = i;
bg[0] = bg[1] = 0;
}
for (int j = 0; j < 2; ++j) bg[j] = max(bg[j], ax[i].pos - ax[last[j]].pos);
if (ax[i].ty < 2) last[ax[i].ty] = i;
if (ax[i].ty == 2) {
long long len = ax[i].pos - ax[lastc].pos;
ans += min(len * 2, len * 3 - bg[0] - bg[1]);
last[0] = last[1] = lastc = i;
bg[0] = bg[1] = 0;
}
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string s;
cin >> n >> s;
map<pair<string, string>, long> m;
for (int i = 0; i < 1 << n; i++) {
string t1, t2;
for (int j = 0; j < n; j++) {
if (i & 1 << j) t1 += s[j];
else t2 += s[j];
}
m[make_pair(t1, t2)]++;
}
long r = 0;
for (int i = 0; i < 1 << n; i++) {
string t1, t2;
for (int j = 0; j < n; j++) {
if (i & 1 << j) t1 += s[n * 2 - j - 1];
else t2 += s[n * 2 - j - 1];
}
auto it = m.find(make_pair(t2, t1));
if (it != m.end())
r += it->second;
}
cout << r << endl;
return 0;
}
| 0 |
// In the name of God
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
vector<int> pt(3);
int n;
cin >> n >> pt[0] >> pt[1] >> pt[2];
vector<pair<int,int>> q;
for(int i = 0; i < n; i++) {
string s;
cin >> s;
if(s == "AB") q.push_back(make_pair(0, 1));
if(s == "AC") q.push_back(make_pair(0, 2));
if(s == "BC") q.push_back(make_pair(1, 2));
}
vector<int> ans;
for(int i = 0; i < n; i++) {
int p1 = q[i].first, p2 = q[i].second;
if(pt[p1] == 0 && pt[p2] == 0) {
cout << "No";
exit(0);
}
if(pt[p1] == pt[p2]) {
if(i != n-1 && (p1 == q[i+1].first || p1 == q[i+1].second)) {
pt[p1]++;
pt[p2]--;
ans.push_back(p1);
}
else {
pt[p2]++;
pt[p1]--;
ans.push_back(p2);
}
}
else {
if(pt[p1] > pt[p2]) {
pt[p2]++;
pt[p1]--;
ans.push_back(p2);
}
else {
pt[p1]++;
pt[p2]--;
ans.push_back(p1);
}
}
}
cout << "Yes\n";
for(int x : ans) {
if(x == 0) cout << "A\n";
if(x == 1) cout << "B\n";
if(x == 2) cout << "C\n";
}
return 0;
}
| 0 |
#include<iostream>
#include<sstream>
#include<fstream>
#include<string>
#include<vector>
#include<deque>
#include<queue>
#include<stack>
#include<set>
#include<map>
#include<algorithm>
#include<functional>
#include<utility>
#include<bitset>
#include<cmath>
#include<cstdlib>
#include<ctime>
#include<cstdio>
using namespace std;
#define REP(i,n) for(int i=0;i<int(n);i++)
#define foreach(c,itr) for(__typeof((c).begin()) itr=(c).begin();itr!=(c).end();itr++)
typedef pair<int,int> P;
typedef long long ll;
int main(void){
string x;
ll a;
cin >> x >> a;
int n=x.size();
ll lr=x[0]-'0';
int i;
for(i=1;i<n;i+=2){
if(x[i]=='+') lr+=x[i+1]-'0';
if(x[i]=='*') lr*=x[i+1]-'0';
}
ll mf=0,q=1;
if(n==1){
if(a==x[0]-'0') cout << "U" << endl;
else cout << "I" << endl;
return 0;
}
for(i=0;i<n;i+=2){
if(i!=0 && i!=n-1) if(x[i-1]=='*' && x[i+1]=='*') q*=x[i]-'0';
if((i==0 && x[i+1]=='*') || (x[i-1]=='+' && x[i+1]=='*')) q*=x[i]-'0';
if((i==n-1 && x[i-1]=='*') || (x[i-1]=='*' && x[i+1]=='+')){
q*=x[i]-'0'; mf+=q; q=1;
}
if(i!=0 && i!=n-1) if(x[i-1]=='+' && x[i+1]=='+') mf+=x[i]-'0';
if(i==0) if(x[i+1]=='+') mf+=x[i]-'0';
if(i==n-1) if(x[i-1]=='+') mf+=x[i]-'0';
}
if(lr==mf && lr==a) cout << "U" << endl;
else if(mf==a) cout << "M" << endl;
else if(lr==a) cout << "L" << endl;
else cout << "I" << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long a[5][200005];
long long fact[200005];
long long POW(long long b, long long p) {
if (p == 0LL) {
return 1LL;
}
long long x = POW(b, p / 2);
x *= x;
x %= 1000000007;
if (p % 2) {
x *= b;
x %= 1000000007;
}
return x;
}
long long INV(long long x) { return POW(x, 1000000007 - 2); }
long long ncr(long long n, long long r) {
long long x = fact[n] * INV(fact[r]);
x %= 1000000007;
x *= INV(fact[n - r]);
x %= 1000000007;
return x;
}
int main() {
fact[0] = fact[1] = 1LL;
for (long long i = 2; i <= 200000; i++) {
fact[i] = fact[i - 1] * i % 1000000007;
}
int n;
scanf("%d", &n);
n--;
int m = n / 4 * 2;
int s = m * 2;
for (int i = 0, j = 0; i <= s; i += 2, j++) {
a[0][i] = ncr(m, j);
}
for (int i = 1, j = s + 1; i < 4; i++, j++) {
for (int k = 0; k <= j; k++) {
if (i == 2 && k % 2 == 0) {
a[i][k] = (k == 0 ? 0 : -a[i - 1][k - 1]) + a[i - 1][k];
} else if (i == 3 && k % 2 == 1) {
a[i][k] = (k == 0 ? 0 : a[i - 1][k - 1]) - a[i - 1][k];
} else {
a[i][k] = (k == 0 ? 0 : a[i - 1][k - 1]) + a[i - 1][k];
}
a[i][k] = (a[i][k] + 1000000007) % 1000000007;
}
}
long long y, ans = 0;
for (int i = 0; i <= n; i++) {
scanf("%lld", &y);
ans += y * a[n - s][i];
ans %= 1000000007;
}
printf("%lld\n", ans);
return 0;
}
| 2 |
#include<iostream>
using namespace std;
int main()
{
long long n,d;
cin>>n>>d;
int counter=0;
while(n--)
{
long long x,y;
cin>>x>>y;
if(x*x+y*y<=d*d)
counter++;
}
cout<<counter<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
int n;
int dis[605][2];
int dp[605][605];
int pre[605][605];
void print(int a, int b) {
if (a == b) {
printf("()");
return;
}
if (dp[a][b] == 2) {
printf("(");
print(a + 1, b);
printf(")");
} else if (dp[a][b] == 1) {
print(a, pre[a][b]);
print(pre[a][b] + 1, b);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d%d", &dis[i][0], &dis[i][1]);
memset(dp, -1, sizeof(dp));
memset(pre, -1, sizeof(pre));
for (int i = 1; i <= n; i++) {
if (1 >= dis[i][0] && 1 <= dis[i][1]) {
dp[i][i] = 1;
pre[i][i] = i;
}
}
for (int len = 2; len <= n; len++) {
for (int i = 1; i + len - 1 <= n; i++) {
int j = i + len - 1;
if (dp[i + 1][j] >= 0 && (j - i) * 2 >= dis[i][0] - 1 &&
(j - i) * 2 <= dis[i][1] - 1) {
dp[i][j] = 2;
pre[i][j] = 0;
continue;
}
for (int k = i; k <= j; k++) {
if (dp[i][k] >= 0 && dp[k + 1][j] >= 0) {
dp[i][j] = 1;
pre[i][j] = k;
break;
}
}
}
}
if (dp[1][n] == -1)
printf("IMPOSSIBLE\n");
else
print(1, n);
return 0;
}
| 5 |
#include<cstdio>
#include<algorithm>
#include<queue>
#include<cstring>
#include<iostream>
#include<cstdio>
#include<cstdio>
using namespace std;
#define N 1000000
#define INF 0x3f3f3f3f
#define MOD 998244353
#define LL long long
int rd()
{
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<<3)+(x<<1)+(c^48); c=getchar();}
return f*x;
}
int n,m;
LL fac[N+5],inv[N+5];
LL ksm(LL a,LL b)
{
LL res=1;
while(b)
{
if(b&1) res=res*a%MOD;
a=a*a%MOD;
b>>=1;
}
return res;
}
void Init()
{
fac[0]=1;
for(int i=1;i<=N;i++)
fac[i]=fac[i-1]*i%MOD;
inv[N]=ksm(fac[N],MOD-2);
for(int i=N-1;i>=0;i--)
inv[i]=inv[i+1]*(i+1)%MOD;
}
LL c(int a,int b)
{
return fac[a]*inv[b]%MOD*inv[a-b]%MOD;
}
int main()
{
Init();
n=rd(),m=rd();
if(n<m) swap(n,m);
LL ans=0;
for(int i=1;i<=m;i++)
ans=(ans+c(n-i+m-i,m-i)*c(2*i,i)%MOD)%MOD;
ans=ans*ksm(2ll/*1/2的贡献*/*c(n+m,m)%MOD,MOD-2)%MOD;
ans=(ans+n)%MOD;
printf("%lld\n",ans);
return 0;
} | 0 |
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <set>
#include <map>
#include <cmath>
#include <queue>
#include <iomanip>
#include <bitset>
#include <stack>
#include <memory.h>
#include <list>
#include <numeric>
#include <functional>
#include <complex>
#include <cassert>
#include <regex>
#include <random>
#include <fstream>
#include <ctime>
using ll = long long;
using LL = long long;
#define ld long double
#define ull unsigned ll
#define mp(xx, yy) make_pair(xx, yy)
#define all(x) (x).begin(),(x).end()
#define rall(x) (x).rbegin(),(x).rend()
#define pii pair<int,int>
#define pll pair<ll, ll>
#define vi vector<int>
#define vll vector<ll>
#define vpii vector<pii>
#define vpll vector<pll>
#define vvll vector<vector<ll>>
#define vvi vector<vector<int>>
#define forn(i,n) for (int i=0;i<n;i++)
#define foran(i,a,n) for (int i=a;i<n;i++)
//#define endl '\n'
ld pi = acos(-1.0);
const int mod = 1e9 + 7;
using namespace std;
ll gcd(ll a, ll b) {
return b ? gcd(b, a % b) : a;
}
LL lcm(LL a, LL b) {
return (a * b / gcd(a, b));
}
LL binpow(LL a, LL n) {
ll res = 1;
while (n)
if (n & 1ll) {
res = (res * a) % mod;
--n;
}
else {
a = (a * a) % mod;
n >>= 1ll;
}
return res;
}
void solve()
{
ll n,x,t;
cin >> n >> x >> t;
ll kol = min(t / x,(n-1));// колчество которые начнут;
// if (kol * x == t)
//kol--;
ll norm = (n - kol)*kol;
ll ost = (kol) * (kol - 1)/2;
cout << ost + norm << "\n";
}
int main() {
#ifdef _DEBUG
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#else
//freopen("longpath.in", "r", stdin);
//freopen("longpath.out", "w", stdout);
#endif
ios::sync_with_stdio(0);
cin.tie(0); cout.tie(0);
ll t = 1;
cin >> t;
while (t--)
solve();
return 0;
} | 1 |
#define _USE_MATH_DEFINES
#define INF 0x3f3f3f3f
#include <cstdio>
#include <iostream>
#include <sstream>
#include <cmath>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <stack>
#include <limits>
#include <map>
#include <string>
#include <cstring>
#include <set>
#include <deque>
#include <bitset>
#include <list>
#include <cctype>
#include <utility>
using namespace std;
typedef long long ll;
typedef pair <int,int> P;
typedef pair <int,P > PP;
int tx[] = {0,1,0,-1};
int ty[] = {-1,0,1,0};
static const double EPS = 1e-8;
bool check_sequence(const string& command){
for(int i=0;i+1<command.size();i++){
if(command[i] == command[i+1]) return false;
}
return true;
}
bool check_cross(int lpos,int rpos){
if(lpos == -1 || rpos == -1) return true;
if(lpos !=0 && lpos < rpos) return false;
if(lpos == 0 && rpos == 3) return false;
return true;
}
int compute_pos(char dir){
int pos = 0;
if(dir == 'U'){
pos = 0;
}
else if(dir == 'R'){
pos= 1;
}
else if(dir == 'D'){
pos = 2;
}
else if(dir == 'L'){
pos = 3;
}
return pos;
}
int main(){
int N;
while(~scanf("%d",&N)){
for(int i = 0; i < N; i++){
bool isok = true;
string command;
cin >> command;
int lpos = -1;
int rpos = -1;
int flag = 0;
if(!check_sequence(command)){
isok = false;
goto gameover;
}
for(int command_i = 0; command_i < command.size(); command_i++){
if(command_i % 2 == 1) {
lpos = compute_pos(command[command_i]);
}
else {
rpos = compute_pos(command[command_i]);
}
if(!check_cross(lpos,rpos)){
flag |= (1<<0);
}
}
lpos = -1;
rpos = -1;
for(int command_i = 0; command_i < command.size(); command_i++){
if(command_i % 2 == 0) {
lpos = compute_pos(command[command_i]);
}
else {
rpos = compute_pos(command[command_i]);
}
if(!check_cross(lpos,rpos)){
flag |= (1<<1);
}
}
gameover:;
printf("%s\n",(!isok || (flag == (1<<2) - 1)) ? "No" : "Yes");
}
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const long long o = 1e4 + 1;
long long n, m, q, a[o], b[o];
long long qwq(long long x) {
long long s = 0;
for (long long i = 1; i <= n; i++) {
if (1.0 * x * a[i] > b[i] * (m + 100)) return m + 1000;
s += 1 + x * a[i] / b[i];
}
return s;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
bool q = 1;
long long x, y;
for (long long i = 1; i <= n; i++) cin >> a[i] >> b[i], q &= !a[i];
if (q) return cout << (n == m ? -1 : 0), 0;
long long l = 1, r = 1e18;
while (l < r) {
long long mid = (l + r + 1) >> 1;
if (qwq(mid) > m)
r = mid - 1;
else
l = mid;
}
if (qwq(l) != m) return cout << 0, 0;
x = l, l = 1, r = 1e18;
while (l < r) {
long long mid = (l + r) >> 1;
if (qwq(mid) < m)
l = mid + 1;
else
r = mid;
}
y = l;
cout << max(0ll, x - y + 1);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int const mx = 200001;
int tmp[mx];
struct node {
int sum, high;
} tree[3 * mx];
int fwt[mx];
int p[mx] = {0};
void init(int node, int b, int e) {
if (b == e) {
tree[node].sum = 1;
tree[node].high = tmp[b];
return;
}
int left = node * 2;
int right = node * 2 + 1;
int mid = (b + e) / 2;
init(left, b, mid);
init(right, mid + 1, e);
tree[node].sum = tree[left].sum + tree[right].sum;
tree[node].high = max(tree[left].high, tree[right].high);
}
int query(int node, int b, int e, int i, int val) {
if (e < i) return tree[node].sum;
if (b > i) return 0;
if (b == i && e == i) return tree[node].sum;
int left = node * 2;
int right = node * 2 + 1;
int mid = (b + e) / 2;
int p1 = query(left, b, mid, i, val);
int p2 = query(right, mid + 1, e, i, val);
return p1 + p2;
}
void update(int node, int b, int e, int i, int val) {
if (i > e || i < b) return;
if (b == e) {
tree[node].sum += val;
return;
}
int left = node * 2;
int right = node * 2 + 1;
int mid = (b + e) / 2;
update(left, b, mid, i, val);
update(right, mid + 1, e, i, val);
tree[node].sum = tree[left].sum + tree[right].sum;
}
void update_fwt(int i, int x, int n) {
i++;
while (i <= n) {
fwt[i] += x;
i += (i & -i);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, x = 0, val;
cin >> n;
for (int i = 1; i <= n; i++) tmp[i] = x++;
init(1, 1, n);
int ans;
for (int i = 1; i <= n; i++) {
cin >> val;
ans = query(1, 1, n, val + 1, val);
p[i - 1] += (ans - 1);
update(1, 1, n, val + 1, -1);
}
cout << endl;
memset(tree, 0, sizeof(tree));
init(1, 1, n);
for (int i = 1; i <= n; i++) {
cin >> val;
ans = query(1, 1, n, val + 1, val);
p[i - 1] += (ans - 1);
update(1, 1, n, val + 1, -1);
}
cout << endl;
for (int i = n - 1; i >= 0; i--) {
int mod = n - i;
if (p[i] >= mod) {
p[i] -= mod;
if (i) p[i - 1]++;
}
}
for (int i = 0; i < n; i++) update_fwt(i, 1, n);
for (int i = 0; i < n; i++) {
int sum = 0;
int pos = 0;
for (int j = 32; j >= 0; j--) {
if (pos + (1LL << j) < n && sum + fwt[pos + (1LL << j)] < p[i] + 1) {
sum += fwt[pos + (1LL << j)];
pos += (1LL << j);
}
}
cout << pos << " ";
update_fwt(pos, -1, n);
}
}
| 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.