solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const long long N = 10005;
const long long INF = 1e15;
const int MOD = 1e9 + 7;
const double EPS = 1e-7;
const double PI = acos(-1.0);
string s;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL), cout.tie(NULL);
cin >> s;
int n = s.size();
if (s[0] == '-') {
cout << "($";
int dot = 1;
while (dot < n && s[dot] != '.') dot++;
for (int i = 1; i < dot; i++) {
cout << s[i];
if (i != dot - 1 && (dot - i) % 3 == 1) cout << ',';
}
cout << '.';
if (dot < n - 1) {
if (dot < n - 2)
cout << s[dot + 1] << s[dot + 2];
else
cout << s[dot + 1] << 0;
} else
cout << "00";
cout << ")" << endl;
} else {
cout << "$";
int dot = 0;
while (dot < n && s[dot] != '.') dot++;
for (int i = 0; i < dot; i++) {
cout << s[i];
if (i != dot - 1 && (dot - i) % 3 == 1) cout << ',';
}
cout << '.';
if (dot < n - 1) {
if (dot < n - 2)
cout << s[dot + 1] << s[dot + 2];
else
cout << s[dot + 1] << 0;
} else
cout << "00";
cout << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 7;
int n;
int prime[maxn];
int cnt = 0;
bool flag[maxn * 2];
int ans[maxn];
void p() {
for (int i = 2; i <= n * 2; i++) {
if (!flag[i]) prime[cnt++] = i;
for (int j = 0; j < cnt; j++) {
if (i * prime[j] > maxn * 2) break;
flag[i * prime[j]] = 1;
if ((i % prime[j]) == 0) break;
}
}
}
int main() {
cin >> n;
int x;
p();
int num1 = 0, num2 = 0;
int sum = 0;
for (int i = 1; i <= n; i++) {
cin >> x;
if (x == 1)
num1++;
else
num2++;
}
if (num2 > 0) {
cout << 2;
num2--;
}
int now = 1;
while (num1 > 0 && num2 > 0) {
int d = prime[now] - prime[now - 1];
while (d > 1 && num2 > 0) {
cout << " " << 2;
d -= 2;
num2--;
}
while (d > 0 && num1 > 0) {
d--;
cout << " " << 1;
num1--;
}
now++;
}
while (num2 > 0) {
cout << " " << 2;
num2--;
}
while (num1 > 0) {
cout << " " << 1;
num1--;
}
}
| 4 |
#include <bits/stdc++.h>
namespace IO {
static const int IN_BUF = 1 << 23, OUT_BUF = 1 << 23;
inline char myGetchar() {
static char buf[IN_BUF], *ps = buf, *pt = buf;
if (ps == pt) {
ps = buf, pt = buf + fread(buf, 1, IN_BUF, stdin);
}
return ps == pt ? EOF : *ps++;
}
template <typename T>
inline bool read(T &x) {
bool op = 0;
char ch = IO::myGetchar();
x = 0;
for (; !isdigit(ch) && ch != EOF; ch = IO::myGetchar()) {
op ^= (ch == '-');
}
if (ch == EOF) {
return false;
}
for (; isdigit(ch); ch = IO::myGetchar()) {
x = x * 10 + (ch ^ '0');
}
if (op) {
x = -x;
}
return true;
}
inline int readStr(char *s) {
int n = 0;
char ch = IO::myGetchar();
for (; isspace(ch) && ch != EOF; ch = IO::myGetchar())
;
for (; !isspace(ch) && ch != EOF; ch = IO::myGetchar()) {
s[n++] = ch;
}
s[n] = '\0';
return n;
}
inline void myPutchar(char x) {
static char pbuf[OUT_BUF], *pp = pbuf;
struct _flusher {
~_flusher() { fwrite(pbuf, 1, pp - pbuf, stdout); }
};
static _flusher outputFlusher;
if (pp == pbuf + OUT_BUF) {
fwrite(pbuf, 1, OUT_BUF, stdout);
pp = pbuf;
}
*pp++ = x;
}
template <typename T>
inline void print_(T x) {
if (x == 0) {
IO::myPutchar('0');
return;
}
static int num[40];
if (x < 0) {
IO::myPutchar('-');
x = -x;
}
for (*num = 0; x; x /= 10) {
num[++*num] = x % 10;
}
while (*num) {
IO::myPutchar(num[*num] ^ '0');
--*num;
}
}
template <typename T>
inline void print(T x, char ch = '\n') {
print_(x);
IO::myPutchar(ch);
}
inline void printStr_(const char *s, int n = -1) {
if (n == -1) {
n = strlen(s);
}
for (int i = 0; i < n; ++i) {
IO::myPutchar(s[i]);
}
}
inline void printStr(const char *s, int n = -1, char ch = '\n') {
printStr_(s, n);
IO::myPutchar(ch);
}
} // namespace IO
using namespace IO;
int n;
long long a[1000005], sum;
void getans(int n, long long sum) {
if (n == 0) {
return;
}
long long l = (sum + n - 1) / n, r = 2 * sum / n + n, ans = l;
while (l <= r) {
long long md = (l + r) >> 1;
if (sum >= (md - n + 1 + md) * n / 2) {
ans = md, l = md + 1;
} else {
r = md - 1;
}
}
getans(n - 1, sum - ans);
print(ans, ' ');
}
void solve() {
read(n);
for (int i = 1; i <= n; ++i) {
read(a[i]);
sum += a[i];
}
getans(n, sum);
IO::myPutchar('\n');
}
int main() {
int T = 1;
while (T--) {
solve();
}
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
bool cmp(int i, int j) { return i < j; }
int main() {
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
long long int min1 = 10000000000;
long long int *pole = new long long int[n];
for (long long int i = 0; i < n; i++) {
cin >> pole[i];
if (pole[i] < min1) {
min1 = pole[i];
}
}
long long int min2 = 10000000000;
long long int *pole2 = new long long int[n];
for (long long int i = 0; i < n; i++) {
cin >> pole2[i];
if (pole2[i] < min2) {
min2 = pole2[i];
}
}
long long int sucet = 0;
for (long long int i = 0; i < n; i++) {
if (pole[i] > min1) {
if (pole2[i] > min2) {
sucet += max((pole[i] - min1), (pole2[i] - min2));
} else {
sucet += pole[i] - min1;
}
} else {
if (pole2[i] > min2) {
sucet += pole2[i] - min2;
} else {
sucet = sucet + 0;
}
}
}
cout << sucet << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 500001;
char s[N], t[N];
long long len, k, ans, r;
int main() {
scanf("%lld%lld", &len, &k);
scanf("%s%s", s, t);
if (s[0] < t[0])
r = 2;
else
r = 1;
if (r >= k) {
ans += len * k;
printf("%lld", ans);
return 0;
}
ans += r;
for (int i = 1; i < len; i++) {
if (s[i] == 'a') {
if (t[i] == 'b')
r = r * 2;
else
r = r * 2 - 1;
} else {
if (t[i] == 'b')
r = r * 2 - 1;
else
r = r * 2 - 2;
}
if (r < k)
ans += r;
else {
ans += (len - i) * k;
printf("%lld", ans);
return 0;
}
}
printf("%lld", ans);
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
void File() {
freopen("output.txt", "w", stdout);
freopen("input.txt", "r", stdin);
}
void fast() {
ios::sync_with_stdio(NULL);
cout.tie(NULL);
cin.tie(NULL);
}
const double pi = 2 * acos(0.0);
const int nn = 1e5 + 4;
const int oo = 0x3f3f3f3f;
long long nCr(long long n, long long r) {
if (n < r) return 0;
if (r == 0) return 1;
return n * nCr(n - 1, r - 1) / r;
}
int main() {
fast();
long long n;
cin >> n;
cout << nCr(n + 4, 5) * nCr(n + 2, 3) << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long int OO = 2e7;
const double EPS = (1e-7);
bool sort_p(pair<int, int> a, pair<int, bool> b) { return a.second < b.second; }
long long int mod = 998244353;
int main() {
ios_base::sync_with_stdio(0);
cin.tie();
cout.tie();
int k, n;
cin >> n >> k;
vector<int> a(n);
for (int i = 0; i < (int)(n); ++i) cin >> a[i];
string s;
cin >> s;
long long int ans = 0;
vector<int> q;
for (int i = 0; i < (int)(n); ++i) {
if (i == n - 1) {
q.push_back(a[i]);
sort(((q).begin()), ((q).end()), greater<int>());
int x = 1;
for (int j = 0; j < ((int)((q).size())); ++j) {
if (x > k) break;
ans = ans + q[j];
x++;
}
q = vector<int>(0);
continue;
}
if (s[i] == s[i + 1]) {
q.push_back(a[i]);
} else if (s[i] != s[i + 1]) {
q.push_back(a[i]);
sort(((q).begin()), ((q).end()), greater<int>());
int x = 1;
for (int j = 0; j < ((int)((q).size())); ++j) {
if (x > k) break;
ans = ans + q[j];
x++;
}
q = vector<int>(0);
}
}
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long t = 1, n, xx, x = 0, y = 0, cc, f, m, k, base = 397;
long long hsh[2000005], ans;
long long pb[2000000 + 5];
string s, ss = "";
long long get_hash(string str, int sz) {
long long ans = 0;
for (int i = 0; i < sz; i++) {
ans += ((str[sz - i - 1] - 'a' + 1) * pb[i]) % 1000000009;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> s;
s = "F" + s;
n = s.size();
pb[0] = 1;
for (int i = 1; i < 1000001; i++) {
pb[i] = (pb[i - 1] * base) % 1000000009;
}
hsh[0] = 0ll;
for (int i = 1; i <= n; i++) {
hsh[i] = ((hsh[i - 1] * base) % 1000000009 + (s[i] - 'a' + 1)) % 1000000009;
}
long long val, vall;
f = 0;
for (int i = n - 3; i > 0; i--) {
val = hsh[i];
vall = (hsh[n - 1] - ((hsh[n - i - 1] * pb[i]) % 1000000009) + 1000000009) %
1000000009;
if (val == vall) {
for (int j = 2; j < n - i; j++) {
vall = (hsh[j + i - 1] - ((hsh[j - 1] * pb[i]) % 1000000009) +
1000000009) %
1000000009;
if (val == vall) {
f = 1;
ans = i;
break;
}
}
if (f) break;
}
}
if (!f)
cout << "Just a legend" << endl;
else {
for (int i = 1; i < ans + 1; i++) cout << s[i];
cout << endl;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 100 + 19;
int A[Maxn], n, Max, Gcd = 0;
int gcd(int a, int b) { return !b ? a : gcd(b, a % b); }
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &A[i]);
if (A[i] > Max) Max = A[i];
Gcd = gcd(Gcd, A[i]);
}
printf("%s\n", (Max / Gcd - n) & 1 ? "Alice" : "Bob");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void func(void) {
freopen("input.c", "r", stdin);
freopen("output.c", "w", stdout);
}
void print(vector<long long> &v) {
cout << v.size() << endl;
for (int i = 0; i < v.size(); i++) {
printf("%lld ", v[i]);
}
printf("\n");
}
void print(vector<pair<long long, long long> > &v) {
cout << v.size() << endl;
for (int i = 0; i < v.size(); i++) {
printf("%lld %lld\n", v[i].first, v[i].second);
}
}
void print(double d) { cout << fixed << setprecision(10) << d << endl; }
void print(string s, double d) {
cout << s << " ";
cout << fixed << setprecision(10) << d << endl;
}
long long a[3];
multiset<long long> s;
long long ans;
void done() {
if (s.size()) return;
cout << ans << endl;
exit(0);
}
long long kisuEkta(long long atLeast, long long baki) {
long long ans = 0;
while (s.size()) {
auto it = s.end();
it--;
long long x = *it;
if (x <= atLeast) break;
s.erase(it);
ans++;
if (s.size()) {
auto it = s.upper_bound(baki);
if (it != s.begin()) {
it--;
s.erase(it);
}
}
}
return ans;
}
int main() {
long long n, q, i, j = 0, temp, t, k, sum = 0, x, y, z, cnt = 0, m, fg = 0,
mx = 0, mx1 = 0, mn = 8000000000000000000,
mn1 = 8000000000000000000;
scanf("%lld", &n);
for (int i = 0; i < 3; i++) scanf("%lld", &a[i]);
sort(a, a + 3);
for (int i = 0; i < n; i++) {
scanf("%lld", &x);
s.insert(x);
}
long long tot = a[0] + a[1] + a[2];
long long atLeast = a[1] + a[2];
while (s.size()) {
auto it = s.end();
it--;
long long x = *it;
if (x > tot) {
cout << -1 << endl;
return 0;
}
if (x > atLeast) {
s.erase(it);
ans++;
} else
break;
}
done();
tot = a[2] + a[1];
atLeast = a[0] + a[2];
ans += kisuEkta(atLeast, a[0]);
done();
mx = max(a[2], a[0] + a[1]);
ans += kisuEkta(mx, a[1]);
done();
if (mx == a[0] + a[1]) {
ans += kisuEkta(a[2], a[2]);
}
while (s.size()) {
auto it = s.end();
it--;
s.erase(it);
ans++;
if (s.size()) {
auto it = s.upper_bound(a[1]);
if (it != s.begin()) {
it--;
s.erase(it);
if (s.size()) {
auto it = s.upper_bound(a[0]);
if (it != s.begin()) {
it--;
s.erase(it);
}
}
} else {
auto it = s.upper_bound(a[0]);
if (it != s.begin()) {
it--;
s.erase(it);
} else {
auto it = s.upper_bound(a[0] + a[1]);
if (it != s.begin()) {
it--;
s.erase(it);
}
}
}
}
}
done();
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
char s[2000005];
int ans;
int main() {
scanf("%s", s + 1);
int n = strlen(s + 1);
if (n == 1) {
puts("1");
return 0;
}
int l = 0;
for (int i = 1; i <= n; i++) s[n + i] = s[i];
s[0] = s[n], s[n + n + 1] = s[1];
for (int i = n + 1; i; i--) {
if (s[i] == s[i + 1] && s[i] != s[i - 1]) {
l = i;
break;
}
}
int t = l + n - 1;
for (int i = l; i <= t; i++) {
int len = 0;
while (s[i] == s[i + 1] && i <= t) {
s[i] = '2';
i++;
len++;
}
if (len) {
ans++;
s[i] = '2';
}
}
for (int i = l; i <= t; i++) {
int len = 0;
while (s[i] != '2' && i <= t) {
i++;
len++;
}
ans += len / 2;
}
printf("%d", ans);
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10, M = 2e5 + 10, M2 = 1e6 + 10, mod = 1e9 + 7,
inf = 1e17 + 10;
const int INF = 1e9 + 7;
void add(int& a, int b) {
a += b;
if (a >= mod) {
a -= mod;
}
}
string s;
string t;
int n, m;
int cache[401][401][401];
int dp(int i, int j, int k) {
if (i == n) {
if (k == m)
return 0;
else
return -1e10;
}
if (j == m && k == m) return 0;
if (j >= k) return -1e10;
int& ans = cache[i][j][k];
if (ans != -1) return ans;
ans = dp(i + 1, j, k);
if (i < n && s[i] == t[j]) ans = max(ans, dp(i + 1, j + 1, k) + 1);
if (j < n && s[i] == t[k]) ans = max(ans, dp(i + 1, j, k + 1) + 1);
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int q;
cin >> q;
while (q--) {
cin >> s >> t;
n = s.size();
m = t.size();
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= n; j++) {
for (int k = 0; k <= n; k++) {
cache[i][j][k] = -1;
}
}
}
bool ok = false;
for (int i = 0; i <= n; i++) {
if (dp(0, 0, i) >= m) ok = true;
}
if (ok)
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:200000000")
using namespace std;
const int MAXN = 5000000;
const long long MOD = (long long)1e9 + 7;
const int INF = 0x3f3f3f3f;
const long long INF_64 = (1LL << 62);
const double eps = 1e-9;
int main() {
int n, m;
cin >> n >> m;
if (m < n - 1 || m > 2 * n + 2) {
cout << -1;
exit(0);
}
string ans;
while (n && m) {
ans += '0';
ans += '1';
n--, m--;
if (2 * n < m) ans += '1', m--;
}
if (n) ans += '0';
while (m) ans = '1' + ans, m--;
cout << ans;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> H;
int n, bit[200010 << 1], d[200010 << 1], dt, cnt;
int f[200010], ans;
struct point {
int x, w;
void in() { scanf("%d %d", &x, &w); }
} a[200010];
bool cmp(point i, point j) { return i.x < j.x; }
int query(int x) {
int s(0);
for (; x; x -= x & -x) s = max(bit[x], s);
return s;
}
void insert(int x, int d) {
for (; x <= cnt; x += x & -x) bit[x] = max(d, bit[x]);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) a[i].in();
sort(a + 1, a + n + 1, cmp);
for (int i = 1; i <= n; i++)
d[++dt] = a[i].x - a[i].w, d[++dt] = a[i].x + a[i].w;
sort(d + 1, d + dt + 1);
for (int i = 1; i <= dt; i++)
H[d[i]] = (i == 1 || d[i] > d[i - 1] ? ++cnt : cnt);
for (int i = 1; i <= n; i++) {
ans = max(f[i] = query(H[a[i].x - a[i].w]) + 1, ans);
insert(H[a[i].x + a[i].w], f[i]);
}
printf("%d", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, cnt = 0;
int arr[200004];
cin >> n;
for (int i = 0; i < n; i++) arr[i] = i;
cnt += n * (n - 1) / 2;
for (int j = n - 1; j > 0; j--) {
for (int i = 0; i < j; i++) cnt += arr[i];
cnt++;
}
cnt++;
cout << cnt << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char s[105];
gets(s);
int j, i, n = strlen(s), res = 0;
vector<int> a;
for (i = 0; i < n; ++i) {
a.clear();
int x = (int)s[i], w = 2;
while (x > 0) {
a.push_back(x % w);
x /= w;
}
int z = a.size();
for (j = z; j < 8; ++j) a.push_back(0);
int naya = 0, po = 1;
for (j = a.size() - 1; j >= 0; --j) {
naya = naya + a[j] * po;
po *= 2;
}
int ans = res - naya;
if (ans >= 256) ans %= 256;
while (ans < 0) ans += 256;
cout << ans << "\n";
res = naya;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL), cout.tie(NULL);
string s;
vector<long long> neg, pos, z;
long long i, n;
cin >> n;
for (i = 0; i < n; i++) {
cin >> s;
long long t = 0, mi = LLONG_MAX;
bool wasneg = false;
for (long long j = 0; j < s.length(); j++) {
t += (s[j] == '(' ? 1 : -1);
wasneg = (wasneg || (t < 0));
mi = min(mi, t);
}
if (t > 0) {
if (!wasneg && s[0] == '(') pos.push_back(t);
} else if (t < 0) {
if (s[s.length() - 1] == ')' && mi == t) neg.push_back(t);
} else {
if (!wasneg) z.push_back(i);
}
}
sort(neg.begin(), neg.end());
sort(pos.begin(), pos.end());
long long ans = 0;
set<long long> pr;
for (i = 0; i < neg.size();) {
long long j = i;
while (j < neg.size()) {
if (neg[j] != neg[i]) break;
j++;
}
long long c1 = upper_bound(pos.begin(), pos.end(), -neg[i]) -
lower_bound(pos.begin(), pos.end(), -neg[i]);
ans += c1 = min(c1, j - i);
pr.insert(neg[i]);
i = j;
}
ans += z.size() / 2;
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100;
const int M = 3;
const char ccs[M + 1] = "CMY";
int cmap[128], dp[MAX_N][M];
char s[MAX_N + 4];
int main() {
for (int i = 0; i < M; i++) cmap[ccs[i]] = i;
int n;
scanf("%d%s", &n, s);
if (s[0] == '?')
for (int j = 0; j < M; j++) dp[0][j] = 1;
else
dp[0][cmap[s[0]]] = 1;
for (int i = 0; i + 1 < n; i++)
for (int j = 0; j < M; j++)
if (dp[i][j] > 0 && (s[i] == '?' || cmap[s[i]] == j))
for (int k = 0; k < M; k++)
if (j != k && (s[i + 1] == '?' || cmap[s[i + 1]] == k))
dp[i + 1][k] = min(2, dp[i + 1][k] + dp[i][j]);
int sum = 0;
for (int j = 0; j < M; j++) sum += dp[n - 1][j];
if (sum >= 2)
puts("Yes");
else
puts("No");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct interval {
int l, r, idx;
bool operator<(const interval& a) const {
return l != a.l ? l < a.l : idx > a.idx;
}
} arr[300005];
vector<pair<int, int> > L[300005];
int uni[300005];
void build(int n) {
set<interval> s;
for (int i = 1; i <= n; i++) {
uni[i] = arr[i].r - arr[i].l + 1;
auto it = s.lower_bound(arr[i]);
while (it != s.end()) {
if (it->l > arr[i].r) break;
interval tem = *it;
s.erase(tem);
L[i].push_back(
pair<int, int>{tem.idx + 1, min(arr[i].r, tem.r) - tem.l + 1});
uni[i] -= min(arr[i].r, tem.r) - tem.l + 1;
tem.l = arr[i].r + 1;
if (tem.l <= tem.r) s.insert(tem);
it = s.lower_bound(arr[i]);
}
while (it != s.begin()) {
it--;
if (it->r < arr[i].l) break;
interval tem = *it;
s.erase(tem);
if (tem.r <= arr[i].r) {
L[i].push_back(pair<int, int>{tem.idx + 1, tem.r - arr[i].l + 1});
uni[i] -= tem.r - arr[i].l + 1;
tem.r = arr[i].l - 1;
s.insert(tem);
} else {
L[i].push_back(pair<int, int>{tem.idx + 1, arr[i].r - arr[i].l + 1});
uni[i] -= arr[i].r - arr[i].l + 1;
s.insert(interval{tem.l, arr[i].l - 1, tem.idx});
s.insert(interval{arr[i].r + 1, tem.r, tem.idx});
}
it = s.lower_bound(arr[i]);
}
s.insert(arr[i]);
}
}
long long tag[300005];
pair<long long, long long> check(int n, int m) {
memset(tag, 0, sizeof tag);
int l = 1;
long long cnt = 0, ans = 0;
long long sum = 0, now = 0;
for (int r = 1; r <= n; r++) {
sum += (long long)uni[r] * l;
now += uni[r];
tag[r + 1] -= uni[r];
for (pair<int, int> tem : L[r]) {
int pos = tem.first, len = tem.second;
sum += (long long)max(0, l - pos + 1) * len;
if (pos <= l)
now += len;
else
tag[pos] += len;
tag[r + 1] -= len;
}
while (l < r && now + tag[l + 1] >= m) {
now += tag[++l];
sum += now;
}
if (now >= m) {
cnt += l;
ans += sum;
}
}
return pair<long long, long long>{cnt, ans};
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, k;
cin >> n >> k;
for (int i = 1, l, r; i <= n; i++) {
cin >> l >> r;
arr[i] = interval{l, r - 1, i};
}
build(n);
int l = 1, r = 1e9, m;
while (true) {
if (r - l < 3) {
for (m = l; m <= r && check(n, m).first >= k; m++)
;
m--;
break;
}
m = (l + r) >> 1;
if (check(n, m).first >= k)
l = m;
else
r = m - 1;
}
pair<long long, long long> ans = check(n, m);
cout << ans.second - (ans.first - k) * m << endl;
return 0;
}
| 27 |
#include <bits/stdc++.h>
long long int power(long long int a, long long int b) {
long long int ans = 1;
long long int k = a;
while (b) {
if (b % 2 == 1) ans *= k, ans %= 1000000007;
k *= k, k %= 1000000007;
b /= 2;
}
return ans;
}
long long int check[110][110];
long long int comb(int a, int b) {
if (b == 0) return 1;
if (a == b) return 1;
if (check[a][b]) return check[a][b];
return check[a][b] = (comb(a - 1, b - 1) + comb(a - 1, b)) % 1000000007;
}
long long int DP[110][110];
long long int check2[110][110][110];
long long int func(int k, int p, int C, int C2) {
if (C < 0) return 0;
if (p < 0) {
if (C == 0)
return 1;
else
return 0;
}
if (check2[p][C][C2] != -1) return check2[p][C][C2];
if (k >= (1 << p)) {
long long int t1 = 0, t2 = 0;
for (int i = 0; i <= C2; i += 2) t1 += comb(C2, i), t1 %= 1000000007;
for (int i = 1; i <= C2; i += 2) t2 += comb(C2, i), t2 %= 1000000007;
long long int S1 = 0;
if (p - C >= 0) {
S1 = DP[p][C] * power(2, (p - C) * C2);
S1 %= 1000000007, S1 *= t1, S1 %= 1000000007;
}
long long int S2 = func(k - (1 << p), p - 1, C, C2);
S2 %= 1000000007, S2 *= t2, S2 %= 1000000007;
long long int S3 = func(k - (1 << p), p - 1, C - 1, C2 + 1);
S3 %= 1000000007;
return check2[p][C][C2] = (S1 + S2 + S3) % 1000000007;
} else {
long long int t1 = 0;
for (int i = 0; i <= C2; i += 2) t1 += comb(C2, i), t1 %= 1000000007;
return check2[p][C][C2] = (func(k, p - 1, C, C2) * t1) % 1000000007;
}
}
int main() {
DP[0][0] = 1;
for (int i = 1; i <= 30; i++) {
DP[i][0] = 1;
for (int j = 1; j <= i; j++) {
long long int s1 = DP[i - 1][j - 1] * power(2, i - j);
s1 %= 1000000007;
long long int s2 = DP[i - 1][j];
DP[i][j] = (s1 + s2) % 1000000007;
}
}
int a;
scanf("%d", &a);
long long int sum = 0;
for (int i = 0; i <= 30; i++)
for (int j = 0; j <= 30; j++)
for (int k = 0; k <= 30; k++) check2[i][j][k] = -1;
for (int i = 0; i <= 30; i++) sum += func(a, 30, i, 0), sum %= 1000000007;
printf("%lld", sum);
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
long long int fact[400005];
int open[200005];
int clo[200005];
long long int power(long long int n, long long int x) {
if (x == 0) return 1;
long long int temp = power(n, x / 2);
if (x & 1)
return (n * ((temp * temp) % 1000000007)) % 1000000007;
else
return (temp * temp) % 1000000007;
}
long long int ncx(long long int n, long long int r) {
return (fact[n] *
power((fact[r] * fact[n - r]) % 1000000007, 1000000007 - 2)) %
1000000007;
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
;
string s;
cin >> s;
int n = s.length();
fact[0] = 1;
for (long long int i = 1; i < 2 * n + 2; i++) {
fact[i] = (fact[i - 1] * i) % 1000000007;
}
open[0] = 0;
clo[n - 1] = 0;
for (int i = 1; i < n; i++) {
open[i] = open[i - 1];
if (s[i - 1] == '(') open[i]++;
}
for (int i = n - 2; i >= 0; i--) {
clo[i] = clo[i + 1];
if (s[i + 1] == ')') clo[i]++;
}
int x, y;
long long int ans = 0;
for (int i = 0; i < n; i++) {
if (s[i] == ')') continue;
x = open[i];
y = clo[i];
ans = (ans + ncx(x + y, x + 1)) % 1000000007;
}
cout << (ans + 1000000007) % 1000000007;
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
long long p(long long l) {
if (l < 10) return l;
long long f, t, ret;
t = l % 10;
f = l;
while (f >= 10) f /= 10;
ret = l / 10 + 9;
if (t < f) ret--;
return ret;
}
int main() {
long long l, r;
cin >> l >> r;
cout << p(r) - p(l - 1) << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
char s[maxn];
int b[maxn];
int c[2][maxn];
pair<int, int> f[maxn];
int main() {
int n, m;
cin >> n >> s + 1 >> m;
for (int i = 1; i <= n; i++) {
b[i] = b[i - 1] + (s[i] == '?');
if (s[i] != 'a') c[0][i] = c[1][i - 1] + 1;
if (s[i] != 'b') c[1][i] = c[0][i - 1] + 1;
if (c[m & 1][i] >= m)
f[i] = make_pair(f[i - m].first + 1, f[i - m].second - b[i] + b[i - m]);
f[i] = max(f[i], f[i - 1]);
}
cout << -1 * f[n].second << endl;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
long long n, T;
cin >> n >> T;
map<long long, vector<vector<long long>>> data;
for (int i = 1; i <= n; ++i) {
long long a, t;
cin >> a >> t;
data[a].push_back({t, i, a});
}
set<vector<long long>> times;
long long anscnt = 0;
long long anstime = 0;
auto ansItr = times.end();
long long ansSoFar = 0;
for (auto itr = data.rbegin(); itr != data.rend(); ++itr) {
for (auto& datum : itr->second) {
times.insert(datum);
if (ansItr == times.end() || datum < *ansItr) {
anstime += datum[0];
--ansItr;
anstime -= (*ansItr)[0];
}
if (ansItr != times.end() && anstime + (*ansItr)[0] <= T) {
anstime += (*ansItr)[0];
++ansItr;
++anscnt;
}
}
ansSoFar = max(ansSoFar, min(itr->first, anscnt));
}
cout << ansSoFar << endl;
cout << ansSoFar << endl;
auto itr = times.begin();
long long cnt = ansSoFar;
for (; cnt; ++itr) {
if ((*itr)[2] >= ansSoFar) {
cout << (*itr)[1] << " ";
--cnt;
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long n, k, bad[1 << 20];
vector<long> vec[1 << 20];
long cnt;
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
vec[i].push_back(6 * i - 4);
vec[i].push_back(6 * i - 5);
vec[i].push_back(6 * i - 3);
vec[i].push_back(6 * i - 1);
}
cout << vec[n].back() * k << endl;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < vec[i].size(); j++) {
if (j) cout << " ";
cout << vec[i][j] * k;
}
cout << endl;
}
cin.get();
cin.get();
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
bool isPrime(long long n) {
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) {
return false;
}
}
return true;
}
bool hasOddFactor(long long n) {
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) {
if (i % 2 == 1 || (n / i) % 2 == 1) {
return true;
}
}
}
return false;
}
long long difFactors(long long n) {
int sum = 0;
long long factor;
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) {
factor = i;
sum++;
if (sum > 1) return -1;
while (n % i == 0) {
n /= i;
}
}
}
if (n > 1) return -1;
return factor;
}
int main() {
long long n;
cin >> n;
if (n == 1) {
cout << 1 << endl;
} else if (n == 2) {
cout << 2 << endl;
} else if (n == 3) {
cout << 3 << endl;
} else if (n == 4) {
cout << 2 << endl;
} else if (n == 5) {
cout << 5 << endl;
} else {
if (isPrime(n)) {
cout << n << endl;
} else {
if ((long long)sqrt(n) * sqrt(n) == n && isPrime(sqrt(n))) {
cout << sqrt(n) << endl;
return 0;
}
if (n % 2 == 0) {
if (hasOddFactor(n)) {
cout << 1 << endl;
} else
cout << 2 << endl;
} else {
long long dif = difFactors(n);
if (dif == -1) {
cout << 1 << endl;
} else {
cout << dif << endl;
}
}
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j, k;
cin >> n;
int l = n % 10;
if (l <= 5 && l != 0) {
cout << n - l;
return 0;
} else if (l > 5) {
int y = 10 - l;
cout << n + y;
} else if (n % 10 == 0)
cout << n;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string M[55];
vector<int> R[55], C[55];
bool vr[55], vc[55];
vector<int> cr, cc;
void dfs(int u, bool d) {
if (!d) {
cr.push_back(u);
vr[u] = 1;
for (int c : R[u]) {
if (!vc[c]) dfs(c, 1);
}
} else {
cc.push_back(u);
vc[u] = 1;
for (int r : C[u]) {
if (!vr[r]) dfs(r, 0);
}
}
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> M[i];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (M[i][j] == '#') R[i].push_back(j);
}
}
for (int j = 0; j < m; j++) {
for (int i = 0; i < n; i++) {
if (M[i][j] == '#') C[j].push_back(i);
}
}
for (int i = 0; i < n; i++) {
if (vr[i]) continue;
cr.clear(), cc.clear();
dfs(i, 0);
for (int r : cr) {
for (int c : cc) {
if (M[r][c] != '#') {
puts("No");
return 0;
}
}
}
}
puts("Yes");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
inline T1 max(T1 a, T2 b) {
return a < b ? b : a;
}
template <typename T1, typename T2>
inline T1 min(T1 a, T2 b) {
return a < b ? a : b;
}
const char lf = '\n';
namespace ae86 {
const int bufl = 1 << 15;
char buf[bufl], *s = buf, *t = buf;
inline int fetch() {
if (s == t) {
t = (s = buf) + fread(buf, 1, bufl, stdin);
if (s == t) return EOF;
}
return *s++;
}
inline int ty() {
int a = 0;
int b = 1, c = fetch();
while (!isdigit(c)) b ^= c == '-', c = fetch();
while (isdigit(c)) a = a * 10 + c - 48, c = fetch();
return b ? a : -a;
}
inline int tc() {
int c = fetch();
while (c <= 32 && c != EOF) c = fetch();
return c;
}
inline string ts() {
string s = "";
int c = fetch();
while (c <= 32 && c != EOF) c = fetch();
while (c > 32 && c != EOF) s.push_back(c), c = fetch();
return s;
}
} // namespace ae86
using ae86::tc;
using ae86::ts;
using ae86::ty;
const int _ = 100007, __ = 1000007, alp = 26;
struct amata {
int fa[__], ch[__][alp], tcnt;
int val[__];
int push(string s) {
int now = 1;
for (auto c_ : s) {
int c = c_ - 'a';
if (!ch[now][c]) ch[now][c] = ++tcnt;
now = ch[now][c];
}
val[now]++;
return now;
}
vector<int> e[__];
void make() {
queue<int> q;
fa[1] = 1;
for (int i = 0; i < alp; i++) {
if (ch[1][i])
fa[ch[1][i]] = 1, q.emplace(ch[1][i]);
else
ch[1][i] = 1;
}
while (!q.empty()) {
int a = q.front();
q.pop();
for (int i = 0; i < alp; i++) {
int b = ch[a][i];
if (b)
fa[b] = ch[fa[a]][i], val[b] += val[fa[b]], q.emplace(b);
else
ch[a][i] = ch[fa[a]][i];
}
}
for (int i = 2; i <= tcnt; i++) e[fa[i]].emplace_back(i);
}
int finding(string s) {
int now = 1, ans = 0;
for (auto c_ : s) {
int c = c_ - 'a';
now = ch[now][c], ans += val[now];
}
return ans;
}
int got[__] = {0};
void change(int x, int d) {
queue<int> q;
q.emplace(x);
while (!q.empty()) {
int a = q.front();
q.pop();
val[a] += d;
for (auto b : e[a])
if (!got[b]) q.emplace(b), got[b] = 1;
got[a] = 0;
}
}
amata() {
memset(this, 0, sizeof(amata));
tcnt = 1;
}
} t;
int n, qn, loc[_] = {0}, ali[_] = {0};
string str[_];
int main() {
ios::sync_with_stdio(0), cout.tie(nullptr);
qn = ty(), n = ty();
for (int i = 1; i <= n; i++)
str[i] = ts(), loc[i] = t.push(str[i]), ali[i] = 1;
t.make();
for (int qq = 1; qq <= qn; qq++) {
int op = tc();
if (op == '?') cout << t.finding(ts()) << lf;
if (op == '-') {
int a = ty();
if (ali[a]) ali[a] = 0, t.change(loc[a], -1);
}
if (op == '+') {
int a = ty();
if (!ali[a]) ali[a] = 1, t.change(loc[a], 1);
}
}
return 0;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, i, j;
string str;
cin >> n >> m;
for (i = 1; i <= n; i++) {
if (i % 2) {
str = "";
for (j = 1; j <= m; j++) str += '#';
} else if ((i % 2 == 0) && (i % 4 == 0)) {
str = "#";
for (j = 2; j <= m; j++) str += '.';
} else {
str = "";
for (j = 2; j <= m; j++) str += '.';
str += '#';
}
cout << str << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1000000000")
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops")
using namespace std;
const int maxn = (int)1e5 + 10;
struct vt {
long double x, y;
};
vt operator-(vt a, vt b) {
a.x -= b.x;
a.y -= b.y;
return a;
}
vt operator+(vt a, vt b) {
a.x += b.x;
a.y += b.y;
return a;
}
vt operator*(vt a, long double x) {
a.x *= x;
a.y *= x;
return a;
}
long double dst(vt a) { return hypotl(a.x, a.y); }
vt operator/(vt a, long double x) {
a.x /= x;
a.y /= x;
return a;
}
const long double eps = 0;
long double pi = 4 * atan(1.);
long double conv(long double ang) {
if (ang < -eps) {
ang += 2 * pi;
}
if (ang + eps >= 2 * pi) {
ang -= 2 * pi;
}
return ang;
}
vector<long double> inter(vt a, long double r) {
if (a.x * a.x + a.y * a.y <= r * r + eps) {
return {};
}
long double d = dst(a);
long double ang = atan2(a.y, a.x);
long double alp = acos(r / d);
return {conv(ang - alp), conv(ang + alp)};
}
vt v[maxn];
int tr[4 * maxn];
void change(int pos) {
for (; pos < 4 * maxn; pos |= pos + 1) {
tr[pos]++;
}
}
int go(int pos) {
int ans = 0;
for (; pos >= 0; pos = (pos & (pos + 1)) - 1) {
ans += tr[pos];
}
return ans;
}
int go(int l, int r) { return go(r) - go(l - 1); }
ostream& operator<<(ostream& out, vt a) { return out << a.x << ' ' << a.y; }
mt19937 rr;
int main() {
int n;
long long k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> v[i].x >> v[i].y;
}
k = (long long)n * (n - 1) / 2 - k;
long double l = 0;
long double r = sqrt(2.) * 1e4;
for (int itr = 0; itr < 36; itr++) {
long double m = (l + r) / 2;
vector<long double> g;
vector<pair<long double, long double> > f;
for (int i = 0; i < n; i++) {
auto a = inter(v[i], m);
if (a.empty()) {
continue;
}
f.push_back(make_pair(a[0], a[1]));
g.push_back(f.back().first);
g.push_back(f.back().second);
}
sort((g).begin(), (g).end());
vector<pair<int, int> > a;
memset(tr, 0, sizeof tr);
for (int i = 0; i < (int)f.size(); i++) {
a.push_back(make_pair(
lower_bound((g).begin(), (g).end(), f[i].first) - g.begin(),
lower_bound((g).begin(), (g).end(), f[i].second) - g.begin()));
if (a.back().first > a.back().second) {
change(a.back().second);
a.back().second += (int)g.size();
}
}
sort((a).begin(), (a).end());
long long tot = 0;
for (int i = 0; i < (int)a.size(); i++) {
tot += go(a[i].first, a[i].second);
change(a[i].second);
}
if (tot <= k) {
r = m;
} else {
l = m;
}
}
printf("%.10lf\n", (double)r);
}
| 24 |
#include <bits/stdc++.h>
using namespace std;
char st[105][105];
int n, m, ans, sx[10005], sy[10005], sz[10005];
bool fl[105][105];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%s", st[i] + 1);
if (st[1][m] == '*' || st[1][1] == '*' || st[n][1] == '*' ||
st[n][m] == '*') {
printf("-1\n");
return 0;
}
for (int siz = n; siz >= 1; siz--) {
for (int i = siz + 1; i <= n - siz; i++)
for (int j = siz + 1; j <= m - siz; j++) {
if (fl[i][j] == true) continue;
bool flag = true;
for (int k = 0; k <= siz; k++)
if (st[i - k][j] != '*') flag = false;
for (int k = 0; k <= siz; k++)
if (st[i][j - k] != '*') flag = false;
for (int k = 0; k <= siz; k++)
if (st[i + k][j] != '*') flag = false;
for (int k = 0; k <= siz; k++)
if (st[i][j + k] != '*') flag = false;
if (flag == false) continue;
ans++, sx[ans] = i, sy[ans] = j, sz[ans] = siz;
fl[i][j] = true;
}
}
for (int i = 1; i <= ans; i++) {
for (int k = 0; k <= sz[i]; k++) st[sx[i] - k][sy[i]] = '.';
for (int k = 0; k <= sz[i]; k++) st[sx[i]][sy[i] - k] = '.';
for (int k = 0; k <= sz[i]; k++) st[sx[i] + k][sy[i]] = '.';
for (int k = 0; k <= sz[i]; k++) st[sx[i]][sy[i] + k] = '.';
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (st[i][j] == '*') {
printf("-1\n");
return 0;
}
printf("%d\n", ans);
for (int i = 1; i <= ans; i++) printf("%d %d %d\n", sx[i], sy[i], sz[i]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x;
char c;
double y;
cin >> x >> c >> y;
cout << ((x % 12) * 30 + (y / 2)) << " " << y * 6;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int iinf = 1e9 + 10;
const long long inf = 1ll << 60;
const long long mod = 1e9 + 7;
void GG() {
cout << "0\n";
exit(0);
}
long long mpow(long long a, long long n, long long mo = mod) {
long long re = 1;
while (n > 0) {
if (n & 1) re = re * a % mo;
a = a * a % mo;
n >>= 1;
}
return re;
}
long long inv(long long b, long long mo = mod) {
if (b == 1) return b;
return (mo - mo / b) * inv(mo % b, mo) % mo;
}
const int maxn = 1e6 + 5;
map<long long, pair<long long, long long> > big;
map<long long, pair<long long, long long> > ids;
map<long long, long long> sho;
map<long long, long long> sid;
long long dp[200005][2];
long long frm[200005][2];
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
long long n;
cin >> n;
vector<pair<long long, long long> > v;
for (long long i = 0; i < n; ++i) {
long long c, second;
cin >> c >> second;
sho[second] = c;
sid[second] = i + 1;
}
long long m;
cin >> m;
for (long long i = 0; i < m; ++i) {
long long d, l;
cin >> l >> d;
if (l > big[d].first) {
ids[d].second = ids[d].first;
big[d].second = big[d].first;
ids[d].first = i + 1;
big[d].first = l;
} else if (l > big[d].second)
big[d].second = l, ids[d].second = i + 1;
}
long long i = 1;
long long prevs = -3;
vector<pair<long long, long long> > th(200005);
vector<pair<long long, long long> > th2(200005);
vector<pair<long long, long long> > buyid(200005);
for (auto &tt : big) {
long long second = tt.first;
if (prevs != second - 1 && i != 1) {
dp[i][0] = dp[i][1] = dp[i - 1][1];
++i;
}
prevs = second;
long long a = tt.second.first, b = tt.second.second;
;
long long L = (sho.count(second) ? sho[second] : 0),
R = (sho.count(second + 1) ? sho[second + 1] : 0);
buyid[i] = {ids[second].first, ids[second].second};
if (a >= max(L, R) && b >= min(L, R)) {
dp[i][1] = dp[i - 1][0] + L + R;
frm[i][1] = 3;
}
if (a >= L) {
dp[i][0] = max(dp[i][0], (__typeof__(dp[i][0]))(dp[i - 1][0] + L));
frm[i][0] = 1;
}
if (a >= R) {
if (dp[i - 1][1] + R > dp[i][1]) {
dp[i][1] = max(dp[i][1], (__typeof__(dp[i][1]))(dp[i - 1][1] + R));
frm[i][1] = 2;
}
}
if (dp[i - 1][1] > dp[i][0]) {
dp[i][0] = dp[i - 1][1];
frm[i][0] = 0;
}
if (dp[i][0] > dp[i][1]) {
dp[i][1] = max(dp[i][1], (__typeof__(dp[i][1]))(dp[i][0]));
frm[i][1] = frm[i][0];
}
th[i] = {sid[second], sid[second + 1]};
th2[i] = th[i];
if (L < R) {
swap(L, R);
swap(th2[i].first, th2[i].second);
}
++i;
}
cout << dp[i - 1][1] << '\n';
vector<pair<long long, long long> > ret;
long long wan = 1;
for (long long at = i - 1; at >= 0; --at) {
;
if (frm[at][wan] == 3) {
ret.push_back({buyid[at].first, th2[at].first});
ret.push_back({buyid[at].second, th2[at].second});
;
} else if (frm[at][wan] == 2) {
ret.push_back({buyid[at].first, th[at].second});
} else if (frm[at][wan] == 1) {
ret.push_back({buyid[at].first, th[at].first});
}
wan = 1 ^ (frm[at][wan] & 1);
}
vector<pair<long long, long long> > re;
for (auto x : ret)
if (x.first && x.second) re.push_back(x);
cout << (long long)re.size() << '\n';
for (auto &x : re) cout << x.first << ' ' << x.second << '\n';
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
int n, m, k, deg[N], ans[N], s[N], t[N];
map<int, bool> adj[N];
vector<int> g[N];
bool alive[N];
void solve() {
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
q;
memset(alive, 1, sizeof(alive));
for (int u = 1; u <= n; u++) q.push(make_pair(deg[u], u));
while (q.size()) {
pair<int, int> now = q.top();
if (now.first >= k) break;
q.pop();
if (!alive[now.second]) continue;
alive[now.second] = 0;
for (int &v : g[now.second]) {
deg[v]--;
if (alive[v]) q.push(make_pair(deg[v], v));
}
}
int res = 0;
for (int u = 1; u <= n; u++) res += alive[u];
ans[m] = res;
for (int i = m; i >= 1; i--) {
if (alive[s[i]] && alive[t[i]]) {
deg[s[i]]--;
deg[t[i]]--;
adj[s[i]][t[i]] = 0;
adj[t[i]][s[i]] = 0;
q.push(make_pair(deg[s[i]], s[i]));
q.push(make_pair(deg[t[i]], t[i]));
pair<int, int> now = q.top();
while (q.size()) {
pair<int, int> now = q.top();
if (now.first >= k) break;
q.pop();
if (!alive[now.second]) continue;
--res;
alive[now.second] = 0;
for (int &v : g[now.second]) {
if (!adj[now.second][v]) continue;
--deg[v];
if (alive[v]) q.push(make_pair(deg[v], v));
}
}
}
ans[i - 1] = res;
}
for (int i = 1; i <= m; i++) printf("%d\n ", ans[i]);
}
int main() {
scanf("%d %d %d ", &n, &m, &k);
for (int i = 1; i <= m; i++) {
scanf("%d %d ", &s[i], &t[i]);
deg[s[i]]++;
deg[t[i]]++;
adj[s[i]][t[i]] = adj[t[i]][s[i]] = 1;
g[s[i]].push_back(t[i]);
g[t[i]].push_back(s[i]);
}
solve();
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int n, a[1200][1200];
int q, ans = 0;
int x, num;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) scanf("%d", &a[i][j]);
for (int i = 1; i <= n; i++)
if (a[i][i]) ans++;
ans %= 2;
scanf("%d", &q);
while (q--) {
scanf("%d", &x);
if (x == 3)
printf("%d", ans);
else {
scanf("%d", &num);
{
a[num][num] = 1 - a[num][num];
if (a[num][num])
ans = (ans + 1) % 2;
else
ans = (ans - 1) % 2;
ans = abs(ans);
}
}
}
printf("\n");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n;
int f[200005], a[200005];
int ans[200005];
int find(int x) {
if (x == f[x])
return x;
else
return f[x] = find(f[x]);
}
void Union(int x, int y) {
int fx = find(x);
int fy = find(y);
if (fx != fy) f[fx] = fy;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) f[i] = i;
int cnt = 0;
int t = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (find(a[i]) == find(i)) {
ans[cnt++] = i;
if (a[i] == i) {
t = find(i);
}
}
Union(i, a[i]);
}
int cnt1 = 0;
if (t == 0) {
for (int i = 1; i <= n; i++) {
if (find(i) == find(a[i])) {
t = find(i);
}
}
}
for (int i = 0; i < cnt; i++) {
if (a[ans[i]] != t) {
a[ans[i]] = t;
cnt1++;
}
}
cout << cnt1 << endl;
for (int i = 1; i <= n; i++) {
if (i == 1)
printf("%d", a[i]);
else
printf(" %d", a[i]);
}
cout << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 7;
const int M = 1e5 + 5;
const int N = 300;
char s[M];
int f[26][M];
int dp[N][N][N];
int ch[4][N];
int main() {
int n, m;
scanf("%d%d%s", &n, &m, s + 1);
for (int k = 25; k >= 0; k--) {
f[k][n + 1] = n + 1;
for (int i = n; i >= 0; i--) {
int c = s[i + 1] - 'a';
if (c != k)
f[k][i] = f[k][i + 1];
else
f[k][i] = i + 1;
}
}
int n1, n2, n3;
n1 = n2 = n3 = 0;
while (m--) {
char op[3];
int flag;
scanf("%s%d", op, &flag);
if (op[0] == '+') {
char t[3];
scanf("%s", t);
int c = t[0] - 'a';
if (flag == 1) {
ch[1][++n1] = c;
dp[n1][0][0] = f[c][dp[n1 - 1][0][0]];
for (int i = 1; i <= n2; i++)
dp[n1][i][0] =
min(f[c][dp[n1 - 1][i][0]], f[ch[2][i]][dp[n1][i - 1][0]]);
for (int j = 1; j <= n3; j++)
dp[n1][0][j] =
min(f[c][dp[n1 - 1][0][j]], f[ch[3][j]][dp[n1][0][j - 1]]);
for (int i = 1; i <= n2; i++)
for (int j = 1; j <= n3; j++) {
dp[n1][i][j] =
min(f[c][dp[n1 - 1][i][j]], min(f[ch[3][j]][dp[n1][i][j - 1]],
f[ch[2][i]][dp[n1][i - 1][j]]));
}
} else if (flag == 2) {
ch[2][++n2] = c;
dp[0][n2][0] = f[c][dp[0][n2 - 1][0]];
for (int i = 1; i <= n1; i++)
dp[i][n2][0] =
min(f[ch[1][i]][dp[i - 1][n2][0]], f[c][dp[i][n2 - 1][0]]);
for (int j = 1; j <= n3; j++)
dp[0][n2][j] =
min(f[c][dp[0][n2 - 1][j]], f[ch[3][j]][dp[0][n2][j - 1]]);
for (int i = 1; i <= n1; i++)
for (int j = 1; j <= n3; j++) {
dp[i][n2][j] =
min(f[c][dp[i][n2 - 1][j]], min(f[ch[3][j]][dp[i][n2][j - 1]],
f[ch[1][i]][dp[i - 1][n2][j]]));
}
} else {
ch[3][++n3] = c;
dp[0][0][n3] = f[c][dp[0][0][n3 - 1]];
for (int i = 1; i <= n1; i++)
dp[i][0][n3] =
min(f[c][dp[i][0][n3 - 1]], f[ch[1][i]][dp[i - 1][0][n3]]);
for (int j = 1; j <= n2; j++)
dp[0][j][n3] =
min(f[c][dp[0][j][n3 - 1]], f[ch[2][j]][dp[0][j - 1][n3]]);
for (int i = 1; i <= n1; i++)
for (int j = 1; j <= n2; j++)
dp[i][j][n3] =
min(f[c][dp[i][j][n3 - 1]], min(f[ch[2][j]][dp[i][j - 1][n3]],
f[ch[1][i]][dp[i - 1][j][n3]]));
}
} else {
if (flag == 1)
n1--;
else if (flag == 2)
n2--;
else
n3--;
}
if (dp[n1][n2][n3] != n + 1)
puts("YES");
else
puts("NO");
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long N, L, K;
map<int, int> mp, mpe;
scanf("%lld%lld%lld", &N, &L, &K);
long long rem = L % N, rc = L / N;
for (int n = 0; n < int(N); n++) {
int x;
scanf("%d", &x);
mp[x]++;
if (n < rem) mpe[x]++;
}
long long ans = 0;
vector<long long> res(mp.size(), 1);
for (int k = 1; k < int(K + 1); k++) {
int i = 0;
long long tb = 0;
for (auto it = mp.begin(); it != mp.end(); ++it, ++i) {
tb = (tb + res[i] * mpe[it->first]) % 1000000007;
res[i] = (res[i] * it->second) % 1000000007;
if (i) res[i] = (res[i] + res[i - 1]) % 1000000007;
}
if (k <= rc)
ans = (ans + res.back() * ((rc - k + 1) % 1000000007)) % 1000000007;
if (k <= rc + 1) ans = (ans + tb) % 1000000007;
}
printf("%lld\n", ans);
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
bool isSubSequence(string str1, string str2, int m, int n) {
if (m == 0) return true;
if (n == 0) return false;
if (str1[m - 1] == str2[n - 1])
return isSubSequence(str1, str2, m - 1, n - 1);
return isSubSequence(str1, str2, m, n - 1);
}
int main() {
string str1, str2;
cin >> str2 >> str1;
if (isSubSequence(str1, str2, str1.size(), str2.size())) {
printf("automaton\n");
} else {
sort(str1.begin(), str1.end());
sort(str2.begin(), str2.end());
if (str1 == str2) {
printf("array\n");
} else if (isSubSequence(str1, str2, str1.size(), str2.size())) {
printf("both\n");
} else {
printf("need tree\n");
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int in() {
int x;
return cin >> x, x;
}
template <class T, class L>
T& smax(T& x, L y) {
return x < y ? x = y : x;
}
template <class T, class L>
T& smin(T& x, L y) {
return x > y ? x = y : x;
}
const int maxn = 1e2 + 17;
int n;
char c[maxn][maxn];
int d[maxn * maxn * maxn];
struct pnt {
int a, b, c;
} x;
bool operator!=(pnt a, pnt b) { return a.a != b.a || a.b != b.b || a.c != b.c; }
pnt it[maxn * maxn * maxn];
pnt _(pnt x) {
if (x.c < x.b) swap(x.c, x.b);
if (x.b < x.a) swap(x.a, x.b);
if (x.c < x.b) swap(x.c, x.b);
return x;
}
int mp(pnt a) {
a = _(a);
return a.a * n * n + a.b * n + a.c;
}
pnt rmp(int a) { return _({a / (n * n), a % (n * n) / n, a % n}); }
queue<pnt> q;
void bfs() {
memset(d, 63, sizeof d);
memset(it, -1, sizeof it);
q.push({0, 1, 2});
d[mp({0, 1, 2})] = 0;
while (q.size()) {
pnt v = _(q.front());
q.pop();
for (int i = 0; i < n; i++)
if (i != v.a && i != v.b && i != v.c && c[v.a][i] == c[v.b][v.c] &&
d[mp({i, v.b, v.c})] > d[mp(v)] + 1) {
d[mp({i, v.b, v.c})] = d[mp(v)] + 1, q.push(_({i, v.b, v.c})),
it[mp({i, v.b, v.c})] = v;
auto tmp = _({i, v.b, v.c});
}
for (int i = 0; i < n; i++)
if (i != v.a && i != v.b && i != v.c && c[v.b][i] == c[v.a][v.c] &&
d[mp({v.a, i, v.c})] > d[mp(v)] + 1) {
d[mp({v.a, i, v.c})] = d[mp(v)] + 1, q.push(_({v.a, i, v.c})),
it[mp({v.a, i, v.c})] = v;
auto tmp = _({v.a, i, v.c});
}
for (int i = 0; i < n; i++)
if (i != v.a && i != v.b && i != v.c && c[v.c][i] == c[v.b][v.a] &&
d[mp({v.a, v.b, i})] > d[mp(v)] + 1) {
d[mp({v.a, v.b, i})] = d[mp(v)] + 1, q.push(_({v.a, v.b, i})),
it[mp({v.a, v.b, i})] = v;
auto tmp = _({v.a, v.b, i});
}
}
}
unordered_set<int> deemo, iman_gh;
void out(pnt x, pnt y) {
int from = -1, to = -1;
deemo.clear(), iman_gh.clear();
deemo.insert(x.a);
deemo.insert(x.b);
deemo.insert(x.c);
iman_gh.insert(y.a);
iman_gh.insert(y.b);
iman_gh.insert(y.c);
for (auto x : deemo)
if (!iman_gh.count(x)) from = x;
for (auto x : iman_gh)
if (!deemo.count(x)) to = x;
cout << from + 1 << ' ' << to + 1 << '\n';
}
int main() {
ios::sync_with_stdio(0), cin.tie();
cin >> n >> x.a >> x.b >> x.c;
x.a--, x.b--, x.c--;
x = _(x);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) cin >> c[i][j];
bfs();
if (d[mp(x)] > 1e9) return cout << "-1\n", 0;
cout << d[mp(x)] << '\n';
while (_(x) != pnt({0, 1, 2})) {
out(_(x), _(it[mp(x)])), x = _(it[mp(x)]);
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_SIZE = 100 + 8;
long long a[MAX_SIZE], bb[MAX_SIZE];
int c[MAX_SIZE];
const long long MOD = 1e9 + 7;
const long long M_SIZE = 16;
long long mod(long long &x) { x -= x / MOD * MOD; }
struct Matrix {
long long m[M_SIZE][M_SIZE];
long long N;
void init() { memset(m, 0, sizeof m); }
void setOne() {
init();
for (int i = 0; i < M_SIZE; i++) m[i][i] = 1;
}
Matrix() { init(); }
Matrix operator*(const Matrix &rhs) const {
Matrix ret;
ret.N = N;
int i, j, k;
for (k = 0; k <= N; k++) {
for (i = 0; i <= N; i++) {
for (j = 0; j <= N; j++) {
mod(ret.m[i][j] += m[i][k] * rhs.m[k][j]);
}
}
}
return ret;
}
void print() {
for (int i = 0; i <= N; i++) {
for (int j = 0; j <= N; j++) cout << m[i][j] << " ";
cout << endl;
}
cout << endl;
}
};
Matrix res, b;
void quickPow(long long index) {
while (index) {
if (index & 1) res = res * b;
index >>= 1;
b = b * b;
}
}
char s[MAX_SIZE];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n, kk;
cin >> n >> kk;
res.N = 15;
b.N = 15;
res.init();
res.setOne();
int i, j, k;
for (i = 1; i <= n; i++) {
cin >> a[i] >> bb[i] >> c[i];
}
for (i = 1; i <= n; i++) {
b.init();
for (j = 0; j <= c[i]; j++) {
if (j + 1 <= c[i]) b.m[j][j + 1]++;
if (j - 1 >= 0) b.m[j][j - 1]++;
b.m[j][j]++;
}
if (bb[i] >= kk)
quickPow(kk - a[i]);
else
quickPow(bb[i] - a[i]);
}
long long ans = res.m[0][0];
cout << ans << endl;
return 0;
}
| 13 |
#include <bits/stdc++.h>
int main() {
int q, a, j;
scanf("%d", &q);
for (j = 0; j < q; j++) {
scanf("%d", &a);
if (a == 2)
printf("2\n");
else if (a % 2 == 0)
printf("0\n");
else
printf("1\n");
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000 * 100 + 10, SQ = 300;
vector<int> graph[MAXN], t[MAXN];
vector<pair<int, int> > vec[MAXN];
int c[MAXN], ans[MAXN];
set<pair<int, int> > st[2][MAXN];
bool mark[MAXN];
void dfs(int v) {
mark[v] = true;
for (int i = 0; i < SQ; i++) t[v].push_back(0);
t[v][1]++;
st[0][v].insert({c[v], 1});
for (auto u : graph[v])
if (!mark[u]) {
dfs(u);
if ((int)st[0][u].size() + (int)st[1][u].size() >
(int)st[0][v].size() + (int)st[1][v].size()) {
st[0][u].swap(st[0][v]);
st[1][u].swap(st[1][v]);
t[u].swap(t[v]);
}
for (int j = 0; j < 2; j++) {
for (auto x : st[j][u]) {
auto it1 = st[0][v].lower_bound({x.first, -1});
auto it2 = st[1][v].lower_bound({x.first, -1});
pair<int, int> new_x = x;
if (it1 != st[0][v].end() && it1->first == x.first) {
t[v][it1->second]--;
x.second += (it1->second);
st[0][v].erase(it1);
} else if (it2 != st[1][v].end() && it2->first == x.first) {
x.second += (it2->second);
st[1][v].erase(it2);
}
if (x.second < SQ) {
t[v][x.second]++;
st[0][v].insert(x);
} else
st[1][v].insert(x);
}
}
st[0][u].clear();
st[1][u].clear();
t[u].clear();
}
for (auto q : vec[v])
if (q.first < SQ) {
ans[q.second] = (int)st[1][v].size();
for (int i = q.first; i < SQ; i++) ans[q.second] += t[v][i];
} else {
for (auto x : st[1][v])
if (x.second >= q.first) ans[q.second]++;
}
}
int main() {
int n, q;
scanf("%d %d", &n, &q);
for (int i = 0; i < n; i++) scanf("%d", c + i);
for (int i = 0; i < n - 1; i++) {
int a, b;
scanf("%d %d", &a, &b);
a--, b--;
graph[a].push_back(b);
graph[b].push_back(a);
}
for (int i = 0; i < q; i++) {
int v, k;
scanf("%d %d", &v, &k);
vec[v - 1].push_back({k, i});
}
for (int i = 0; i < n; i++) sort(vec[i].begin(), vec[i].end());
dfs(0);
for (int i = 0; i < q; i++) printf("%d\n", ans[i]);
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long k, p, ans;
map<long long, long long> mp;
int main() {
scanf("%d%lld%lld", &n, &p, &k);
for (int i = 1; i <= n; i++) {
long long x;
scanf("%lld", &x);
x = ((x % p * x % p * x % p * x % p - (k * x) % p) % p + p) % p;
ans += mp[x], mp[x]++;
}
printf("%lld", ans);
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
using i64 = long long;
int n, a[423456], cnt[423456];
int s[423456], pos[423456], answer;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
cnt[a[i]]++;
}
int cntmode = 0;
for (int i = 1; i <= n; i++) cntmode = max(cntmode, cnt[i]);
vector<int> modes;
for (int i = 1; i <= n; i++)
if (cnt[i] == cntmode) {
modes.push_back(i);
}
if (modes.size() >= 2) {
printf("%d\n", n);
return 0;
}
int M = modes[0];
for (int m = 1; m <= 100; m++) {
if (m == M) continue;
for (int j = 1; j <= n; j++) {
if (a[j] == M)
s[j] = s[j - 1] + 1;
else if (a[j] == m)
s[j] = s[j - 1] - 1;
else
s[j] = s[j - 1];
}
for (int i = 0; i <= 2 * n + 1; i++) pos[i] = n + 1;
for (int i = 0; i <= n; i++) pos[s[i] + n] = min(pos[s[i] + n], i);
for (int i = 2 * n; i >= 0; i--) pos[i] = min(pos[i], pos[i + 1]);
for (int i = 1; i <= n; i++) {
answer = max(answer, i - pos[s[i] + n]);
}
}
printf("%d\n", answer);
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
char s[20];
int main() {
scanf("%s", s);
int len = strlen(s);
while (len && s[len - 1] == '0') --len;
int mid = len / 2;
bool ans = true;
for (int i = 0; i <= mid; ++i) {
if (s[i] != s[len - 1 - i]) {
ans = false;
break;
}
}
printf("%s\n", ans ? "YES" : "NO");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long bulls = 0, cows = 0, bullsm, l1 = 0, l2 = 0, l3 = 0, l4 = 0;
for (long long i = 0; i < 10; i++) {
cout << "000" << i << endl;
fflush(stdout);
cin >> bulls >> cows;
if (i == 0) bullsm = bulls;
if (bullsm < bulls) l4 = i;
}
bulls = bullsm = cows = 0;
for (long long i = 0; i < 10; i++) {
cout << "00" << i << "0" << endl;
fflush(stdout);
cin >> bulls >> cows;
if (i == 0) bullsm = bulls;
if (bullsm < bulls) l3 = i;
}
bulls = bullsm = cows = 0;
for (long long i = 0; i < 10; i++) {
cout << "0" << i << "00" << endl;
fflush(stdout);
cin >> bulls >> cows;
if (i == 0) bullsm = bulls;
if (bullsm < bulls) l2 = i;
}
bulls = bullsm = cows = 0;
for (long long i = 0; i < 10; i++) {
cout << i << "000" << endl;
fflush(stdout);
cin >> bulls >> cows;
if (i == 0) bullsm = bulls;
if (bullsm < bulls) l1 = i;
}
cout << l1 << l2 << l3 << l4 << endl;
fflush(stdout);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct {
bool operator()(const string what, const string what1) const {
return what.length() < what1.length();
}
} LenCompare;
struct {
void str(vector<string> VecStr) {
for (int i = 0; i < VecStr.size(); i++) {
cout << VecStr[i] << ' ';
}
}
void iint(vector<int> VecInt) {
for (int i = 0; i < VecInt.size(); i++) {
cout << VecInt[i] << ' ';
}
}
void chr(vector<char> VecChr) {
for (int i = 0; i < VecChr.size(); i++) {
cout << VecChr[i] << ' ';
}
}
} show_vector;
int main() {
ios_base::sync_with_stdio(false);
string ciphre;
cin >> ciphre;
string h;
int right = 0;
int left = 0;
for (int i = 0; i < ciphre.length(); i++) {
if (i % 2 == 0) {
if (ciphre.length() % 2 == 0) {
h.push_back(ciphre[ciphre.length() - left - 1]);
left++;
} else {
h.push_back(ciphre[right]);
right++;
}
} else {
if (ciphre.length() % 2 == 0) {
h.push_back(ciphre[right]);
right++;
} else {
h.push_back(ciphre[ciphre.length() - left - 1]);
left++;
}
}
}
for (int i = h.length() - 1; i >= 0; i--) {
cout << h[i];
}
return (0);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 200;
int qianzhui[maxn];
int n, k;
char a[maxn];
bool check(int x) {
int L, R;
for (int i = 1; i <= n; i++) {
if (a[i] == '1') continue;
L = max(i - x, 1);
R = min(i + x, n);
if (qianzhui[R] - qianzhui[L - 1] >= k + 1) {
return true;
}
}
return false;
}
int main() {
int i;
scanf("%d%d", &n, &k);
scanf("%s", a + 1);
for (i = 1; i <= n; i++) {
qianzhui[i] = qianzhui[i - 1] + (a[i] == '0');
}
int left = 0, right = n, mid;
while (right - left > 1) {
mid = (left + right) >> 1;
if (check(mid))
right = mid;
else
left = mid;
}
cout << right << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100 * 1000 + 20;
int main() {
int cnt = 0;
string heidi = "heidiA", str;
cin >> str;
for (int i = 0; i < str.size(); i++)
if (heidi[cnt] == str[i]) cnt++;
if (cnt == 5)
cout << "YES";
else
cout << "NO";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int N = 1010;
int dp[N][N][2];
int bits[N];
int t, k;
long long dfs(int len, int pos, int num, bool mark) {
int maxx;
long long sum;
if (!len) {
if (num == 1) {
return true;
} else {
return false;
}
}
if (!mark && dp[len][pos][num] != -1) {
return dp[len][pos][num];
}
if (mark) {
maxx = bits[len];
} else {
maxx = 9;
}
sum = 0;
for (int i = 0; i <= maxx; i++) {
int x, y;
if (i == 4 || i == 7) {
if (pos && pos - len <= k) {
x = true;
} else if (num) {
x = true;
} else {
x = false;
}
if (mark && i == maxx) {
y = true;
} else {
y = false;
}
sum += dfs(len - 1, len, x, y);
} else {
if (mark && i == maxx) {
y = true;
} else {
y = false;
}
sum += dfs(len - 1, pos, num, y);
}
}
sum %= MOD;
if (!mark) {
dp[len][pos][num] = sum;
}
return sum;
}
long long f(string s) {
int len;
len = 0;
for (int i = s.size() - 1; i >= 0; i--) {
len++;
bits[len] = s[i] - '0';
}
return dfs(len, 0, 0, 1);
}
bool check(string s) {
int p;
p = 0;
for (int i = 1; i <= s.size(); i++) {
if (s[i - 1] == '4' || s[i - 1] == '7') {
if (!p || i - p > k) {
p = i;
} else if (i - p <= k) {
return true;
}
}
}
return false;
}
int main() {
string l, r;
long long ans;
while (scanf("%d%d", &t, &k) == 2) {
memset(dp, -1, sizeof(dp));
for (int i = 0; i < t; i++) {
cin >> l >> r;
ans = f(r) - f(l);
if (check(l)) {
ans += 1;
}
printf("%lld\n", (ans % MOD + MOD) % MOD);
}
}
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
long long int P = 1000000007;
long long int a[100001], parent[100001], value[100001], flag = 0, ans = 0;
vector<long long int> adj[100001];
long long int visited[100001];
void dfs(long long int src, long long int val) {
visited[src] = 1;
for (long long int i = 0; i < adj[src].size(); i++) {
if (!visited[adj[src][i]]) {
if (value[adj[src][i]] < val && value[adj[src][i]] != -1) {
flag = 1;
return;
} else {
if (value[adj[src][i]] != -1) ans += value[adj[src][i]] - val;
dfs(adj[src][i], max(value[adj[src][i]], val));
}
}
}
}
int main() {
long long int i, j, k, l, m, n, o, p, q, r, s, t, d;
cin >> n;
memset(visited, 0, sizeof(visited));
for (i = 2; i <= n; i++) {
cin >> parent[i];
adj[parent[i]].push_back(i);
adj[i].push_back(parent[i]);
}
for (i = 1; i <= n; i++) cin >> value[i];
ans += value[1];
long long int ma = value[1];
for (i = 2; i <= n; i++) {
long long int v1 = LLONG_MAX;
if (value[i] == -1) {
for (j = 0; j < adj[i].size(); j++) {
if (parent[i] != adj[i][j]) {
v1 = min(v1, value[adj[i][j]]);
}
}
if (v1 != LLONG_MAX) value[i] = v1;
}
}
dfs(1, ma);
if (flag)
cout << "-1\n";
else
cout << ans << "\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false), cin.tie(nullptr);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int arr1[n], arr2[n];
for (int i = 0; i < n; i++) {
cin >> arr1[i];
}
for (int i = 0; i < n; i++) {
cin >> arr2[i];
}
if (n == 1) {
if (arr1[0] == arr2[0])
cout << "YES" << endl;
else if (arr1[0] < arr2[0])
cout << "YES" << endl;
else
cout << "NO" << endl;
} else {
int diff1 = 0, flag = 0, i = 0;
for (; i < n; i++) {
if ((arr1[i] - arr2[i]) < 0) {
diff1 = (arr1[i] - arr2[i]);
break;
} else if (arr1[i] - arr2[i] > 0) {
flag = 1;
break;
} else
continue;
}
if (diff1 != 0) {
int diff = diff1;
for (; i < n; i++) {
diff1 = (arr1[i] - arr2[i]);
if (diff1 == diff)
continue;
else if (diff1 == 0) {
break;
} else {
flag = 1;
break;
}
}
}
if (diff1 == 0) {
for (; i < n; i++) {
diff1 = (arr1[i] - arr2[i]);
if (diff1 == 0)
continue;
else {
flag = 1;
break;
}
}
}
if (flag == 0)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, a, b, k;
int dp[5001][5001] = {0};
int sum[5001][5001] = {0};
int solve1() {
for (int i = 0; i <= k; i++) {
for (int j = 1; j <= n; j++) {
if (!i) {
dp[i][j] = 1;
} else {
int diff = abs(j - b);
dp[i][j] = (dp[i][j] + (sum[i - 1][min(n, j + diff - 1)] -
sum[i - 1][j] + 1000000007) %
1000000007) %
1000000007;
dp[i][j] = (dp[i][j] + (sum[i - 1][j - 1] -
sum[i - 1][max(0, j - diff)] + 1000000007) %
1000000007) %
1000000007;
}
}
sum[i][0] = 0;
for (int j = 1; j <= n; j++) {
sum[i][j] = sum[i][j - 1] + dp[i][j];
sum[i][j] %= 1000000007;
}
}
return dp[k][a];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> a >> b >> k;
cout << solve1() << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
bool prime[1000001 + 3];
void SieveOfEratosthenes() {
memset(prime, true, sizeof(prime));
for (long long p = 2; p * p <= 1000001; p++) {
if (prime[p] == true) {
for (long long i = p * p; i <= 1000001; i += p) prime[i] = false;
}
}
}
long long gcd(long long a, long long b) {
if (b == 0) {
return a;
} else {
return gcd(b, a % b);
}
}
signed main() {
long long n;
cin >> n;
long long a[400001];
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
long long g = a[0];
for (long long i = 1; i < n; i++) {
g = gcd(g, a[i]);
}
long long M = sqrt(g);
long long ans = 0;
for (long long i = 1; i <= M; i++) {
if (g % i == 0) {
if (i * i == g) {
ans++;
} else {
ans += 2;
}
}
}
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int i = 0;
i = i + n / 5;
n = n % 5;
i = i + n / 4;
n = n % 4;
i = i + n / 3;
n = n % 3;
i = i + n / 2;
n = n % 2;
i = i + n / 1;
n = n % 1;
cout << i;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxd = 1000000007, N = 501000;
const double pi = acos(-1.0);
struct node {
int id, l, r;
} q[N];
int n, m, p[22], a[N], pos[22], ans[N];
int read() {
int x = 0, f = 1;
char ch = getchar();
while ((ch < '0') || (ch > '9')) {
if (ch == '-') f = -1;
ch = getchar();
}
while ((ch >= '0') && (ch <= '9')) {
x = x * 10 + (ch - '0');
ch = getchar();
}
return x * f;
}
bool cmp(node p, node q) { return p.r < q.r; }
void init() {
n = read();
int i;
for (i = 1; i <= n; i++) a[i] = read();
m = read();
for (i = 1; i <= m; i++) {
q[i].l = read();
q[i].r = read();
q[i].id = i;
}
sort(q + 1, q + 1 + m, cmp);
}
void add(int x, int id) {
int i;
for (i = 20; i >= 0; i--) {
if (!(x & (1 << i))) continue;
if (!p[i]) {
p[i] = x;
pos[i] = id;
return;
}
if (pos[i] < id) {
swap(pos[i], id);
swap(x, p[i]);
}
x ^= p[i];
}
}
int query(int l) {
int i, sum = 0;
for (i = 20; i >= 0; i--) {
if ((pos[i] >= l) && ((sum ^ p[i]) > sum)) sum ^= p[i];
}
return sum;
}
void work() {
int i, nowr = 0;
for (i = 1; i <= m; i++) {
while (nowr < q[i].r) {
nowr++;
add(a[nowr], nowr);
}
ans[q[i].id] = query(q[i].l);
}
for (i = 1; i <= m; i++) printf("%d\n", ans[i]);
}
int main() {
init();
work();
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int a, b, c, d;
cin >> a >> b >> c >> d;
if (a != c && b != d)
cout << 2 * (abs(a - c) + abs(b - d) + 2);
else
cout << 2 * (abs(a - c) + abs(b - d) + 3);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
cout << n - 1 << " " << 1 << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> vec;
const long long MOD = 1e9 + 7;
long long sel[1000003], cnt[1000003];
bool isprime[1000003];
void sieve() {
memset(isprime, 1, sizeof isprime);
isprime[1] = 0;
for (int i = 2; i <= 1000000; i++) {
if (isprime[i]) {
vec.push_back(i);
for (int j = 2; j * i <= 1000000; j++) isprime[j * i] = 0;
}
}
}
void make_sel() {
for (int i = 1; i <= 1000000; i++) sel[i] = i;
for (long long i = 0; i < vec.size(); i++) {
for (long long j = 2; j * vec[i] <= 1000000; j++) sel[j * vec[i]] -= vec[i];
}
for (long long i = 2; i <= 1000000; i++) {
if (!isprime[i]) {
for (long long j = 2; j * i <= 1000000; j++) sel[i * j] -= sel[i];
}
}
}
long long pw(long long a, long long b) {
long long res = 1;
while (b) {
long long x = a, y = 1;
while (y * 2 <= b) {
y += y;
x *= x;
x %= MOD;
}
b -= y;
res *= x;
res %= MOD;
}
return res;
}
int main() {
sieve();
make_sel();
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
for (int j = 1; j <= sqrt(x); j++) {
if (x % j == 0) {
cnt[j]++;
if (j * j != x) cnt[x / j]++;
}
}
}
long long res = 0;
for (long long i = 2; i <= 1000000; i++) {
if (cnt[i]) {
long long temp = cnt[i] * pw(2, cnt[i] - 1);
temp %= MOD;
res += temp * sel[i];
res %= MOD;
}
}
printf("%lld\n", res);
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
using pi = pair<int, int>;
using lint = long long;
const int mod = 1e9 + 7;
const int inv2 = (mod + 1) / 2;
const int MAXN = 100005;
char s[MAXN];
int main() {
scanf("%s", s);
int n = strlen(s);
lint r = 0, k = 0, p = 1;
for (int i = 1; i <= n; ++i) {
lint l = n - i;
r = (r + lint(s[n - i] - '0') *
(k + p * l % mod * (l + 1) % mod * inv2 % mod)) %
mod;
k = (k + p * i) % mod;
p = p * 10 % mod;
}
printf("%lld\n", r);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 100;
const int mod = 1e9 + 7;
mt19937 rng(chrono::high_resolution_clock::now().time_since_epoch().count());
int n, m, arr[maxn], nxt = 1;
vector<int> adj[maxn];
void no() {
cout << "NO\n";
exit(0);
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0);
cin >> n >> m;
if (n == 1) no();
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
for (int i = 1; i <= n; i++) arr[i] = i;
for (int it = 0; it < 600; it++) {
shuffle(arr + 1, arr + n + 1, rng);
for (int i = 1; i <= n; i++) {
int mx = 0;
int mn = n + 1;
for (int u : adj[i]) {
if (arr[u] < arr[i])
mx = max(mx, arr[u]);
else
mn = min(mn, arr[u]);
}
if (mx + 1 != mn - 1) {
cout << "YES\n";
for (int j = 1; j <= n; j++) cout << arr[j] << " ";
cout << "\n";
for (int j = mx + 1; j < mn; j++)
if (j != arr[i]) {
arr[i] = j;
break;
}
for (int j = 1; j <= n; j++) cout << arr[j] << " ";
cout << "\n";
return 0;
}
}
}
no();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200000 + 10;
int n;
long long area, cnt;
double fac[200], calc, ans;
struct Point {
long long x, y;
Point() {}
Point(long long x, long long y) : x(x), y(y) {}
Point operator-(const Point& tmp) const {
return Point(x - tmp.x, y - tmp.y);
}
} p[maxn];
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;
}
long long gcd(long long x, long long y) { return y == 0 ? x : gcd(y, x % y); }
long long cross(Point A, Point B) { return A.x * B.y - A.y * B.x; }
int main() {
if (fopen("D.in", "r") != NULL) {
freopen("D.in", "r", stdin);
freopen("D.out", "w", stdout);
}
n = read();
for (int i = 0; i < n; i++) p[i].x = read(), p[i].y = read();
fac[0] = 1;
for (int i = 1; i <= 100; i++) fac[i] = fac[i - 1] * 2;
if (n <= 100) calc = fac[n] - 1 - n - n * (n - 1) / 2;
for (int i = 0; i < n; i++)
cnt += gcd(abs(p[i].x - p[(i + 1) % n].x), abs(p[i].y - p[(i + 1) % n].y));
for (int i = 1; i < n - 1; i++) area += cross(p[i] - p[0], p[i + 1] - p[0]);
ans = (area - cnt) / 2 + 1;
for (int i = 0; i < n; i++) {
area = 0,
cnt =
gcd(abs(p[i].x - p[(i + 1) % n].x), abs(p[i].y - p[(i + 1) % n].y)) + 1;
for (int k = 2, j; k <= 62; k++) {
j = (i + k) % n;
if ((j + 1) % n == i) break;
cnt += gcd(abs(p[j].x - p[(j - 1 + n) % n].x),
abs(p[j].y - p[(j - 1 + n) % n].y));
area += cross(p[(j + n - 1) % n] - p[i], p[j] - p[i]);
long long tmp = gcd(abs(p[j].x - p[i].x), abs(p[j].y - p[i].y)) - 1;
long long s = (area - (cnt + tmp)) / 2 + 1;
if (n <= 100)
ans -= (double)(tmp + s) * (fac[n - k - 1] - 1) / calc;
else
ans -= (double)(tmp + s) * (1.0 / fac[k + 1]);
}
}
printf("%.12lf\n", ans);
return 0;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
int prime[1000005];
bool vis[1000005];
int n, tot;
void getprime() {
for (int i = 2; i <= n; i++) {
if (vis[i] == 0) prime[tot++] = i;
for (int j = 0; j < tot && i * prime[j] <= n; j++) {
vis[i * prime[j]] = 1;
if (i % prime[j] == 0) break;
}
}
}
int main() {
scanf("%d", &n);
getprime();
printf("%d", n);
for (int i = 0; i < tot && prime[i] <= n; i++) {
while (n % prime[i] == 0) {
n /= prime[i];
printf(" %d", n);
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int T;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
string s1, s2, s3;
getline(cin, s1);
getline(cin, s2);
getline(cin, s3);
unsigned long long n1, n2, n3;
n1 = ((int)(s1.size()));
n2 = ((int)(s2.size()));
n3 = ((int)(s3.size()));
string ans = "YES";
int n = 0;
for (int i = 0; i < n1; i++) {
if ((s1[i] == 'a') || (s1[i] == 'e') || (s1[i] == 'i') || (s1[i] == 'o') ||
(s1[i] == 'u')) {
n += 1;
}
}
if (n != 5) {
ans = "NO";
n = 0;
} else {
n = 0;
}
for (int i = 0; i < n2; i++) {
if ((s2[i] == 'a') || (s2[i] == 'e') || (s2[i] == 'i') || (s2[i] == 'o') ||
(s2[i] == 'u')) {
n += 1;
}
}
if (n != 7) {
ans = "NO";
n = 0;
} else {
n = 0;
}
for (int i = 0; i < n3; i++) {
if ((s3[i] == 'a') || (s3[i] == 'e') || (s3[i] == 'i') || (s3[i] == 'o') ||
(s3[i] == 'u')) {
n += 1;
}
}
if (n != 5) {
ans = "NO";
n = 0;
} else {
n = 0;
}
cout << ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int nax = 3e5 + 69;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t, n, a[nax];
cin >> t;
while (t--) {
cin >> n;
map<int, vector<int> > m;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
if (!m[a[i]].size()) m[a[i]].push_back(0);
m[a[i]].push_back(i);
}
vector<int> ans(n + 1, nax);
for (auto i : m) {
i.second.push_back(n + 1);
int currval = 0;
for (int j = 1; j < i.second.size(); ++j) {
currval = max(currval, i.second[j] - i.second[j - 1]);
}
ans[currval] = min(ans[currval], i.first);
}
for (int i = 1; i < n + 1; ++i) {
if (i > 1) ans[i] = min(ans[i], ans[i - 1]);
cout << (ans[i] == nax ? -1 : ans[i]) << ' ';
}
cout << '\n';
}
return 0;
}
| 7 |
#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);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int T;
cin >> T;
while (T--) {
long long a, m;
cin >> a >> m;
long long g = gcd(a, m);
long long temp_m = m / g;
vector<long long> primes;
for (long long i = 2; i * i <= temp_m; i++) {
if (temp_m % i == 0) {
primes.push_back(i);
}
while (temp_m % i == 0) {
temp_m /= i;
}
}
if (temp_m > 1) {
primes.push_back(temp_m);
}
int n = primes.size();
long long start = a / g;
long long end = a / g + m / g - 1;
long long solution = end - start + 1;
for (int i = 1; i < (1 << n); i++) {
bitset<10> bit_set(i);
long long num = 1;
int parity = 0;
for (int j = 0; j < n; j++) {
if (bit_set[j] == 1) {
num *= primes[j];
parity++;
}
}
long long ans = end / num - start / num;
if (parity % 2 == 0) {
solution += ans;
} else {
solution -= ans;
}
}
cout << solution << "\n";
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const long long inf = 1e18 * 4;
const long double pai = acos(-1);
int n, m;
vector<pair<char, pair<int, int> > > v;
string s[509];
int done[509][509];
int X[] = {-1, 0, 1, 0};
int Y[] = {0, 1, 0, -1};
void dfs(int x, int y, int last) {
done[x][y] = 1;
v.push_back({'B', {x, y}});
for (int i = 0; i < 4; i++) {
int nx = x + X[i];
int ny = y + Y[i];
if (nx < n && nx >= 0 && ny < m && ny >= 0) {
if (!done[nx][ny] && s[nx][ny] != '#') {
dfs(nx, ny, 1);
}
}
}
if (last) {
v.push_back({'D', {x, y}});
v.push_back({'R', {x, y}});
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> s[i];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (s[i][j] == '#' || done[i][j] == 1) continue;
dfs(i, j, 0);
}
}
cout << v.size() << endl;
for (auto u : v) {
printf("%c ", u.first);
printf("%d ", u.second.first + 1);
printf("%d\n", u.second.second + 1);
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int dp[2000 + 1];
int v[2000 + 1];
int gcd(int a, int b) { return (b == 0 ? a : gcd(b, a % b)); }
int main() {
int i, j, N, t = -1, res = 0;
scanf("%d", &N);
for (i = 1; i <= N; ++i) scanf("%d", &v[i]);
for (i = 1; i <= N; ++i)
if (v[i] != 1) ++res;
for (i = 1; i <= N; ++i) dp[i] = v[i];
if (res != N) {
printf("%d\n", res);
return 0;
}
for (i = 2; i <= N; ++i) {
for (j = 1; j <= N - i + 1; ++j) {
dp[j] = gcd(dp[j], v[j + i - 1]);
if (dp[j] == 1) {
t = i;
i = j = N + 1;
}
}
}
if (t < 0)
printf("-1\n");
else
printf("%d\n", res + t - 2);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int fx[] = {-1, 1, 0, 0}, fy[] = {0, 0, -1, 1};
int main() {
int a, b, c, d, e, f, g;
char p[100][100];
cin >> a;
for (int i = 0; i < a; i++) {
cin >> p[i];
}
for (int i = 0; i < a; i++) {
for (int j = 0; j < a; j++) {
b = 0;
for (int k = 0; k < 4; k++) {
int tx = i + fx[k], ty = j + fy[k];
if (tx >= 0 && tx < a && ty >= 0 && ty < a) {
if (p[tx][ty] == 'o') {
b++;
}
}
}
if (b % 2) {
cout << "NO";
return 0;
}
}
}
cout << "YES";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
int n, k;
long long ips[maxn];
long long fmt(int a[4]) {
return ((a[0] << 24) | (a[1] << 16) | (a[2] << 8) | a[3]);
}
string outfmt(long long a) {
string res = "";
for (int i = 3; i >= 0; i--) {
int r = 0;
for (int j = 0; j < 8; j++) {
int b = ((a >> (i * 8 + j)) & 1) << j;
r |= b;
}
res += to_string(r);
if (i != 0) res += '.';
}
return res;
}
int main() {
scanf("%d %d\n", &n, &k);
for (int i = 0; i < n; i++) {
int a[4];
scanf("%d.%d.%d.%d\n", a, a + 1, a + 2, a + 3);
long long f = fmt(a);
ips[i] = f;
}
long long subnetMask = 0LL;
for (int i = 31; i > 0; i--) {
subnetMask |= (1 << i);
unordered_set<long long> addresses;
for (int j = 0; j < n; j++) {
addresses.insert(subnetMask & ips[j]);
}
if (addresses.size() == k) {
cout << outfmt(subnetMask) << '\n';
return 0;
}
}
cout << -1 << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int inf = 1000000001;
long long int llinf = 1000000000000000001LL;
long long int mod = 1000000007;
double eps = 1e-15;
int dx[] = {1, 1, -1, -1};
int dy[] = {1, -1, 1, -1};
vector<bool> isprime;
vector<int> primes;
void seive(int n, bool wantlist = true) {
isprime.resize(n + 1, true);
isprime[0] = isprime[1] = false;
int sq = sqrt(n + 1);
for (int i = 2; i < sq + 1; i++) {
if (isprime[i]) {
for (int j = i * i; j <= n; j += i) isprime[j] = false;
}
}
for (int i = 2; wantlist && i <= n; i++) {
if (isprime[i]) primes.push_back(i);
}
}
template <class T>
inline T gcd(T a, T b) {
while (b > 0) {
a %= b;
swap(a, b);
}
return a;
}
template <class T>
inline T lcm(T a, T b) {
return a * b / gcd(a, b);
}
inline long long int bexp(long long int x, long long int n) {
long long int res = 1;
x %= mod;
while (n) {
if (n & 1) res = res * x % mod;
x = x * x % mod;
n >>= 1;
}
return res;
}
int main() {
int a, b;
cin >> a >> b;
int n;
scanf("%d", &n);
;
double t = inf;
for (int i = 0; i < n; i++) {
int x, y, v;
scanf("%d", &x);
;
scanf("%d", &y);
;
scanf("%d", &v);
;
double dist = sqrt((x - a) * (x - a) + (y - b) * (y - b));
t = min(t, dist / v);
}
cout << fixed << setprecision(15) << t << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int64_t> w(n), m(n);
vector<vector<pair<int, int64_t>>> e(n);
vector<int64_t> p(n), r(n);
for (int i = 0; i < n; ++i) {
cin >> w[i];
}
for (int i = 1; i < n; ++i) {
int u, v;
int64_t c;
cin >> u >> v >> c;
u--;
v--;
e[u].push_back(pair<int, int64_t>(v, c));
e[v].push_back(pair<int, int64_t>(u, c));
}
int d = 0;
int64_t max = 0;
while (d >= 0) {
int v = p[d];
int vp = d > 0 ? p[d - 1] : -1;
int i = r[d];
if (i < e[v].size()) {
r[d]++;
if (e[v][i].first != vp) {
d++;
p[d] = e[v][i].first;
r[d] = 0;
}
} else {
int64_t m1 = 0, m2 = 0;
for (auto &i : e[v]) {
int vi = i.first;
int64_t ci = i.second;
int64_t c = m[vi] - ci;
if (c > m1) {
m2 = m1;
m1 = c;
} else if (c > m2) {
m2 = c;
}
}
m[v] = w[v] + m1;
if (m[v] + m2 > max) max = m[v] + m2;
d--;
}
}
cout << max << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int f[4], n, m, ans, xs, ys;
char c[100][100];
string s;
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
int go(int x, int y, int ind) {
if (x < 0 || x >= n || y < 0 || y >= m || c[x][y] == '#') return 0;
if (c[x][y] == 'E') return 1;
if (ind >= s.size()) return 0;
x += dx[f[int(s[ind] - '0')]];
y += dy[f[int(s[ind] - '0')]];
return go(x, y, ind + 1);
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
cin >> c[i][j];
if (c[i][j] == 'S') xs = i, ys = j;
}
cin >> s;
for (int i = 0; i < 4; i++) f[i] = i;
do {
ans += go(xs, ys, 0);
} while (next_permutation(f, f + 4));
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long x, long long y, long long md) {
long long res = 1;
x %= md;
while (y > 0) {
if (y & 1) res = (res * x) % md;
x = (x * x) % md;
y = y >> 1;
}
return res % md;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n;
cin >> n;
long long mna, mnb, mnc, mnab, mnbc, mnca, mnabc;
mna = mnb = mnc = mnab = mnbc = mnca = mnabc = 1e9;
bool visit[3] = {false};
long long x;
string second;
for (long long i = 0; i < n; ++i) {
cin >> x >> second;
if (second.length() == 1) {
sort(second.begin(), second.end());
if (second == "A") {
mna = min(mna, x);
visit[0] = true;
} else if (second == "B") {
visit[1] = true;
mnb = min(mnb, x);
} else {
visit[2] = true;
mnc = min(mnc, x);
}
} else if (second.length() == 2) {
sort(second.begin(), second.end());
if (second == "AB") {
visit[1] = visit[0] = true;
mnab = min(mnab, x);
} else if (second == "BC") {
visit[1] = visit[2] = true;
mnbc = min(mnbc, x);
} else {
visit[2] = visit[0] = true;
mnca = min(mnca, x);
}
} else {
visit[0] = visit[1] = visit[2] = true;
mnabc = min(mnabc, x);
}
}
for (long long i = 0; i < 3; ++i) {
if (!visit[i]) {
cout << -1;
return 0;
}
}
long long ans = mna + mnb + mnc;
ans = min(ans, mnabc);
ans = min(ans, mnab + mnc);
ans = min(ans, mnbc + mna);
ans = min(ans, mnca + mnb);
ans = min(ans, mnab + mnbc);
ans = min(ans, mnbc + mnca);
ans = min(ans, mnca + mnab);
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int main() {
cin >> n >> m;
for (int i = 0; i < 1000; i++) cout << "5";
cout << endl;
for (int i = 0; i < 999; i++) cout << "4";
cout << "5";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, ans;
pair<int, int> coord[200025];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i) cin >> coord[i].first >> coord[i].second;
for (int i = 1; i <= n; ++i) {
int vecst = 0, vecs = 0, vecj = 0, vecd = 0;
for (int j = 1; j <= n; ++j)
if (i != j) {
if (coord[j].first > coord[i].first &&
coord[i].second == coord[j].second)
++vecd;
if (coord[j].first < coord[i].first &&
coord[i].second == coord[j].second)
++vecst;
if (coord[j].first == coord[i].first &&
coord[i].second > coord[j].second)
++vecj;
if (coord[j].first == coord[i].first &&
coord[i].second < coord[j].second)
++vecs;
}
if (vecd > 0 && vecst > 0 && vecj > 0 && vecs > 0) ++ans;
}
cout << ans << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int x[200005], n, c, j;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x[i];
}
sort(x, x + n);
for (int i = 0; i < n; i++) {
while (j < n && x[j] - x[i] <= 5) {
j++;
c = max(c, j - i);
}
}
cout << c << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
register int x = 0, f = 1;
register char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = 0;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + (ch ^ '0');
ch = getchar();
}
return f ? x : -x;
}
const int N = 1e2 + 10, mod = 1e9 + 7;
int n, E[N][N], K[N][N], y[N], f[N], g[N], ifc[N];
inline int Det(int a[][N], int n) {
int ans = 1;
for (int i = (1), ed = (n); i <= ed; ++i) {
for (int j = (i + 1), ed = (n); j <= ed; ++j)
while (a[j][i]) {
int t = a[i][i] / a[j][i];
for (int k = (i), ed = (n); k <= ed; ++k)
a[i][k] = (a[i][k] - 1ll * a[j][k] * t % mod + mod) % mod;
swap(a[i], a[j]);
ans = mod - ans;
}
ans = 1ll * ans * a[i][i] % mod;
if (!a[i][i]) continue;
}
return (ans + mod) % mod;
}
inline void Lagrange() {
g[0] = 1;
for (int i = (1), ed = (n); i <= ed; ++i) {
for (int j = (n), ed = (1); j >= ed; --j)
g[j] = (g[j - 1] - 1ll * g[j] * i % mod + mod) % mod;
g[0] = (mod - 1ll * g[0] * i % mod) % mod;
}
ifc[0] = ifc[1] = 1;
for (int i = (2), ed = (n); i <= ed; ++i)
ifc[i] = 1ll * (mod - mod / i) * ifc[mod % i] % mod;
for (int i = (2), ed = (n); i <= ed; ++i)
ifc[i] = 1ll * ifc[i - 1] * ifc[i] % mod;
for (int i = (1), ed = (n); i <= ed; ++i) {
int las = 0, t = 1ll * y[i] * ifc[i - 1] % mod * ifc[n - i] % mod;
if ((n - i) & 1) t = (mod - t) % mod;
for (int j = (n), ed = (1); j >= ed; --j) {
las = (g[j] + 1ll * i * las % mod) % mod;
f[j - 1] = (f[j - 1] + 1ll * las * t % mod) % mod;
}
}
}
int main() {
n = read();
for (int i = (1), ed = (n - 1); i <= ed; ++i) {
int u = read(), v = read();
E[u][v] = E[v][u] = 1;
}
for (int x = (1), ed = (n); x <= ed; ++x) {
memset(K, 0, sizeof(K));
for (int i = (1), ed = (n); i <= ed; ++i)
for (int j = (1), ed = (n); j <= ed; ++j) {
if (i == j) continue;
if (E[i][j])
K[i][j] += mod - x, K[i][i] += x;
else
K[i][j] += mod - 1, K[i][i] += 1;
}
y[x] = Det(K, n - 1);
}
Lagrange();
for (int i = (0), ed = (n - 1); i <= ed; ++i) printf("%d ", f[i]);
puts("");
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
long long t;
long long n, m, k;
long long x, y, a, b;
long long sad, sol;
long long maxx, minn;
vector<long long> v;
int main() {
cin >> t;
while (t--) {
cin >> n >> a >> b;
for (int i = 0; i < n; i++) {
cout << char('a' + (i % b));
}
cout << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int dx4[] = {-1, 0, 1, 0};
int dy4[] = {0, 1, 0, -1};
int dx8[] = {-1, -1, 0, 1, 1, 1, 0, -1};
int dy8[] = {0, 1, 1, 1, 0, -1, -1, -1};
void Duxar(int _this_line) {}
bool AreEqual(double a, double b) { return (fabs(a - b) < 1e-10); }
template <class T>
bool GetNr(T &_value) {
T _sign = 1;
char ch;
_value = 0;
while (!isdigit(ch = getchar())) {
if (ch == -1) {
return false;
}
ch == '-' ? _sign = -1 : _sign = 1;
}
do {
_value = _value * 10 + (ch - '0');
} while (isdigit(ch = getchar()));
_value *= _sign;
return true;
}
long long X, Y;
vector<pair<long long, char> > ans;
long long GetGcd(long long x, long long y) { return y ? GetGcd(y, x % y) : x; }
int main() {
string fileInput = "sum";
int i;
GetNr(X);
GetNr(Y);
if (GetGcd(X, Y) != 1) {
cout << "Impossible\n" << '\n';
return 0;
}
while (X > 1 || Y > 1) {
if (X == 1) {
ans.push_back(make_pair(Y - 1, 'B'));
break;
} else if (Y == 1) {
ans.push_back(make_pair(X - 1, 'A'));
break;
} else if (X > Y) {
ans.push_back(make_pair(X / Y, 'A'));
X %= Y;
} else {
ans.push_back(make_pair(Y / X, 'B'));
Y %= X;
}
}
for (auto p : ans) {
cout << p.first << p.second;
}
putchar('\n');
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2000000000;
const double PI = acos(-1.0);
const int MAXN = 100000 + 7;
int a[MAXN];
int n;
long long solve(int l, int r) {
vector<int> v(r - l);
for (int i = l + 1; i <= r; i++) {
v[i - l - 1] = abs(a[i] - a[i - 1]);
}
int n = v.size();
vector<long long> val(n), occ(n), tot(n);
int it = 1;
val[0] = v[0];
occ[0] = 1;
tot[0] = v[0];
long long ans = 0;
ans += tot[0];
for (int i = 1; i < v.size(); i++) {
long long new_occ = 1;
while (it && val[it - 1] < v[i]) {
it--;
new_occ += occ[it];
}
val[it] = v[i];
occ[it] = new_occ;
tot[it] = (it ? tot[it - 1] : 0) + v[i] * new_occ;
ans += tot[it];
it++;
}
return ans;
}
int main() {
int q;
scanf("%d%d", &n, &q);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
while (q--) {
int l, r;
scanf("%d%d", &l, &r);
l--;
r--;
cout << solve(l, r) << endl;
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long u, v;
cin >> u >> v;
if (u % 2 != v % 2 || u > v) {
cout << -1;
return 0;
}
if (u == v) {
if (u == 0)
cout << 0;
else
cout << 1 << endl << u;
return 0;
}
long long ans = (v - u) / 2;
if (u & ans)
cout << 3 << endl << u << " " << ans << " " << ans << " ";
else
cout << 2 << endl << ans << " " << (u ^ ans);
}
| 9 |
#include <bits/stdc++.h>
int main() {
char A[101], B[101];
int t;
scanf("%d", &t);
while (t--) {
scanf("%s%s", A, B);
int a[26] = {0}, b[26] = {0};
for (int i = 0; A[i] != '\0'; i++) {
a[A[i] - 'a']++;
b[B[i] - 'a']++;
}
for (int i = 0; i < 26; i++) {
if (a[i] > 0 && b[i] > 0) {
printf("YES\n");
goto alpha;
}
}
printf("NO\n");
alpha:
printf("");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
string pat = "aeiouy";
int n;
cin >> n;
char p, c;
cin >> p;
cout << p;
while (cin >> c) {
if (pat.find(c) != string::npos && pat.find(p) != string::npos) continue;
p = c;
cout << p;
}
cout << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, q, x, y;
pair<int, int> a[30005], b[30005];
int posa[30005], posb[30005], match[30005];
long long dp[30005];
void updp(int bas) {
for (int i = bas; i <= n; i++) {
dp[i] = -200000000000000000;
if (match[i] != i)
dp[i] = max(dp[i], dp[i - 1] + 1ll * a[i].first * b[i].first);
if (i >= 2 && match[i] != i - 1 && match[i - 1] != i)
dp[i] = max(dp[i], dp[i - 2] + 1ll * a[i - 1].first * b[i].first +
1ll * a[i].first * b[i - 1].first);
if (i >= 3 && match[i] != i - 1 && match[i - 1] != i - 2 &&
match[i - 2] != i)
dp[i] = max(dp[i], dp[i - 3] + 1ll * a[i].first * b[i - 1].first +
1ll * a[i - 1].first * b[i - 2].first +
1ll * a[i - 2].first * b[i].first);
if (i >= 3 && match[i] != i - 2 && match[i - 1] != i &&
match[i - 2] != i - 1)
dp[i] = max(dp[i], dp[i - 3] + 1ll * a[i].first * b[i - 2].first +
1ll * a[i - 1].first * b[i].first +
1ll * a[i - 2].first * b[i - 1].first);
}
}
int main() {
scanf("%d %d", &n, &q);
for (int i = 1; i <= n; i++) scanf("%d", &a[i].first);
for (int i = 1; i <= n; i++) scanf("%d", &b[i].first);
for (int i = 1; i <= n; i++) a[i].second = b[i].second = i;
sort(a + 1, a + 1 + n);
sort(b + 1, b + 1 + n);
for (int i = 1; i <= n; i++) {
posb[b[i].second] = i;
posa[a[i].second] = i;
}
for (int i = 1; i <= n; i++) {
match[i] = posb[a[i].second];
}
updp(1);
while (q--) {
scanf("%d %d", &x, &y);
swap(match[posa[x]], match[posa[y]]);
updp(min(posa[x], posa[y]));
printf("%lld\n", dp[n]);
}
}
| 22 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, v;
cin >> n >> m >> v;
--v;
long long sum = ((n - 1) * (n - 2)) / 2;
if (m < n - 1 || m > sum + 1) {
cout << -1;
return 0;
}
vector<pair<int, int>> vec;
vec.push_back({0, 1});
m--;
for (int i = 1; m && i < n; i++) {
for (int j = i + 1; m && j < n; j++) {
--m;
vec.push_back({i, j});
}
}
for (pair<int, int> x : vec) {
int a = x.first;
if (a == v)
a = 1;
else if (a == 1)
a = v;
int b = x.second;
if (b == v)
b = 1;
else if (b == 1)
b = v;
cout << a + 1 << " " << b + 1 << "\n";
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
mt19937_64 rnd(503984);
unordered_map<unsigned long long, int> mp;
int n, cnt = 0;
vector<int> v[100010];
unsigned long long val[300010], S[300010];
int a[100010], b[100010];
bool vis[300010];
void dfs1(int np, int fath) {
unsigned long long sum = 0;
for (int &x : v[np]) {
if (x == fath) continue;
dfs1(x, np);
sum += val[a[x]];
}
if (mp.find(sum) == mp.end()) mp[sum] = ++cnt, S[cnt] = sum, val[cnt] = rnd();
a[np] = mp[sum];
}
void dfs2(int np, int fath) {
for (int &x : v[np]) {
if (x == fath) continue;
unsigned long long tv = S[b[np]] - val[a[x]];
if (mp.find(tv) == mp.end()) mp[tv] = ++cnt, S[cnt] = tv, val[cnt] = rnd();
unsigned long long sx = val[mp[tv]] + S[a[x]];
if (mp.find(sx) == mp.end()) mp[sx] = ++cnt, S[cnt] = sx, val[cnt] = rnd();
b[x] = mp[sx];
dfs2(x, np);
}
}
int main() {
scanf("%d", &n);
for (int i = 1, ti, tj; i < n; i++) {
scanf("%d%d", &ti, &tj);
v[ti].push_back(tj);
v[tj].push_back(ti);
}
dfs1(1, 0);
b[1] = a[1];
dfs2(1, 0);
int ans = 0;
for (int i = 1; i <= n; i++)
if (!vis[b[i]] && v[i].size() < 4) vis[b[i]] = 1, ans++;
printf("%d\n", ans);
return 0;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 5e-5;
map<string, int> M;
int main() {
int n, m;
double k;
cin >> n >> m >> k;
string s;
int v;
for (int i = 0; i < n; i++) {
cin >> s >> v;
double b = v * k;
if (b + EPS < 100) {
b = 0;
continue;
}
M[s] = (int)(b + EPS);
}
for (int i = 0; i < m; i++) {
cin >> s;
if (M.find(s) == M.end()) M[s] = 0;
}
cout << M.size() << endl;
for (map<string, int>::iterator it = M.begin(); it != M.end(); it++)
cout << it->first << ' ' << it->second << endl;
}
| 9 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
mt19937 rng(time(NULL));
using ll = long long;
using vi = vector<int>;
using vl = vector<ll>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using ld = long double;
using vb = vector<bool>;
const ll MOD = 1000000007;
ll sqr(ll a) { return a * a; }
ll powmod(ll a, ll x, ll p = MOD) {
if (x <= 0) return 1;
if (x % 2 == 0)
return sqr(powmod(a, x >> 1, p)) % p;
else
return (a * powmod(a, x - 1, p)) % p;
}
ll gcd(ll a, ll b) {
if (a < b) return gcd(b, a);
if (b == 0) return a;
return gcd(b, a % b);
}
int32_t main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n;
cin >> n;
time_t start = clock();
vl a(n);
vi b(n);
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> b[i];
ll ans = 0;
bool changed = true;
vb taken(n, true);
while (changed) {
ll mask = 0;
changed = false;
for (int i = 0; i < n; i++) {
if (!taken[i]) continue;
bool bad = true;
for (int j = 0; j < n && bad; j++) {
if (i != j && taken[j] && (a[i] & a[j]) == a[i]) bad = false;
}
if (bad) {
taken[i] = false;
changed = true;
}
}
}
for (int i = 0; i < n; i++)
if (taken[i]) ans += b[i];
cout << ans << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
int n;
double x[100000];
double y[100005];
double dist(double x1, double y1, double x2, double y2) {
double d1 = (x1 - x2) * (x1 - x2);
double d2 = (y1 - y2) * (y1 - y2);
return sqrt(d1 + d2);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%lf %lf", &x[i], &y[i]);
}
x[0] = x[n];
y[0] = y[n];
x[n + 1] = x[1];
y[n + 1] = y[1];
double minc = 100000LL * 10000LL * 10000LL;
for (int i = 1; i <= n; i++) {
double c = (x[i - 1] * y[i] + x[i] * y[i + 1] + x[i + 1] * y[i - 1]) -
(x[i - 1] * y[i + 1] + x[i + 1] * y[i] + x[i] * y[i - 1]);
if (c < 0) c *= -1;
c /= 2;
c /= dist(x[i - 1], y[i - 1], x[i + 1], y[i + 1]);
if (minc > c) minc = c;
}
printf("%lf", minc);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
map<int, int> mp;
for (int i = 0; i < n; i++) {
int a;
scanf("%d", &a);
mp[a] = 1;
}
int ans = 0;
if (mp.find(m) != mp.end()) ans++;
for (int i = 0; i < m; i++) {
if (mp.find(i) == mp.end()) {
ans++;
}
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 10, MOD = 1e9 + 7;
int n;
void solve(int i, int j, int k, int l, int m) {
printf("%d %d\n", i, j);
printf("%d %d\n", i, k);
printf("%d %d\n", l, m);
printf("%d %d\n", k, m);
printf("%d %d\n", i, l);
printf("%d %d\n", j, m);
printf("%d %d\n", i, m);
printf("%d %d\n", j, l);
printf("%d %d\n", k, l);
printf("%d %d\n", j, k);
}
int main() {
scanf("%d", &n);
if (n % 4 > 1) return !printf("NO\n");
printf("YES\n");
if (n < 2) return 0;
if (n % 4 < 1) {
for (int i = 0; i < n; i += 4) {
printf("%d %d\n%d %d\n%d %d\n%d %d\n%d %d\n%d %d\n", i + 1, i + 2, i + 3,
i + 4, i + 2, i + 3, i + 1, i + 4, i + 1, i + 3, i + 2, i + 4);
}
for (int i = 0; i < n; i += 4) {
for (int j = i + 4; j < n; j += 4) {
printf("%d %d\n%d %d\n%d %d\n%d %d\n", i + 1, j + 1, i + 2, j + 2,
i + 3, j + 3, i + 4, j + 4);
printf("%d %d\n%d %d\n%d %d\n%d %d\n", i + 1, j + 2, i + 2, j + 1,
i + 3, j + 4, i + 4, j + 3);
printf("%d %d\n%d %d\n%d %d\n%d %d\n", i + 1, j + 3, i + 2, j + 4,
i + 3, j + 1, i + 4, j + 2);
printf("%d %d\n%d %d\n%d %d\n%d %d\n", i + 1, j + 4, i + 2, j + 3,
i + 3, j + 2, i + 4, j + 1);
}
}
} else {
for (int i = 1; i <= n - 1; i += 4) solve(i, i + 1, i + 2, i + 3, n);
for (int i = 0; i < n - 1; i += 4) {
for (int j = i + 4; j < n - 1; j += 4) {
printf("%d %d\n%d %d\n%d %d\n%d %d\n", i + 1, j + 1, i + 2, j + 2,
i + 3, j + 3, i + 4, j + 4);
printf("%d %d\n%d %d\n%d %d\n%d %d\n", i + 1, j + 2, i + 2, j + 1,
i + 3, j + 4, i + 4, j + 3);
printf("%d %d\n%d %d\n%d %d\n%d %d\n", i + 1, j + 3, i + 2, j + 4,
i + 3, j + 1, i + 4, j + 2);
printf("%d %d\n%d %d\n%d %d\n%d %d\n", i + 1, j + 4, i + 2, j + 3,
i + 3, j + 2, i + 4, j + 1);
}
}
}
return 0;
}
| 23 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void print_vector(vector<T> path) {
copy(path.begin(), path.end(), ostream_iterator<T>(cout, " "));
cout << endl;
}
template <typename T>
void print_array(T a, long long n) {
for (long long i = 0; i < n; i++) cout << a[i] << " ";
cout << endl;
}
vector<long long> take_input(long long n) {
vector<long long> v(n);
for (long long i = 0; i < n; i++) cin >> v[i];
return v;
}
struct hash_pair {
template <class T1, class T2>
size_t operator()(const pair<T1, T2>& p) const {
auto hash1 = hash<T1>{}(p.first);
auto hash2 = hash<T2>{}(p.second);
return hash1 ^ hash2;
}
};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
long long test;
cin >> test;
while (test--) {
long long n;
cin >> n;
vector<long long> a = take_input(n);
long long ans = 0, k1 = 0, k2 = 0;
for (auto x : a) {
if (x % 3 == 0)
ans++;
else if (x % 3 == 1) {
k1++;
} else {
k2++;
}
}
long long tmp = min(k1, k2);
k1 -= tmp;
k2 -= tmp;
ans += tmp;
ans += k1 / 3;
ans += k2 / 3;
cout << ans << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 1000005;
int b[maxn];
vector<pair<int, int>> h[maxn], v[maxn];
int query(int x) {
int ret = 0;
while (x) {
ret += b[x];
x -= x & (-x);
}
return ret;
}
void update(int x, int d) {
while (x < maxn) {
b[x] += d;
x += x & (-x);
}
}
void go() {
int n, m;
cin >> n >> m;
unsigned long long ans = 1;
for (int i = 0; i < n; i++) {
int y, l, r;
cin >> y >> l >> r;
y++, l++, r++;
h[y].push_back({l, r});
if (r - l == 1000000) {
ans++;
}
}
for (int i = 0; i < m; i++) {
int x, u, d;
cin >> x >> d >> u;
x++, u++, d++;
if (u - d == 1000000) {
ans++;
}
v[d].push_back({x, 1});
v[u + 1].push_back({x, -1});
}
for (int i = 1; i < 1000001 + 1; i++) {
for (auto &j : v[i]) {
update(j.first, j.second);
}
for (auto &j : h[i]) {
ans += query(j.second) - query(j.first - 1);
}
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int c = 0;
int t;
if (!c) {
t = 1;
} else {
cin >> t;
}
while (t--) {
go();
}
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const int mo = 1000000007 * 2;
int a[17][17], ans[17][17], b[17][17], l, r;
int P(int x, int y) { return y + x * 4; }
void pret() {
int j, k, l;
for (j = 0; j < 4; ++j)
for (k = 0; k < 4; ++k) {
for (l = 0; l < 4; ++l) {
if (k == l) continue;
if (k == 0 && l == 3) continue;
if (k == 3 && l == 0) continue;
if (k == 2 && l == 1) continue;
if (k == 1 && l == 2) continue;
if (j == 1 && k == 0 && l == 2) continue;
if (j == 2 && k == 0 && l == 1) continue;
a[P(j, k)][P(k, l)]++;
}
a[P(j, k)][16] = 1;
}
a[16][16] = 1;
}
void cheng(int a[17][17], int b[17][17]) {
int c[17][17] = {0}, i, j, k;
for (i = 0; i <= 16; ++i)
for (j = 0; j <= 16; ++j)
for (k = 0; k <= 16; ++k)
c[i][k] = ((long long)a[i][j] * b[j][k] + c[i][k]) % mo;
for (i = 0; i <= 16; ++i)
for (j = 0; j <= 16; ++j) a[i][j] = c[i][j];
}
long long calc(int x) {
memset(ans, 0, sizeof(ans));
ans[0][P(0, 0)] = ans[0][P(1, 1)] = ans[0][P(2, 2)] = ans[0][P(3, 3)] = 1;
memcpy(b, a, sizeof(b));
while (x) {
if (x & 1) cheng(ans, b);
cheng(b, b);
x /= 2;
}
return ans[0][16];
}
long long work(int x) {
if (!x) return 0;
return (calc(x) + calc((x + 1) / 2)) / 2;
}
int main() {
pret();
scanf("%d%d", &l, &r);
printf("%d\n", (work(r) - work(l - 1) + 1000000007ll * 4) % 1000000007);
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
const int N = ((1 << 18) + 100);
const int M = N << 2;
long long sum[M], L[M], R[M];
int n, q, Rev[30], Swap[30];
inline void up(int x) {
sum[x] = sum[(x << 1)] + sum[(x << 1 | 1)];
return;
}
inline void build(int x, int l, int r) {
L[x] = l;
R[x] = r;
if (l == r) {
scanf("%lld", &sum[x]);
return;
}
int mid = (l + r) >> 1;
build((x << 1), l, mid);
build((x << 1 | 1), mid + 1, r);
up(x);
}
inline void update(int x, int id, int val, int dep = n) {
if (L[x] == R[x] && L[x] == id) {
sum[x] = val;
return;
}
int mid = (L[x] + R[x]) >> 1;
if (Swap[dep]) {
if (id <= mid)
id = id + (1 << (dep - 1));
else
id = id - (1 << (dep - 1));
}
if (Rev[dep]) id = L[x] + R[x] - id;
if (id <= mid)
update((x << 1), id, val, dep - 1);
else
update((x << 1 | 1), id, val, dep - 1);
up(x);
}
long long Query(int x, int l, int r, int dep = n) {
if (L[x] == l && R[x] == r) return sum[x];
int mid = (L[x] + R[x]) >> 1, F = 0;
if (Rev[dep]) {
l = L[x] + R[x] - l;
r = L[x] + R[x] - r;
swap(l, r);
}
if (Swap[dep]) {
if (l <= mid)
l = l + (1 << (dep - 1));
else
l = l - (1 << (dep - 1));
if (r <= mid)
r = r + (1 << (dep - 1));
else
r = r - (1 << (dep - 1));
if (l > r) F = 1;
}
if (!F) {
if (r <= mid)
return Query((x << 1), l, r, dep - 1);
else if (l >= mid + 1)
return Query((x << 1 | 1), l, r, dep - 1);
else
return Query((x << 1), l, mid, dep - 1) +
Query((x << 1 | 1), mid + 1, r, dep - 1);
} else
return Query((x << 1), L[x], r, dep - 1) +
Query((x << 1 | 1), l, R[x], dep - 1);
}
int main() {
scanf("%d%d", &n, &q);
build(1, 1, (1 << n));
while (q--) {
int op, x, k, l, r;
scanf("%d", &op);
if (op == 1) {
scanf("%d%d", &x, &k);
update(1, x, k);
}
if (op == 2) {
scanf("%d", &k);
Rev[k] ^= 1;
}
if (op == 3) {
scanf("%d", &k);
Swap[k + 1] ^= 1;
}
if (op == 4) {
scanf("%d%d", &l, &r);
printf("%lld\n", Query(1, l, r));
}
}
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int A[1000005];
int B[1000005];
int LD[2000005];
int LI[2000005];
int main() {
int n, l, t;
cin >> n >> l >> t;
for (int i = (0); i < (n); i++) scanf("%d", &A[i]);
for (int i = (0); i < (n); i++) B[i] = l - A[i];
for (int i = (0); i < (n); i++) LD[i] = A[i];
for (int i = (0); i < (n); i++) LD[i + n] = A[i] + l;
for (int i = (0); i < (n); i++) LI[i] = B[n - 1 - i];
for (int i = (0); i < (n); i++) LI[i + n] = B[n - 1 - i] + l;
double ans = 0;
for (int i = (0); i < (n); i++) {
int nv = (2 * t) / l;
int extra = (2 * t) % l;
int cntD = upper_bound(LD + i, LD + i + n, extra + LD[i]) - (LD + i + 1);
ans += cntD * (0.25);
int cntI = upper_bound(LI + i, LI + i + n, extra + LI[i]) - (LI + i + 1);
ans += cntI * (0.25);
ans += nv * ((n - 1) * (0.5));
}
printf("%.10lf\n", ans / 2);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int u, d;
} cards[100010];
int main() {
map<int, int> totnum;
map<int, int> upside;
map<int, int> downside;
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d%d", &cards[i].u, &cards[i].d);
if (cards[i].u != cards[i].d) {
totnum[cards[i].d]++, totnum[cards[i].u]++;
} else {
totnum[cards[i].d]++;
}
upside[cards[i].u]++;
downside[cards[i].d]++;
}
int f = 0, cnt = 10000000, mid = (n + 1) / 2;
for (int i = 0; i < n; i++) {
int t = totnum[cards[i].u];
int tmp = upside[cards[i].u];
if (t >= mid) {
f = 1;
if (tmp >= mid) {
cnt = 0;
break;
} else if (cnt > mid - tmp)
cnt = mid - tmp;
}
t = totnum[cards[i].d];
tmp = downside[cards[i].d];
if (t >= mid) {
f = 1;
if (t - tmp >= mid) {
cnt = 0;
break;
} else if (mid + tmp - t < cnt)
cnt = mid + tmp - t;
}
}
if (f)
cout << cnt << endl;
else
cout << "-1" << endl;
return 0;
}
| 7 |
Subsets and Splits