solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const long long N = 5e3 + 5;
vector<pair<long long, pair<long long, long long>>> H;
vector<pair<pair<long long, long long>, long long>> V;
vector<pair<long long, long long>> s[2 * N];
pair<pair<long long, long long>, pair<long long, long long>> a[N];
long long T[2 * N];
long long f[2 * N];
long long g[2 * N];
long long sg[2 * N];
long long n, ans;
void update(long long i, long long val) {
while (i <= 10001) {
T[i] += val;
i += i & -i;
}
}
long long get(long long i) {
long long res = 0;
while (i) {
res += T[i];
i -= i & -i;
}
return res;
}
void solve() {
for (long long i = 0, k = 0; i < H.size(); i++) {
while (k < V.size() && V[k].first.first <= H[i].first) {
s[i].push_back(make_pair(V[k].second, 1));
long long l = i;
long long r = H.size();
while (r - l > 1) {
long long mid = (l + r) >> 1;
if (V[k].first.second >= H[mid].first)
l = mid;
else
r = mid;
}
s[r].push_back(make_pair(V[k].second, -1));
k++;
}
for (pair<long long, long long> x : s[i]) {
update(x.first, x.second);
}
for (long long j = i + 1; j <= H.size(); j++) {
for (pair<long long, long long> x : s[j]) {
update(x.first, x.second);
}
long long l = max(H[i].second.first, H[j].second.first);
long long r = min(H[i].second.second, H[j].second.second);
if (l <= r) {
long long num = get(r) - get(l - 1);
ans += num * (num - 1) / 2;
}
}
for (long long j = i + 1; j <= H.size(); j++) {
for (pair<long long, long long> x : s[j]) {
update(x.first, -x.second);
}
}
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> a[i].first.first >> a[i].second.first >> a[i].first.second >>
a[i].second.second;
a[i].first.first += 5001;
a[i].first.second += 5001;
a[i].second.first += 5001;
a[i].second.second += 5001;
if (a[i].first.first > a[i].first.second)
swap(a[i].first.first, a[i].first.second);
if (a[i].second.first > a[i].second.second)
swap(a[i].second.first, a[i].second.second);
if (a[i].first.first == a[i].first.second) {
V.push_back(make_pair(a[i].second, a[i].first.first));
} else
H.push_back(make_pair(a[i].second.first, a[i].first));
}
sort(V.begin(), V.end());
sort(H.begin(), H.end());
solve();
cout << ans;
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
const int mxN = 50;
int k, n;
string s;
void solve() {
int ans = 0;
cin >> n;
while (n > 0) {
n -= 5;
ans++;
}
cout << ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
solve();
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
int i, j, k, n, m, x, y, T, ans, big, cas, num, len, an, bn, ans_num, cur;
bool flag;
map<string, int> mp;
vector<int> st[10002];
int vis[10002];
int tmp[10002];
string a, b, rev[10002];
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) st[i].clear();
mp.clear();
memset(tmp, 0, sizeof(tmp));
num = 0;
an = bn = 0;
ans_num = 0;
cur = 0;
ans = 0;
for (i = 1; i <= n; i++) {
cin >> a >> b;
if (!mp.count(a)) {
mp[a] = ++num;
rev[num] = a;
an = num;
} else
an = mp[a];
if (!mp.count(b)) {
mp[b] = ++num;
rev[num] = b;
bn = num;
} else
bn = mp[b];
st[an].push_back(bn);
st[bn].push_back(an);
}
for (i = 1; i <= num; i++) {
sort(st[i].begin(), st[i].end());
}
printf("%d\n", num);
for (i = 1; i <= num; i++) {
int pre = 0;
cur = 0;
ans = 0;
ans_num = 0;
memset(vis, 0, sizeof(vis));
for (vector<int>::iterator it = st[i].begin(); it != st[i].end(); it++) {
vis[*it] = 1;
}
vis[i] = 1;
for (j = 1; j <= num; j++) {
if (vis[j]) continue;
cur = set_intersection(st[i].begin(), st[i].end(), st[j].begin(),
st[j].end(), tmp) -
tmp;
if (cur > ans_num) {
ans_num = cur;
ans = 1;
} else if (cur == ans_num) {
ans++;
}
}
cout << rev[i] << " " << ans << endl;
}
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
const long long m = 998244353;
long long extgcd(long long a, long long b, long long &x, long long &y) {
long long d = a;
if (b != 0) {
d = extgcd(b, a % b, y, x);
y -= (a / b) * x;
} else {
x = 1;
y = 0;
}
return d;
}
long long mod_inverse(long long a) {
long long x, y;
extgcd(a, m, x, y);
return (m + x % m) % m;
}
const int N = 1e6 + 10;
long long fact[N];
long long C(int n, int k) {
return fact[n] * mod_inverse(fact[n - k]) % m * mod_inverse(fact[k]) % m;
}
long long reg(long long x) { return (m + x % m) % m; }
void add(long long &a, long long b) {
a += b;
a = (m + a % m) % m;
}
long long Pow(long long x, long long n) {
long long res = 1;
while (n > 0) {
if (n & 1) res = res * x % m;
x = x * x % m;
n >>= 1;
}
return res;
}
int get(int i) { return i % 2 == 0 ? 1 : -1; }
int main() {
fact[0] = 1;
for (int i = 1; i < N; i++) fact[i] = fact[i - 1] * i % m;
int n;
scanf("%d", &n);
if (n == 1) {
puts("3");
return 0;
}
long long ans = 0;
for (int i = 0; i < n; i++) {
long long temp = Pow(reg(-Pow(3, i) + 1), n);
add(temp, get(n + 1) * Pow(Pow(3, i), n));
add(ans, (i % 2 == 0 ? -1 : 1) * (3 * C(n, i) % m * temp % m));
}
for (int i = 1; i <= n; i++)
add(ans, (i % 2 == 0 ? -1 : 1) * 2 *
(C(n, i) * Pow(3, i + (long long)n * (n - i)) % m));
printf("%lld\n", ans);
}
| 17
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int N = 1005;
long long C[N][N], tp[N], a[N];
int main() {
int i, j;
for (int i = 0; i < N; i++) C[i][0] = 1;
for (int i = 1; i < N; i++)
for (int j = 1; j < N; j++) C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % mod;
tp[0] = 1;
for (int i = 1; i < N; i++) tp[i] = (tp[i - 1] * 2) % mod;
int n, m;
long long ans, num;
while (scanf("%d%d", &n, &m) != EOF) {
for (int i = 1; i <= m; i++) scanf("%I64d", &a[i]);
sort(a + 1, a + 1 + m);
num = n - m;
ans = C[num][a[1] - 1], num -= a[1] - 1;
for (int i = 2; i <= m; i++) {
long long x = a[i] - a[i - 1] - 1;
if (x) ans = ((ans * C[num][x]) % mod * tp[x - 1]) % mod;
num -= a[i] - a[i - 1] - 1;
}
printf("%I64d\n", ans);
}
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
long long a[101], n;
long long f(long long s, long long e) {
long long an = 1, ss = a[s] + a[e];
for (long long i = s + 1; i <= e - 1; i++)
if (a[i] >= 0) {
ss += a[i];
an = 0;
}
return ss;
}
vector<long long> ans;
void ff(long long l, long long r, long long an) {
for (long long i = 0; i <= l - 1; i++) ans.push_back(i + 1);
if (an < 0) {
for (long long i = l + 1; i <= r - 1; i++)
if (an >= 0) ans.push_back(i + 1);
} else
for (long long i = l + 1; i <= r - 1; i++)
if (a[i] < 0) ans.push_back(i + 1);
for (long long i = r + 1; i <= n - 1; i++) ans.push_back(i + 1);
}
int main() {
long long an = INT_MIN, l = 0, r = 0, p;
cin >> n;
for (long long i = 0; i < n; i++) cin >> a[i];
for (long long i = 0; i < n; i++)
for (long long j = i + 1; j <= n - 1; j++)
if (a[i] == a[j]) {
p = f(i, j);
if (p > an) {
an = p;
l = i;
r = j;
}
}
ff(l, r, an);
cout << an << " " << ans.size() << endl;
for (long long i = 0; i < ans.size(); i++) cout << ans[i] << " ";
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string g, h, l;
int no = 0, a = 0;
cin >> g >> h >> l;
sort(g.begin(), g.end());
sort(h.begin(), h.end());
sort(l.begin(), l.end());
if (g.size() + h.size() == l.size()) {
for (int i = 0; i < l.size(); i++) {
if (l[i] == '0') continue;
for (int a = 0; a < g.size(); a++) {
if (g[a] == '0') continue;
if (g[a] == l[i]) {
l[i] = '0';
g[a] = '0';
break;
}
}
}
for (int i = 0; i < l.size(); i++) {
if (l[i] == '0') continue;
for (int a = 0; a < h.size(); a++) {
if (h[a] == '0') continue;
if (h[a] == l[i]) {
l[i] = '0';
h[a] = '0';
break;
}
}
}
for (int i = 0; i < l.size(); i++) {
if (l[i] != '0') {
no++;
break;
}
}
if (no > 0)
cout << "NO";
else
cout << "YES";
} else
cout << "NO";
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
long long a[1013];
int main() {
long long n, cnt = 0;
cin >> n;
for (int i = 0; i < 2 * n; i++) {
cin >> a[i];
}
for (int i = 0; i < 2 * n; i++) {
long long k = i;
if (i + 1 < n && a[i] == a[i + 1]) {
i++;
continue;
}
for (int j = i + 1; j < 2 * n; j++) {
if (a[j] == a[i]) {
k = j;
break;
}
}
for (int j = k; j > i + 1; j--) {
swap(a[j], a[j - 1]);
cnt++;
}
i++;
}
cout << cnt;
return 0;
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
struct perem {
long long t = 0, l = 1, p = -1, q = 0;
};
ifstream fin("AAtest.in.txt");
long long n, k, m, c, vas, cc = 1000000;
vector<long long> vv;
string s;
vector<vector<long long>> la;
vector<perem> pr;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cerr.tie(0);
cin >> n >> k >> s;
la.resize(n, vector<long long>(0));
pr.resize(k);
for (int(i) = (0); ((i)) < ((k)); ((i))++) {
cin >> m;
for (int(j) = (0); ((j)) < ((m)); ((j))++) {
cin >> c;
la[c - 1].emplace_back(i);
}
}
for (int(i) = (0); ((i)) < ((n)); ((i))++) {
vas = 0;
if (la[i].size() > 0) {
long long a = la[i][0];
bool b1 = s[i] == '1' ? 1 : 0;
while (a != -1) {
b1 ^= pr[a].q;
if (pr[a].p != -1)
a = pr[a].p;
else
break;
}
if (la[i].size() == 1) {
if (!b1) {
vas += pr[a].l;
pr[a].q ^= 1;
}
pr[a].l = cc;
} else {
long long b = la[i][1];
while (b != -1) {
b1 ^= pr[b].q;
if (pr[b].p != -1)
b = pr[b].p;
else
break;
}
if (a != b) {
long long kl = 0;
if (!b1) {
if (pr[a].l < pr[b].l) {
vas += pr[a].l;
pr[a].q ^= 1;
} else {
vas += pr[b].l;
pr[b].q ^= 1;
}
kl = abs(pr[a].l - pr[b].l);
} else
kl = min(pr[a].l + pr[b].l, cc);
if (pr[a].t < pr[b].t) swap(a, b);
if (pr[a].q) pr[b].q ^= 1;
if (pr[a].t == pr[b].t) pr[a].t++;
pr[a].l = kl;
pr[b].p = a;
}
}
}
if (i)
vv.emplace_back(vv.back() + vas);
else
vv.emplace_back(vas);
}
for (long long i : vv) cout << i << endl;
}
| 16
|
#include <bits/stdc++.h>
#pragma optimization_level 3
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math,O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx")
using namespace std;
const long long MAXN = 1e+2 + 7;
const long long MOD = 1e+9 + 7, INF = 0x7f7f7f7f7f7f7f7f;
const int INFi = 0x7f7f7f7f;
double EPS = 1e-9;
double PI = acos(-1);
long long l, r, m, flag, t, t1, t2, i;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed;
cout << setprecision(10);
;
cin >> t;
while (t--) {
cin >> l >> r >> m;
for (i = l; i <= r; i++) {
t1 = (i - m % i) % i;
t2 = m % i;
if (m < i && r - l >= t1) {
cout << i << ' ' << l << ' ' << l + t1;
cout << "\n";
break;
} else if (m >= i) {
if (r - l >= t1) {
cout << i << ' ' << l << ' ' << l + t1;
cout << "\n";
break;
} else if (r - l >= t2) {
cout << i << ' ' << l + t2 << ' ' << l;
cout << "\n";
break;
}
}
}
}
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
char s[100005];
int n;
int d[100005];
int rem[30];
int main() {
scanf("%s", s);
n = strlen(s);
memset(rem, -1, sizeof(rem));
char bg = 'a' - 1;
int f = 0;
for (int i = 0; i < n; ++i) {
rem[s[i] - 'a'] = i;
if (bg < s[i]) {
bg = s[i], f = i;
}
}
while (f < n) {
printf("%c", s[f]);
for (int i = n - 1; i > f; --i) {
if (s[i] == s[f]) {
for (int j = f + 1; j <= i; ++j)
if (s[j] == s[f]) printf("%c", s[j]);
f = i;
break;
}
}
for (int i = s[f] - 'a'; i >= 0; --i) {
if (rem[i] > f) {
bg = 'a' + i;
break;
}
}
if (bg != s[f]) {
for (; f < n; ++f)
if (s[f] == bg) break;
} else
break;
}
return 0;
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e6 + 5;
long long int dp[maxn], t[maxn], a, n, kam[maxn], v, m;
int main() {
cin.tie(0), cout.tie(0), ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a;
t[a]++;
}
for (int i = 1; i < maxn; i++) {
for (int j = i; j < maxn; j += i) {
if (i * i != j)
dp[j] += t[i] * t[j / i];
else
dp[j] += t[i] * (t[i] - 1);
}
}
for (int i = 1; i < maxn; i++) {
kam[i] += dp[i] + kam[i - 1];
}
cin >> m;
while (m--) {
cin >> v;
cout << n * (n - 1) - kam[v - 1] << "\n";
}
cin >> n;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
int a[200001], n, k, i, j;
int main() {
scanf("%d%d", &n, &k);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
while (k >= 1 && a[k] == a[k - 1]) k--;
j = 0;
for (i = k + 1; i <= n; i++)
if (a[i] != a[k]) j = 1;
if (!j)
printf("%d\n", k - 1);
else
printf("-1\n");
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
int ans = 0;
getline(cin, str);
int len = str.length();
for (int i = 0; i <= len - 1; i++) {
if (isupper(str[i])) {
ans += str[i] - 64;
}
if (islower(str[i])) {
ans -= str[i] - 96;
}
}
cout << ans << endl;
return 0;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[1001], n, sum = 0;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++)
if (a[i] == 1) sum++;
cout << sum << endl;
for (int i = 1; i < n; i++)
if (a[i + 1] == 1) cout << a[i] << " ";
cout << a[n] << endl;
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
pair<int, int> ar[200];
int main() {
int n, k, m;
vector<pair<int, int> > res;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> ar[i].first;
ar[i].second = i;
}
sort(ar, ar + n);
m = 0;
for (int i = 0; (i < k) && (ar[n - 1].first - ar[0].first > 1); i++) {
ar[n - 1].first--;
ar[0].first++;
m++;
res.push_back(make_pair(ar[n - 1].second, ar[0].second));
sort(ar, ar + n);
}
cout << ar[n - 1].first - ar[0].first << ' ' << m << '\n';
for (int i = 0; i < m; i++) {
cout << res[i].first + 1 << ' ' << res[i].second + 1 << '\n';
}
return 0;
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int n, w, x, v;
long long ans;
pair<double, double> a[N], b[N];
inline int cmp(pair<double, double> x, pair<double, double> y) {
return x.first < y.first || (x.first == y.first && x.second > y.second);
}
void CDQ(int l, int r) {
if (l == r) return;
int mid = (l + r) / 2;
CDQ(l, mid);
CDQ(mid + 1, r);
for (int i = l; i <= r; i++) b[i] = a[i];
int cnt = l;
for (int i = l, j = mid + 1; i <= mid || j <= r;) {
if ((j > r || b[i].second < b[j].second) && i <= mid)
a[cnt++] = b[i++];
else
a[cnt++] = b[j++], ans += mid - i + 1;
}
}
int main() {
scanf("%d%d", &n, &w);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &x, &v);
a[i] = make_pair((double)x / (v + w), (double)x / (v - w));
}
sort(a + 1, a + 1 + n, cmp);
CDQ(1, n);
printf("%lld\n", ans);
}
| 17
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<long long> A(n);
for (int i = 0; i < n; i++) {
cin >> A[i];
}
vector<vector<long long> > vars(n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
vars[i].push_back(A[j] + i - j);
}
sort(vars[i].begin(), vars[i].end());
vars[i].resize(unique(vars[i].begin(), vars[i].end()) - vars[i].begin());
}
auto d = vars;
for (int i = 0; i < int(d[0].size()); i++) {
d[0][i] = abs(A[0] - vars[0][i]);
}
for (int i = 1; i < n; i++) {
long long prev = -1;
int ptr = 0;
for (int j = 0; j < int(d[i].size()); j++) {
d[i][j] = -1;
while (ptr < int(vars[i - 1].size()) && vars[i - 1][ptr] < vars[i][j]) {
if (d[i - 1][ptr] != -1) {
prev = prev == -1 ? d[i - 1][ptr] : min(prev, d[i - 1][ptr]);
}
ptr++;
}
if (prev != -1) {
d[i][j] = abs(A[i] - vars[i][j]) + prev;
}
}
}
long long res = -1;
for (int j = 0; j < int(d[n - 1].size()); j++) {
if (d[n - 1][j] != -1) {
res = res == -1 ? d[n - 1][j] : min(res, d[n - 1][j]);
}
}
cout << res << '\n';
return 0;
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int T;
cin >> T;
while (T--) {
int n;
cin >> n;
string s[n];
for (int i = (0); i < (n); i++) {
cin >> s[i];
}
unordered_map<char, int> u;
for (int i = 0; i < n; i++) {
for (int j = 0; j < (long long)(s[i]).size(); j++) {
u[s[i][j]]++;
}
}
int f = 0;
for (auto x : u) {
if (x.second % n != 0) {
f = 1;
break;
}
}
if (f == 0) {
cout << "YES"
<< "\n";
} else {
cout << "NO"
<< "\n";
}
}
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e6 + 2;
bool np[N];
int p[N], pi[N];
int getprime() {
int cnt = 0;
np[0] = np[1] = true;
pi[0] = pi[1] = 0;
for (int i = 2; i < N; ++i) {
if (!np[i]) p[++cnt] = i;
for (int j = 1; j <= cnt && i * p[j] < N; ++j) {
np[i * p[j]] = true;
}
pi[i] = cnt;
}
return cnt;
}
const int M = 7;
const int PM = 2 * 3 * 5 * 7 * 11 * 13 * 17;
int phi[PM + 1][M + 1], sz[M + 1];
void init() {
getprime();
sz[0] = 1;
for (int i = 0; i <= PM; ++i) phi[i][0] = i;
for (int i = 1; i <= M; ++i) {
sz[i] = p[i] * sz[i - 1];
for (int j = 1; j <= PM; ++j) {
phi[j][i] = phi[j][i - 1] - phi[j / p[i]][i - 1];
}
}
}
int sqrt2(long long x) {
long long r = (long long)sqrt(x - 0.1);
while (r * r <= x) ++r;
return int(r - 1);
}
int sqrt3(long long x) {
long long r = (long long)cbrt(x - 0.1);
while (r * r * r <= x) ++r;
return int(r - 1);
}
long long getphi(long long x, int s) {
if (s == 0) return x;
if (s <= M) return phi[x % sz[s]][s] + (x / sz[s]) * phi[sz[s]][s];
if (x <= p[s] * p[s]) return pi[x] - s + 1;
if (x <= p[s] * p[s] * p[s] && x < N) {
int s2x = pi[sqrt2(x)];
long long ans = pi[x] - (s2x + s - 2) * (s2x - s + 1) / 2;
for (int i = s + 1; i <= s2x; ++i) {
ans += pi[x / p[i]];
}
return ans;
}
return getphi(x, s - 1) - getphi(x / p[s], s - 1);
}
long long getpi(long long x) {
if (x < N) return pi[x];
long long ans = getphi(x, pi[sqrt3(x)]) + pi[sqrt3(x)] - 1;
for (int i = pi[sqrt3(x)] + 1, ed = pi[sqrt2(x)]; i <= ed; ++i)
ans -= getpi(x / p[i]) - i + 1;
return ans;
}
long long lehmer_pi(long long x) {
if (x < N) return pi[x];
int a = (int)lehmer_pi(sqrt2(sqrt2(x)));
int b = (int)lehmer_pi(sqrt2(x));
int c = (int)lehmer_pi(sqrt3(x));
long long sum = getphi(x, a) + (long long)(b + a - 2) * (b - a + 1) / 2;
for (int i = a + 1; i <= b; i++) {
long long w = x / p[i];
sum -= lehmer_pi(w);
if (i > c) continue;
long long lim = lehmer_pi(sqrt2(w));
for (int j = i; j <= lim; j++) {
sum -= lehmer_pi(w / p[j]) - (j - 1);
}
}
return sum;
}
long long getans(long long x) {
long long ans = 0;
for (int i = 1, ed = pi[sqrt2(x - 1)]; i <= ed; ++i)
ans += lehmer_pi(x / p[i]) - i;
return ans;
}
int main() {
init();
long long n;
scanf("%lld", &n);
printf("%lld\n", getans(n) + pi[sqrt3(n)]);
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
long double success[100001];
long double fac[301];
double choose(int n, int k) {
if (k < 0 || k > n) return 0;
return fac[n] / (fac[k] * fac[n - k]);
}
void solve() {
int n, k, m;
cin >> n >> m >> k;
fac[0] = 1;
for (int i = 1; i <= n; i++) {
fac[i] = fac[i - 1] * i;
}
success[0] = 1;
for (int i = 0; i < k; i++) {
success[i + 1] = success[i] * (k - i) / (m - i);
}
long double ret = 0;
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= n; j++) {
long double inc =
choose(n, i) * choose(n, j) * success[n * (i + j) - (i * j)];
ret += inc;
if (ret >= 1e99) {
cout << "1e99\n";
return;
}
}
}
cout << fixed << setprecision(12) << ret << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
}
| 19
|
#include <bits/stdc++.h>
using namespace std;
const double pi = 2 * acos(0.0);
int oo = 0x3f3f3f3f;
double inf = 1.0 / 0.0;
int main() {
ios::sync_with_stdio(false);
int n, q;
cin >> n >> q;
while (q--) {
int l, r;
cin >> l >> r;
}
string s = "";
for (int i = 0; i < n; i++) {
if (i % 2 == 0)
s.push_back('0');
else
s.push_back('1');
}
cout << s << endl;
return 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
int ans = 0;
vector<tuple<int, int, int>> maxg;
int explore(vector<int> &s, vector<int> &dp, int dec,
vector<tuple<int, int, int>> &g) {
if (dp[dec] != -1) {
return dp[dec];
}
bool flag = true;
int max1 = -1;
int max2 = -1;
int max3 = -1;
for (auto i = s.begin(); i < s.end(); i++) {
if (*i != s[0]) {
flag = false;
}
if (max1 == -1 || *i >= s[max1]) {
max3 = max2;
max2 = max1;
max1 = i - s.begin();
} else if (max2 == -1 || *i >= s[max2]) {
max3 = max2;
max2 = i - s.begin();
} else if (max3 == -1 || *i >= s[max3]) {
max3 = i - s.begin();
}
}
if (flag) {
if (s[0] > ans || maxg.empty()) {
ans = s[0];
maxg = g;
}
return s[0];
}
int temp = dec + 2;
s[max1]--;
s[max2]--;
if (s[max2] < 0) {
s[max2]++;
temp--;
}
g.push_back(make_tuple(max1, max2, -1));
int ans2 = explore(s, dp, temp, g);
g.pop_back();
s[max3]--;
if (s[max3] < 0) {
s[max1]++;
s[max2] += temp - dec - 1;
s[max3]++;
dp[dec] = ans2;
return ans2;
}
g.push_back(make_tuple(max1, max2, max3));
int ans3 = explore(s, dp, temp + 1, g);
g.pop_back();
s[max1]++;
s[max2] += temp - dec - 1;
s[max3]++;
dp[dec] = max(ans2, ans3);
return max(ans2, ans3);
}
int main() {
int n;
cin >> n;
vector<int> a(n);
vector<int> dp(n * 100);
vector<tuple<int, int, int>> games;
for (int i = 0; i < n * 100; i++) {
dp[i] = -1;
}
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
if (n == 2) {
if (a[0] == a[1]) {
cout << a[0] << endl;
cout << 0;
return 0;
}
cout << 0 << endl;
cout << max(a[0], a[1]) << endl;
for (int i = 0; i < max(a[0], a[1]); i++) cout << 1 << 1 << endl;
return 0;
}
explore(a, dp, 0, games);
cout << ans << endl;
cout << maxg.size() << endl;
for (int j = 0; j < maxg.size(); ++j) {
vector<int> temp(n, 0);
temp[get<0>(maxg[j])] = 1;
temp[get<1>(maxg[j])] = 1;
int z = get<2>(maxg[j]);
if (z != -1) temp[z] = 1;
for (int i = 0; i < n; ++i) {
cout << temp[i];
}
cout << endl;
}
return 0;
}
| 10
|
#include <bits/stdc++.h>
using db = double;
const int N = 100007;
const db eps = 1e-10, inf = 1e10;
int n, m, fa[N], dep[N], size[N], son[N], top[N], vis[N];
db ans = inf, t, c[N], ed[N];
struct line {
int x, id, o;
db t, c;
} b[N];
db cal(const line& x) { return dep[x.x] + (t - x.t) * c[x.id]; }
int operator<(const line& a, const line& b) { return cal(a) < cal(b); }
std::vector<int> e[N];
std::vector<line> f[N];
std::multiset<line> s;
int read() {
int x = 0, c = getchar();
while (!isdigit(c)) c = getchar();
while (isdigit(c)) (x *= 10) += c & 15, c = getchar();
return x;
}
void dfs(int u) {
size[u] = 1;
for (int v : e[u])
if (v ^ fa[u])
fa[v] = u, dep[v] = dep[u] + 1, dfs(v), size[u] += size[v],
son[u] = size[v] > size[son[u]] ? v : son[u];
}
void dfs(int u, int tp) {
top[u] = tp;
if (son[u]) dfs(son[u], tp);
for (int v : e[u])
if (v ^ fa[u] && v ^ son[u]) dfs(v, v);
}
int lca(int u, int v) {
for (; top[u] ^ top[v]; u = fa[top[u]])
if (dep[top[v]] > dep[top[u]]) std::swap(u, v);
return dep[u] > dep[v] ? v : u;
}
db cal(int u, int v, db c) { return (dep[u] - dep[v]) / c; }
void update(const line& x, const line& y) {
db v = cal(y) - cal(x),
p = fabs(v) < eps ? 0 : (cal(y) - cal(x)) / (c[x.id] - c[y.id]);
if (p > -eps && p + t < std::min(ed[x.id], ed[y.id]) + eps)
ans = std::min(ans, p + t);
}
void work(int u) {
s.clear(),
std::sort(f[u].begin(), f[u].end(), [](const line& a, const line& b) {
return fabs(a.t - b.t) < eps ? a.o > b.o : a.t < b.t;
});
for (line x : f[u])
if (x.o)
b[x.id] = x;
else
ed[x.id] = x.t;
for (line x : f[u]) {
if ((t = x.t) > ans + eps) break;
if (x.o) {
auto it = s.insert(x);
c[x.id] = x.c;
if (it != s.begin()) update(x, *prev(it));
if (++it != s.end()) update(x, *it);
} else {
auto it = s.find(b[x.id]);
if (it != s.begin() && next(it) != s.end()) update(*prev(it), *next(it));
if (it != s.end()) s.erase(it);
}
}
}
int main() {
n = read(), m = read();
for (int i = 1, u, v; i < n; ++i)
u = read(), v = read(), e[u].push_back(v), e[v].push_back(u);
dfs(1), dfs(1, 1);
for (int i = 1; i <= m; ++i) {
db t = read(), T;
c[i] = read();
int x = read(), y = read(), u = x, v = y, p = lca(u, v), flg = 1;
T = t + cal(u, p, c[i]);
for (; top[u] ^ top[v]; u = fa[top[u]]) {
if (dep[top[u]] < dep[top[v]]) std::swap(u, v), flg ^= 1;
if (flg)
f[top[u]].push_back({u, i, 1, t + cal(x, u, c[i]), -c[i]}),
f[top[u]].push_back(
{fa[top[u]], i, 0, t + cal(x, fa[top[u]], c[i]), -c[i]});
else
f[top[u]].push_back({u, i, 0, T + cal(u, p, c[i]), c[i]}),
f[top[u]].push_back(
{fa[top[u]], i, 1, T + cal(fa[top[u]], p, c[i]), c[i]});
}
if (dep[u] < dep[v]) std::swap(u, v), flg ^= 1;
if (flg)
f[top[u]].push_back({u, i, 1, t + cal(x, u, c[i]), -c[i]}),
f[top[u]].push_back({v, i, 0, T, -c[i]});
else
f[top[u]].push_back({v, i, 1, T, c[i]}),
f[top[u]].push_back({u, i, 0, T + cal(u, v, c[i]), c[i]});
}
for (int i = 1; i <= n; ++i)
if (!vis[top[i]]) vis[top[i]] = 1, work(top[i]);
fabs(ans - inf) < eps ? puts("-1") : printf("%.10lf", ans);
}
| 25
|
#include <bits/stdc++.h>
using namespace std;
int jogfol[100001];
int timarr[100001];
int main() {
int aa, tim;
cin >> aa >> tim;
int a[aa + 1];
for (int z = 1; z < aa + 1; z++) {
cin >> a[z];
}
for (int z = 1; z < aa + 1; z++) {
if (a[z] != 0) {
int plas = 0;
timarr[z] = min(z + tim, aa);
plas = plas + (timarr[z] - max(z, timarr[a[z]]));
if (timarr[a[z]] < z) {
int wow = max(z - tim, 1);
wow = max(wow, timarr[a[z]] + 1);
plas = plas + (z - wow);
}
if (timarr[a[z]] < z) {
plas++;
}
jogfol[z] = jogfol[a[z]] + plas;
} else {
int plas = 0;
timarr[z] = min(z + tim, aa);
plas = plas + (timarr[z] - z);
int wow = max(z - tim, 1);
plas = plas + (z - wow);
jogfol[z] = plas + 1;
}
}
for (int z = 1; z < aa + 1; z++) {
cout << jogfol[z] << " ";
}
return 0;
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
void task();
int main() {
task();
return 0;
}
const int N = (int)1e5 + 10;
const int MODULO = (int)1e6 + 3;
int sz[20010];
int a[20010][210];
int tans[210];
bool used_nums[210];
int ind[210];
vector<vector<int> > sets;
void task() {
int n;
scanf("%d", &n);
int up = n * (n - 1) / 2;
for (int i = 0; i < up; ++i) {
scanf("%d", &sz[i]);
for (int j = 0; j < sz[i]; ++j) scanf("%d", &a[i][j]);
sort(a[i], a[i] + sz[i]);
}
if (n == 2) {
printf("1 %d\n", a[0][0]);
printf("%d ", sz[0] - 1);
for (int i = 1; i < sz[0]; ++i) {
printf("%d ", a[0][i]);
}
return;
}
int mn = 1000;
for (int i = 0; i < up; ++i) mn = min(mn, *min_element(a[i], a[i] + sz[i]));
for (int i = 0, j = 0; i < n * (n - 1) / 2; ++i) {
if (a[i][0] == mn) ind[j++] = i;
}
sets.resize(n);
for (int k = 0; k < n - 1; ++k) {
int i = ind[k];
for (int j = 0; j < sz[i]; ++j) {
++tans[a[i][j]];
if (k == n - 2 && tans[a[i][j]] == n - 1) {
sets[0].push_back(a[i][j]);
used_nums[a[i][j]] = 1;
}
}
}
for (int k = 0, si = 1; k < n - 1; ++k, ++si) {
int i = ind[k];
for (int j = 0; j < sz[i]; ++j) {
if (!used_nums[a[i][j]]) {
sets[si].push_back(a[i][j]);
}
}
}
for (auto x : sets) {
printf("%d ", x.size());
for (auto y : x) {
printf("%d ", y);
}
printf("\n");
}
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXN = 1000;
typedef struct P {
int x, y;
P(int x, int y) : x(x), y(y) {}
P() {}
} P;
const P operator-(const P &a, const P &b) { return P(a.x - b.x, a.y - b.y); }
const long long operator^(const P &a, const P &b) {
return (long long)a.x * b.y - (long long)a.y * b.x;
}
const long long operator*(const P &a, const P &b) {
return (long long)a.x * b.x + (long long)a.y * b.y;
}
typedef struct R {
long long num, den;
int type;
} R;
bool operator<(const R &p, const R &q) {
if ((p.num < 0) != (q.num < 0)) return p.num < 0;
long long a = abs(p.num), b = p.den, c = abs(q.num), d = q.den;
bool inv = p.num < 0;
while (true) {
long long aa = a / b, cc = c / d;
if (aa != cc) return !inv ? aa < cc : cc < aa;
a %= b, c %= d;
if (a == 0 || c == 0) break;
inv = !inv;
swap(a, b);
swap(c, d);
}
if (a != 0 || c != 0) return !inv ? a == 0 : c == 0;
return false;
}
P p[MAXN + 1];
int n, nq;
R r[2 * MAXN];
int nr;
char buff[100];
int read() {
scanf("%s", buff);
int at = 0, sgn = +1, ret = 0, flen = 0;
if (buff[at] == '-') sgn = -sgn, ++at;
while (isdigit(buff[at])) ret = ret * 10 + buff[at++] - '0';
if (buff[at] == '.') ++at;
while (isdigit(buff[at])) ret = ret * 10 + buff[at++] - '0', ++flen;
for (int i = (0); i < (2 - flen); ++i) ret = ret * 10;
return sgn * ret;
}
void intersect(const P &a, const P &b, const P &c, const P &d) {
long long den = (d - c) ^ (b - a);
if (den == 0) {
long long side = (a - c) ^ (d - c);
bool hor = d.x == c.x;
if (side != 0) return;
r[nr].num = !hor ? a.x - c.x : a.y - c.y,
r[nr].den = !hor ? d.x - c.x : d.y - c.y, r[nr].type = 2, ++nr;
r[nr].num = !hor ? b.x - c.x : b.y - c.y,
r[nr].den = !hor ? d.x - c.x : d.y - c.y, r[nr].type = 2, ++nr;
} else {
long long num1 = (a - c) ^ (d - c), num2 = (a - c) ^ (b - a);
if (den < 0) num1 = -num1, num2 = -num2, den = -den;
if (num1 < 0 || num1 > den) return;
r[nr].num = num2, r[nr].den = den,
r[nr].type = num1 == 0 ? (((b - c) ^ (d - c)) > 0 ? +1 : -1)
: num1 == den ? (((a - c) ^ (d - c)) > 0 ? +1 : -1)
: 0,
++nr;
}
}
void run() {
scanf("%d%d", &n, &nq);
for (int i = (0); i < (n); ++i) p[i].x = read(), p[i].y = read();
p[n] = p[0];
for (int qi = (0); qi < (nq); ++qi) {
P a, b;
a.x = read(), a.y = read(), b.x = read(), b.y = read();
nr = 0;
for (int i = (0); i < (n); ++i) intersect(p[i], p[i + 1], a, b);
for (int i = (0); i < (n); ++i)
if (r[i].den < 0) r[i].den = -r[i].den, r[i].num = -r[i].num;
sort(r, r + nr);
double ret = 0;
int ctype = 0;
for (int at = 0, to = at; at < nr; at = to++) {
if (ctype != 0)
ret +=
1.0 * r[at].num / r[at].den - 1.0 * r[at - 1].num / r[at - 1].den;
while (to < nr && !(r[at] < r[to])) ++to;
if (to - at == 1) {
assert(ctype == 0 || ctype == 2);
assert(r[at].type == 0);
ctype = 2 - ctype;
} else if (to - at == 2) {
assert(r[at].type != 0 && r[at + 1].type != 0);
if (ctype == 0 || ctype == 2) {
assert(r[at].type != 2 || r[at + 1].type != 2);
if (r[at].type == r[at + 1].type)
ctype = ctype;
else if (r[at].type == -r[at + 1].type)
ctype = 2 - ctype;
else
ctype = ctype == 0 ? r[at].type + r[at + 1].type - 2
: 2 - r[at].type - r[at + 1].type;
} else {
assert(r[at].type == 2 || r[at + 1].type == 2);
if (r[at].type == 2 && r[at + 1].type == 2)
ctype = ctype;
else if (ctype == r[at].type || ctype == r[at + 1].type)
ctype = 0;
else
ctype = 2;
}
} else
assert(false);
}
assert(ctype == 0);
ret *= sqrt((b - a) * (b - a)) / 100;
printf("%.9lf\n", ret);
}
}
int main() {
run();
return 0;
}
| 21
|
#include <bits/stdc++.h>
using namespace std;
void dfs(vector<pair<long long, long long>> &p, vector<bool> &vis, long long x,
long long N) {
vis[x] = true;
for (long long i = 0; i < N; i++)
if (!vis[i] && (p[i].first == p[x].first || p[i].second == p[x].second))
dfs(p, vis, i, N);
}
int32_t main() {
long long N;
cin >> N;
vector<bool> vis(N, false);
vector<pair<long long, long long>> p(N);
for (long long n = 0; n < N; n++) cin >> p[n].first >> p[n].second;
long long cnt = 0;
for (long long i = 0; i < N; i++) {
if (!vis[i]) {
dfs(p, vis, i, N);
cnt++;
}
}
cout << cnt - 1 << endl;
return 0;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
const long long MN = 211;
long long m, n, k;
long long p[MN][MN], priority[MN];
pair<long long, long long> order[MN];
char res[MN];
long long f[MN][MN];
const long long INF = 1000111000111000111LL;
long long solve() {
memset(f, 0, sizeof f);
f[0][0] = 1;
for (long long i = (0), _b = (n - 1); i <= _b; ++i)
for (long long s = (0), _b = (i); s <= _b; ++s) {
long long t = f[i][s];
if (!t) continue;
if (t > INF) t = f[i][s] = INF;
if (res[i + 1] == '(') {
f[i + 1][s + 1] += t;
} else if (res[i + 1] == ')') {
if (s) {
f[i + 1][s - 1] += t;
}
} else {
f[i + 1][s + 1] += t;
if (s) f[i + 1][s - 1] += t;
}
}
return f[n][0];
}
int main() {
ios ::sync_with_stdio(0);
cin.tie(0);
cout << (fixed) << setprecision(9);
while (cin >> m >> n >> k) {
long long savem = m, saven = n;
for (long long i = (1), _b = (m + n - 1); i <= _b; ++i)
priority[i] = MN * MN;
for (long long i = (1), _b = (m); i <= _b; ++i)
for (long long j = (1), _b = (n); j <= _b; ++j) {
cin >> p[i][j];
long long s = i + j - 1;
priority[s] = min(priority[s], p[i][j]);
}
n = m + n - 1;
for (long long i = (1), _b = (n); i <= _b; ++i)
order[i] = make_pair(priority[i], i);
sort(order + 1, order + n + 1);
memset(res, 0, sizeof res);
for (long long i = (1), _b = (n); i <= _b; ++i) {
long long pos = order[i].second;
res[pos] = '(';
long long cur = solve();
if (cur >= k) continue;
res[pos] = ')';
k -= cur;
}
for (long long i = (1), _b = (savem); i <= _b; ++i) {
for (long long j = (1), _b = (saven); j <= _b; ++j)
cout << res[i + j - 1];
cout << '\n';
}
}
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
bool customS(pair<int64_t, int64_t> a, pair<int64_t, int64_t> b) {
if (a.second == b.second) return a.first < b.first;
return a.second < b.second;
}
bool customS2(vector<int> a, vector<int> b) {
int t1 = a.size(), t2 = b.size();
return t1 < t2;
}
class CompareDist {
public:
bool operator()(pair<int64_t, int64_t> a, pair<int64_t, int64_t> b) {
if (a.second == b.second) return a.first > b.first;
return a.second > b.second;
}
};
int64_t gcd(int64_t a, int64_t b) {
if (b == 0) return a;
return gcd(b, a % b);
}
double gcdfloat(double a, double b) {
if (a < b) return gcd(b, a);
if (fabs(b) < 0.001)
return a;
else
return (gcd(b, a - floor(a / b) * b));
}
int main() {
int64_t n, k, i, j;
cin >> n >> k;
vector<int64_t> arr(n);
vector<int64_t> dp_1(n, 0);
vector<int64_t> dp_2(n, 0);
vector<int64_t> dp_3(n, 0);
for (i = 0; i < n; i++) {
cin >> arr[i];
}
int64_t running_sum = 0;
for (i = 0; i < k - 1; i++) running_sum += arr[i];
for (i = k - 1; i < n; i++) {
running_sum += arr[i];
dp_1[i] = running_sum;
running_sum -= arr[i - k + 1];
}
running_sum = 0;
for (i = n - 1; i > (n - k); i--) running_sum += arr[i];
for (i = n - k; i >= 0; i--) {
running_sum += arr[i];
dp_2[i] = running_sum;
dp_3[i] = running_sum;
running_sum -= arr[i + k - 1];
}
for (i = 1; i < n; i++) {
if (dp_1[i] < dp_1[i - 1]) {
dp_1[i] = dp_1[i - 1];
}
}
for (i = n - 2; i >= 0; i--) {
if (dp_2[i] < dp_2[i + 1]) {
dp_2[i] = dp_2[i + 1];
}
}
int64_t maxi_value = INT64_MIN, a, b;
for (i = k - 1; i + 1 <= (n - k); i++) {
if (dp_1[i] + dp_2[i + 1] > maxi_value) {
maxi_value = dp_1[i] + dp_2[i + 1];
a = dp_1[i];
b = dp_2[i + 1];
}
}
for (i = 0; i < n; i++) {
if (dp_1[i] == a) {
break;
}
}
for (j = i + 1; j < n; j++) {
if (dp_3[j] == b) {
break;
}
}
cout << i + 1 - k + 1 << " " << j + 1 << "\n";
return 0;
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
int n, m, num, Father[100000 + 5], res[100000 + 5], b[100000 + 5],
d[100000 + 5], Trace[100000 + 5];
pair<int, int> e[100000 + 5];
vector<int> t[1000000 + 5], tmp, c[100000 + 5];
map<pair<int, int>, vector<int> > my_map;
void Init();
void Process();
int main() {
Init();
Process();
return 0;
}
void Init() {
int p, q, r;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; ++i) {
scanf("%d%d%d", &p, &q, &r);
e[i] = pair<int, int>(p, q);
t[r].push_back(i);
}
}
int Get(int x) {
if (x != Father[x]) Father[x] = Get(Father[x]);
return Father[x];
}
void Union(int x, int y) {
x = Get(x);
y = Get(y);
if (x == y) return;
Father[x] = y;
}
void Add(int p, int q) { c[p].push_back(q); }
void DFS(int i) {
vector<int>::iterator it;
b[i] = ++num;
d[i] = b[i];
for (it = c[i].begin(); it != c[i].end(); ++it)
if (*it != Trace[i])
if (b[*it] == 0) {
Trace[*it] = i;
DFS(*it);
d[i] = min(d[i], d[*it]);
} else
d[i] = min(d[i], b[*it]);
}
void Process() {
int x, y;
vector<int>::iterator it, itx;
map<pair<int, int>, vector<int> >::iterator it2;
for (int i = 1; i <= n; ++i) Father[i] = i;
for (int i = 1; i <= 1000000; ++i)
if (t[i].size() > 0) {
num = 0;
my_map.clear();
tmp.clear();
for (it = t[i].begin(); it != t[i].end(); ++it) {
x = Get(e[*it].first);
y = Get(e[*it].second);
if (x > y) swap(x, y);
if (x != y) {
my_map[pair<int, int>(x, y)].push_back(*it);
tmp.push_back(x);
tmp.push_back(y);
}
}
for (it2 = my_map.begin(); it2 != my_map.end(); ++it2) {
Add(it2->first.first, it2->first.second);
Add(it2->first.second, it2->first.first);
}
for (it2 = my_map.begin(); it2 != my_map.end(); ++it2)
for (it = (it2->second).begin(); it != (it2->second).end(); ++it)
res[*it] = 1;
for (it = tmp.begin(); it != tmp.end(); ++it)
if (Trace[*it] == 0) {
Trace[*it] = -1;
DFS(*it);
}
for (it = tmp.begin(); it != tmp.end(); ++it)
if (Trace[*it] != -1)
if (d[*it] >= b[*it]) {
x = min(*it, Trace[*it]);
y = max(*it, Trace[*it]);
if (my_map[pair<int, int>(x, y)].size() == 1) {
itx = my_map[pair<int, int>(x, y)].begin();
res[*itx] = 2;
}
Trace[*it] = 0;
}
for (it = t[i].begin(); it != t[i].end(); ++it)
Union(e[*it].first, e[*it].second);
for (it = tmp.begin(); it != tmp.end(); ++it) {
c[*it].clear();
b[*it] = Trace[*it] = 0;
}
}
for (int i = 1; i <= m; ++i)
if (res[i] == 0)
printf("none\n");
else if (res[i] == 1)
printf("at least one\n");
else if (res[i] == 2)
printf("any\n");
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
int n;
int a[200005];
double check(double mid) {
double ans = 0.0;
double x = 0.0, y = 0.0;
double hamada = 0.0;
for (int i = 0; i < n; i++) {
hamada += a[i] - mid;
x = max(x, hamada);
if (hamada < 0) hamada = 0.0;
ans = max(ans, (x, hamada));
}
hamada = 0.0;
for (int i = 0; i < n; i++) {
hamada += -a[i] + mid;
y = max(y, hamada);
if (hamada < 0) hamada = 0.0;
ans = max(ans, (y, hamada));
}
return ans;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
double lo = -10000.0, hi = 10000.0;
int x = 0;
while (x++ < 500) {
double mid1 = (lo + lo + hi) / 3.0, mid2 = (hi + hi + lo) / 3.0;
if (check(mid1) > check(mid2)) {
lo = mid1;
} else
hi = mid2;
}
printf("%.12lf", check((lo + hi) / 2.0));
return 0;
}
| 12
|
#include <bits/stdc++.h>
struct myc {
int x, y, a, b;
};
std::deque<bool> m[305][305];
std::vector<myc> sol[2];
char s[100009];
int nrlin, nrcol;
int destL[2], destC[2];
inline void baga(int sursaL, int sursaC, int dest0L, int dest0C, int dest1L,
int dest1C, int t) {
destL[0] = dest0L;
destC[0] = dest0C;
destL[1] = dest1L;
destC[1] = dest1C;
auto &v = m[sursaL][sursaC];
while (!v.empty()) {
bool x;
if (t == 0) {
x = v.back();
v.pop_back();
} else {
x = v.front();
v.pop_front();
}
sol[t].push_back({sursaL, sursaC, destL[x], destC[x]});
if (t == 0)
m[destL[x]][destC[x]].push_front(x);
else
m[destL[x]][destC[x]].push_back(x);
}
}
inline void solve(int t) {
for (int i = 1; i <= nrlin; i++) {
fgets(s, 100009, stdin);
int pos = 0;
for (int j = 1; j <= nrcol; j++) {
m[i][j].clear();
while (s[pos] != '0' && s[pos] != '1') pos++;
while (s[pos] == '0' || s[pos] == '1') m[i][j].push_back(s[pos++] - '0');
}
}
for (int i = 1; i < nrlin; i++) baga(i, 1, nrlin, 1, nrlin, 1, t);
for (int i = 2; i <= nrcol; i++) baga(nrlin, i, nrlin, 1, nrlin, 1, t);
baga(nrlin, 1, 1, 1, nrlin, nrcol, t);
for (int i = 1; i < nrlin; i++)
for (int j = 2; j <= nrcol; j++) baga(i, j, i, 1, nrlin, j, t);
for (int i = 2; i < nrlin; i++) baga(i, 1, 1, 1, 1, 1, t);
for (int i = 2; i < nrcol; i++) baga(nrlin, i, nrlin, nrcol, nrlin, nrcol, t);
}
int main() {
fscanf(stdin, "%d%d ", &nrlin, &nrcol);
solve(0);
solve(1);
fprintf(stdout, "%u\n", sol[0].size() + sol[1].size());
for (auto &x : sol[0]) fprintf(stdout, "%d %d %d %d\n", x.x, x.y, x.a, x.b);
for (int i = sol[1].size() - 1; i >= 0; i--)
fprintf(stdout, "%d %d %d %d\n", sol[1][i].a, sol[1][i].b, sol[1][i].x,
sol[1][i].y);
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
long long n = s.length();
long long h = 0;
long long sharp = 0;
long long lastsharp = -1;
for (long long i = 0; i < n; i++) {
if (s[i] == '(') {
h++;
} else if (s[i] == ')') {
h--;
} else if (s[i] == '#') {
h--;
sharp++;
lastsharp = i;
}
if (h < 0) {
cout << -1 << endl;
return 0;
}
}
long long lastsharpminus = 1 + h;
h = 0;
for (long long i = 0; i < n; i++) {
if (i == lastsharp) {
h -= lastsharpminus;
} else if (s[i] == '(') {
h++;
} else if (s[i] == ')') {
h--;
} else if (s[i] == '#') {
h--;
}
if (h < 0) {
cout << -1 << endl;
return 0;
}
}
for (long long i = 0; i < (sharp - 1); i++) {
cout << 1 << endl;
}
cout << lastsharpminus << endl;
return 0;
}
| 7
|
#include <bits/stdc++.h>
int main() {
char str[10000];
int j = 0;
gets(str);
int len = strlen(str);
for (int i = 0; i < len;) {
int j = 0;
bool read_alpha = false;
bool read_char = false;
while (isalpha(str[i])) {
read_alpha = true;
printf("%c", str[i++]);
if (i >= len) {
puts("");
return 0;
}
}
if (str[i] != ' ') {
putchar(str[i]);
read_char = true;
putchar(' ');
i++;
}
if (str[i] == ' ') {
while (str[i] == ' ') i++;
if (isalpha(str[i]) && !read_char) putchar(' ');
}
}
puts("");
return 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int cnt, sum, ans;
bool vis[1000005];
vector<int> e[1000005];
vector<int> v;
void dfs(int x) {
if (vis[x]) return;
vis[x] = 1;
cnt++;
for (int i = 0; i < e[x].size(); i++) dfs(e[x][i]);
}
int main() {
scanf("%d%d%d", &n, &m, &k);
while (m--) {
int x, y;
scanf("%d%d", &x, &y);
e[x].push_back(y);
e[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
cnt = 0;
dfs(i);
if (cnt) v.push_back(min(k, cnt));
}
sort(v.begin(), v.end());
if (k == 1) {
printf("%d\n", max(0, (int)v.size() - 2));
return 0;
}
for (int i = 0; i < v.size(); i++) sum += v[i];
ans = v.size() - sum / 2 - 1;
if (ans <= 0)
printf("0\n");
else
printf("%d\n", ans);
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
for (; !isdigit(ch); ch = getchar()) {
if (ch == '-') f = -1;
}
for (; isdigit(ch); ch = getchar()) {
x = x * 10 + ch - 48;
}
return x * f;
}
const int N = 101;
const int S = 26;
char str[N + 3];
namespace Subtask {
int a[N + 3][N + 3][S + 3], cnta[N + 3], b[N + 3][N + 3][S + 3], cntb[N + 3];
bool fa[N + 3][N + 3], fb[N + 3][N + 3];
int cur[S + 3];
char ans[N + 3];
void solve(int n, char ans[]) {
cout << '?' << ' ' << 1 << ' ' << n - 1 << ' ' << endl;
cout.flush();
for (int i = 1; i <= (n - 1) * n / 2; i++) {
cin >> str + 1;
int len = strlen(str + 1);
cnta[len]++;
for (int j = 1; j <= len; j++) a[len][cnta[len]][str[j] - 96]++;
}
cout << '?' << ' ' << 1 << ' ' << n << ' ' << endl;
cout.flush();
for (int i = 1; i <= n * (n + 1) / 2; i++) {
cin >> str + 1;
int len = strlen(str + 1);
cntb[len]++;
for (int j = 1; j <= len; j++) b[len][cntb[len]][str[j] - 96]++;
}
for (int i = 1; i <= n; i++) {
int id = 0;
for (int k = 1; k <= cntb[i]; k++) {
bool found = false;
for (int j = 1; j <= cnta[i]; j++) {
if (fa[i][j]) continue;
bool same = true;
for (int s = 1; s <= S; s++) {
if (a[i][j][s] != b[i][k][s]) {
same = false;
break;
}
}
if (same) {
found = true;
fa[i][j] = true;
break;
}
}
if (!found) {
id = k;
break;
}
}
for (int s = 1; s <= S; s++) {
if (b[i][id][s] != cur[s]) {
cur[s]++;
ans[n - i + 1] = s + 96;
break;
}
}
}
}
} // namespace Subtask
int a[N + 3][N + 3][S + 3], cnta[N + 3];
int tot[N + 3][S + 3];
int dif[N + 3][S + 3];
char ans[N + 3];
int n;
int main() {
cin >> n;
if (n == 1) {
cout << '?' << ' ' << 1 << ' ' << 1 << endl;
cout.flush();
cin >> ans;
cout << '!' << ' ' << ans << endl;
cout.flush();
return 0;
} else if (n == 2) {
Subtask::solve(2, ans);
cout << '!' << ' ' << ans + 1 << endl;
cout.flush();
return 0;
}
int nn = (n + 1) >> 1;
Subtask::solve(nn, ans);
cout << '?' << ' ' << 1 << ' ' << n << endl;
cout.flush();
for (int i = 1; i <= n * (n + 1) / 2; i++) {
cin >> str + 1;
int len = strlen(str + 1);
cnta[len]++;
for (int j = 1; j <= len; j++)
a[len][cnta[len]][j] = str[j] - 96, tot[len][str[j] - 96]++;
}
for (int l = nn + 1; l <= n; l++) {
for (int i = 1; i <= nn; i++) {
tot[l][ans[i] - 96] -= min(i, n - l + 1);
}
}
for (int l = nn + 1; l <= n; l++) {
for (int i = 1; i <= S; i++) {
dif[l][i] = tot[l][i] - tot[l + 1][i];
if (dif[l][i] != dif[l - 1][i]) {
ans[l] = i + 96;
}
}
}
cout << '!' << ' ' << ans + 1 << endl;
cout.flush();
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b;
cin >> a >> b;
char c[a.length() + 1];
int i = 1;
int k = 0;
c[k++] = a[0];
while (a[i] < b[0] && i < a.length()) {
c[k++] = a[i];
i++;
}
c[k++] = b[0];
c[k] = '\0';
cout << c;
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
inline void mine(T1 &x, T2 y) {
if (x > y) x = y;
}
template <typename T1, typename T2>
inline void maxe(T1 &x, T2 y) {
if (x < y) x = y;
}
ostream &operator<<(ostream &a, const vector<int> &b) {
for (auto k : b) cout << k << ' ';
return a;
}
const int MOD = 1000000007;
const int INF = 1000000050;
const long long BIG = (long long)2e18 + 50;
const int MX = 10000;
const double EPS = 1e-9;
const int BUBEN = INF;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
string tos(int x, int len) {
string res;
while (x) {
res += '0' + x % 10;
x /= 10;
}
while ((int)res.size() < len) res += '0';
reverse(res.begin(), res.end());
return res;
}
int toi(string s) {
int res = 0;
for (auto &x : s) res = res * 10 + (x - '0');
return res;
}
int m;
set<string> res;
inline void add(string s) {
res.insert(s);
if ((int)res.size() == m) {
for (auto &x : res) cout << x << '\n';
exit(0);
}
}
vector<int> can[5][MX];
vector<string> divs[MX];
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
for (int i = 0; i < 10; i++) can[1][i].push_back(i);
int pw = 100;
for (int i = 2; i < 5; i++) {
for (int j = 0; j < pw; j++) {
string s = tos(j, i);
can[i][j].push_back(j);
for (int k = 0; k < i - 1; k++) {
int left = toi(s.substr(0, k + 1));
int right = toi(s.substr(k + 1, i - k - 1));
for (auto &l : can[k + 1][left]) {
for (auto &r : can[i - k - 1][right]) {
can[i][j].push_back(l * r);
can[i][j].push_back(l - r);
can[i][j].push_back(l + r);
}
}
}
sort(can[i][j].begin(), can[i][j].end());
can[i][j].resize(unique(can[i][j].begin(), can[i][j].end()) -
can[i][j].begin());
if (i == 4) {
for (auto &x : can[i][j]) {
if (x >= 0 && x < MX) divs[x].push_back(s);
}
}
}
pw *= 10;
}
int k;
cin >> k >> m;
for (int i = 0; i < k + 1; i++) {
int j = k - i;
if (j >= MX || i >= MX) continue;
for (auto &x : divs[i]) {
for (auto &y : divs[j]) {
add(x + y);
}
}
}
for (int i = k; i < MX; i++) {
int j = i - k;
if (j >= MX) continue;
for (auto &x : divs[i]) {
for (auto &y : divs[j]) {
add(x + y);
}
}
};
assert(k < 0);
}
| 19
|
#include <bits/stdc++.h>
using namespace std;
char buf[1 << 21], *p1 = buf, *p2 = buf;
template <class T>
void read(T &x) {
x = 0;
int c = getchar();
int flag = 0;
while (c < '0' || c > '9') flag |= (c == '-'), c = getchar();
while (c >= '0' && c <= '9')
x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
if (flag) x = -x;
}
template <class T>
T _max(T a, T b) {
return b < a ? a : b;
}
template <class T>
T _min(T a, T b) {
return a < b ? a : b;
}
template <class T>
bool checkmax(T &a, T b) {
return a < b ? a = b, 1 : 0;
}
template <class T>
bool checkmin(T &a, T b) {
return b < a ? a = b, 1 : 0;
}
const int N = 300005;
int n, m, k;
int arr[N], top = 0;
struct seg {
int l, r, bel;
bool operator<(const seg &rhs) const { return r < rhs.r; }
} a[N];
int rt[N], cnt = 0;
struct node {
int lson, rson, val;
node() { lson = rson = val = 0; }
} t[N * 25];
void push_up(int x) { t[x].val = _min(t[t[x].lson].val, t[t[x].rson].val); }
int update(int pre, int l, int r, int pos, int v) {
int now = ++cnt;
t[now] = t[pre];
if (l == r) {
checkmax(t[now].val, v);
return now;
}
int mid = (l + r) >> 1;
if (pos <= mid)
t[now].lson = update(t[pre].lson, l, mid, pos, v);
else
t[now].rson = update(t[pre].rson, mid + 1, r, pos, v);
push_up(now);
return now;
}
int query(int x, int l, int r, int L, int R) {
if (!x) return 0;
if (L <= l && r <= R) return t[x].val;
int mid = (l + r) >> 1;
if (R <= mid) return query(t[x].lson, l, mid, L, R);
if (L > mid) return query(t[x].rson, mid + 1, r, L, R);
return _min(query(t[x].lson, l, mid, L, R),
query(t[x].rson, mid + 1, r, L, R));
}
void init() {
read(n);
read(m);
read(k);
for (int i = 1; i <= k; ++i) {
read(a[i].l);
read(a[i].r);
read(a[i].bel);
}
sort(a + 1, a + k + 1);
for (int i = 1; i <= k;) {
int j = i;
while (j < k && a[j + 1].r == a[i].r) ++j;
arr[++top] = a[i].r;
for (int p = i, f = 1; p <= j; ++p) {
if (f)
f = 0, rt[top] = update(rt[top - 1], 1, n, a[p].bel, a[p].l);
else
rt[top] = update(rt[top], 1, n, a[p].bel, a[p].l);
}
i = j + 1;
}
}
int gpos(int num) {
int l = 1, r = top, mid, best = -1;
while (l <= r) {
int mid = (l + r) >> 1;
if (arr[mid] <= num)
best = mid, l = mid + 1;
else
r = mid - 1;
}
return best;
}
void solve() {
int l, r, x, y;
for (int i = 1; i <= m; ++i) {
read(l);
read(r);
read(x);
read(y);
if (y < arr[1]) {
printf("no\n");
fflush(stdout);
continue;
}
int pos = gpos(y);
int v = query(rt[pos], 1, n, l, r);
if (v >= x)
printf("yes\n");
else
printf("no\n");
fflush(stdout);
}
}
int main() {
init();
solve();
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
cin >> str;
int len = str.length();
int arr[len];
memset(arr, 0, sizeof arr);
for (int i = 0; i < str.length(); i++) {
if (i == 0) {
arr[i] = 1;
continue;
}
if (str[i] == str[i - 1])
arr[i] = arr[i - 1] + 1;
else
arr[i] = 1;
}
string t = "";
for (int i = 0; i < len; i++) {
if (arr[i] == 1 || arr[i] == 2) t += str[i];
}
for (int i = 0; i < t.length(); i++) {
if (i == 0) {
arr[i] = 1;
continue;
}
if (t[i] == t[i - 1])
arr[i] = arr[i - 1] + 1;
else
arr[i] = 1;
}
bool flag = false;
string ans = "";
for (int i = 0; i < t.length(); i++) {
if (arr[i] == 2) {
if (flag) {
flag = false;
} else {
ans += t[i];
flag = true;
}
} else {
ans += t[i];
if (i != t.length()) {
if (arr[i + 1] == 1) flag = false;
}
}
}
cout << ans;
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, v[300];
bool vis[300][300], F[300];
vector<pair<int, int> > edge;
void print() {
for (int i = 0; i < edge.size(); ++i)
printf("%d %d\n", edge[i].first + 1, edge[i].second + 1);
exit(0);
}
void addEdge(int a, int b) {
if (a > b) swap(a, b);
if (vis[a][b]) return;
vis[a][b] = true;
edge.push_back(make_pair(a, b));
if (edge.size() == m) print();
}
int main() {
scanf("%d%d%d", &n, &m, &k);
if (n == k) {
puts("-1");
return 0;
}
for (int i = 0; i < k; ++i) {
scanf("%d", v + i);
F[--v[i]] = true;
}
for (int i = 0; i < n; ++i)
if (i != v[0] && i != v[1]) addEdge(v[1], i);
for (int i = 0; i < n; ++i)
if (i != v[0] && !F[i]) {
addEdge(i, v[0]);
break;
}
for (int i = 0; i < n; ++i)
for (int j = i + 1; j < n; ++j)
if (i != v[0] && j != v[0] || (i == v[0] && !F[j]) ||
(j == v[0] && !F[i]))
addEdge(i, j);
printf("-1");
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, n, c = 0, d;
int arr[10000];
cin >> x >> n;
for (int i = 0; i < x; i++) {
cin >> arr[i];
if (arr[i] + n <= 5) c++;
}
d = c / 3;
cout << d;
c = 0;
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 20, MAXB = 1 << MAXN;
int dp[MAXB], a[MAXN][MAXN];
int sum[46], mx[46], mv[46], dx[46];
char s[MAXN][MAXN + 1];
int sz;
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", s[i]);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) scanf("%d", &a[i][j]);
memset(dp, 63, sizeof dp);
dp[0] = 0;
int MASK = 1 << n, lim = 26 + n;
for (int i = 0; i < m; i++) {
for (int j = 0; j < 26; j++) sum[j] = mx[j] = mv[j] = 0;
for (int j = 0; j < n; j++) {
dx[j + 26] = a[j][i];
mv[j + 26] = 1 << j;
int c = s[j][i] - 'a';
mv[c] |= (1 << j);
sum[c] += a[j][i];
mx[c] = max(mx[c], a[j][i]);
}
for (int j = 0; j < 26; j++) dx[j] = sum[j] - mx[j];
for (int mask = 0; mask < MASK; mask++)
for (int j = 0; j < 46; j++)
if (dp[mask | mv[j]] > dp[mask] + dx[j])
dp[mask | mv[j]] = dp[mask] + dx[j];
;
}
cout << dp[MASK - 1];
}
| 17
|
#include <bits/stdc++.h>
using namespace std;
vector<string> names;
int sum = 0;
int main() {
string str;
while (getline(cin, str)) {
if (str[0] == '+')
names.push_back(str);
else if (str[0] == '-') {
str[0] = '+';
for (int i = 0; i < names.size(); i++)
if (names[i] == str) names.erase(names.begin() + i);
} else {
int size = str.size(), n;
for (int i = 0; i < str.size(); i++)
if (str[i] == ':') n = i;
++n;
size -= n;
int result = (names.size() * size);
sum += result;
}
}
cout << sum << endl;
return 0;
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
long long GCD(long long a, long long b) { return b ? GCD(b, a % b) : a; }
long long LCM(long long a, long long b) { return a * b / GCD(a, b); }
const int N = 2e5 + 7;
const int mod = 1e9 + 7;
const long long inf = 1e18 + 7;
long long n, mOd;
long long a[N];
int main() {
cin >> n >> mOd;
for (int i = 1; i <= n; i++) cin >> a[i];
if (n > mOd) {
cout << "0\n";
return 0;
}
long long ans = 1;
sort(a + 1, a + 1 + n);
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
ans = ans * abs(a[i] - a[j]) % mOd;
if (ans == 0) break;
}
if (ans == 0) break;
}
cout << ans << "\n";
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
void voi() {
int n, a[205];
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) {
int g = 0;
bool f = 1;
for (int j = i; j <= n; j++) {
if (a[j] != ++g) {
f = 0;
break;
}
}
for (int j = 1; j < i; j++) {
if (a[j] != ++g) {
f = 0;
break;
}
}
if (f) {
puts("YES");
return;
}
g = n + 1;
f = 1;
for (int j = i; j <= n; j++) {
if (a[j] != --g) {
f = 0;
break;
}
}
for (int j = 1; j < i; j++) {
if (a[j] != --g) {
f = 0;
break;
}
}
if (f) {
puts("YES");
return;
}
}
puts("NO");
}
int main() {
int n, i;
cin >> n;
for (i = 0; i < n; i++) voi();
return 0;
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
bool leap(int x) {
if ((x % 4 == 0 && x % 100 != 0) || x % 400 == 0)
return true;
else
return false;
}
int main() {
int mon[13] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}, ar[6];
int y1, y2, m1, m2, d1, d2, m1a;
long long days = 0;
scanf("%d:%d:%d\n", &ar[0], &ar[1], &ar[2]);
scanf("%d:%d:%d", &ar[3], &ar[4], &ar[5]);
if (ar[0] > ar[3]) {
y2 = ar[0];
m2 = ar[1];
d2 = ar[2];
y1 = ar[3];
m1 = ar[4];
d1 = ar[5];
} else {
y2 = ar[3];
m2 = ar[4];
d2 = ar[5];
y1 = ar[0];
m1 = ar[1];
d1 = ar[2];
}
days += mon[m1] - d1;
m1a = m1;
m1a++;
while (m1a <= 12) {
days += mon[m1a];
m1a++;
}
if (leap(y1) && m1 <= 2) {
days++;
}
for (int i = y1 + 1; i < y2; i++) {
if (i >= y2) break;
if (leap(i))
days += 366;
else
days += 365;
}
for (int j = 1; j < m2; j++) {
days += mon[j];
}
days += d2;
if (leap(y2) && m2 > 2) {
days++;
}
if (y1 == y2) {
if (leap(y1))
days -= 366;
else
days = days - 365;
}
if (days < 0) days = (-1) * days;
cout << days << "\n";
}
| 5
|
#include <bits/stdc++.h>
const int N = 5e6 + 6;
int n, x, a[N], len;
inline int pow(int x, int k, int mod) {
long long res = 1, r = x % mod;
for (; k; k >>= 1, r = r * r % mod)
if (k & 1) res = res * r % mod;
return res;
}
int main() {
scanf("%d%d", &n, &x);
if (n == 1 && x <= 2) {
puts("-1");
return 0;
}
for (int i = 2; i * i <= n + 1; ++i)
if ((n + 1) % i == 0) {
puts("-1");
return 0;
}
for (int i = 1; i * i <= n; ++i)
if (n % i == 0) a[++len] = i, a[++len] = n / i;
if (a[len] == a[len - 1]) --len;
for (int i = x - 1; i >= 1; --i) {
bool flag = true;
for (int k = 1; k <= len; ++k)
if (a[k] != n && pow(i, a[k], n + 1) == 1) {
flag = false;
break;
}
if (flag) {
printf("%d\n", i);
return 0;
}
}
puts("-1");
return 0;
}
| 18
|
#include <bits/stdc++.h>
using namespace std;
int n, k, Ti = 0, idx, a, b, t;
bool flag;
string s;
int main() {
cin >> n >> k >> s;
idx = a = b = 0;
for (int i = 0; i < n; i++) {
flag = 1;
for (int j = idx; j < n; j++) {
if (s[j] == 'a')
a++;
else
b++;
t = min(a, b);
if (t > k) {
flag = 0;
Ti = max(Ti, b + a - 1);
idx = j;
if (s[j] == 'a')
a--;
else
b--;
break;
}
}
if (flag) {
Ti = max(Ti, b + a);
break;
} else {
if (s[i] == 'a')
a--;
else
b--;
}
}
cout << Ti << endl;
return 0;
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
const int MXN = 7007;
int n, k[2], moves[2][MXN], cnts[2][MXN];
int dp[2][MXN];
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < 2; i++) {
cin >> k[i];
for (int j = 0; j < k[i]; j++) cin >> moves[i][j];
}
memset(dp, -1, sizeof(dp));
dp[0][0] = 0;
dp[1][0] = 0;
queue<pair<int, int> > q;
q.push(make_pair(0, 0));
q.push(make_pair(1, 0));
while (!q.empty()) {
pair<int, int> front = q.front();
q.pop();
int player = front.first;
int loc = front.second;
if (dp[player][loc] == 0) {
for (int j = 0; j < k[player ^ 1]; j++) {
int jump = moves[player ^ 1][j];
int new_loc = (loc - jump + n) % n;
if (dp[player ^ 1][new_loc] == -1) {
dp[player ^ 1][new_loc] = 1;
q.push(make_pair(player ^ 1, new_loc));
}
}
} else {
for (int j = 0; j < k[player ^ 1]; j++) {
int jump = moves[player ^ 1][j];
int new_loc = (loc - jump + n) % n;
cnts[player ^ 1][new_loc]++;
if (cnts[player ^ 1][new_loc] == k[player ^ 1] &&
dp[player ^ 1][new_loc] == -1) {
dp[player ^ 1][new_loc] = 0;
q.push(make_pair(player ^ 1, new_loc));
}
}
}
}
for (int player = 0; player <= 1; player++) {
for (int i = 1; i < n; i++) {
switch (dp[player][i]) {
case 0:
cout << "Lose ";
break;
case 1:
cout << "Win ";
break;
case -1:
cout << "Loop ";
break;
}
}
cout << endl;
}
return 0;
}
| 12
|
#include <bits/stdc++.h>
char c;
void consumirInteiro() {
while (c >= '0' && c <= '9') {
printf("%c", c);
c = getchar();
}
}
void consumirDots() {
for (int i = 0; i < 3; i++) c = getchar();
printf("...");
}
int main() {
char space = 0;
c = getchar();
while (c != '\n') {
if (c >= '1' && c <= '9') {
consumirInteiro();
space = 1;
break;
} else if (c == '.') {
consumirDots();
space = 0;
break;
} else if (c == ',') {
printf(",");
c = getchar();
space = 2;
break;
}
c = getchar();
}
while (c != '\n') {
if (c >= '1' && c <= '9') {
if (space) printf(" ");
consumirInteiro();
space = 1;
} else if (c == '.') {
printf(" ");
consumirDots();
space = 0;
} else if (c == ',') {
if (space == 2)
printf(" ,");
else
printf(",");
c = getchar();
space = 2;
} else
c = getchar();
}
puts("");
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
struct arr {
char c;
int u;
int v;
};
struct arr q[1005];
int main() {
int n, k, i, m = 0, j, t, l = 99999999, p = 0, s = 0;
int a[1005];
cin >> n >> k;
for (i = 0; i < n; i++) {
cin >> a[i];
m = max(m, a[i] + (k * (n - i - 1)));
}
for (i = m; i >= (1 + (n - 1) * k); i--) {
s = 0;
t = i;
for (j = n - 1; j >= 0; j--) {
if (abs(a[j] - t) != 0) s++;
t = t - k;
}
if (s < l) {
l = s;
p = i;
}
}
t = 1;
l = 0;
for (i = n - 1; i >= 0; i--) {
if (a[i] < (p)) {
q[l].c = '+';
q[l].u = i + 1;
q[l].v = abs(a[i] - p);
l++;
} else if (a[i] > (p)) {
q[l].c = '-';
q[l].u = i + 1;
q[l].v = abs(a[i] - p);
l++;
}
p = p - k;
}
cout << l << endl;
for (i = l - 1; i >= 0; i--) {
cout << q[i].c << " " << q[i].u << " " << q[i].v << endl;
}
return 0;
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 50000 + 10, MOD = (int)1e9 + 7, MAXLOG = 31;
struct Trie {
int prev, size, son[2], num[MAXLOG];
} t[MAXN * MAXLOG];
int n, m, a[MAXN], I2, Tohka, tot = 1;
int Pow(int a, int b) {
int d = 1;
for (; b; d = (b & 1) ? (long long)d * a % MOD : d,
a = (long long)a * a % MOD, b /= 2)
;
return d;
}
int Get(int w, int p) { return ((w & (1 << p))) > 0; }
void Insert(int a) {
int first = 1;
for (int i = MAXLOG - 1; i >= 0; --i) {
++t[first].size;
for (int j = 0; j < MAXLOG; ++j) t[first].num[j] += Get(a, j);
int id = Get(a, i);
if (t[first].son[id])
first = t[first].son[id];
else
t[first].son[id] = ++tot, t[tot].prev = (t[first].prev << 1) + id,
first = tot;
}
++t[first].size;
for (int j = 0; j < MAXLOG; ++j) t[first].num[j] += Get(a, j);
}
void init() {
cin >> n >> m;
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]), Insert(a[i]);
I2 = Pow(2, MOD - 2);
}
int Push(int prev, int p) {
int first = 1;
for (int i = 30, id = Get(prev, i); i >= p; --i, id = Get(prev, i))
if (t[first].son[id])
first = t[first].son[id];
else
return -1;
return first;
}
long long Calc(int prev, int p) {
long long Tohka = 0;
for (int i = 1; i <= n; ++i) {
int b = a[i] ^ prev, first = Push(b, p);
if (first == -1) continue;
Tohka += t[first].size;
}
return Tohka / 2;
}
long long Count(int prev, int p) {
long long Tohka = 0;
for (int i = 1; i <= n; ++i) {
int b = a[i] ^ prev, first = Push(b, p);
if (first == -1) continue;
for (int j = 0; j <= p; ++j)
Tohka = (Tohka + (long long)(1 << j) *
((!Get(a[i], j)) ? t[first].num[j]
: t[first].size - t[first].num[j]) %
MOD) %
MOD;
}
return (Tohka * I2) % MOD;
}
void solve() {
for (int i = MAXLOG - 1, prev = 0; i >= 0; --i) {
long long num = Calc(prev + (1 << i), i);
if (num > m)
prev += (1 << i), Tohka = (Tohka + (long long)(1 << i) * m % MOD) % MOD;
else
Tohka = (Tohka + Count(prev + (1 << i), i)) % MOD, m -= num;
}
cout << Tohka << endl;
}
int main() {
init();
solve();
fclose(stdin);
fclose(stdout);
return 0;
}
| 19
|
#include <bits/stdc++.h>
#pragma GCC optimize "03"
using namespace std;
const int N = 2e5 + 5;
const int mod = 1e9 + 7;
const int inf = 1e9 + 9;
int a[N], b[N];
map<int, int> m;
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
vector<char> s(n, '\0');
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) cin >> b[i];
int c = 0;
for (int i = 1; i <= n; i++) {
if (m.find(a[i]) == m.end()) {
m[a[i]]++;
} else {
m[a[i]]--;
m.erase(a[i]);
}
if (m.find(b[i]) == m.end()) {
m[b[i]]++;
} else {
m[b[i]]--;
m.erase(b[i]);
}
if (c > 25)
s[a[i] - 1] = 'z';
else
s[a[i] - 1] = char('a' + c);
if (m.size() == 0 && c <= k - 1) c++;
}
if (c <= k - 1) return cout << "NO", 0;
cout << "YES" << '\n';
for (auto i : s) cout << i;
return 0;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int sub(int x, int y, int p) {
x -= y;
return (x < 0) ? (x + p) : x;
}
int mul(int x, int y, int p) { return (ll)x * y % p; }
int get(int x, int k, int p) {
return sub(mul(mul(x, x, p), mul(x, x, p), p), mul(x, k, p), p);
}
unordered_map<int, int> cnt;
int main() {
cin.sync_with_stdio(false), cin.tie(nullptr);
int n, p, k;
cin >> n >> p >> k;
ll res = 0;
for (int i = 0, x, v; i < n; i++) {
cin >> x, v = get(x % p, k % p, p);
if (cnt.count(v)) {
res += cnt[v];
}
cnt[v]++;
}
cout << res << "\n";
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, b, q;
scanf("%d%d%d", &n, &b, &q);
int ans1 = 0, ans2 = n * q;
while (n != 1) {
int temp = 1;
while (temp <= n) temp *= 2;
temp /= 2;
ans1 += 2 * b * (temp / 2) + (temp / 2);
n = n - temp + temp / 2;
}
printf("%d %d\n", ans1, ans2);
return 0;
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
bool isprim(int n) {
if (n == 2) return 1;
if (n % 2 == 0 || n < 2) return 0;
for (int i = 3; i * i <= n; i += 2)
if (n % i == 0) return 0;
return 1;
}
int main() {
vector<int> myvec;
int n, counter = 0;
cin >> n;
for (int i = 2; i <= n; i++)
if (isprim(i)) myvec.push_back(i);
int len = myvec.size();
for (int i = 3; i <= n; i++) {
int cnt = 0;
for (int j = 0; j < len; j++) {
if (i >= myvec[j])
if (i % myvec[j] == 0 && myvec[j] * myvec[j] != i) cnt++;
}
if (cnt == 2) counter++;
}
cout << counter << endl;
return 0;
}
| 1
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 5;
bool check(string a, string b) {
if (a.size() < b.size()) return false;
int start1 = 0, start2 = 0;
while (1) {
if (start2 == b.size()) return true;
if (start1 == a.size()) return false;
if (a[start1] == b[start2]) {
start1++;
start2++;
} else
start1++;
}
return false;
}
void solve() {
string s1, s2;
cin >> s1 >> s2;
int ans = 0;
int len = s1.size();
for (int i = 0; i < len; i++) {
for (int j = i; j < len; j++) {
string cur = "";
for (int k = 0; k < i; k++) cur += s1[k];
for (int k = j + 1; k < len; k++) cur += s1[k];
if (check(cur, s2)) {
ans = max(ans, (int)(s1.size() - cur.size()));
}
}
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) solve();
cerr << "Time : " << 1000 * ((double)clock()) / (double)CLOCKS_PER_SEC
<< "ms\n";
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y;
cin >> x >> y;
if (x > 0 && y > 0) cout << "0 " << x + y << " " << x + y << " 0";
if (x < 0 && y > 0) cout << x - y << " 0 0 " << y - x;
if (x > 0 && y < 0) cout << "0 " << y - x << " " << x - y << " 0";
if (x < 0 && y < 0) cout << x + y << " 0 0 " << x + y;
return 0;
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
inline int rd() {
int a = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) a = a * 10 + (ch ^ 48), ch = getchar();
return a * f;
}
int n, q, num[100009], tr[100009], a[100009], dp[100009], ans;
int fa[100009], top[100009], dep[100009], son[100009], dfn[100009], siz[100009],
timer;
vector<int> g[100009];
void add(int x, int d) {
for (int i = x; i <= n; i += i & -i) tr[i] += d;
}
int ask(int x) {
int res = 0;
for (int i = x; i > 0; i -= i & -i) (res += tr[i]) %= 1000000007;
return res;
}
void dfs1(int u, int ft) {
siz[u] = 1;
for (int v : g[u]) {
if (v == ft) continue;
dep[v] = dep[u] + 1, fa[v] = u;
dfs1(v, u), siz[u] += siz[v];
if (siz[v] > siz[son[u]]) son[u] = v;
}
}
void dfs2(int u, int tp) {
dfn[u] = ++timer, top[u] = tp;
if (son[u]) dfs2(son[u], tp);
for (int v : g[u]) {
if (v == fa[u] || v == son[u]) continue;
dfs2(v, v);
}
}
int query(int x, int y) {
int res = 0;
while (top[x] != top[y]) {
if (dep[top[x]] < dep[top[y]]) x ^= y ^= x ^= y;
res += ask(dfn[x]) - ask(dfn[top[x]] - 1);
x = fa[top[x]];
}
if (dfn[x] > dfn[y]) x ^= y ^= x ^= y;
res += ask(dfn[y]) - ask(dfn[x] - 1);
return res;
}
signed main() {
n = rd(), q = rd();
for (int i = 1; i < n; ++i) {
int x = rd(), y = rd();
g[x].push_back(y), g[y].push_back(x);
}
dfs1(1, 0), dfs2(1, 1);
while (q--) {
int k = rd(), m = rd(), r = rd();
for (int i = 1; i <= k; ++i) a[i] = rd(), add(dfn[a[i]], 1);
for (int i = 1; i <= k; ++i) num[i] = query(r, a[i]) - 1, dp[i] = 0;
dp[0] = 1, ans = 0;
sort(num + 1, num + k + 1);
for (int i = 1; i <= k; ++i) {
for (int j = min(m, i); j >= 0; --j) {
if (j <= num[i]) dp[j] = 0;
if (!j) break;
dp[j] =
(dp[j - 1] + 1ll * dp[j] * (j - num[i]) % 1000000007) % 1000000007;
}
}
for (int i = 1; i <= k; ++i) ans = (ans + dp[i]) % 1000000007;
printf("%d\n", ans);
for (int i = 1; i <= k; ++i) add(dfn[a[i]], -1);
}
return 0;
}
| 17
|
#include <bits/stdc++.h>
int main() {
int a, b, x1, x2, y1, y2;
int s, a1, b1;
while (scanf("%d%d", &a, &b) != EOF) {
if (a < 0) {
a1 = -a;
} else
a1 = a;
if (b < 0) {
b1 = -b;
} else
b1 = b;
s = a1 + b1;
if (a >= 0 && b >= 0) {
x1 = 0;
y1 = s;
x2 = s;
y2 = 0;
}
if (a >= 0 && b < 0) {
x1 = 0;
y1 = -s;
x2 = s;
y2 = 0;
}
if (a < 0 && b >= 0) {
x1 = -s;
y1 = 0;
x2 = 0;
y2 = s;
}
if (a < 0 && b < 0) {
x1 = -s;
y1 = 0;
x2 = 0;
y2 = -s;
}
printf("%d %d %d %d\n", x1, y1, x2, y2);
}
return 0;
}
| 2
|
#include <bits/stdc++.h>
const int N = 1e5;
struct Node {
long long l, r;
mutable bool v;
Node(long long _l, long long _r = 0, bool _v = 0) : l(_l), r(_r), v(_v) {}
};
inline bool operator<(const Node& x, const Node& y) { return x.l < y.l; }
std::set<Node> s;
long long n;
inline void read(long long& x) {
x = 0;
char c = getchar();
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + c - 48, c = getchar();
}
inline std::set<Node>::iterator split(long long pos) {
std::set<Node>::iterator it = s.lower_bound(Node(pos));
if (it->l == pos && it != s.end()) return it;
it--;
long long l = it->l, r = it->r;
bool v = it->v;
s.erase(it);
s.insert(Node(l, pos - 1, v));
return s.insert(Node(pos, r, v)).first;
}
inline void assign(long long l, long long r, bool v) {
std::set<Node>::iterator itr = split(r + 1), itl = split(l);
s.erase(itl, itr);
s.insert(Node(l, r, v));
}
inline void reverse(long long l, long long r) {
std::set<Node>::iterator itr = split(r + 1), itl = split(l);
for (std::set<Node>::iterator it = itl; it != itr; it++) it->v ^= 1;
}
inline long long query() {
for (std::set<Node>::iterator it = s.begin(); it != s.end(); it++)
if (it->v == 0) return it->l;
return -1;
}
int main() {
read(n);
s.insert(Node(1, 1e18, 0));
while (n--) {
long long opt, l, r;
read(opt), read(l), read(r);
if (opt == 1) assign(l, r, 1);
if (opt == 2) assign(l, r, 0);
if (opt == 3) reverse(l, r);
printf("%lld\n", query());
}
return 0;
}
| 15
|
#include <bits/stdc++.h>
struct solver {
int mod, inv_10_mod_mod;
int64_t ans;
struct edge {
int node, digit;
bool constexpr operator==(edge e) const { return node == e.node; }
};
struct edge_hash {
size_t operator()(edge e) const { return e.node; }
};
std::vector<std::unordered_set<edge, edge_hash>> adjl;
solver(int nnode, int mod)
: mod(mod), ans(), adjl(nnode), treeSizeResult(nnode) {
int64_t one_MOD_mod = 1;
while (one_MOD_mod % 10) one_MOD_mod += mod;
inv_10_mod_mod = one_MOD_mod / 10;
}
void addEdge(int x, int y, int digit) {
adjl[x].insert({y, digit});
adjl[y].insert({x, digit});
}
std::vector<int> treeSizeResult;
int treeSize(int node, int parent = -1) {
int ans = 1;
for (edge e : adjl[node])
if (e.node != parent) ans += treeSize(e.node, node);
return treeSizeResult[node] = ans;
}
int findCentroid(int node) {
int componentSize = treeSize(node);
int maxSTSize = (componentSize + 1) / 2;
int centroid = node, parent = -1;
continue_finding:
for (edge e : adjl[centroid])
if (e.node != parent)
if (treeSizeResult[e.node] > maxSTSize) {
parent = centroid;
centroid = e.node;
goto continue_finding;
}
return centroid;
}
std::unordered_map<int, int> upValuesCount, downValuesCount;
std::vector<int> upValues, downValues;
void findPathValues(int node, int parent, int selfUpValue, int selfDownValue,
int multiplier, int divider) {
upValues.push_back(selfUpValue);
downValues.push_back(selfDownValue);
for (edge e : adjl[node])
if (e.node != parent) {
int childUpValue = (selfUpValue + e.digit * (int64_t)multiplier) % mod;
int childDownValue = (selfDownValue + e.digit * (int64_t)divider) % mod;
findPathValues(e.node, node, childUpValue, childDownValue,
multiplier * 10LL % mod,
divider * (int64_t)inv_10_mod_mod % mod);
}
}
void solve(int node) {
int const root = findCentroid(node);
assert(std::cout << "solve(" << node << ") => root=" << root << '\n');
if (adjl[root].empty()) return;
upValuesCount.clear();
downValuesCount.clear();
for (edge e : adjl[root]) {
assert(std::cout << " branch " << e.node << "\n");
upValues.clear();
downValues.clear();
findPathValues(e.node, root, e.digit,
e.digit * (int64_t)inv_10_mod_mod % mod, 10 % mod,
inv_10_mod_mod * (int64_t)inv_10_mod_mod % mod);
for (int upv : upValues) {
assert(std::cout << " upv " << upv << '\n');
auto it = downValuesCount.find((mod - upv) % mod);
if (it != downValuesCount.end()) ans += it->second;
}
for (int downv : downValues) {
assert(std::cout << " downv " << downv << '\n');
auto it = upValuesCount.find((mod - downv) % mod);
if (it != upValuesCount.end()) ans += it->second;
}
for (int upv : upValues) ++upValuesCount[upv];
for (int downv : downValues) ++downValuesCount[downv];
}
ans += upValuesCount[0];
ans += downValuesCount[0];
for (edge e : adjl[root]) {
adjl[e.node].erase({root, e.digit});
solve(e.node);
}
adjl[root].clear();
}
};
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
int nnode, mod;
std::cin >> nnode >> mod;
solver s(nnode, mod);
for (int i = nnode - 1; i-- > 0;) {
int u, v, digit;
std::cin >> u >> v >> digit;
s.addEdge(u, v, digit % mod);
}
s.solve(0);
std::cout << s.ans << '\n';
}
| 19
|
#include <bits/stdc++.h>
using namespace std;
inline long long read();
const int N = 1e5 + 2;
int n, tp, t[N];
long long x[N], sum;
queue<int> c[62];
void Work() {
n = read();
for (int i = 1; i <= n; ++i) {
x[i] = read();
sum ^= x[i];
for (int j = 60; j >= 0; --j)
if ((x[i] >> j) & 1) {
c[j].push(i);
break;
}
}
while (sum) {
bool ok = 0;
for (int i = 0; i <= 60; ++i)
if ((sum >> i) & 1 && !c[i].empty()) {
t[++tp] = c[i].front();
c[i].pop();
sum ^= x[t[tp]];
ok = 1;
break;
}
if (!ok) {
printf("No");
return;
}
}
if (tp != n) {
printf("No");
return;
}
printf("Yes\n");
for (int i = n; i >= 1; --i) printf("%lld ", x[t[i]]);
}
int main() {
Work();
return 0;
}
inline long long read() {
char c;
bool type = 1;
while ((c = getchar()) < '0' || c > '9')
if (c == '-') type = 0;
long long ans = c ^ 48;
while ((c = getchar()) >= '0' && c <= '9')
ans = (ans << 3) + (ans << 1) + (c ^ 48);
return type ? ans : -ans;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
int n, a[10000], b[10000], ans;
int main(int argc, char const *argv[]) {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i] >> b[i];
}
for (int i = 1; i <= n; i++) {
int cnt = 0;
for (int j = 1; j <= n; j++) {
if (a[i] == a[j] && b[i] > b[j]) {
cnt++;
break;
}
}
for (int j = 1; j <= n; j++) {
if (a[i] == a[j] && b[i] < b[j]) {
cnt++;
break;
}
}
for (int j = 1; j <= n; j++) {
if (a[i] > a[j] && b[i] == b[j]) {
cnt++;
break;
}
}
for (int j = 1; j <= n; j++) {
if (a[i] < a[j] && b[i] == b[j]) {
cnt++;
break;
}
}
if (cnt == 4) ans++;
}
cout << ans << endl;
return 0;
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
char arr[1001];
int main() {
int i, odd = 0, hash[26] = {0};
scanf("%s", arr);
for (i = 0; i < strlen(arr); i++) hash[arr[i] - 'a']++;
for (i = 0; i < 26; i++)
if (hash[i] % 2 != 0) odd++;
if (odd <= 1)
printf("%s", "First");
else {
if (odd % 2 != 0)
printf("%s", "First");
else
printf("%s", "Second");
}
return 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100005;
long long p, pos1, pos2, q, x, l, ans = 0, r, y, z, k, n, m, t, d, c = 0;
vector<int> f;
long long int mn = 0x3f3f3f3f, len, cnt = 1, mx = -1000;
int main() {
cin >> n >> m;
cin >> x;
vector<long long int>::iterator it1, it2;
vector<long long int> v1, v2;
for (int i = 0; i < x; i++) {
cin >> z;
v1.push_back(z);
}
cin >> x;
for (int i = 0; i < x; i++) {
cin >> z;
v2.push_back(z);
}
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
for (int i = n; i >= 1; i--)
for (int j = 1; j <= m; j++) {
it1 = lower_bound(v1.begin(), v1.end(), i + j);
it2 = lower_bound(v2.begin(), v2.end(), i + m + 1 - j);
if (it1 != v1.end())
v1.erase(it1);
else if (it2 != v2.end())
v2.erase(it2);
else {
cout << "NO";
return 0;
}
}
cout << "YES";
return 0;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool isLeap(T y) {
return (y % 400 == 0) || (y % 100 ? y % 4 == 0 : false);
}
template <class T>
inline T gcd(T a, T b) {
return (b) == 0 ? (a) : gcd((b), ((a) % (b)));
}
template <class T>
inline T lcm(T a, T b) {
return ((a) / gcd((a), (b)) * (b));
}
template <class T>
inline T BigMod(T Base, T power, T M = 1000000007) {
if (power == 0) return 1;
if (power & 1)
return ((Base % M) * (BigMod(Base, power - 1, M) % M)) % M;
else {
T y = BigMod(Base, power / 2, M) % M;
return (y * y) % M;
}
}
template <class T>
inline T ModInv(T A, T M = 1000000007) {
return BigMod(A, M - 2, M);
}
int fx[] = {-1, +0, +1, +0, +1, +1, -1, -1, +0};
int fy[] = {+0, -1, +0, +1, +1, -1, +1, -1, +0};
int day[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int main() {
int n, x;
long long s = 0, min = 1e10;
scanf("%d", &n);
while (n--) {
scanf("%d", &x);
s += x;
if (x & 1 && x < min) min = x;
}
if (s & 1) s -= min;
printf("%lld\n", s);
return 0;
}
| 1
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void pr(vector<T> &v) {
for (int i = 0; i < (int)(v).size(); i++) cout << v[i] << " ";
cout << '\n';
;
}
template <typename T>
void pr(vector<vector<T>> &v) {
for (int i = 0; i < (int)(v).size(); i++) {
pr(v[i]);
}
}
template <typename T>
void re(T &x) {
cin >> x;
}
template <typename T>
void re(vector<T> &a) {
for (int i = 0; i < (int)(a).size(); i++) re(a[i]);
}
template <class Arg, class... Args>
void re(Arg &first, Args &...rest) {
re(first);
re(rest...);
}
template <typename T>
void pr(T x) {
cout << x << '\n';
;
}
template <class Arg, class... Args>
void pr(const Arg &first, const Args &...rest) {
cout << first << " ";
pr(rest...);
cout << '\n';
;
}
void ps() {
cout << '\n';
;
}
template <class T, class... Ts>
void ps(const T &t, const Ts &...ts) {
cout << t;
if (sizeof...(ts)) cout << " ";
ps(ts...);
}
int n;
vector<vector<pair<int, int>>> g;
vector<vector<char>> ans;
bool connect(int p, int q, int r, int s, char c1, char c2) {
if (g[r][s].second < 0) {
ans[r][s] = c2;
if (ans[p][q] == '0') ans[p][q] = c1;
return true;
}
return false;
}
void dfs(int p, int q, char d) {
if (ans[p][q] != '0') return;
ans[p][q] = d;
if (g[p][q].first == g[p + 1][q].first &&
g[p][q].second == g[p + 1][q].second) {
dfs(p + 1, q, 'U');
}
if (g[p][q].first == g[p - 1][q].first &&
g[p][q].second == g[p - 1][q].second) {
dfs(p - 1, q, 'D');
}
if (g[p][q].first == g[p][q + 1].first &&
g[p][q].second == g[p][q + 1].second) {
dfs(p, q + 1, 'L');
}
if (g[p][q].first == g[p][q - 1].first &&
g[p][q].second == g[p][q - 1].second) {
dfs(p, q - 1, 'R');
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
re(n);
g.resize(n + 5, vector<pair<int, int>>(n + 5, {INT_MAX, INT_MAX}));
ans.resize(n + 5, vector<char>(n + 5, '0'));
for (int i = 1; i < n + 1; i++) {
for (int j = 1; j < n + 1; j++) {
int x, y;
cin >> x >> y;
g[i][j] = {x, y};
}
}
vector<int> x = {0, 0, -1, 1};
vector<int> y = {1, -1, 0, 0};
vector<char> x1 = {'R', 'L', 'U', 'D'};
vector<char> y1 = {'L', 'R', 'D', 'U'};
for (int i = 1; i < n + 1; i++) {
for (int j = 1; j < n + 1; j++) {
if (g[i][j].second < 0) {
bool connected = (ans[i][j] != '0');
int k = 0;
while (!connected && k < 4) {
connected = connect(i, j, i + x[k], j + y[k], x1[k], y1[k]);
k++;
}
if (!connected) {
pr("INVALID");
return 0;
}
}
if (g[i][j].first == i && g[i][j].second == j) {
dfs(i, j, 'X');
}
}
}
for (int i = 1; i < n + 1; i++) {
for (int j = 1; j < n + 1; j++) {
if (ans[i][j] == '0') {
cout << "INVALID" << '\n';
;
return 0;
}
}
}
cout << "VALID" << '\n';
;
for (int i = 1; i < n + 1; i++) {
for (int j = 1; j < n + 1; j++) {
cout << ans[i][j];
}
cout << '\n';
;
}
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << '\n';
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
template <class T>
void mxi(T& a, const T& b) {
a = max(a, b);
}
template <class T>
void mni(T& a, const T& b) {
a = min(a, b);
}
long double EPS = 1e-9;
mt19937 RNG(chrono::steady_clock::now().time_since_epoch().count());
long long v[300300], p[300300], s[300300], d[300300], t[4 * 300300][2];
map<long long, vector<long long> > mp;
void bd(long long id, long long l, long long r) {
if (l == r) {
t[id][0] = p[l];
t[id][1] = s[l];
return;
}
bd(id << 1, l, ((l + r) >> 1));
bd(id << 1 | 1, ((l + r) >> 1) + 1, r);
for (long long i = 0; i < (2); i++)
t[id][i] = max(t[id << 1][i], t[id << 1 | 1][i]);
}
long long qu(long long id, long long l, long long r, long long lq, long long rq,
long long tp) {
if (r < lq || rq < l)
return -1e18;
else if (lq <= l && rq >= r)
return t[id][tp];
return max(qu(id << 1, l, ((l + r) >> 1), lq, rq, tp),
qu(id << 1 | 1, ((l + r) >> 1) + 1, r, lq, rq, tp));
}
void solve() {
set<long long> intervals;
long long n, a;
cin >> n >> a;
for (long long i = 1; i <= n; i++) {
cin >> d[i] >> v[i];
v[i] = a - v[i];
p[i] = v[i] + p[i - 1];
}
intervals.insert(1);
intervals.insert(n);
for (long long i = n; i >= 1; i--) {
s[i] = v[i] + s[i + 1];
}
for (long long i = 1; i < n; i++) {
long long del = d[i + 1] - d[i];
mp[-del].push_back(i);
}
bd(1, 0, n);
long long ans = 0;
for (long long i = 1; i <= n; i++) mxi(ans, v[i]);
for (auto x : mp) {
long long diff = x.first * x.first;
for (auto y : x.second) {
long long idl = y, idr = y + 1;
long long L = *(--intervals.upper_bound(idl));
long long R = *(intervals.lower_bound(idr));
ans = max(ans, -diff + qu(1, 0, n, idr, R, 0) + qu(1, 0, n, L, idl, 1) -
p[idl] - s[idr]);
long long xx = -diff + qu(1, 0, n, idr, R, 0) + qu(1, 0, n, L, idl, 1) -
p[idl] - s[idr];
}
for (auto y : x.second) {
intervals.insert(y);
intervals.insert(y + 1);
}
}
cout << ans << '\n';
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t, tab;
t = 1;
tab = t;
while (t--) {
solve();
}
cerr << ((double)clock() / CLOCKS_PER_SEC);
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
const int N = 500005;
vector<int> G[N], son[N];
int n, m, h[N], a[N], v[N];
set<pair<int, int> > st;
void dfs(int u, int fa) {
v[u] = h[u];
if (u ^ fa) v[u] = min(v[u], v[fa]);
st.insert(make_pair(h[u], u));
set<pair<int, int> >::iterator A, B = st.begin();
A = B;
++B;
if (B == st.end() || B->first > A->first) {
int v = B == st.end() ? 0x3f3f3f3f : B->first;
son[A->second].push_back(v);
}
for (int i = 0; i < (int)G[u].size(); ++i) {
int v = G[u][i];
if (v == fa) continue;
dfs(v, u);
}
st.erase(make_pair(h[u], u));
}
int L[N * 4], R[N * 4], mx[N * 4], lazy[N * 4];
inline void push_up(int id) { mx[id] = min(mx[(id << 1)], mx[(id << 1 | 1)]); }
inline void push_down(int id) {
if (!lazy[id]) return;
lazy[(id << 1)] += lazy[id];
lazy[(id << 1 | 1)] += lazy[id];
mx[(id << 1)] += lazy[id];
mx[(id << 1 | 1)] += lazy[id];
lazy[id] = 0;
}
void build(int id, int l, int r) {
L[id] = l;
R[id] = r;
lazy[id] = 0;
if (l == r) {
mx[id] = -(m - l + 1);
return;
}
int mid = (l + r) >> 1;
build((id << 1), l, mid);
build((id << 1 | 1), mid + 1, r);
push_up(id);
}
void update(int id, int l, int r, int v) {
if (L[id] == l && R[id] == r) {
mx[id] += v;
lazy[id] += v;
return;
}
push_down(id);
int mid = (L[id] + R[id]) >> 1;
if (r <= mid)
update((id << 1), l, r, v);
else if (l > mid)
update((id << 1 | 1), l, r, v);
else {
update((id << 1), l, mid, v);
update((id << 1 | 1), mid + 1, r, v);
}
push_up(id);
}
inline int query() {
int id = 1;
while (L[id] != R[id]) {
push_down(id);
id = mx[(id << 1 | 1)] < 0 ? (id << 1 | 1) : (id << 1);
}
return L[id];
}
inline void add(int x, int v) {
int p = upper_bound(a + 1, a + 1 + m, x) - a;
if (p - 1 >= 1) update(1, 1, p - 1, v);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", h + i);
}
for (int i = 1; i < n; ++i) {
int u, v;
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
scanf("%d", &m);
for (int i = 1; i <= m; ++i) {
scanf("%d", a + i);
}
dfs(1, 1);
sort(a + 1, a + 1 + m);
sort(v + 1, v + 1 + n);
build(1, 1, m);
for (int i = 1; i <= n; ++i) add(v[i], 1);
if (mx[1] >= 0) {
puts("0");
return 0;
}
int ans = 0x3f3f3f3f;
for (int i = 1; i <= n; ++i) {
if (son[i].empty()) continue;
int sz = son[i].size();
add(h[i], -sz);
int p = query();
for (int j = 0; j < sz; ++j) add(min(son[i][j], a[p]), 1);
if (mx[1] >= 0) ans = min(ans, a[p] - h[i]);
for (int j = 0; j < sz; ++j) add(min(son[i][j], a[p]), -1);
add(h[i], sz);
}
if (ans == 0x3f3f3f3f) ans = -1;
printf("%d\n", ans);
return 0;
}
| 22
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int vis[1000001];
int top = 0;
int v[1000001];
int anss[1000001];
int rnd() {
static int KEY = 12345678;
return KEY += KEY << 2 | 1;
}
struct Treap {
struct node {
pair<int, pair<int, int> > val;
int key, size;
node *c[2];
node(pair<int, pair<int, int> > _val, node *C) {
val = _val;
key = rnd();
c[0] = c[1] = C;
size = 1;
}
void rz() { size = c[0]->size + c[1]->size + 1; }
};
node *root, *Null;
Treap() {
Null = new node(pair<int, pair<int, int> >(0, make_pair(0, 0)), 0);
Null->size = 0;
Null->key = INT_MAX;
Null->c[0] = Null->c[1] = Null;
root = Null;
}
void rot(node *&t, bool d) {
node *p = t->c[d];
t->c[d] = p->c[!d];
p->c[!d] = t;
t->rz();
p->rz();
t = p;
}
void _insert(node *&t, pair<int, pair<int, int> > x) {
if (t == Null) {
t = new node(x, Null);
return;
}
bool d = x > t->val;
_insert(t->c[d], x);
if (t->c[d]->key < t->key)
rot(t, d);
else
t->rz();
}
void _del(node *&t, pair<int, pair<int, int> > x) {
if (t == Null) return;
if (t->val == x) {
bool d = t->c[0]->key > t->c[1]->key;
if (t->c[d] == Null) {
delete t;
t = Null;
return;
}
rot(t, d);
_del(t->c[!d], x);
} else {
bool d = x > t->val;
_del(t->c[d], x);
}
t->rz();
}
pair<int, pair<int, int> > _kth(node *&t, int x) {
int r = t->c[0]->size;
if (x == r) return t->val;
if (x < r) return _kth(t->c[0], x);
return _kth(t->c[1], x - r - 1);
}
void insert(pair<int, pair<int, int> > x) { _insert(root, x); }
void del(pair<int, pair<int, int> > x) { _del(root, x); }
pair<int, pair<int, int> > kth(int x) { return _kth(root, x); }
int size() { return root->size; }
pair<int, pair<int, int> > Min() {
node *p = root;
while (p->c[0] != Null) p = p->c[0];
return p->val;
}
} T;
void Run() {
anss[0] = 0;
while (T.size()) {
pair<int, pair<int, int> > k = T.Min();
anss[k.second.first] = k.second.second;
if (~k.second.second) v[k.second.second] = 1;
T.del(k);
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
T.insert(pair<int, pair<int, int> >(i, make_pair(i, -1)));
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
pair<int, pair<int, int> > k = T.kth(y - 1);
if (k.second.second == -1) {
if (vis[x]) {
puts("-1");
return 0;
}
vis[x] = 1;
} else {
if (k.second.second != x) {
puts("-1");
return 0;
}
}
T.insert(pair<int, pair<int, int> >(top--, make_pair(k.second.first, x)));
T.del(k);
}
Run();
int p = 0;
for (int i = 1; i <= n; i++) {
if (~anss[i])
printf("%d ", anss[i]);
else {
p++;
while (v[p]) p++;
printf("%d ", p);
}
}
return 0;
}
| 14
|
#include <bits/stdc++.h>
const int MOD = 1e9 + 7;
using namespace std;
int32_t main() {
unsigned long long n, l, r;
cin >> n >> l >> r;
l -= 1;
r -= 1;
vector<unsigned long long> a(n);
vector<unsigned long long> b(n);
for (unsigned long long i = 0; i < n; i++) cin >> a[i];
for (unsigned long long i = 0; i < n; i++) cin >> b[i];
bool flag = true;
for (unsigned long long i = 0; i < n; i++) {
if (a[i] != b[i] && (i < l || i > r)) {
flag = false;
break;
}
}
if (flag)
cout << "TRUTH\n";
else
cout << "LIE\n";
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 110000;
const int MAXS = 256;
int n;
char a[MAXN];
int sa[MAXN], rnk[2 * MAXN], rnk1[2 * MAXN];
int st[MAXS], cnt[MAXN], tmp[MAXN];
int height[MAXN], top;
struct Node {
int id, val;
Node(int i = 0, int v = 0) : id(i), val(v) {}
} sta[MAXN];
int main() {
scanf("%s", a + 1);
n = strlen(a + 1);
memset(st, 0, sizeof st);
memset(rnk, 0, sizeof rnk);
for (int i = 1; i <= n; i++) st[a[i]] = 1;
for (int i = 1; i < MAXS; i++) st[i] += st[i - 1];
for (int i = 1; i <= n; i++) rnk[i] = st[a[i]];
for (int k = 0, p = 1; k < n && p <= n; p <<= 1) {
memset(cnt, 0, sizeof cnt);
for (int i = 1; i <= n; i++) cnt[rnk[i + p]]++;
for (int i = 1; i <= n; i++) cnt[i] += cnt[i - 1];
for (int i = n; i >= 1; i--) tmp[cnt[rnk[i + p]]--] = i;
memset(cnt, 0, sizeof cnt);
for (int i = 1; i <= n; i++) cnt[rnk[i]]++;
for (int i = 1; i <= n; i++) cnt[i] += cnt[i - 1];
for (int i = n; i >= 1; i--) sa[cnt[rnk[tmp[i]]]--] = tmp[i];
memcpy(rnk1, rnk, sizeof rnk1);
rnk[sa[1]] = k = 1;
for (int i = 2; i <= n; i++) {
if (rnk1[sa[i]] != rnk1[sa[i - 1]] ||
rnk1[sa[i] + p] != rnk1[sa[i - 1] + p])
k++;
rnk[sa[i]] = k;
}
}
height[n + 1] = 0;
for (int i = 1, k = 0; i <= n; i++) {
if (rnk[i] == 1) {
height[rnk[i]] = k = 0;
continue;
}
if (--k < 0) k = 0;
while (a[i + k] == a[sa[rnk[i] - 1] + k]) k++;
height[rnk[i]] = k;
}
long long ans = 0;
for (int i = 1; i <= n; i++)
ans += n - sa[i] + 1 - max(height[i], height[i + 1]);
top = 0;
for (int i = 1; i <= n + 1; i++) {
int t = i;
while (top > 0 && height[i] < sta[top - 1].val) {
int l = i - sta[--top].id + 1;
int k = sta[top].val - max(height[i], top > 0 ? sta[top - 1].val : 0);
ans += 1ll * l * (l + 1) / 2 * k;
t = min(t, sta[top].id);
}
if (top == 0 || height[i] > sta[top - 1].val)
sta[top++] = Node(t, height[i]);
}
cout << ans << endl;
return 0;
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
inline string toString(long long x) {
string ans = "";
bool negtive = x < 0;
x = abs(x);
while (x) ans.push_back(x % 10 + '0'), x /= 10;
if (ans.size() == 0) ans = "0";
if (negtive) ans.push_back('-');
for (long long i = 0; i < ans.size() / 2; i++)
swap(ans[i], ans[ans.size() - 1 - i]);
return ans;
}
inline long long toInt(const string &str) {
long long ans = 0;
bool negtive = str[0] == '-';
for (long long i = negtive; i < str.size(); i++)
ans = ans * 10 + str[i] - '0';
if (negtive) ans *= -1;
return ans;
}
inline long long gcd(long long x, long long y) { return x ? gcd(y % x, x) : y; }
long long exgcd(long long a, long long b, long long &x, long long &y) {
long long d = a;
if (b == 0)
x = 1, y = 0;
else {
d = exgcd(b, a % b, y, x), y -= a / b * x;
}
return d;
}
const long long mod = 1e9 + 7;
inline long long rd() {
register signed ans = 0;
char last = ' ', ch = getchar();
while (!(ch >= '0' && ch <= '9')) last = ch, ch = getchar();
while (ch >= '0' && ch <= '9')
ans = (ans << 3) + (ans << 1) + ch - '0', ch = getchar();
return ans;
}
inline long long QPow(long long a, long long b) {
long long ans = 1;
if (b < 0) return 0;
while (b) {
if (b & 1) ans = ans * a % mod;
a = a * a % mod;
b >>= 1;
}
return ans;
}
inline long long QPow(long long a, long long b, const long long &mod) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % mod;
a = a * a % mod;
b >>= 1;
}
return ans;
}
const double PI = 3.141592653589793115997963468544185161590576171875;
const double eps = 1e-8;
const double e = 2.718281828459045;
void ask(long long x, long long y) {
cout << "? " << x << ' ' << y << endl;
cout.flush();
;
}
void decide(long long x) {
cout << "! " << x << endl;
cout.flush();
;
}
const long long inf = 1e9;
const long long maxn = 100005;
long long arr[maxn][6];
deque<pair<long long, long long> > dq[6];
long long ans[6];
long long Ans;
signed main() {
ios::sync_with_stdio(0);
cout.tie(0), cin.tie(0);
long long n, m, k;
cin >> n >> m >> k;
for (long long i = 1; i <= n; i++)
for (long long j = 1; j <= m; j++) cin >> arr[i][j];
long long ptr = 1;
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) {
while (dq[j].size() && dq[j].back().first < arr[i][j]) dq[j].pop_back();
dq[j].push_back({arr[i][j], i});
}
bool flag1 = 0, flag2 = 0;
while (ptr <= i) {
for (long long j = 1; j <= m; j++)
while (dq[j].size() && dq[j].front().second < ptr) {
dq[j].pop_front();
}
for (long long j = 1; j <= m; j++)
if (dq[j].size() == 0) flag1 = 1;
if (flag1) break;
long long sum = 0;
for (long long j = 1; j <= m; j++) sum += dq[j].front().first;
if (sum <= k) flag2 = 1;
if (flag2) break;
ptr++;
}
if (flag2) {
if (Ans < i - ptr + 1) {
Ans = i - ptr + 1;
for (long long j = 1; j <= m; j++) ans[j] = dq[j].front().first;
}
}
}
for (long long j = 1; j <= m; j++) cout << ans[j] << ' ';
cout << '\n';
return 0;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, h, i, cnt = 0;
scanf("%d%d", &n, &h);
int a[n];
for (i = 0; i < n; i++) scanf("%d", &a[i]);
for (i = 0; i < n; i++) {
if (a[i] > h) {
cnt += 2;
} else
cnt++;
}
printf("%d\n", cnt);
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
const int nax = 1e6 + 5;
long long len[nax], allow[nax];
vector<long long> w;
long long ans = 0;
const int magic = 100 * 1000;
int main() {
int n;
long long R;
scanf("%d%lld", &n, &R);
for (int i = 0; i < n; ++i) scanf("%lld", &len[i]);
for (int i = 0; i < n; ++i) scanf("%lld", &allow[i]);
for (int i = 0; i < n; ++i)
if (len[i] > allow[i]) {
puts("-1");
return 0;
}
long long already = 0, fast = 0;
for (int i = 0; i < n; ++i) {
if (i) already += len[i - 1];
if (fast >= len[i]) {
fast -= len[i];
continue;
}
if (fast + 2 * (len[i] - fast) <= allow[i]) {
fast = 0;
continue;
}
long long x = fast + 2 * (len[i] - fast) - allow[i];
assert(x > 0);
ans += x / R;
for (long long j = 0; j < x / R && (int)w.size() < magic; ++j)
w.push_back(already + fast + j * R);
if (x % R) {
++ans;
if ((int)w.size() < magic) w.push_back(already + len[i] - x % R);
}
fast = R - x % R;
if (fast == R) fast = 0;
}
printf("%lld\n", ans);
long long move = 0;
if (ans <= magic) {
for (long long x : w) {
printf("%lld ", 2 * x - move);
move += R;
}
puts("");
}
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long power(long long x, long long y) {
long long res = 1;
while (y > 0) {
if (y & 1) res = res * x;
y = y >> 1;
x = x * x;
}
return res;
}
vector<vector<long long> > adj;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> n;
long long x = n / 2;
cout << x * (n - x) << "\n";
for (int i = 1; i <= x; i++) {
for (int j = x + 1; j <= n; j++) {
cout << i << " " << j << "\n";
}
}
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
long i, k, n, x, p;
while (cin >> n) {
string s;
cin >> s;
p = 0;
for (i = 0; i < n; i++) {
if (s[i] == '<')
p++;
else
break;
}
for (i = n - 1; i >= 0; i--) {
if (s[i] == '>')
p++;
else
break;
}
cout << p << endl;
}
return 0;
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
const long long M = 1e9 + 7;
const long long N = 2000 + 10;
const long long IM = 1e15 + 37;
const long double PI = 3.1415926535897932384;
inline void PP(long long n) { cout << n << " "; }
void PV(vector<long long> v) {
for (long long i = 0; i < v.size(); i++) cout << v[i] << " ";
cout << "\n";
}
void PVV(vector<pair<long long, long long> > v) {
for (long long i = 0; i < v.size(); i++)
cout << v[i].first << " " << v[i].second << "\n";
}
void PA(long long v[], long long n, long long x = 0) {
for (long long i = x; i < n + x; i++) cout << v[i] << ' ';
cout << "\n";
}
void IN(long long a[], long long n, long long x = 0) {
for (long long i = x; i < n + x; i++) cin >> a[i];
}
inline void op() {}
long long n, m;
bool ck(long long x, long long y) {
if (x >= 0 && y >= 0 && x < n && y < m) return 1;
return 0;
}
void pr(long long a[N][N]) {
cout << "\n";
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
cout << a[i][j] << " ";
}
cout << "\n";
}
cout << "\n";
}
long long ld[N][N], rd[N][N], dl[N][N], dr[N][N];
signed main() {
op();
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m;
string s[n];
for (long long i = 0; i < n; i++) cin >> s[i];
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
long long x = i - 1, y = j, a = i, b = j - 1;
if (ck(x, y) && s[x][y] == s[i][j] && ck(a, b) && s[i][j] == s[a][b])
ld[i][j] = min(ld[x][y], ld[a][b]) + 1;
}
}
for (long long i = 0; i < n; i++) {
for (long long j = m - 1; j >= 0; j--) {
long long x = i - 1, y = j, a = i, b = j + 1;
if (ck(x, y) && s[x][y] == s[i][j] && ck(a, b) && s[i][j] == s[a][b])
rd[i][j] = min(rd[x][y], rd[a][b]) + 1;
}
}
for (long long i = n - 1; i >= 0; i--) {
for (long long j = 0; j < m; j++) {
long long x = i + 1, y = j, a = i, b = j - 1;
if (ck(x, y) && s[x][y] == s[i][j] && ck(a, b) && s[i][j] == s[a][b])
dl[i][j] = min(dl[x][y], dl[a][b]) + 1;
}
}
for (long long i = n - 1; i >= 0; i--) {
for (long long j = m - 1; j >= 0; j--) {
long long x = i + 1, y = j, a = i, b = j + 1;
if (ck(x, y) && s[x][y] == s[i][j] && ck(a, b) && s[i][j] == s[a][b])
dr[i][j] = min(dr[x][y], dr[a][b]) + 1;
}
}
long long ans = n * m;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
long long d = min({ld[i][j], rd[i][j], dl[i][j], dr[i][j]});
ans += d;
}
}
cout << (ans) << "\n";
return 0;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, x, t = 0, ans = 0;
cin >> n;
vector<int> v;
for (i = 0; i < n; i++) {
cin >> x;
v.push_back(x);
}
sort(v.begin(), v.end());
for (i = 0; i < v.size(); i++) {
if (v[i] >= t) {
ans++;
t += v[i];
}
}
cout << ans << endl;
return 0;
}
| 5
|
#include<deque>
#include<queue>
#include<vector>
#include<algorithm>
#include<iostream>
#include<set>
#include<cmath>
#include<tuple>
#include<string>
#include<chrono>
#include<functional>
#include<iterator>
#include<random>
#include<unordered_set>
#include<array>
#include<map>
#include<iomanip>
#include<assert.h>
#include<list>
#include<bitset>
#include<stack>
#include<memory>
#include<numeric>
#include <utility>
using namespace std;
typedef long long int llint;
llint K=1000000000;
vector<llint>kak(vector<llint>in,int a){
int n=in.size();
for(int i=0;i<n;i++){in[i]*=a;}
if(n==0||in[n-1]>K){in.push_back(0);n++;}
for(int i=0;i+1<n;i++){
in[i+1]+=in[i]/K;
in[i]%=K;
}
return in;
}
bool dai(vector<llint>in,vector<llint>jn){
while(in.size()>0&&in.back()==0){in.pop_back();}
while(jn.size()>0&&jn.back()==0){jn.pop_back();}
if(in.size()>jn.size()){return true;}
if(in.size()<jn.size()){return false;}
for(int i=((int)in.size())-1;i>=0;i--){
if(in[i]>jn[i]){return true;}
if(in[i]<jn[i]){return false;}
}
return false;
}
int main(void){
int n,d,i,h,j;cin>>n>>d;
vector<int>suu[10];
for(i=0;i<n;i++){
int a;cin>>a;
suu[a%10].push_back(a);
}
int mir[10];
for(h=0;h<10;h++){
sort(suu[h].begin(),suu[h].end());
mir[h]=(1+suu[h].size())%4 +3;//4の倍数はまとめることができる
if(mir[h]>suu[h].size()){mir[h]=suu[h].size();}
}
//mirに入っていないものをみる
vector<llint>dp[10];
vector<int>da[10];
dp[1].push_back(1);
//これでDPの初期化完了
for(h=0;h<=9;h++){
for(i=0;i<mir[h];i++){
//cerr<<"de"<<endl;
vector<llint>ep[10];
vector<int>ea[10];
for(j=0;j<=9;j++){ep[j]=dp[j];ea[j]=da[j];}
for(j=0;j<=9;j++){
auto sss=kak(dp[j],suu[h][i]);
if(dai(sss,ep[h*j%10])){
ep[h*j%10]=sss;
ea[h*j%10]=da[j];
ea[h*j%10].push_back(suu[h][i]);
}
}
for(j=0;j<=9;j++){dp[j]=ep[j];da[j]=ea[j];}
/*for(j=0;j<=9;j++){
for(auto it:dp[j]){cerr<<it<<" ";}cerr<<endl;
}*/
}
}
//まず、da[d]をみる
vector<int>ans=da[d];
vector<llint>kra={};
vector<llint>kkra={0};
if(dp[d]==kra){cout<<-1<<endl;return 0;}
if(dp[d]==kkra){cout<<-1<<endl;return 0;}
if(ans.size()==0){cout<<-1<<endl;return 0;}
for(i=mir[1];i<suu[1].size();i++){ans.push_back(suu[1][i]);}
for(i=mir[3];i<suu[3].size();i++){ans.push_back(suu[3][i]);}
for(i=mir[7];i<suu[7].size();i++){ans.push_back(suu[7][i]);}
for(i=mir[9];i<suu[9].size();i++){ans.push_back(suu[9][i]);}
if(d%2==0){
for(i=mir[2];i<suu[2].size();i++){ans.push_back(suu[2][i]);}
for(i=mir[4];i<suu[4].size();i++){ans.push_back(suu[4][i]);}
for(i=mir[6];i<suu[6].size();i++){ans.push_back(suu[6][i]);}
for(i=mir[8];i<suu[8].size();i++){ans.push_back(suu[8][i]);}
}
if(d%5==0){
for(i=mir[5];i<suu[5].size();i++){ans.push_back(suu[5][i]);}
}
if(d%10==0){
for(i=mir[0];i<suu[0].size();i++){ans.push_back(suu[0][i]);}
}
sort(ans.begin(),ans.end());
cout<<ans.size()<<endl;
for(auto it:ans){cout<<it<<" ";}cout<<endl;
}
/*
6 4
4 11 8 2 1 13
*/
| 13
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
long long n;
cin >> n;
long long g = 1;
while (n) {
if (n == 3) {
cout << g << ' ' << g << ' ' << (g << 1) + g;
n = 0;
}
long long m = n >> 1;
for (long long j = 0; j < n - m; j++) {
cout << g << ' ';
}
g <<= 1;
n = m;
}
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
bool prime(int n) {
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) {
return false;
}
}
return true;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
if (prime(n)) {
cout << "1\n";
} else if (n % 2 == 0 || prime(n - 2)) {
cout << "2\n";
} else {
cout << "3\n";
}
}
| 8
|
#include <bits/stdc++.h>
int n, i, j, Len;
char Str[200], Std[200];
int main() {
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%s", Str);
if (i) {
for (j = 0; j < Len; j++)
if (Str[j] != Std[j]) break;
Len = j;
} else {
Len = strlen(Str);
strcpy(Std, Str);
}
}
printf("%d\n", Len);
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long INFLL = 0x3f3f3f3f3f3f3f3fLL;
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
const int maxn = 1e5 + 10;
map<int, bool> okl, okr;
set<int> s;
int main() {
int n = read();
for (int i = 1; i <= n; i++) {
int x = read(), v;
if (i > 1) {
set<int>::iterator it;
it = s.lower_bound(x);
if (it != s.end() && okl[*it] == 0) {
okl[*it] = 1;
v = *it;
} else {
it = s.lower_bound(x);
it--;
if (it != s.end() && okr[*it] == 0) {
okr[*it] = 1;
v = *it;
}
}
cout << v << " ";
}
s.insert(x);
okl[x] = okr[x] = 0;
}
puts("");
return 0;
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
int INF = numeric_limits<int>::max();
int INF2 = numeric_limits<long long>::max();
int n, m, k;
int b[105][105];
int a1[105], a2[105];
int main() {
cin >> n >> m >> k;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) cin >> b[i][j];
int res = INF, temp, temp1, temp2;
if (n <= 10 && m <= 10) {
if (n <= 10) {
for (int i = 0; i <= min(n, 5); ++i) {
for (int j = 0; j < n; ++j) {
a1[j] = !(j < i);
}
do {
temp = 0;
for (int k = 0; k < m; ++k) {
temp1 = temp2 = 0;
for (int l = 0; l < n; ++l) {
if (b[l][k] != a1[l]) ++temp1;
if (b[l][k] != !a1[l]) ++temp2;
}
temp += min(temp1, temp2);
}
res = min(res, temp);
} while (next_permutation(a1, a1 + n));
}
} else {
for (int i = 0; i <= min(m, 5); ++i) {
for (int j = 0; j < m; ++j) {
a1[j] = !(j < i);
}
do {
temp = 0;
for (int k = 0; k < n; ++k) {
temp1 = temp2 = 0;
for (int l = 0; l < m; ++l) {
if (b[k][l] != a1[l]) ++temp1;
if (b[k][l] != !a1[l]) ++temp2;
}
temp += min(temp1, temp2);
}
res = min(res, temp);
} while (next_permutation(a1, a1 + n));
}
}
} else {
for (int l = 0; l < m; ++l) {
for (int i = 0; i < n; ++i) a1[i] = b[i][l], a2[i] = !b[i][l];
temp = 0;
for (int j = 0; j < m; ++j) {
temp1 = temp2 = 0;
for (int i = 0; i < n; ++i) {
if (b[i][j] != a1[i]) temp1++;
if (b[i][j] != a2[i]) temp2++;
}
temp += min(temp1, temp2);
}
res = min(res, temp);
}
for (int l = 0; l < n; ++l) {
for (int i = 0; i < m; ++i) a1[i] = b[l][i], a2[i] = !b[l][i];
temp = 0;
for (int j = 0; j < n; ++j) {
temp1 = temp2 = 0;
for (int i = 0; i < m; ++i) {
if (b[j][i] != a1[i]) temp1++;
if (b[j][i] != a2[i]) temp2++;
}
temp += min(temp1, temp2);
}
res = min(res, temp);
}
}
if (res <= k)
cout << res << endl;
else
cout << -1 << endl;
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
vector<int> ans;
int main() {
int n, a, b;
cin >> n >> a >> b;
int cur = 1;
if (a > b) swap(a, b);
for (int i = 0; i <= n / a; i++) {
if ((n - a * i) % b == 0) {
while (i--) {
int mod = cur;
while (cur < mod + a) ans.push_back((cur++ - mod + 1) % a + mod);
}
for (int j = 0; cur <= n; j++) {
int mod = cur;
while (cur < mod + b) ans.push_back((cur++ - mod + 1) % b + mod);
}
break;
}
}
if (ans.begin() != ans.end()) {
for (int i = 0; i < ans.size(); i++) cout << ans[i] << " \n"[i == n - 1];
} else
cout << "-1" << endl;
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
int m, i, n, k, a[250];
int main() {
scanf("%d%d", &n, &k);
m = 2 * n + 1;
for (i = 1; i <= m; ++i) scanf("%d", &a[i]);
for (int j = 1; j <= n; ++j) {
i = j * 2;
if (a[i] - a[i - 1] > 1 && a[i] - a[i + 1] > 1 && k) --a[i], --k;
}
for (int i = 1; i < m; ++i) printf("%d ", a[i]);
printf("%d\n", a[m]);
return 0;
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
int n;
int arr[100001];
int dp[100001];
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) cin >> arr[i];
for (int i = n; i >= 1; i--) dp[arr[i]] = 1 + dp[arr[i] + 1];
int resultat = n + 1;
for (int i = 0; i <= n; ++i)
resultat = min(resultat, i + (n - i - dp[i + 1]));
cout << resultat << endl;
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename T1>
ostream &operator<<(ostream &out, pair<T, T1> obj) {
out << "(" << obj.first << "," << obj.second << ")";
return out;
}
template <typename T, typename T1>
ostream &operator<<(ostream &out, map<T, T1> cont) {
typename map<T, T1>::const_iterator itr = cont.begin();
typename map<T, T1>::const_iterator ends = cont.end();
for (; itr != ends; ++itr) out << *itr << " ";
out << endl;
return out;
}
template <typename T>
ostream &operator<<(ostream &out, set<T> cont) {
typename set<T>::const_iterator itr = cont.begin();
typename set<T>::const_iterator ends = cont.end();
for (; itr != ends; ++itr) out << *itr << " ";
out << endl;
return out;
}
template <typename T>
ostream &operator<<(ostream &out, multiset<T> cont) {
typename multiset<T>::const_iterator itr = cont.begin();
typename multiset<T>::const_iterator ends = cont.end();
for (; itr != ends; ++itr) out << *itr << " ";
out << endl;
return out;
}
template <typename T,
template <typename ELEM, typename ALLOC = allocator<ELEM>> class CONT>
ostream &operator<<(ostream &out, CONT<T> cont) {
typename CONT<T>::const_iterator itr = cont.begin();
typename CONT<T>::const_iterator ends = cont.end();
for (; itr != ends; ++itr) out << *itr << " ";
out << endl;
return out;
}
template <typename T, unsigned int N, typename CTy, typename CTr>
typename enable_if<!is_same<T, char>::value, basic_ostream<CTy, CTr> &>::type
operator<<(basic_ostream<CTy, CTr> &out, const T (&arr)[N]) {
for (auto i = 0; i < N; ++i) out << arr[i] << " ";
out << endl;
return out;
}
template <typename T>
T gcd(T a, T b) {
T min_v = min(a, b);
T max_v = max(a, b);
while (min_v) {
T temp = max_v % min_v;
max_v = min_v;
min_v = temp;
}
return max_v;
}
template <typename T>
T lcm(T a, T b) {
return (a * b) / gcd(a, b);
}
template <typename T>
T fast_exp_pow(T base, T exp, T mod) {
long long res = 1;
while (exp) {
if (exp & 1) {
res *= base;
res %= mod;
}
exp >>= 1;
base *= base;
base %= mod;
}
return res % mod;
}
int minimum[100010];
int pos;
stack<int> stc;
string word;
int main() {
cin >> word;
minimum[word.size()] = 30;
for (int i = (int)word.size() - 1; i >= 0; --i)
minimum[i] = min(minimum[i + 1], word[i] - 'a');
while (pos < word.size()) {
if (word[pos] - 'a' > minimum[pos]) {
stc.push(word[pos++] - 'a');
continue;
}
printf("%c", word[pos++]);
while (!stc.empty()) {
int val = stc.top();
if (val <= minimum[pos]) {
printf("%c", val + 'a');
stc.pop();
} else
break;
}
}
printf("\n");
return 0;
}
| 9
|
#include <bits/stdc++.h>
#define rep(i, l, r) for(int i = (l); i <= (r); i++)
#define per(i, r, l) for(int i = (r); i >= (l); i--)
#define mem(a, b) memset(a, b, sizeof a)
#define For(i, l, r) for(int i = (l), i##e = (r); i < i##e; i++)
using namespace std;
typedef long long ll;
const int N = 1e5 + 5;
int n, K, a[N];
ll f[N][40], ans[N];
vector <int> G[N];
void add(int u, int v) {
For(i, 0, K) f[u][(i + 1) % K] ^= f[v][i];
}
void dfs(int u, int fa) {
f[u][0] = a[u];
for(int v : G[u]) if(v ^ fa) dfs(v, u), add(u, v);
}
void Dfs(int u, int fa) {
For(i, K / 2, K) ans[u] ^= f[u][i];
for(int v : G[u]) if(v ^ fa) add(u, v), add(v, u), Dfs(v, u), add(v, u), add(u, v);
}
int main() {
#ifdef local
// freopen(".in", "r", stdin);
#endif
cin >> n >> K, K *= 2;
int u, v;
rep(i, 2, n) {
scanf("%d%d", &u, &v);
G[u].push_back(v), G[v].push_back(u);
}
rep(i, 1, n) scanf("%d", &a[i]);
dfs(1, 0), Dfs(1, 0);
rep(i, 1, n) printf("%d ", ans[i] != 0);
return 0;
}
| 17
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, coup = 0;
long long mat[21] = {0};
cin >> n;
int res[n];
for (int i = 0; i < n; i++) {
cin >> res[i];
mat[res[i] + 10]++;
}
for (int i = 0; i < 10; i++) coup = coup + mat[i] * mat[20 - i];
for (int i = 0; i < mat[10]; i++) coup = coup + i;
cout << coup << endl;
return 0;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
long long int a[200005];
vector<long long int> v;
int main() {
long long int n, d = 0, k = 0, l, mid, c = 0, x = 0, i = 0, m, f = 0, j = 0,
j1, sum = 0, s = 0, mx = 100000000000000000;
cin >> n;
m = n;
for (i = 1; i < m; i++) {
d = log2(n - i);
d = (double)pow(2, d);
d += i;
cin >> x;
a[i] += x;
if (i < d) {
sum += a[i];
a[d] += a[i];
v.push_back(sum);
}
}
for (i = 0; i < v.size(); i++) {
cout << v[i] << endl;
}
return 0;
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
long long MOD = 1e9 + 7;
int setBit(int num, int idx, int value = 1) {
return (value) ? (num | (1 << idx)) : (num & ~(1 << idx));
}
int getBit(int num, int idx) { return ((num >> idx) & 1) == 1; }
int cntBits(int num) {
int ret = 0;
while (num) {
if (num % 2) ret++;
num /= 2;
}
return ret;
}
int is_prime[1000001];
void Sieve() {
for (int i = 0; i <= 1000000; i++) {
is_prime[i] = 1;
}
is_prime[0] = 0;
is_prime[1] = 0;
for (int i = 2; i * i <= 1000000; i++) {
if (is_prime[i]) {
for (int j = i * i; j <= 1000000; j += i) {
is_prime[j] = 0;
}
}
}
}
vector<int> get_bin(int n) {
vector<int> ret;
while (n > 0) {
if (n % 2 == 0)
ret.push_back(0);
else
ret.push_back(1);
n /= 2;
}
return ret;
}
unordered_map<long long, long long> factorise(long long n) {
unordered_map<long long, long long> map;
if (n % 2 == 0) {
while (n % 2 == 0) {
if (map.find(2) != map.end())
map[2]++;
else
map[2] = 1;
n = n / 2;
}
}
for (long long i = 3; i * i <= n; i += 2) {
if (n % i == 0) {
while (n % i == 0) {
if (map.find(i) != map.end())
map[i]++;
else
map[i] = 1;
n = n / i;
}
}
}
if (n > 1) map[n] = 1;
return map;
}
unsigned long long power(unsigned long long x, int y, int p) {
unsigned long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
vector<vector<long long> > mat_mul(vector<vector<long long> > mat,
vector<vector<long long> > mat1) {
vector<vector<long long> > ret{{0, 0}, {0, 0}};
ret[0][0] =
((mat[0][0] * mat1[0][0]) % MOD + (mat[0][1] * mat1[1][0]) % MOD) % MOD;
ret[0][1] =
((mat[0][0] * mat1[1][0]) % MOD + (mat[0][1] * mat1[1][1]) % MOD) % MOD;
ret[1][0] =
((mat[1][0] * mat1[0][0]) % MOD + (mat[1][1] * mat1[1][0]) % MOD) % MOD;
ret[1][1] =
((mat[1][0] * mat1[1][0]) % MOD + (mat[1][1] * mat1[1][1]) % MOD) % MOD;
return ret;
}
vector<vector<long long> > mat_exp(vector<vector<long long> > mat,
long long ex) {
if (ex == 0) return {{1, 1}, {1, 1}};
if (ex == 1) return mat;
if (ex % 2 == 0)
return mat_exp(mat_mul(mat, mat), ex / 2);
else
return mat_mul(mat, mat_exp(mat, ex - 1));
}
int main() {
int t;
t = 1;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
vector<int> mrk(n + 1, 1);
while (m--) {
int a, b, c;
cin >> a >> b >> c;
mrk[b] = -1;
}
int cand = -1;
for (int i = 1; i <= n; i++) {
if (mrk[i] == 1) {
cand = i;
break;
}
}
for (int i = 1; i <= n; i++) {
if (i != cand) cout << i << " " << cand << endl;
}
}
return 0;
}
| 4
|
#include <bits/stdc++.h>
const int MAXL = 2000000;
const int AUX_SIZE = 10;
struct Trie {
int cover[MAXL], ch[MAXL][AUX_SIZE];
int cnt;
inline int idx(const char c) { return c - '0'; }
inline void insert(const char* s) {
int cur = 0;
for (int i = 0; s[i]; i++) {
int t = idx(s[i]);
if (ch[cur][t]) {
cur = ch[cur][t];
cover[cur]++;
} else {
assert(cnt < MAXL);
ch[cur][t] = ++cnt;
cur = ch[cur][t];
cover[cur] = 1;
}
}
}
inline void del(const char* s) {
int cur = 0;
for (int i = 0; s[i]; i++) {
int t = idx(s[i]);
cur = ch[cur][t];
if (cur) cover[cur]--;
}
}
inline bool query(const char* s) {
int cur = 0;
for (int i = 0; s[i]; i++) {
int t = idx(s[i]), o = ch[cur][t];
if (!o || !cover[o])
return 0;
else
cur = o;
}
return 1;
}
} T;
const int MAXSIZE = 13;
const int MAXN = 70000 + 5;
char s[MAXN][MAXSIZE], tmp[MAXSIZE];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%s", s[i]);
for (int j = 0; s[i][j]; j++) {
T.insert(s[i] + j);
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; s[i][j]; j++) {
T.del(s[i] + j);
}
int lx = strlen(s[i]);
for (int len = 1; len <= lx; len++) {
bool ok = 0;
for (int start = 0; start + len - 1 < lx; start++) {
for (int x = start; x <= start + len - 1; x++) {
tmp[x - start] = s[i][x];
}
tmp[len] = '\0';
if (!T.query(tmp)) {
printf("%s\n", tmp);
ok = 1;
break;
}
}
if (ok) break;
}
for (int j = 0; s[i][j]; j++) {
T.insert(s[i] + j);
}
}
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
int n, a, ans, t, in[1000005];
char c;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> c >> a;
if (c == '+')
in[a]++, t++;
else {
if (in[a] == 0)
ans++;
else
in[a] = 0, t--;
}
if (ans < t) ans = t;
}
cout << ans;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int g;
multimap<float, int> m;
multimap<float, int>::iterator it;
int i;
int stat = 0;
int temp;
double f;
int n;
int a[1001][3];
int s;
cin >> n;
cin >> s;
for (i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
cin >> a[i][j];
}
f = sqrt(pow(a[i][0], 2) + pow(a[i][1], 2));
m.insert(pair<float, int>(f, i));
}
temp = 1000000 - s;
for (it = m.begin(); it != m.end(); ++it) {
i = it->second;
temp = temp - a[i][2];
g = i;
if (temp <= 0) {
stat = 1;
break;
}
}
if (stat == 1) {
f = sqrt(pow(a[g][0], 2) + pow(a[g][1], 2));
cout << setprecision(9) << f << endl;
} else {
cout << "-1" << endl;
}
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
set<string> explr;
string dest;
bool solve(string cur) {
if (cur == dest) return true;
if (explr.count(cur)) return false;
explr.insert(cur);
int xrow, xcol;
for (int i = 0; i < 4; i++)
if (cur[i] == 'X') {
xrow = i / 2;
xcol = i % 2;
}
string next = cur;
swap(next[xrow * 2], next[xrow * 2 + 1]);
if (solve(next)) return true;
next = cur;
swap(next[xcol], next[2 + xcol]);
if (solve(next)) return true;
return false;
}
int main() {
string ini, p;
cin >> p;
ini += p;
cin >> p;
ini += p;
cin >> p;
dest += p;
cin >> p;
dest += p;
if (solve(ini))
cout << "YES\n";
else
cout << "NO\n";
return 0;
}
| 4
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.