solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n, k;
for (cin >> t; t-- > 0; cout << n - max(0, n % k - k / 2) << '\n')
cin >> n >> k;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> vec[150005];
long long n, m, x, y, cnt = 0, ans = 0;
long long visited[150005];
void dfs(int v) {
visited[v] = 1;
cnt++;
for (int i = 0; i < vec[v].size(); i++) {
long long u = vec[v][i];
if (!visited[u]) {
dfs(u);
}
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
scanf("%lld %lld", &x, &y);
vec[x].push_back(y);
vec[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
if (!visited[i]) {
cnt = 0;
dfs(i);
ans += cnt * (cnt - 1) / 2ll;
}
}
if (ans == m)
cout << "YES";
else
cout << "NO";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t, n, s;
cin >> t;
while (t--) {
cin >> n;
s = (n * n + n) / 2;
for (int i = 1; n; i++) {
s -= (1 << i);
n >>= 1;
}
cout << s << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
constexpr int N = 2e5 + 5;
int ans[N];
int degree[N];
int is_good[N];
vector<pair<int, int>> E[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, m, k;
cin >> n >> m >> k;
vector<pair<int, int>> e(m);
for (int i = 0; i < m; i++) {
auto& [x, y] = e[i];
cin >> x >> y;
x--;
y--;
degree[x]++;
degree[y]++;
E[x].push_back({y, i});
E[y].push_back({x, i});
}
set<pair<int, int>> good;
for (int i = 0; i < n; i++) good.insert({degree[i], i});
fill_n(is_good, n, 1);
auto keep_good = [&](int t) -> void {
while (!good.empty() && good.begin()->first < k) {
int x = good.begin()->second;
good.erase(good.begin());
for (const auto& [y, i] : E[x]) {
if (is_good[y] && i < t) {
good.erase({degree[y], y});
degree[y]--;
good.insert({degree[y], y});
}
}
is_good[x] = 0;
}
};
keep_good(m);
for (int i = m - 1; i >= 0; i--) {
ans[i] = good.size();
const auto& [x, y] = e[i];
if (is_good[x] && is_good[y]) {
good.erase({degree[x], x});
degree[x]--;
good.insert({degree[x], x});
good.erase({degree[y], y});
degree[y]--;
good.insert({degree[y], y});
keep_good(i);
}
}
for (int i = 0; i < m; i++) cout << ans[i] << "\n";
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, i = 0, j = 0;
cin >> n;
vector<tuple<int, long long, string> > v(n, {1, 1, "pushBack"});
for (auto& [a, b, c] : v) cin >> b, a = ++i;
i = 0;
while (j < n) {
while (get<1>(v[j]) != 0 && j < n) j++;
sort(v.begin() + i, v.begin() + j,
[](tuple<int, long long, string> a, tuple<int, long long, string> b) {
return get<1>(a) > get<1>(b);
});
if (i < j) get<2>(v[i]) = "pushStack";
if (i + 1 < j) get<2>(v[i + 1]) = "pushQueue";
if (i + 2 < j) get<2>(v[i + 2]) = "pushFront";
if (j < n) switch (j - i) {
case 0:
get<2>(v[j]) = "0";
break;
case 1:
get<2>(v[j]) = "1 popStack";
break;
case 2:
get<2>(v[j]) = "2 popStack popQueue";
break;
default:
get<2>(v[j]) = "3 popStack popQueue popFront";
break;
}
i = ++j;
}
sort(v.begin(), v.end(),
[](tuple<int, long long, string> a, tuple<int, long long, string> b) {
return get<0>(a) < get<0>(b);
});
for (auto& [a, b, c] : v) cout << c << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int a[100005];
map<long long, long long> m;
string s;
map<string, long long> x;
string h(long long n) {
string t = "";
while (n) {
if ((n % 10) % 2 == 0)
t += "0";
else
t += "1";
n /= 10;
}
while (t.length() < 20) t += "0";
reverse(t.begin(), t.end());
return t;
}
int main() {
long long int n, i, k;
char c;
string temp;
cin >> n;
while (n--) {
cin >> c;
if (c == '+') {
cin >> k;
m[k]++;
x[h(k)]++;
} else if (c == '-') {
cin >> k;
m[k]--;
x[h(k)]--;
} else {
cin >> s;
temp = "";
if (s.size() < 20) {
for (i = 0; i < 20 - s.size(); i++) temp += "0";
temp += s;
}
cout << x[temp] << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) {
long long n, x;
cin >> n >> x;
vector<long long> a(n);
long long s = 0;
long long sm = 0;
for (long long i = 0; i < n; i++) cin >> a[i], s += a[i], sm += a[i];
for (long long i = 0; i < n; i++) a[i] = s - a[i];
reverse(a.begin(), a.end());
long long flag = 1;
s = a[0];
for (long long i = 0; i < n; i++) a[i] -= s;
long long add = 0;
while (flag) {
vector<long long> v;
long long cnt0 = 0;
for (long long i = 0; i < a.size(); i++) {
if (a[i] == 0)
cnt0++;
else {
if (cnt0 % x != 0) {
flag = 0;
break;
} else {
v.push_back(a[i] - 1);
cnt0 = 0;
}
}
if (cnt0 == x) {
v.push_back(0);
cnt0 = 0;
}
}
if (cnt0 < x and cnt0 > 0) {
flag = 0;
}
if (flag) {
a.clear();
s++;
a = v;
}
}
long long result = 1;
if (s > sm) s = sm;
while (s) {
if (s % 2)
result = (result * x) % 1000000007, s--;
else {
x = (x * x) % 1000000007;
s /= 2;
}
}
cout << result;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool ret[2][100000];
pair<int, pair<int, int> > place[200000];
int main() {
int n;
cin.sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> place[2 * i].first >> place[2 * i + 1].first;
place[2 * i].second = make_pair(0, i);
place[2 * i + 1].second = make_pair(1, i);
}
sort(place, place + 2 * n);
for (int i = 0; i < n; i++)
ret[place[i].second.first][place[i].second.second] = true;
for (int i = 0; i < 2; i++) {
for (int j = 0; j < n; j++) {
if ((j + 1) * 2 <= n || ret[i][j])
cout.put('1');
else
cout.put('0');
}
cout << '\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
long long ans = 0, a[52];
bool f[52][52];
bool check(long long x) {
for (int i = 1; i <= n; ++i) {
f[i][1] = ((a[i] & x) == x);
for (int j = 2; j <= k && j <= i; ++j) {
f[i][j] = false;
for (int d = j - 1; d < i; ++d) {
if (f[d][j - 1] == true && ((a[i] - a[d]) & x) == x) {
f[i][j] = true;
break;
}
}
}
}
return f[n][k];
}
int main() {
cin >> n >> k;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
a[i] += a[i - 1];
}
for (int i = 63; i >= 0; --i) {
if (check(ans + (1LL << i))) ans += 1LL << i;
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 10005;
struct edge {
int r, next;
} e[N * 200];
int h[N], tto;
void add(int x, int y) {
e[++tto].r = y;
e[tto].next = h[x];
h[x] = tto;
}
int a[N], n, k, l, t[N], tt;
int d[N];
int f[1048576];
int dis[25][25];
int q[N], tat;
void bfs(int x) {
int l = 1, r = 0;
tat = 0;
q[++r] = x;
d[x] = 0;
while (l <= r) {
if (tat >= tt) break;
int x = q[l++];
for (int i = h[x]; i; i = e[i].next) {
int y = e[i].r;
if (d[y] > d[x] + 1) {
d[y] = d[x] + 1;
q[++r] = y;
if (t[y]) tat++;
}
}
}
}
int main() {
cin >> n >> k >> l;
n++;
for (int i = 1; i <= k; i++) scanf("%d", &a[i]), t[a[i]] = 1;
for (int i = n; i >= 1; i--) t[i] = t[i - 1] ^ t[i];
for (int i = 1; i <= n; i++)
if (t[i]) a[++tt] = i;
int s = (1 << tt);
for (int i = 1; i <= l; i++) {
int b;
scanf("%d", &b);
for (int i = 1; i <= n - b; i++) add(i, b + i), add(i + b, i);
}
memset(dis, 63, sizeof(dis));
for (int i = 1; i <= tt; i++) {
memset(d, 63, sizeof(d));
bfs(a[i]);
for (int j = i + 1; j <= tt; j++) dis[i - 1][j - 1] = d[a[j]];
}
memset(f, 63, sizeof(f));
f[0] = 0;
for (int i = 0; i < s; i++)
if (f[i] <= 100000000) {
for (int j = 0; j < tt; j++)
if ((i & (1 << j)) == 0) {
for (int k = j + 1; k < tt; k++)
if ((i & (1 << k)) == 0) {
f[i | (1 << j) | (1 << k)] =
min(f[i | (1 << j) | (1 << k)], f[i] + dis[j][k]);
}
break;
}
}
int ans = f[s - 1] <= 100000000 ? f[s - 1] : -1;
printf("%d", ans);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(nullptr);
long long test;
cin >> test;
for (int cs = 1; cs <= test; cs++) {
long long A[101][101];
long long n;
cin >> n;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) A[i][j] = 0;
for (int i = 1; i <= n; i++) A[i][i] = A[i][n - i + 1] = 1;
if (n % 2) {
A[n / 2 + 1][1] = A[n / 2 + 1][n] = 1;
A[1][n / 2 + 1] = A[n][n / 2 + 1] = 1;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) cout << A[i][j] << " ";
cout << "\n";
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> a[1000];
bool safe[1000];
int n;
int main() {
memset(safe, false, sizeof(safe));
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i].first;
a[i].second = i;
}
sort(a, a + n);
for (int i = 0; i < n; i++) {
safe[a[i].second] = true;
if (a[i].second == 0 || a[i].second == n - 1) {
cout << a[i].first;
return 0;
}
if (safe[a[i].second - 1] || safe[a[i].second + 1]) {
cout << a[i].first;
return 0;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long k, a, b;
cin >> k >> a >> b;
if (a < k && b < k || (a < k && b % k != 0) || (a % k != 0 && b < k))
cout << "-1";
else
cout << (a / k) + (b / k);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 5e2 + 5;
const int MaxM = 5e2 + 5;
int t, n, m, a[MaxN], c[MaxN];
long long ans;
void mergesort(int l, int r) {
if (l == r) {
return;
}
int mid = (l + r) >> 1;
register int i = l, j = mid + 1, k = l;
mergesort(l, mid);
mergesort(mid + 1, r);
while (i <= mid && j <= r) {
if (a[i] <= a[j]) {
c[k++] = a[i++];
} else {
c[k++] = a[j++];
ans += mid - i + 1;
}
}
while (i <= mid) {
c[k++] = a[i++];
}
while (j <= r) {
c[k++] = a[j++];
}
for (register int h = l; h <= r; h++) {
a[h] = c[h];
}
}
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d%d", &n, &m);
for (register int i = 1; i <= n; i++) {
for (register int j = 1; j <= m; j++) {
scanf("%d", &a[j]);
a[j] = -a[j];
}
}
ans = 0;
mergesort(1, m);
printf("%lld\n", ans);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, x;
cin >> a >> b;
x = min(a, b);
cout << x << ' ';
if (a > b) {
cout << (a - b) / 2;
}
if (b > a) {
cout << (b - a) / 2;
}
if (a == b) {
cout << "0";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int point;
int sum;
};
vector<node> son[1000000];
int dp[1000000][2];
int n, k;
int cnt;
int head[1000000];
int ver[1000000];
int nxt[1000000];
int link[1000000];
void add(int x, int y, int z) {
nxt[++cnt] = head[x];
head[x] = cnt;
ver[cnt] = y;
link[cnt] = z;
}
bool cmp(node a, node b) { return a.sum > b.sum; }
void Dp(int now, int father) {
for (int i = head[now]; i; i = nxt[i]) {
int v0 = ver[i];
if (v0 == father) continue;
Dp(v0, now);
son[now].push_back({v0, dp[v0][0] + link[i]});
}
sort(son[now].begin(), son[now].end(), cmp);
for (int i = 0; i < son[now].size(); i++) {
dp[now][0] += son[now][i].sum;
if (i >= k - 2) break;
}
int sum = 0;
for (int i = 0; i < son[now].size(); i++) {
sum += son[now][i].sum;
if (i >= k - 1) break;
}
for (int i = 0; i < son[now].size(); i++) {
dp[now][1] = max(dp[now][1],
sum + dp[son[now][i].point][1] - dp[son[now][i].point][0]);
if (i >= k - 1) break;
}
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i < n; i++) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
a++;
b++;
add(a, b, c);
add(b, a, c);
}
Dp(1, 1);
printf("%d\n", dp[1][1]);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long M = 1e9 + 7;
const long long INF = 1e9;
inline long long pwr(long long base, long long n, long long m) {
long long ans = 1;
while (n > 0) {
if (n & 1) ans = (ans * base) % m;
base = (base * base) % m;
n >>= 1;
}
return ans;
}
const int N = 2e5 + 10;
long long a[N], sum[N];
int n, p, k;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
cin >> n >> p >> k;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
int ans = 0;
for (int i = 0; i < n; i++) {
sum[i] = a[i];
int prev = i - k;
if (prev < -1) {
if (i) sum[i] += sum[i - 1];
} else {
if (prev != -1) sum[i] += sum[i - k];
}
if (sum[i] <= p) ans = max(ans, i + 1);
}
cout << ans << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, i, j;
cin >> n >> m;
char w[n + 1][m + 1], a[n + 1][m + 1];
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
cin >> w[i][j];
}
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
if (w[i][j] == '.') {
if ((i + j) % 2 == 0)
w[i][j] = 'B';
else
w[i][j] = 'W';
}
}
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
cout << w[i][j];
}
cout << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T, class U>
inline T max(T &a, U &b) {
return a > b ? a : b;
}
template <class T, class U>
inline T min(T &a, U &b) {
return a < b ? a : b;
}
template <class T, class U>
inline T swap(T &a, U &b) {
T tmp = a;
a = b;
b = tmp;
}
const long long INF = (1ll) << 50;
const int mx = 1e5 + 7;
const int mod = 1000000007;
const double pi = 2 * acos(0.0);
int EQ(double d) {
if (fabs(d) < 1e-7) return 0;
return d > 1e-7 ? 1 : -1;
}
int arr[110][110], core[110];
bool cell[110];
int main() {
int n, m, k;
while (cin >> n >> m >> k) {
memset(arr, 0, sizeof(arr));
memset(core, 0, sizeof(core));
memset(cell, 0, sizeof(cell));
for (__typeof((n)-1) i = (0); i <= ((n)-1); ++i)
for (__typeof((m)-1) j = (0); j <= ((m)-1); ++j) {
arr[i][j] = ({
int a;
scanf("%d", &a);
a;
});
}
int A[110];
for (__typeof((m)-1) i = (0); i <= ((m)-1); ++i) {
memset(A, 0, sizeof(A));
for (__typeof((n)-1) j = (0); j <= ((n)-1); ++j) {
if (core[j]) continue;
if (cell[arr[j][i]]) {
continue;
}
A[arr[j][i]]++;
if (A[arr[j][i]] > 1) {
cell[arr[j][i]] = true;
}
}
for (__typeof((n)-1) j = (0); j <= ((n)-1); ++j) {
if (core[j]) continue;
if (arr[j][i] == 0) continue;
if (cell[arr[j][i]]) {
core[j] = i + 1;
continue;
}
}
}
for (__typeof((n)-1) i = (0); i <= ((n)-1); ++i) cout << core[i] << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int T;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> T;
for (int t = 0; t < T; ++t) {
int n, x;
vector<int> a, b;
cin >> n >> x;
for (int i = 0; i < n; ++i) {
int d, h;
cin >> d >> h;
b.push_back(d);
a.push_back(d - h);
}
sort(a.begin(), a.end(), greater<int>());
sort(b.begin(), b.end(), greater<int>());
if (b[0] >= x) {
cout << 1 << endl;
continue;
}
x -= b[0];
int res = 1;
if (a[0] <= 0)
cout << -1 << endl;
else {
res += x / a[0];
if (x % a[0]) ++res;
cout << res << endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
const long long INF = 1e9;
const long long MOD = 1000000007;
vector<vector<int>> ve(N);
int arr[N];
int ans = 0;
void dfs1(int ind, int prev) {
for (auto it : ve[ind]) {
if (it == prev) continue;
dfs1(it, ind);
if (arr[it] == 0 && arr[ind] != 1) {
ans++;
arr[ind] = 1;
arr[it] = 2;
}
if (arr[it] == 1 && arr[ind] != 1) arr[ind] = 2;
}
}
void dfs(int ind, int prev, int dist) {
if (dist == 2) {
arr[ind] = 2;
dfs1(ind, prev);
return;
}
dist++;
for (auto it : ve[ind]) {
if (it == prev) continue;
dfs(it, ind, dist);
}
}
int main() {
ios ::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
ve[x].push_back(y);
ve[y].push_back(x);
}
memset(arr, 0, sizeof(arr));
dfs(1, -1, 0);
cout << ans;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
long long int i, l = s.size(), left = 0, right = 0, pivot = s.find('^');
for (i = 0; i < pivot; i++) {
if (s[i] != '=') {
left += (pivot - i) * (s[i] - '0');
}
}
for (i = pivot + 1; i < l; i++) {
if (s[i] != '=') {
right += (i - pivot) * (s[i] - '0');
}
}
if (left == right)
cout << "balance";
else if (left > right)
cout << "left";
else
cout << "right";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1000000000;
const int P = 10;
int L10(long long n) {
int res = 0;
while (n) {
++res;
n /= 10;
}
return res;
}
long long sh(long long n) {
long long res = 1;
int p = L10(n);
while (p) {
res *= 10;
--p;
}
return res;
}
long long long_mod(int n, long long p, int k) {
long long res = n % k;
while (p > 1) {
p /= 10;
res = (res * 10) % k;
}
return res;
}
int main() {
ios::sync_with_stdio(false);
int n, k;
scanf("%d %d", &n, &k);
vector<int> a(n);
map<int, int> m1[P + 1];
map<int, int> m2[P + 1];
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
for (long long j = 1, p = 1; j <= P; ++j) {
p *= 10;
int lm = (int)long_mod(a[i], p, k);
++m1[(int)j][lm];
}
++m2[L10(a[i])][a[i] % k];
}
if (k == 999999929) {
printf("0\n");
return 0;
}
long long res = 0;
for (int p = 1; p <= P; ++p) {
for (map<int, int>::iterator it2 = m2[p].begin(), end2 = m2[p].end();
it2 != end2; ++it2) {
map<int, int>::iterator it1 = m1[p].find((k - it2->first) % k);
if (it1 != m1[p].end()) {
res += (long long)it2->second * (long long)it1->second;
}
}
}
int bigs = 0;
for (int i = 0; i < n; ++i) {
if (a[i] == MAX) {
++bigs;
} else {
if (!((a[i] * sh(a[i]) + a[i]) % k)) --res;
}
}
if (bigs) {
int lm = (int)long_mod(MAX, (long long)MAX * 10, k);
lm += (MAX % k);
lm %= k;
if (!lm) res -= bigs;
}
printf("%I64d\n", res);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 300005;
const long long Inf = 1000000000000000000ll;
int n, w;
int a[Maxn], b[Maxn];
int seq[Maxn];
set<pair<int, int> > best, worse;
long long cur, res = Inf;
int wth;
int col[Maxn];
bool Less(const int &i, const int &j) {
if (b[i] != b[j]) return b[i] < b[j];
if (a[i] != a[j]) return a[i] < a[j];
return i < j;
}
pair<int, int> getLast(set<pair<int, int> > &S) {
set<pair<int, int> >::iterator it = S.end();
it--;
return *it;
}
int main() {
scanf("%d %d", &n, &w);
for (int i = 0; i < n; i++) {
scanf("%d %d", &a[i], &b[i]);
seq[i] = i;
}
sort(seq, seq + n, Less);
for (int i = 0; i < n; i++) worse.insert(pair<int, int>(a[seq[i]], seq[i]));
for (int i = 0; i <= n; i++) {
int need = w - i;
while (!best.empty() && best.size() > need) {
pair<int, int> p = getLast(best);
cur -= p.first;
worse.insert(p);
best.erase(p);
}
while (best.size() < need && !worse.empty() ||
!best.empty() && !worse.empty() &&
worse.begin()->first < getLast(best).first) {
cur += worse.begin()->first;
best.insert(*worse.begin());
worse.erase(worse.begin());
if (best.size() > need) {
pair<int, int> p = getLast(best);
cur -= p.first;
best.erase(p);
worse.insert(p);
}
}
if (best.size() == need && cur < res) {
res = cur;
wth = i;
}
if (i < n) {
pair<int, int> p = pair<int, int>(a[seq[i]], seq[i]);
if (best.count(p)) {
best.erase(p);
cur -= p.first;
} else
worse.erase(p);
cur += a[seq[i]];
worse.insert(pair<int, int>(b[seq[i]] - a[seq[i]], seq[i]));
}
}
printf("%I64d\n", res);
best.clear();
worse.clear();
for (int i = 0; i < wth; i++) {
col[seq[i]]++;
worse.insert(pair<int, int>(b[seq[i]] - a[seq[i]], seq[i]));
}
for (int i = wth; i < n; i++) worse.insert(pair<int, int>(a[seq[i]], seq[i]));
int need = w - wth;
while (need--) {
col[worse.begin()->second]++;
worse.erase(worse.begin());
}
for (int i = 0; i < n; i++) printf("%d", col[i]);
printf("\n");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 1000000007;
const long long BIG = 1446803456761533460LL;
const int Big = 336860180;
const long long int INF = LONG_LONG_MAX;
const long long int adj4[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
const long long int adj8[8][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0},
{-1, -1}, {1, -1}, {-1, 1}, {1, 1}};
long long int gcd(long long int a, long long int b) {
return b == 0 ? a : gcd(b, a % b);
}
long long int powMod(long long int a, long long int b) {
long long int n = 1;
long long int p = a;
while (b > 0) {
if (b % 2 == 1) {
n *= p;
n %= MOD;
}
p *= p;
p %= MOD;
b /= 2;
}
return n;
}
long long int modularInverse(long long int a) { return powMod(a, MOD - 2); }
stringstream sss;
const long long int maxn = 2010;
char grid[maxn][maxn];
long long int dp[maxn][maxn][2];
long long int ps[maxn][maxn][2];
long long int rows[maxn][maxn];
long long int cols[maxn][maxn];
void MAIN() {
long long int n, m;
cin >> n >> m;
for (long long int i = (0); i < (n); ++i) {
for (long long int j = (0); j < (m); ++j) {
cin >> grid[i][j];
}
}
if (1 == m && n == 1) {
cout << (1) << '\n';
return;
}
for (long long int i = (n)-1; i >= (0); --i) {
for (long long int j = (m)-1; j >= (0); --j) {
rows[i][j] = rows[i][j + 1] + (grid[i][j] == 'R');
cols[i][j] = cols[i + 1][j] + (grid[i][j] == 'R');
}
}
dp[1][1][0] = dp[1][1][1] = 1;
for (long long int i = (1); i < (n + 1); ++i) {
for (long long int j = (1); j < (m + 1); ++j) {
long long int l = 0;
long long int r = i;
while (r - l > 1) {
long long int k = (l + r) / 2;
if (cols[k][j - 1] <= n - i && rows[k][j] <= m - j) {
r = k;
} else {
l = k;
}
}
dp[i][j][0] = (dp[i][j][0] + (ps[i - 1][j][1] - ps[l][j][1] + MOD)) % MOD;
l = 0;
r = j;
while (r - l > 1) {
long long int k = (l + r) / 2;
if (rows[i - 1][k] <= m - j && cols[i][k] <= n - i) {
r = k;
} else {
l = k;
}
}
dp[i][j][1] = (dp[i][j][1] + (ps[i][j - 1][0] - ps[i][l][0] + MOD)) % MOD;
ps[i][j][0] = (ps[i][j - 1][0] + dp[i][j][0]) % MOD;
ps[i][j][1] = (ps[i - 1][j][1] + dp[i][j][1]) % MOD;
}
}
cout << ((dp[n][m][0] + dp[n][m][1]) % MOD) << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(10);
sss << R"(
4 4
...R
.RR.
.RR.
R...
)";
MAIN();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long base = 777777777, tree[320100][4][4];
int n, m;
int lb[320100], rb[320100];
int mas[4][4];
void modify(int v, int x, int q) {
if (lb[v] == rb[v]) {
for (int i = 1; i <= 3; i++)
for (int j = 1; j <= 3; j++) tree[v][i][j] = 0;
if (q == 0) {
for (int i = 1; i <= 3; i++) tree[v][i][i] = 1;
} else {
tree[v][q][q] = 1;
}
return;
}
int med = (lb[v] + rb[v]) / 2;
if (x <= med) {
modify(2 * v + 1, x, q);
} else {
modify(2 * v + 2, x, q);
}
for (int l = 1; l <= 3; l++)
for (int r = 1; r <= 3; r++) {
tree[v][l][r] = 0;
for (int ll = 1; ll <= 3; ll++)
for (int rr = 1; rr <= 3; rr++) {
if (mas[ll][rr] == 1) {
tree[v][l][r] += tree[2 * v + 1][l][ll] * tree[2 * v + 2][rr][r];
tree[v][l][r] %= base;
}
}
}
return;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= 3; i++)
for (int j = 1; j <= 3; j++) scanf("%d", &mas[i][j]);
lb[0] = 1;
rb[0] = n;
for (int i = 1; i <= n * 4 + 100; i++)
if (i % 2 == 1) {
lb[i] = lb[i / 2];
rb[i] = (lb[i / 2] + rb[i / 2]) / 2;
} else {
rb[i] = rb[(i - 2) / 2];
lb[i] = (lb[(i - 2) / 2] + rb[(i - 2) / 2]) / 2 + 1;
}
for (int i = 1; i <= n; i++) modify(0, i, 0);
for (int i = 1; i <= m; i++) {
int aa, bb;
scanf("%d%d", &aa, &bb);
modify(0, aa, bb);
long long ans = 0;
for (int l = 1; l <= 3; l++)
for (int r = 1; r <= 3; r++) ans += tree[0][l][r], ans %= base;
printf("%I64d\n", ans);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, p, m;
char s[100005];
int vis[100];
int main() {
scanf("%d %s", &n, s);
for (int i = 0; i < (int)strlen(s); ++i)
if (!vis[s[i] - 'A']) vis[s[i] - 'A'] = 1, ++m;
memset(vis, 0, sizeof vis);
int ans = 1e9;
for (int i = 0, j = 0; i < (int)strlen(s); ++i) {
if (!vis[s[i] - 'A']) p++;
vis[s[i] - 'A']++;
while (vis[s[j] - 'A'] > 1) {
vis[s[j] - 'A']--;
++j;
}
if (p == m) ans = min(ans, i - j + 1);
}
printf("%d", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int a, b, c, d, k;
cin >> a >> b >> c >> d >> k;
int pens;
if (a % c == 0)
pens = a / c;
else
pens = a / c + 1;
int pencils;
if (b % d == 0)
pencils = b / d;
else
pencils = b / d + 1;
if (pens + pencils > k)
cout << -1 << endl;
else
cout << pens << ' ' << pencils << endl;
}
int main(void) {
int t;
cin >> t;
while (t--) solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 2;
const int LOG = 17;
const int inf = 1e9;
int jump[LOG][maxn];
int depth[maxn];
bool red[maxn];
int tin[maxn];
int tout[maxn];
int tmr = 0;
int dist[maxn];
int nearest[maxn];
queue<int> q;
vector<int> e[maxn];
vector<int> New;
int n;
void dfs(int v, int id, int p, int h) {
if (id == 0)
jump[id][v] = p;
else
jump[id][v] = jump[id - 1][jump[id - 1][v]];
depth[v] = h;
for (int i = 0; i < (int)e[v].size(); i++)
if (e[v][i] != p) dfs(e[v][i], id, v, h + 1);
}
void dfsT(int v, int p) {
tin[v] = tmr++;
for (int i = 0; i < (int)e[v].size(); i++)
if (e[v][i] != p) dfsT(e[v][i], v);
tout[v] = tmr++;
}
inline bool pred(int v, int u) {
return tin[v] <= tin[u] && tout[u] <= tout[v];
}
inline int lca(int v, int u) {
if (pred(v, u)) return v;
if (pred(u, v)) return u;
for (int i = LOG - 1; i >= 0; i--)
if (!pred(jump[i][v], u)) v = jump[i][v];
return jump[0][v];
}
inline int len(int v, int u) {
int z = lca(v, u);
return (depth[v] - depth[z]) + (depth[u] - depth[z]);
}
void re_build() {
int v;
for (int i = 0; i < (int)New.size(); i++) red[New[i]] = 1;
New.clear();
memset(dist, 63, sizeof(dist));
for (int i = 0; i < n; i++)
if (red[i]) {
dist[i] = 0;
q.push(i);
}
while (!q.empty()) {
v = q.front();
q.pop();
for (int i = 0; i < (int)e[v].size(); i++)
if (dist[e[v][i]] > dist[v] + 1) {
dist[e[v][i]] = dist[v] + 1;
q.push(e[v][i]);
}
}
}
int main() {
int m, m_sqrt, v, u, ans, t;
scanf("%d%d", &n, &m);
for (int i = 0; i < n - 1; i++) {
scanf("%d%d", &v, &u);
v--;
u--;
e[v].push_back(u);
e[u].push_back(v);
}
for (int i = 0; i < LOG; i++) dfs(0, i, 0, 0);
dfsT(0, -1);
m_sqrt = sqrt(m);
if (m_sqrt == 0) m_sqrt++;
red[0] = 1;
re_build();
for (int i = 0; i < m; i++) {
scanf("%d%d", &t, &v);
v--;
if (i % m_sqrt == 0) re_build();
if (t == 1) {
New.push_back(v);
}
if (t == 2) {
ans = dist[v];
for (int j = 0; j < (int)New.size(); j++) ans = min(ans, len(v, New[j]));
printf("%d\n", ans);
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
int n, m;
int k, l;
int main() {
scanf("%1d%1d:%1d%1d", &n, &m, &k, &l);
n *= 10, n += m;
int u = k;
u *= 10;
u += l;
int u1 = l;
u1 *= 10;
u1 += k;
k = n % 10;
k *= 10;
k += (n / 10);
if (n == u1 || k < u || n % 10 > 5) {
n++, n %= 24;
while (n % 10 > 5) {
n++;
n %= 24;
}
}
k = n % 10;
k *= 10;
k += (n / 10);
if (n < 10) printf("0");
printf("%d:", n);
if (k < 10) printf("0");
printf("%d\n", k);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline 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;
}
const int N = 3e5 + 5;
int a[N], b[N], f[N], pre[N];
int n;
void print(int x) {
if (x == n) return;
print(pre[x]);
cout << x << " ";
}
int main() {
n = read();
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 1; i <= n; i++) b[i] = read();
for (int i = n, v = n - 1; i >= 1; i--) {
for (int u = i + b[i]; v >= u - a[u] && v >= 0; v--)
f[v] = f[i] + 1, pre[v] = i;
if (v == i - 1) return cout << -1 << endl, 0;
}
cout << f[0] << endl;
print(0);
cout << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
int main() {
double d, h, v, e;
scanf("%lf%lf%lf%lf", &d, &h, &v, &e);
if (v <= pi * (d / 2) * (d / 2) * e ||
(d / 2) * (d / 2) * pi * h / (v - pi * (d / 2) * (d / 2) * e) >= 10000)
printf("NO");
else {
printf("YES\n");
printf("%.12lf",
(d / 2) * (d / 2) * pi * h / (v - pi * (d / 2) * (d / 2) * e));
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
int a[N];
int b[N];
int pre[N];
char s[N];
int n, m;
int dp[N];
int maxv[N];
int main() {
scanf("%d", &n);
scanf("%s", s + 1);
scanf("%d", &m);
for (int i = n; i >= 1; --i) {
pre[i] = pre[i + 1];
if (s[i] == '?') pre[i]++;
if (s[i] == 'a' || s[i] == '?') a[i] = b[i + 1] + 1;
if (s[i] == 'b' || s[i] == '?') b[i] = a[i + 1] + 1;
maxv[i] = maxv[i + 1];
if (a[i] >= m) maxv[i] = maxv[i + m] + 1;
}
for (int i = n - m + 1; i >= 1; --i) {
dp[i] = 10000000;
if (maxv[i] == maxv[i + 1]) dp[i] = dp[i + 1];
if (a[i] >= m) dp[i] = min(dp[i], dp[i + m] + pre[i] - pre[i + m]);
}
printf("%d\n", dp[1]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long MX = 1e5 + 10;
const long long LUCKY = MX;
vector<pair<long long, long long> > val;
map<long long, long long> num;
vector<long long> adj[MX];
long long ans[LUCKY];
bool vis[MX];
long long dfs(long long u) {
long long ans = 1;
vis[u] = true;
for (long long v : adj[u]) {
if (!vis[v]) {
ans += dfs(v);
}
}
return ans;
}
bool isLuck(long long x) {
while (x > 0) {
if (!(x % 10 == 4 || x % 10 == 7)) {
return false;
}
x /= 10;
}
return true;
}
void genera(long long cnt, long long x) {
while (cnt != 0) {
long long pos = 63 - __builtin_clzll(cnt);
for (long long i = 0; i < pos; i++) {
val.push_back({(1ll << i), (x << i)});
}
if (cnt == (1ll << (pos + 1)) - 1) {
val.push_back({(1ll << pos), (x << pos)});
break;
}
cnt -= (1ll << pos) - 1;
}
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout.precision(10);
cout << fixed;
for (long long i = 0; i < LUCKY; i++) {
ans[i] = MX;
}
long long n, m, x, y;
cin >> n >> m;
for (long long i = 0; i < m; i++) {
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
for (long long i = 1; i <= n; i++) {
if (!vis[i]) {
num[dfs(i)]++;
}
}
for (auto par : num) {
genera(par.second, par.first);
}
ans[0] = 0;
for (auto par : val) {
y = par.first;
x = par.second;
for (long long i = LUCKY - 1; i >= 0; i--) {
if (i - x >= 0) {
ans[i] = min(ans[i], ans[i - x] + y);
}
}
}
long long rp = MX;
for (long long i = 4; i < LUCKY; i++) {
if (ans[i] != MX && isLuck(i)) {
rp = min(rp, ans[i] - 1);
}
}
if (rp == MX) {
cout << -1 << "\n";
} else {
cout << rp << "\n";
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
int duval(const T* s, int n, int* d) {
int r = 0;
for (int i = 0, j, k; i < n;) {
for (k = i, j = i + 1; j < n && s[k] <= s[j]; ++j)
s[k] < s[j] ? k = i : ++k;
for (d[r++] = i; i <= k; i += j - k)
;
}
return r;
}
template <class T>
void z_function(const T* s, int n, int* z) {
z[0] = n;
for (int i = 1, l = 0, r = 0; i < n; ++i) {
z[i] = i > r ? 0 : min(r - i + 1, z[i - l]);
while (i + z[i] < n && s[z[i]] == s[i + z[i]]) ++z[i];
if (i + z[i] - 1 > r) l = i, r = i + z[i] - 1;
}
}
const int N = 5e6 + 1;
int n, k, z[2 * N], d[N];
char s[2 * N], ans[N], t[N];
char* cur = ans;
void add(const char* src, int l, char*& dst) {
copy(src, src + l, dst);
dst += l;
}
void add_suf(int l, char* dst) {
int c = z[2 * n + 1 - l];
add((c >= l || s[c] > s[l - 1 - c]) ? s + 2 * n + 1 - l : s, l, dst);
}
int main() {
scanf("%s%d", s, &k);
n = strlen(s);
copy(s, s + n, s + n + 1);
reverse_copy(s + n + 1, s + 2 * n + 1, s);
z_function(s, 2 * n + 1, z);
int l = n, m = duval(s, n, d) - 1;
if (k > 2)
for (; 0 <= m; l = d[m], --m) {
bool ok = true;
for (int i = d[m]; i < l; ++i)
if (s[i] != s[l - 1]) ok = false;
if (!ok) break;
}
if (l != n) --k;
add(s + n + 1, n - l, cur);
for (; 0 <= m && 2 < k; l = d[m], --m, --k) add(s + d[m], l - d[m], cur);
if (k == 1 || m <= 0) {
add_suf(l, cur);
} else {
char* c = t;
add(ans, n - l, c);
add(s + d[m], l - d[m], cur);
add_suf(d[m], cur);
add(s + d[m - 1], l - d[m - 1], c);
add_suf(d[m - 1], c);
if (strcmp(t, ans) < 0) copy(t, t + n, ans);
int best = 1;
for (int i = 2; i < l; ++i) {
int p = z[2 * n + 1 - i];
if (p < i - best) {
if (s[p] < s[i - 1 - p]) best = i;
} else {
p = z[i - best];
if (p <= best && s[i - best + p] < s[p]) best = i;
}
}
add(ans, n - l, c = t);
add(s + 2 * n + 1 - l, l - best, c);
add(s, best, c);
if (strcmp(t, ans) < 0) copy(t, t + n, ans);
}
printf("%s\n", ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << "=" << a << " ! ";
err(++it, args...);
}
const long long N = 2e3 + 7, M = 1e9 + 7, inf = 2e18;
string a[N], b[N];
long long n, m, i, j, k;
int main() {
cin >> n >> m;
for (i = 0; i < n; i++) cin >> a[i];
for (i = 0; i < m; i++) cin >> b[i];
for (i = 0; i <= n - m; i++) {
for (j = 0; j <= n - m; j++) {
for (k = 0; k < m; k++)
if (memcmp(&a[i + k][0], &b[k][j], m)) break;
if (k == m) {
cout << i + 1 << " " << j + 1 << "\n";
exit(0);
}
}
}
}
| 6 |
#include<bits/stdc++.h>
#define ls p<<1
#define rs p<<1|1
#define fast ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define FOR(i,a,b) for(int i=a;i<=b;i++)
#define mm make_pair
#define pi 2*acos(0.0)
#define lcm(a,b) (a*b)/__gcd(a,b)
#define cp(i,ans) printf("%.if",ans);
#define cpp(i,ans) cout.precision(i);cout<<fixed<<ans<<endl;
#define lowbit(x) (x)&(-x)
#define out(x) {cout<<x<<endl;return 0;}
#define all(v) v.begin(),v.end()
#define mem(x,i) memset(x,i,sizeof(x))
#define mec(x,y) memcpy(x,y,sizeof(y))
#define eps 1e-8
#define ull unsigned long long
#define cps CLOCKS_PER_SEC
#define int long long
using namespace std;
typedef long long ll;
const int mod=1e9+7;
const int inf=0x3f3f3f3f;
ll gcd(ll x,ll y){if(y==0) return x;else return gcd(y,x%y);}
ll ksm(ll a,ll b){ll r=1;while(b){if(b&1) r=(r*a)%mod;a=a*a%mod;b>>=1;}return r;}
void exgcd(ll a, ll b, ll &x, ll &y, ll &d){if(!b) d=a,x=1,y=0;else exgcd(b,a%b,y,x,d),y-=a/b*x;}
ll inv(ll a, ll p){ll x,y,d;exgcd(a,p,x,y,d);x=(x%p+p)%p;return x;}
inline int read()
{
char c=getchar();int x=0,f=1;
while(c<'0'||c>'9'){if(c=='-')f=-1;c=getchar();}
while(c>='0'&&c<='9'){x=x*10+c-'0';c=getchar();}
return x*f;
}
const int maxn=1e6+100;
int n,m,k,q;
string s[205],t,w;
int p[maxn];
/*inline void pre_kmp(const string &b){
nex[0]=0;
int t=0,m=b.size();
for(int i=1;i<m;i++){
t=nex[i-1];
if(b[t]!=b[i]&&t>0) t=nex[t];
if(b[t]==b[i]) nex[i]=t+1;
else nex[i]=0;
}
}
inline int kmp(const string &a,const string &b){
int i=0,j=0;
int n=a.size(),m=b.size(),cnt=0;
while(i<n){
if(a[i]==b[j]){
i++;j++;
if(j==m) j=nex[j-1],cnt++;
}
else{
if(j==0) i++;
else j=nex[j-1];
}
}
return cnt;
}*/
void pre_kmp(const string& b)
{
int lb=b.size();
p[0]=0;
for(int i=1,j=0;i<lb;i++)
{
while(j>0 && b[i]!=b[j]) j=p[j-1];
if(b[i]==b[j]) j++;
p[i]=j;
}
return ;
}
int kmp(const string &a,const string &b)
{
//计算a中多少个b
int sum=0,la=a.size(),lb=b.size();
for(int i=0,j=0;i<la;i++)
{
while(j>0 && a[i]!=b[j])
j=p[j-1];
if(a[i]==b[j])
j++;
if(j==lb)
{
sum++;
j=p[j-1];
}
}
return sum;
}
inline string work(const string &s,int m,char x){
string w="";
int n=s.size();
for(int i=n-m+1;i<n;i++){
w+=s[i];
}
w+=x;
for(int i=0;i<m-1;i++){
w+=s[i];
}
return w;
}
ll tw[maxn],f[27][maxn];
inline ll add(ll x,ll y){
return (x+y)%mod;
}
signed main()
{
fast;
cin>>n>>q;
cin>>s[0]>>t;
int mx=0;
//预处理
for(int i=0;i<t.size()&&s[i].size()<1000000+100;i++){
s[i+1]=s[i]+t[i]+s[i];
}
tw[0]=1;
for(int i=1;i<maxn;i++){
tw[i]=tw[i-1]*2ll%mod;
}
for(int i=1;i<=t.size();i++){
for(int j=0;j<26;j++){
f[j][i]=f[j][i-1];
}
(f[t[i-1]-'a'][i]+=inv(tw[i],mod))%=mod;
}//求出每一个t中的字符的贡献和
while(q--){
ll ans=0;
cin>>k>>w;
pre_kmp(w);
for(int i=0;i<=k;i++){
if(s[i].size()+1>=w.size()){
for(int j=0;j<26;j++){
string ss=work(s[i],w.size(),j+'a');
ll cnt=kmp(ss,w);
//cout<<ss<<endl;
(ans+=1ll*tw[k]*(f[j][k]-f[j][i]+mod)%mod *cnt%mod)%=mod;
}
if(s[i].size()>=w.size()){
int cnt=kmp(s[i],w);
(ans+=1ll* tw[k-i]* cnt%mod)%=mod;
}
break;
}
}
cout<<(ans%mod+mod)%mod<<endl;
}
return 0;
}
/*
3 3
aa
bcd
3 ca
2 aba
3 aa
*/ | 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 120 + 8;
class TaskB {
public:
int score[6];
double l[6], r[6];
int ok[5];
int cnt[N][5];
int arr[5];
int tup[5];
int n;
int x;
bool can = false;
void rec(int i) {
if (i == 5) {
int sum = 0;
bool good = true;
for (int j = 0; j < 5; j++) {
if (ok[j] > r[arr[j]] * x) {
good = false;
break;
}
if (ok[j] > l[arr[j]] * x) {
continue;
}
int need = (int)(l[arr[j]] * x - ok[j]);
while ((ok[j] + need) <= l[arr[j]] * x) {
need++;
}
if ((ok[j] + need) > r[arr[j]] * x) {
good = false;
break;
}
if (need != 0 && cnt[0][j] == -1) {
good = false;
break;
}
tup[j] = need;
sum = max(sum, need);
}
if (sum > x - n) {
good = false;
} else if (good) {
int p_a = 0, p_b = 0;
for (int i = 0; i < 5; i++) {
if (cnt[0][i] != -1) {
p_a += score[arr[i]] * (1 - cnt[0][i] / (double)250);
}
if (cnt[1][i] != -1) {
p_b += score[arr[i]] * (1 - cnt[1][i] / (double)250);
}
}
if (p_a <= p_b) {
good = false;
}
}
can |= good;
} else {
for (int a = 0; a < 6; a++) {
arr[i] = a;
rec(i + 1);
}
}
}
void solve(std::istream &in, std::ostream &out) {
l[0] = 1.0 / 2.0;
r[0] = 1;
l[1] = 1.0 / 4.0;
r[1] = 1.0 / 2.0;
l[2] = 1.0 / 8.0;
r[2] = 1.0 / 4.0;
l[3] = 1.0 / 16.0;
r[3] = 1.0 / 8.0;
l[4] = 1.0 / 32.0;
r[4] = 1.0 / 16.0;
l[5] = -1;
r[5] = 1.0 / 32.0;
score[0] = 500, score[1] = 1000, score[2] = 1500, score[3] = 2000,
score[4] = 2500, score[5] = 3000;
for (int j = 0; j < 5; j++) {
ok[j] = 0;
}
in >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 5; j++) {
in >> cnt[i][j];
ok[j] += (cnt[i][j] != -1);
}
}
for (int m = 0; m <= 1000; m++) {
x = n + m;
can = false;
rec(0);
if (can) {
out << m << '\n';
return;
}
}
int l = 1000, r = (int)1e9 + 7;
while (l < r - 1) {
int m = (l + r) / 2;
x = n + m;
can = false;
rec(0);
if (can) {
r = m;
} else {
l = m;
}
}
if (r == (int)1e9 + 7) {
out << -1 << '\n';
} else {
out << r << '\n';
}
}
};
int main() {
ios::sync_with_stdio(0);
TaskB solver;
std::istream &in(std::cin);
std::ostream &out(std::cout);
solver.solve(in, out);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int iinf = 0x3f3f3f3f;
const long long linf = 0x3f3f3f3f3f3f3f3f;
const int N = 5e5;
int n, m, a[N];
const int A = 22;
pair<int, int> lb[N][A];
void add(pair<int, int> *f, pair<int, int> v) {
for (int i = (A)-1, I = (0) - 1; i > I; i--)
if (v.first >> i)
if (~f[i].second) {
if (v.second > f[i].second) swap(f[i], v);
v.first ^= f[i].first;
} else
return void(f[i] = v);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
cin >> n;
fill(lb[0], lb[0] + A, make_pair((0), (-1)));
for (int i = (0), I = (n); i < I; i++) {
cin >> a[i];
if (i)
for (int j = (0), I = (A); j < I; j++) lb[i][j] = lb[i - 1][j];
add(lb[i], make_pair((a[i]), (i)));
}
cin >> m;
for (int i = (0), I = (m); i < I; i++) {
int l, r, res = 0;
cin >> l >> r, --l, --r;
for (int j = (A)-1, I = (0) - 1; j > I; j--)
if (lb[r][j].second >= l) res = max(lb[r][j].first ^ res, res);
cout << res << '\n';
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s;
cin >> s;
unordered_map<char, int> m;
for (int i = 0; i < n; i++) {
m[s[i]]++;
}
string ans = "";
for (auto x : m) {
for (int i = 0; i < x.second; i++) {
ans += x.first;
}
}
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0)->sync_with_stdio(0);
long long t;
cin >> t;
while (t--) {
long long n, k;
cin >> n >> k;
long long a[n];
long long mx = -(int)1e9 - 1;
long long mn = (int)1e9 + 1;
for (long long i = 0; i < n; i++) {
long long u;
cin >> u;
a[i] = u;
mx = max(mx, u);
mn = min(mn, u);
}
for (long long i = 0; i < n; i++) a[i] = mx - a[i];
if (k % 2 == 1) {
for (long long i : a) cout << i << " ";
} else {
mx = -(int)1e9 + 1;
for (long long i = 0; i < n; i++) {
mx = max(mx, a[i]);
}
for (long long i : a) cout << mx - i << " ";
}
cout << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int x[4], y[4];
inline bool between(int a, int b, int c) {
return min(a, b) <= c && c <= max(a, b);
}
inline bool check(int i, int j, int k) {
return (x[k] == x[i] || x[k] == x[j]) && between(y[i], y[j], y[k]) ||
(y[k] == y[i] || y[k] == y[j]) && between(x[i], x[j], x[k]);
}
int main() {
int tt = 1;
while (tt--) {
for (int i = 1; i <= 3; i++) {
cin >> x[i] >> y[i];
}
if (x[1] == x[2] && x[2] == x[3] || y[1] == y[2] && y[2] == y[3]) {
cout << "1\n";
} else {
cout << ((check(1, 2, 3) || check(1, 3, 2) || check(2, 3, 1)) ? "2\n"
: "3\n");
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using lli = long long;
using ld = long double;
mt19937 rnd(time(nullptr));
void Count(set<lli>& buffer, lli k, lli r) {
for (lli x = 1;;) {
if (x <= r) buffer.insert(x);
if (x > r / k) break;
x *= k;
}
}
inline void Solve() {
lli l = 0, r = 0, k = 0;
cin >> l >> r >> k;
set<lli> first, second;
Count(first, k, l - 1);
Count(second, k, r);
vector<lli> result;
for (auto it : second)
if (first.count(it) == 0) result.push_back(it);
if (result.empty())
cout << -1;
else {
for (auto it : result) cout << it << ' ';
}
}
signed main() {
cout << fixed << setprecision(20);
Solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> rest;
vector<vector<long long>> a;
int main() {
long long N, M;
cin >> N >> M;
rest.resize(N);
a.resize(N);
for (long long i = 0; i < M; i++) {
long long v, t;
cin >> v >> t;
v--;
t--;
a[v].push_back(t);
}
for (long long i = 0; i < N; i++) {
sort(a[i].begin(), a[i].end(), [&](long long a, long long b) {
long long f = (a + N - i) % N;
long long s = (b + N - i) % N;
return f < s;
});
}
for (long long i = 0; i < N; i++) {
if (a[i].empty()) {
rest[i] = 0;
} else {
long long r = (a[i][0] + N - i) % N;
rest[i] = (a[i].size() - 1) * N + r;
}
}
for (long long i = 0; i < N; i++) {
long long res = 0;
for (long long j = 0; j < N; j++) {
if (rest[j]) {
res = max(rest[j] + (j - i + N) % N, res);
}
}
cout << res << " ";
}
cout << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool isPrime(long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
int main() {
int n, k, c = 0;
cin >> n >> k;
vector<int> v;
int a;
for (int i = 0; i < n; i++) {
cin >> a;
v.push_back(a);
}
sort(v.begin(), v.end());
for (int i = 0; i < n; i++) {
if (v[i] + k <= 5) c++;
}
cout << c / 3;
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int n, m;
cin >> n >> m;
int i, j, a[n][m], mn = INT_MAX, z = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
cin >> a[i][j];
if (a[i][j] == 1) z++;
}
}
int x = 0, y = 0, k = 0, l = 0, c = 0;
cin >> x >> y;
for (i = 0; i <= n - x; i++) {
for (j = 0; j <= m - y; j++) {
for (k = i; k < i + x; k++) {
for (l = j; l < j + y; l++) {
if (a[k][l] == 1) c++;
}
}
mn = min(mn, c);
c = 0;
}
}
c = 0;
if (x != y) {
swap(x, y);
for (i = 0; i <= n - x; i++) {
for (j = 0; j <= m - y; j++) {
for (k = i; k < i + x; k++) {
for (l = j; l < j + y; l++) {
if (a[k][l] == 1) c++;
}
}
mn = min(mn, c);
c = 0;
}
}
}
if (mn != INT_MAX)
cout << mn;
else
cout << z;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m, sz[1000001], h[1000001], cnt[1000001], ans[1000001];
vector<int> a[1000001], vec[1000001];
vector<pair<int, int>> query[1000001];
set<pair<int, int>> s;
void get_sz(int u, int p) {
sz[u] = 1;
for (auto v : a[u])
if (v != p) {
h[v] = h[u] + 1;
get_sz(v, u);
sz[u] += sz[v];
}
}
void update(int u) {
s.erase({-cnt[h[u]], h[u]});
cnt[h[u]]++;
s.insert({-cnt[h[u]], h[u]});
}
void dfs(int u, int p, bool keep) {
int big_sz = -1, big_child = -1;
for (auto v : a[u])
if (v != p && big_sz < sz[v]) {
big_sz = sz[v];
big_child = v;
}
for (auto v : a[u])
if (v != p && v != big_child) dfs(v, u, false);
if (big_child != -1) {
dfs(big_child, u, true);
swap(vec[u], vec[big_child]);
}
vec[u].push_back(u);
update(u);
for (auto v : a[u])
if (v != p && v != big_child)
for (auto x : vec[v]) {
vec[u].push_back(x);
update(x);
}
ans[u] = s.begin()->second - h[u];
if (!keep) {
for (auto v : vec[u]) cnt[h[v]] = 0;
s.clear();
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n - 1; i++) {
int x, y;
scanf("%d%d", &x, &y);
a[x].push_back(y);
a[y].push_back(x);
}
memset(cnt, 0, sizeof(cnt));
h[1] = 0;
get_sz(1, 0);
dfs(1, 0, true);
for (int i = 1; i <= n; i++) printf("%d\n", ans[i]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T gcd(T a, T b) {
if (a == 0) return b;
return gcd(b % a, a);
}
template <typename T>
T pow(T a, T b, long long m) {
T ans = 1;
while (b > 0) {
if (b % 2 == 1) ans = (ans * a) % m;
b /= 2;
a = (a * a) % m;
}
return ans % m;
}
int m;
map<long long, long long> m1;
map<pair<long long, long long>, long long> m2;
int cnt;
long long p;
long long a[100005], b[100005];
long long fac(long long x) {
long long ans = 1;
while (x > 0) {
if (cnt > 0 && x % 2 == 0) {
p = x / 2;
ans *= p;
cnt--;
} else
ans *= x;
ans %= m;
x--;
}
return ans % m;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n;
cin >> n;
long long res = 1;
for (int i = 0; i < n; i++) {
cin >> a[i];
m2[make_pair(a[i], i + 1)]++;
m1[a[i]]++;
}
for (int i = 0; i < n; i++) {
cin >> b[i];
m2[make_pair(b[i], i + 1)]++;
if (m2[make_pair(b[i], i + 1)] == 2) cnt++;
m1[b[i]]++;
}
cin >> m;
for (map<long long, long long>::iterator it = m1.begin(); it != m1.end();
it++) {
res = (res * fac(it->second)) % m;
}
cout << res;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T POW(T B, T P) {
if (P == 0) return 1;
if (P & 1)
return B * POW(B, P - 1);
else
return SQR(POW(B, P / 2));
}
template <typename T>
inline T ModInv(T b, T m) {
return BigMod(b, m - 2, m);
}
template <typename T>
inline T ABS(T a) {
if (a < 0)
return -a;
else
return a;
}
template <typename T>
inline T gcd(T a, T b) {
if (a < 0) return gcd(-a, b);
if (b < 0) return gcd(a, -b);
return (b == 0) ? a : gcd(b, a % b);
}
template <typename T>
inline T lcm(T a, T b) {
if (a < 0) return lcm(-a, b);
if (b < 0) return lcm(a, -b);
return a * (b / gcd(a, b));
}
template <class T>
inline T BMOD(T p, T e, T m) {
T ret = 1;
while (e) {
if (e & 1) ret = (ret * p) % m;
p = (p * p) % m;
e >>= 1;
}
return (T)ret;
}
int n, m, arr[300005], mp[300005], cs[100005], ex[300005];
int ok(int x) {
if (x == 0) return 0;
if (x > n) return 1;
memset(mp, 0, sizeof mp);
int free = 0;
int cnt = 0;
for (int i = x; i >= 1; i--) {
if ((arr[i] == 0 || mp[arr[i]] == 1) && free == 0) {
} else if ((arr[i] == 0 || mp[arr[i]] == 1) && free)
free--;
else {
free += ex[arr[i]];
mp[arr[i]] = 1;
cnt++;
}
}
if (free || cnt < m)
return 0;
else
return 1;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &arr[i]);
}
for (int i = 1; i <= m; i++) {
scanf("%d", &ex[i]);
}
int lo = 1, hi = n + n, mid, ans = n + n + n;
while (lo <= hi) {
mid = (lo + hi) / 2;
if (ok(mid) == 1) {
hi = mid - 1;
ans = min(ans, mid);
} else
lo = mid + 1;
}
if (ans > n) ans = -1;
printf("%d", ans), puts("");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int i = 2, j = 1;
long long cnt = 0;
while (n > 0) {
if ((n - 1) >= 0 && j % 2 != 0) {
n--;
cnt++;
} else if ((n - 2) >= 0 && j % 2 == 0) {
n -= 2;
cnt++;
} else
break;
j++;
}
cout << cnt << endl;
}
| 0 |
#include <bits/stdc++.h>
int main() {
char c;
std::set<char> s;
while (std::cin >> c) {
if ((c >= 'a') && (c <= 'z')) {
s.insert(c);
}
}
std::cout << s.size() << '\n';
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long fpow(long long a, int b, int mod) {
long long res = 1;
for (; b > 0; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res % mod;
}
const int mod = 1e9 + 7;
const int INF = 0x3f3f3f3f;
const int N = 1e5 + 100;
inline int read() {
static char buf[1000000], *p1 = buf, *p2 = buf;
register int x = false;
register char ch =
p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1000000, stdin), p1 == p2)
? EOF
: *p1++;
;
register bool sgn = false;
while (ch != '-' && (ch < '0' || ch > '9'))
ch = p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1000000, stdin), p1 == p2)
? EOF
: *p1++;
;
if (ch == '-')
sgn = true,
ch = p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1000000, stdin), p1 == p2)
? EOF
: *p1++;
;
while (ch >= '0' && ch <= '9')
x = (x << 1) + (x << 3) + (ch ^ 48),
ch = p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1000000, stdin), p1 == p2)
? EOF
: *p1++;
;
return sgn ? -x : x;
}
int a[N];
set<int> s;
int main() {
int t;
cin >> t;
while (t--) {
int a, b;
cin >> a >> b;
if (a > 2 * b || b > 2 * a) {
cout << "NO" << endl;
continue;
};
if (a == 2 * b || b == 2 * a) {
cout << "YES" << endl;
continue;
};
if ((2 * a - b) % 3 == 0)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
long long sum, ans, fac[1000010], Inv[1000010], f[1000010];
long long power(long long a, int b, long long res = 1) {
for (; b; b >>= 1, a = a * a % 1000000007)
if (b & 1) res = res * a % 1000000007;
return res;
}
long long P(int n, int m) { return fac[n] * Inv[n - m] % 1000000007; }
int main() {
scanf("%d%d", &n, &k);
fac[0] = 1ll;
for (int i = 1; i <= n; i++) fac[i] = 1ll * fac[i - 1] * i % 1000000007;
Inv[n] = power(fac[n], 1000000007 - 2);
for (int i = n; i; i--) Inv[i - 1] = Inv[i] * i % 1000000007;
for (int i = k + 2; i <= n; i++) {
sum = (sum + f[i - 1] * Inv[i - 2] % 1000000007) % 1000000007;
sum = (sum - f[i - k - 1] * Inv[i - k - 2] % 1000000007 + 1000000007) %
1000000007;
f[i] = ((i - k - 1) * fac[i - 2] % 1000000007 +
fac[i - 2] * sum % 1000000007) %
1000000007;
ans = (ans + P(n - 1, n - i) * f[i] % 1000000007) % 1000000007;
}
printf("%lld\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
int i, j, k;
int n, m, q;
vector<int> v;
cin >> n >> k;
m = n / k;
bool used[100] = {};
int a[100];
for (i = (int)(0); i < (int)(n); i++) cin >> a[i];
cin >> q;
for (i = (int)(0); i < (int)(q); i++) {
bool b = false;
int ys[100], t = 0;
for (j = (int)(0); j < (int)(m); j++) cin >> ys[j], ys[j]--;
for (j = (int)(0); j < (int)(m); j++) {
b = used[ys[j]];
used[ys[j]] = true;
t += a[ys[j]];
}
if (!b) v.push_back(t);
}
if (v.size() < k) {
vector<int> ys;
for (i = (int)(0); i < (int)(n); i++)
if (!used[i]) ys.push_back(a[i]);
sort(ys.begin(), ys.end());
int s = 0, t = 0;
for (i = (int)(0); i < (int)(m); i++)
s += ys[i], t += ys[ys.size() - 1 - i];
v.push_back(s);
v.push_back(t);
}
sort(v.begin(), v.end());
double dv = m;
printf("%.10f %.10f\n", v[0] / dv, v[v.size() - 1] / dv);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int l[10], d;
memset(l, 0, sizeof(l));
for (int i = 1; i <= 6; i++) {
scanf("%d", &d);
l[d]++;
}
int state = 0;
for (int i = 1; i <= 9; i++)
if (l[i] >= 4) {
state = i;
break;
}
if (state == 0)
puts("Alien");
else {
l[state] -= 4;
int tmp1 = 0, tmp2 = 0;
for (int i = 1; i <= 9; i++)
if (l[i]) {
tmp1 = i;
l[i]--;
break;
}
for (int i = 1; i <= 9; i++)
if (l[i]) {
tmp2 = i;
l[i]--;
break;
}
if (tmp1 == tmp2)
puts("Elephant");
else
puts("Bear");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
vector<int> L;
int P[1000005];
int sol(int i, int j) {
int ans = 0;
for (int p = (i); p < (j + 1); p++) {
int cnt =
min(n - k, p + k) - p - L.size() - ((L.size() and L[0] == p) ? 0 : 1);
ans += P[cnt];
ans = ans % 1000000007;
}
return ans;
}
int main() {
int m, u, v;
cin >> n >> m >> k;
k++;
int pos = 1;
for (int i = (0); i < (m); i++) {
scanf("%d %d", &u, &v);
if (v - u != 1) {
if (v - u == k) {
L.push_back(u - 1);
} else
pos = 0;
}
}
if (pos == 0) {
cout << "0" << endl;
return 0;
}
sort((L).begin(), (L).end());
P[0] = 1;
for (int i = (0); i < (1000000); i++) P[i + 1] = (2 * P[i]) % 1000000007;
if (L.size() == 0) {
cout << (sol(0, n - k - 1) + 1) % 1000000007 << endl;
return 0;
} else {
int fin = L[0];
int ini = max(0, L[L.size() - 1] - (k - 1));
cout << sol(ini, fin) << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> adj[200005];
bool vis[200005] = {false};
long long val[200005];
long long pos[200005];
long long total = 0;
vector<long long> ans, ans1;
void dfs(long long s) {
vis[s] = true;
long long i;
for (i = 0; i < adj[s].size(); i++) {
if (!vis[adj[s][i]]) dfs(adj[s][i]);
}
ans.push_back(s);
}
int main() {
long long n, i;
cin >> n;
map<long long, long long> mpp;
for (i = 1; i <= n; i++) cin >> val[i];
for (i = 1; i <= n; i++) {
cin >> pos[i];
if (pos[i] != -1) {
adj[i].push_back(pos[i]);
mpp[i] = pos[i];
}
}
for (i = 1; i <= n; i++)
if (!vis[i]) dfs(i);
for (i = ans.size() - 1; i >= 0; i--) {
if (val[ans[i]] > 0) {
if (mpp.count(ans[i])) val[mpp[ans[i]]] += val[ans[i]];
ans1.push_back(ans[i]);
}
total += val[ans[i]];
}
for (i = 0; i < ans.size(); i++)
if (val[ans[i]] <= 0) ans1.push_back(ans[i]);
cout << total << "\n";
for (i = 0; i < ans1.size(); i++) cout << ans1[i] << " ";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1e9 + 7;
bool rev(pair<long long int, long long int> &a,
pair<long long int, long long int> &b) {
return a.first < b.first || (a.first == b.first && a.second > b.second);
}
const long long int maxn = 1000 + 5, inf = 1e18;
void test() {
long long int c1, c2, c3, c4;
cin >> c1 >> c2 >> c3 >> c4;
long long int n, m;
cin >> n >> m;
long long int a[n];
long long int b[m];
for (long long int i = 0; i < n; ++i) cin >> a[i];
for (long long int i = 0; i < m; ++i) cin >> b[i];
long long int bs = inf, k = 0;
for (long long int i = 0; i < n; ++i) k += min(c1 * a[i], c2);
bs = min(bs, min(k, c3));
long long int tr = inf;
k = 0;
for (long long int i = 0; i < m; ++i) k += min(c1 * b[i], c2);
tr = min(tr, min(k, c3));
cout << min(bs + tr, c4) << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t = 1;
while (t--) test();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
struct vec {
int x, y, i;
vec(int _x = 0, int _y = 0) : x(_x), y(_y), i(0) {}
vec operator+(const vec& o) const { return vec(x + o.x, y + o.y); }
vec operator+=(const vec& o) {
x += o.x;
y += o.y;
return *this;
}
vec operator-() const { return vec(-x, -y); }
vec operator-(const vec& o) const { return *this + (-o); }
vec operator-=(const vec& o) {
x -= o.x;
y -= o.y;
return *this;
}
};
const long long TARGET = 1.5e6 * 1.5e6;
long long abs(const vec& v) {
return (long long)v.x * v.x + (long long)v.y * v.y;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<vec> vecs(n);
for (int i = 0; i < n; i++) {
cin >> vecs[i].x >> vecs[i].y;
vecs[i].i = i;
}
vector<int> ans(n);
while (1) {
shuffle(vecs.begin(), vecs.end(),
mt19937(chrono::system_clock::now().time_since_epoch().count()));
vec result;
for (const auto& v : vecs) {
if (abs(result + v) < abs(result - v)) {
result += v;
ans[v.i] = 1;
} else {
result -= v;
ans[v.i] = -1;
}
}
if (abs(result) <= TARGET) {
for (int i : ans) {
cout << i << " ";
}
cout << '\n';
return 0;
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
const double pi = acos(-1);
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, a, b, arr1[100005], arr2[100005];
cin >> n >> a >> b;
for (int i = 0; i < n; i++) cin >> arr1[i];
for (int i = 0; i < n; i++) cin >> arr2[i];
for (int i = 0; i < n; i++) {
if (i < a - 1 || i > b - 1) {
if (arr1[i] != arr2[i]) return cout << "LIE" << endl, 0;
}
}
cout << "TRUTH" << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline void Fail() {
printf("0");
exit(0);
}
const int maxn = 55;
int n, m, s1, s2, g1, g2;
int dis[maxn][maxn], slow[maxn], fast[maxn], sum[maxn][maxn * 1000];
long long ans;
long long dp[maxn][maxn][maxn];
int main() {
scanf("%d%d", &n, &m);
for (int(i) = 0; (i) < n; i++)
for (int(j) = 0; (j) < n; j++)
if (i != j) dis[i][j] = 1e9;
for (int(i) = 0; (i) < m; i++) {
int u, v, c;
scanf("%d%d%d", &u, &v, &c);
u--;
v--;
dis[u][v] = dis[v][u] = c;
}
scanf("%d%d%d%d", &g1, &g2, &s1, &s2);
for (int(k) = 0; (k) < n; k++)
for (int(i) = 0; (i) < n; i++)
for (int(j) = 0; (j) < n; j++)
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
for (int(i) = 0; (i) < n; i++) {
slow[i] = 0;
fast[i] = 1e9;
for (int(j) = 0; (j) < n; j++)
if (i != j) {
slow[i] = max(slow[i], dis[i][j]);
fast[i] = min(fast[i], dis[i][j]);
sum[i][dis[i][j]] = 1;
}
for (int(j) = 1; (j) <= n * 1000; j++) sum[i][j] += sum[i][j - 1];
}
for (int(i) = 0; (i) < n; i++)
for (int(j) = 0; (j) < n; j++) {
if (i == j) continue;
int gold = fast[i], bronze = slow[j];
if (gold > bronze || gold == bronze && i > j) continue;
memset(dp, 0, sizeof(dp));
dp[0][0][0] = 1;
for (int(k) = 0; (k) < n; k++)
for (int(g) = 0; (g) < n + 1; g++)
for (int(s) = 0; (s) < n + 1; s++) {
long long cur = dp[k][g][s];
if (!cur) continue;
if (k == i || k == j) {
dp[k + 1][g][s] = cur;
continue;
}
if (fast[k] < gold || fast[k] == gold && k < i)
dp[k + 1][g + 1][s] += cur;
if (sum[k][bronze - 1] - sum[k][gold] > 0 ||
sum[k][gold] - sum[k][gold - 1] > 0 && k > i &&
(gold != bronze || k < j) ||
sum[k][bronze] - sum[k][bronze - 1] > 0 && k < j &&
(gold != bronze || k > i))
dp[k + 1][g][s + 1] += cur;
if (slow[k] > bronze || slow[k] == bronze && k > j)
dp[k + 1][g][s] += cur;
}
for (int g = g1 - 1; g <= g2 - 1; g++)
for (int s = s1; s <= s2; s++) ans += dp[n][g][s];
}
printf("%I64d", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int begin, end, next;
} edge[100010 * 2], edge1[100010 * 2];
int cnt, Head[2010], cnt1, Head1[2010], DFN[2010], LOW[2010], STACK[2010], n, m,
belong[2010], degree[2010], SCC, top, SIZE, from[2010], dis[2010], pp, gs;
bool INSTACK[2010], tag[2010], vis[2010], bj[2010];
int read() {
int s = 0, fh = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') fh = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
s = s * 10 + (ch - '0');
ch = getchar();
}
return s * fh;
}
void addedge(int bb, int ee) {
edge[++cnt].begin = bb;
edge[cnt].end = ee;
edge[cnt].next = Head[bb];
Head[bb] = cnt;
}
void addedge1(int bb, int ee) {
addedge(bb, ee);
addedge(ee, bb);
}
void Addedge(int bb, int ee) {
edge1[++cnt1].begin = bb;
edge1[cnt1].end = ee;
edge1[cnt1].next = Head1[bb];
Head1[bb] = cnt1;
}
void Addedge1(int bb, int ee) {
Addedge(bb, ee);
Addedge(ee, bb);
}
void Tarjan(int u, int Last) {
int i, v;
DFN[u] = LOW[u] = ++SIZE;
STACK[top++] = u;
INSTACK[u] = true;
for (i = Head[u]; i != -1; i = edge[i].next) {
v = edge[i].end;
if (i == (Last ^ 1)) continue;
if (!DFN[v]) {
Tarjan(v, i);
LOW[u] = min(LOW[u], LOW[v]);
} else if (INSTACK[v] == true)
LOW[u] = min(LOW[u], DFN[v]);
}
if (DFN[u] == LOW[u]) {
SCC++;
do {
v = STACK[--top];
INSTACK[v] = false;
belong[v] = SCC;
} while (u != v);
}
}
void Solve() {
for (int i = 1; i <= n; i++)
if (!DFN[i]) Tarjan(i, 0);
}
void dfs(int u, int fa) {
int i, v;
from[u] = fa;
vis[u] = true;
if (degree[u] == 1) {
gs++;
bj[u] = true;
}
if (dis[u] > dis[pp]) pp = u;
for (i = Head1[u]; i != -1; i = edge1[i].next) {
v = edge1[i].end;
if (v == fa) continue;
dis[v] = dis[u] + 1;
dfs(v, u);
}
}
int main() {
int i, u, v, tot, Block, p1, p2, j;
n = read();
m = read();
memset(Head, -1, sizeof(Head));
cnt = 1;
for (i = 1; i <= m; i++) {
u = read();
v = read();
addedge1(u, v);
}
Solve();
memset(Head1, -1, sizeof(Head1));
cnt1 = 1;
memset(degree, 0, sizeof(degree));
for (i = 2; i <= cnt; i += 2) {
if (belong[edge[i].begin] != belong[edge[i].end]) {
Addedge1(belong[edge[i].begin], belong[edge[i].end]);
degree[belong[edge[i].begin]]++;
degree[belong[edge[i].end]]++;
}
}
memset(vis, false, sizeof(vis));
tot = 0;
Block = 0;
for (i = 1; i <= SCC; i++) {
if (vis[i] == false) {
Block++;
gs = 0;
pp = 0;
memset(dis, 0, sizeof(dis));
p1 = 0;
memset(from, 0, sizeof(from));
dfs(i, 0);
p1 = pp;
gs = 0;
pp = 0;
memset(dis, 0, sizeof(dis));
p2 = 0;
memset(from, 0, sizeof(from));
memset(bj, false, sizeof(bj));
dfs(p1, 0);
p2 = pp;
memset(tag, false, sizeof(tag));
j = p2;
while (1) {
tag[j] = true;
tot++;
if (bj[j] == true) tot--;
j = from[j];
if (j == 0) break;
}
tot += gs;
}
}
printf("%d", n - (tot - (Block - 1)));
fclose(stdin);
fclose(stdout);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T Max(T a, T b) {
return a > b ? a : b;
}
template <class T>
T Min(T a, T b) {
return a < b ? a : b;
}
bool stb(const string &a, const string &b) { return a.size() < b.size(); }
bool bts(const string &a, const string &b) { return a.size() > b.size(); }
bool pas(const pair<int, int> &a, const pair<int, int> &b) {
return a.second < b.second;
}
int A[12][12];
int check(int i, int j, int p, int l) {
int sum = 0;
for (int k = i; k <= p; k++)
for (int u = j; u <= l; u++)
if (A[k][u] == 1) sum++;
return sum;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int r, c, n, k, x, y, sum = 0;
memset(A, 0, sizeof(A));
cin >> r >> c >> n >> k;
for (int i = 0; i < n; i++) {
cin >> x >> y;
A[x - 1][y - 1] = 1;
}
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
for (int p = i; p < r; p++) {
for (int l = j; l < c; l++) {
if (check(i, j, p, l) >= k) sum++;
}
}
}
}
cout << sum;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#include <unordered_set>
#define PI 3.14159265359
#define fn(i,n) for(int i=0;i<n;i++)
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
#define speed ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
using namespace std;
void solve(){
int n ;
cin>>n;
if(n/2020-n%2020<0) cout<<"NO\n";
else cout<<"YES\n";
}
int main()
{
speed;
int t ;
cin>>t;
while(t--)
solve();
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int P = 998244353;
const int N = 1e5 + 5;
const double PI = acos(-1);
mt19937 rng(time(0));
int T, n, a, b, x, y, len;
int dep[N], maxd[N], fa[N], upa[N], upb[N];
vector<int> g[N];
struct dat {
array<int, 4> a;
void ins(int x) {
int i;
for (i = 2; i >= 0 && x > a[i]; i--) a[i + 1] = a[i];
a[++i] = x;
}
void print(int i) {
cout << i << " " << a[0] << " " << a[1] << " " << a[2] << endl;
}
} dp[N];
void calD(int x, int fa) {
for (auto u : g[x])
if (u != fa) {
calD(u, x);
dp[x].ins(dp[u].a[0] + 1);
}
}
void calU(int x, int fa, int d) {
if (x == b) len = d;
for (auto u : g[x])
if (u != fa) {
if (dp[u].a[0] + 1 != dp[x].a[0])
dp[u].ins(dp[x].a[0] + 1);
else
dp[u].ins(dp[x].a[1] + 1);
calU(u, x, d + 1);
}
}
void dfs(int x, int fa_) {
maxd[x] = dep[x] = dep[fa_] + 1;
fa[x] = fa_;
for (auto u : g[x])
if (u != fa_) {
dfs(u, x);
maxd[x] = max(maxd[x], maxd[u]);
}
}
int main() {
cin >> T;
while (T--) {
scanf("%d%d%d", &n, &a, &b);
for (int i = (1); i <= (n); ++i) g[i].clear(), dp[i].a.fill(0);
for (int i = (1); i <= (n - 1); ++i) {
scanf("%d%d", &x, &y);
g[x].push_back(y), g[y].push_back(x);
}
calD(a, 0), calU(a, 0, 1);
int rt = 0;
for (int i = (1); i <= (n); ++i)
if (dp[i].a[2] >= len - 1) rt = i;
if (!rt) {
printf("NO\n");
continue;
}
dep[0] = 0, dfs(rt, 0);
int na = 0, nb = 0, idSame = 1;
while (a) upa[++na] = a, a = fa[a];
a = upa[1], reverse(upa + 1, upa + na + 1);
while (b) upb[++nb] = b, b = fa[b];
b = upb[1], reverse(upb + 1, upb + nb + 1);
while (upa[idSame] == upb[idSame]) idSame++;
idSame--;
int da = dep[a], db = dep[b], lastb = b;
while (1) {
da -= maxd[b] - db, db = maxd[b], a = upa[da];
if (da <= idSame) break;
db -= maxd[a] - da, da = maxd[a], b = upb[db];
if (db <= idSame) break;
if (lastb == b) break;
lastb = b;
}
cout << (min(da, db) > idSame ? "NO\n" : "YES\n");
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int nodes[2050], depth, score = 0;
int abs(int a) {
if (a > 0) return a;
return -a;
}
int max(int a, int b) {
if (a > b) return a;
return b;
}
int dfs(int d, int i, int total) {
if (d == depth) return nodes[i];
int r = dfs(d + 1, i * 2, 0);
int l = dfs(d + 1, i * 2 + 1, 0);
score += abs(r - l);
return max(r, l) + nodes[i];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> depth;
for (size_t i = 2; i < pow(2, depth + 1); i++) cin >> nodes[i];
dfs(0, 1, 0);
cout << score;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int tc = 0; tc < t; tc++) {
long long n, m, a, b, c;
cin >> n >> m >> a >> b >> c;
vector<vector<long long> > g(n + 5);
vector<long long> cost;
cost.push_back(0);
for (long long i = 0; i < m; i++) {
long long x;
cin >> x;
cost.push_back(x);
}
sort(cost.begin(), cost.end());
for (long long i = 1; i <= m; i++) {
cost[i] = cost[i] + cost[i - 1];
}
for (long long i = 0; i < m; i++) {
long long u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
long long dist[n + 3][4];
dist[a][0] = 0;
dist[b][1] = 0;
dist[c][2] = 0;
queue<long long> q1;
vector<long long> vis1(n + 3, 0);
q1.push(a);
vis1[a] = 1;
while (!q1.empty()) {
long long u = q1.front();
q1.pop();
for (long long i = 0; i < g[u].size(); i++) {
long long v = g[u][i];
if (vis1[v] == 0) {
vis1[v] = 1;
q1.push(v);
dist[v][0] = dist[u][0] + 1;
}
}
}
queue<long long> q2;
vector<long long> vis2(n + 3, 0);
q2.push(b);
vis2[b] = 1;
while (!q2.empty()) {
long long u = q2.front();
q2.pop();
for (long long i = 0; i < g[u].size(); i++) {
long long v = g[u][i];
if (vis2[v] == 0) {
vis2[v] = 1;
q2.push(v);
dist[v][1] = dist[u][1] + 1;
}
}
}
queue<long long> q3;
vector<long long> vis3(n + 3, 0);
q3.push(c);
vis3[c] = 1;
while (!q3.empty()) {
long long u = q3.front();
q3.pop();
for (long long i = 0; i < g[u].size(); i++) {
long long v = g[u][i];
if (vis3[v] == 0) {
vis3[v] = 1;
q3.push(v);
dist[v][2] = dist[u][2] + 1;
}
}
}
long long ans = 5e18;
for (long long i = 1; i <= n; i++) {
if (dist[i][0] + dist[i][1] + dist[i][2] <= m) {
long long x = dist[i][1];
long long y = dist[i][0] + dist[i][1] + dist[i][2];
ans = min(ans, cost[x] + cost[y]);
}
}
cout << ans << '\n';
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string t, sb, se;
cin >> t >> sb >> se;
int x[3000] = {0}, y[3000] = {0};
for (int i = 0; i < t.size(); ++i) {
if (t.substr(i, sb.size()) == sb) x[i] = 1;
if (t.substr(i, se.size()) == se) y[i + se.size() - 1] = 1;
}
unordered_set<long long> st;
for (int i = 0; i < t.size(); ++i) {
if (x[i]) {
long long hash = 0;
for (int j = i; j < t.size(); ++j) {
hash = 2019 * hash + t[j];
if (y[j] and j - i + 1 >= max(se.size(), sb.size())) st.insert(hash);
}
}
}
cout << st.size() << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int mod1 = 998244353;
const int mod2 = 1313131;
const int mod = 1e9 + 7;
const int inf = 2e9;
const int maxn = 1e6 + 10;
int pre[maxn], suf[maxn];
char s[maxn], t[maxn];
int main() {
scanf("%s%s", s + 1, t + 1);
int lens = strlen(s + 1);
int lent = strlen(t + 1);
int j = 1;
for (int i = 1; i <= lens; i++) {
if (j <= lent && s[i] == t[j]) {
j++;
}
pre[i] = j - 1;
}
j = lent;
for (int i = lens; i >= 1; i--) {
if (j >= 1 && s[i] == t[j]) {
j--;
}
suf[i] = j + 1;
}
suf[lens + 1] = 1e9;
int l = 1, r = 1;
int mx = 0;
while (l <= r && r <= lens + 1) {
if (pre[l - 1] + 1 >= suf[r] || pre[l - 1] >= lent || suf[r] == 1) {
mx = max(mx, r - l);
r++;
} else
l++;
}
printf("%d\n", mx);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 555;
int n, m, a[N];
void enter() {
cin >> n >> m;
for (int i = (1), _b = (n); i <= _b; ++i) {
cin >> a[i];
}
}
void process() {
long double ans = 0;
int u, v, w;
for (int i = (1), _b = (m); i <= _b; ++i) {
cin >> u >> v >> w;
ans = max(ans, (long double)(a[u] + a[v]) / w);
}
cout << (fixed) << setprecision(9);
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
enter();
process();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int i;
int a[1000009];
for (i = 1; i <= n; i++) cin >> a[i];
int temp = n;
int cnt = 1;
cout << "1 ";
int now = 1;
vector<int> mark(n + 2, 0);
for (i = 1; i <= n; i++) {
if (a[i] == temp) {
int j = temp;
int vv = -1;
mark[a[i]] = 1;
while (mark[j] == 1) {
j--;
vv++;
}
temp = j;
now = now - vv;
cout << now << " ";
} else {
mark[a[i]] = 1;
now++;
cout << now << " ";
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
ostream& operator<<(ostream& Stream, const vector<T>& Vec) {
for (const T& i : Vec) Stream << i << " ";
return Stream;
}
template <typename A, typename B>
ostream& operator<<(ostream& Stream, const pair<A, B>& Pair) {
return Stream << Pair.first << ' ' << Pair.second;
}
template <typename A, typename B, typename C>
ostream& operator<<(ostream& Stream, const tuple<A, B, C>& T) {
return Stream << get<0>(T) << ' ' << get<1>(T) << ' ' << get<2>(T);
}
const int N = 200002;
void solve() {
int n, k;
cin >> n >> k;
vector<vector<pair<int, int>>> begin(N);
vector<vector<int>> end(N);
vector<bool> vis(N, false);
for (int i = 0; i < n; ++i) {
int l, r;
cin >> l >> r;
begin[l].push_back({r, i + 1});
end[r].push_back(i + 1);
}
priority_queue<pair<int, int>> pq;
set<int> cur;
vector<int> answer;
for (int i = 1; i < N; ++i) {
for (auto& p : begin[i]) {
pq.push(p);
cur.insert(p.second);
}
while (int(cur.size()) > k) {
auto p = pq.top();
pq.pop();
if (vis[p.second]) continue;
if (cur.find(p.second) != cur.end()) {
cur.erase(p.second);
answer.emplace_back(p.second);
}
}
for (auto& x : end[i]) {
vis[x] = true;
if (cur.find(x) != cur.end()) cur.erase(x);
}
}
cout << answer.size() << '\n' << answer;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cout.precision(10);
cout << fixed;
int t = 1;
while (t--) solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = (1 << 18);
int p[N];
int s[N];
int init(int n) {
iota(p, p + n, 0);
fill(s, s + n, 1);
return 1;
}
int lead(int x) { return p[x] == x ? x : p[x] = lead(p[x]); }
int join(int x, int y) {
x = lead(x);
y = lead(y);
if (x == y) return 0;
if (s[x] < s[y]) swap(x, y);
p[y] = x;
s[x] += s[y];
return 1;
}
int arr[N];
pair<int, int> opt[N][2];
pair<int, pair<int, int> > best[N];
void upd(int x, pair<int, int> F) {
if (opt[x][0] < F && F.second != opt[x][1].second) opt[x][0] = F;
if (opt[x][1] < opt[x][0]) swap(opt[x][0], opt[x][1]);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
long long ans = 0;
for (int i = 0; i < n; ++i) {
cin >> arr[i];
ans -= arr[i];
}
init(++n);
int numTrees = n;
while (numTrees > 1) {
for (int i = 0; i < N; ++i)
opt[i][0] = pair<int, int>(-1, -1), opt[i][1] = pair<int, int>(-1, -1);
for (int i = 0; i < n; ++i)
upd(arr[i], pair<int, int>(arr[i], lead(i))),
best[i] = pair<int, pair<int, int> >(-1, pair<int, int>(i, i));
for (int i = 0; i < 18; ++i)
for (int j = 0; j < N; ++j)
if (j >> i & 1)
upd(j, opt[j ^ (1 << i)][0]), upd(j, opt[j ^ (1 << i)][1]);
for (int i = 0; i < n; ++i) {
int x = (1 << 18) - 1 - arr[i];
pair<int, int> F = pair<int, int>(-1, -1);
if (opt[x][1].second != lead(i))
F = opt[x][1];
else
F = opt[x][0];
if (F.second >= 0) {
int nxt = arr[i] + F.first;
pair<int, pair<int, int> >& val = best[lead(i)];
if (val.first < nxt) {
val.first = nxt;
val.second = pair<int, int>(i, F.second);
}
}
}
for (int i = 0; i < n; ++i) {
int u = best[i].second.first;
int v = best[i].second.second;
if (join(u, v)) ans += best[i].first, numTrees--;
}
}
cout << ans << endl;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int modulo = (119 << 23) + 1;
const int maxn = 3e5 + 1;
int test() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
double h, l;
cin >> h >> l;
double ans = (h * h - l * l) / (-2 * h);
cout << setprecision(8) << ans;
return 0;
}
int solve(int tmp[], int a, int b, int n) {
int cnt = 0;
int div = tmp[b] - tmp[a];
int now = 2;
for (int i = b + 1; i < n; i++) {
if (tmp[i] == tmp[a] + div * now) {
cnt++, now++;
}
}
return cnt;
}
static int search(int num, int b[], int n) {
for (int i = 0; i < n; i++) {
if (b[i] == num) {
i + 1;
return 0;
}
}
return 1;
}
int donot() { return 0; }
int hack() { return 1; }
string me() {
const char* s = "do not hack me";
return s;
}
class havenoidea {
int ameaninglessnum = 49935;
bool iamanaduit = 1;
public:
int iwillsolvefiveproblems(int x) { return x; }
};
int main() {
if (hack()) donot();
int tmp[6] = {1, 1, 4, 5, 1, 4};
solve(tmp, search(114514, tmp, 6), 1, 6);
int a, b, c, d;
havenoidea fuck;
fuck.iwillsolvefiveproblems(hack());
test();
if (me() == "do not fack me")
if (me() == "do not hack me") hack() == donot();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
unordered_map<string, int> lucky;
vector<string> luck;
int main() {
luck.push_back("4");
luck.push_back("7");
int start = 0;
while ((*(luck.end() - 1)).size() < 10) {
int length = luck.size();
for (int i = start; i < length; i++) {
luck.push_back(luck[i] + '4');
luck.push_back(luck[i] + '7');
start++;
}
}
string s;
cin >> s;
int place = 0;
while (luck[place] != s) {
place++;
}
cout << place + 1;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " =: " << a << "\n";
err(++it, args...);
}
template <typename T1, typename T2>
inline std::ostream& operator<<(std::ostream& os, const std::pair<T1, T2>& p) {
return os << "(" << p.first << ": " << p.second << ")";
}
template <typename T>
inline std::ostream& operator<<(std::ostream& os, const std::vector<T>& v) {
bool first = true;
os << "[";
for (unsigned int i = 0; i < v.size(); i++) {
if (!first) os << ", ";
os << v[i];
first = false;
}
return os << "]";
}
template <typename T>
inline std::ostream& operator<<(std::ostream& os, const std::set<T>& v) {
bool first = true;
os << "{";
for (typename std::set<T>::const_iterator ii = v.begin(); ii != v.end();
++ii) {
if (!first) os << ", ";
os << *ii;
first = false;
}
return os << "}";
}
template <typename T1, typename T2>
inline std::ostream& operator<<(std::ostream& os, const std::map<T1, T2>& v) {
bool first = true;
os << "{";
for (typename std::map<T1, T2>::const_iterator ii = v.begin(); ii != v.end();
++ii) {
if (!first) os << ", ";
os << *ii;
first = false;
}
return os << "}";
}
template <typename T>
inline std::ostream& operator<<(std::ostream& os,
const std::unordered_set<T>& v) {
return os << std::set<T>(v.begin(), v.end());
}
template <typename T1, typename T2>
inline std::ostream& operator<<(std::ostream& os,
const std::unordered_map<T1, T2>& v) {
return os << std::map<T1, T2>(v.begin(), v.end());
}
const long long int MOD = 1e9 + 7;
const long long int INF = 1e18;
const double E = 1e-6;
long long int mpow(long long int base, long long int ex, long long int MOD) {
long long int res = 1LL;
while (ex > 0) {
if (ex & 1) res = (base * res) % MOD;
base = (base * base) % MOD;
ex >>= 1;
}
return res;
}
long long int mul(long long int a, long long int b) { return a * b % MOD; }
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
int a, b, n;
cin >> a >> b >> n;
char ca = '0' + a, cb = '0' + b;
long long int ans = 0;
vector<long long int> fac(n + 1), ifac(n + 1);
fac[0] = 1LL;
for (long long int i = 1; i <= n; ++i) fac[i] = (i * fac[i - 1]) % MOD;
ifac[n] = mpow(fac[n], MOD - 2, MOD);
for (long long int i = n; i > 0; --i) ifac[i - 1] = (i * ifac[i]) % MOD;
for (long long int i = 0; i <= n; ++i) assert((fac[i] * ifac[i]) % MOD == 1);
for (int cnta = 0; cnta <= n; cnta++) {
int sum = a * cnta + b * (n - cnta);
bool ok = true;
for (char c : to_string(sum))
if (c != ca && c != cb) {
ok = false;
break;
}
if (ok) {
ans += mul(mul(fac[n], ifac[cnta]), ifac[n - cnta]);
ans %= MOD;
}
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
bool odd = 0;
if (n & 1) {
n--;
odd = 1;
}
long long mn, mx;
if (n) {
mn = n / 2;
mx = 500000000;
long long cur = 500000000 - 1;
long long nn = n;
while (nn -= 2 > 0) {
mx += cur;
cur--;
}
}
if (n == 0 && k == 0) {
cout << 1;
} else if (n == 0 && k) {
cout << -1;
} else if (k < mn || k > mx) {
cout << -1;
} else {
long long cur = 500000000;
vector<long long> num;
while (k > cur) {
num.push_back(cur * 2);
num.push_back(cur);
k -= cur;
cur--;
}
num.push_back(k * 2);
num.push_back(k);
long long rem = (n - (int)num.size()) / 2;
num[(int)num.size() - 1] -= rem;
num[(int)num.size() - 2] -= (rem * 2);
cur = 500000000 + 1;
while (rem > 0) {
num.push_back(cur);
num.push_back(cur + 2);
cur += 4;
rem--;
}
if (odd) {
num.push_back(999999999);
}
for (int i = 0; i < (int)num.size(); i++) {
cout << num[i] << " ";
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int arr[1000005];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &arr[i]);
stack<pair<double, int> > st;
for (int i = n - 1; i >= 0; i--) {
pair<long long, int> cur(arr[i], 1);
while (!st.empty() &&
cur.first * st.top().second >= st.top().first * cur.second) {
cur.first += st.top().first;
cur.second += st.top().second;
st.pop();
}
st.push(cur);
}
while (!st.empty()) {
auto cur = st.top();
st.pop();
for (int i = 0; i < cur.second; i++)
printf("%.12lf\n", 1.0 * cur.first / cur.second);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void print(vector<int> &a) {
for (int i = 0; i < a.size(); i++) {
cout << a[i] << " ";
}
}
bool safe(int x, int y, int n, int m, vector<vector<bool>> &v) {
if (x >= 0 && y >= 0 && x < n && y < m && v[x][y] == 0) return true;
return false;
}
int sumof(int n) {
int ans = 0;
while (n) {
int temp = n % 10;
ans += temp;
n /= 10;
}
return ans;
}
void solve() {
long long k;
cin >> k;
double chk = (double)sqrt(k);
if (chk == (int)chk) {
cout << chk << " " << 1 << "\n";
return;
}
long long n = (long long)chk + 1;
if ((long long)n * (n - 1) + 1ll == k) {
cout << n << " " << n << "\n";
return;
} else {
long long corner = (long long)n * (n - 1) + 1ll;
if (k > corner) {
long long diff = k - corner;
cout << n << " " << n - diff << "\n";
} else {
long long diff = corner - k;
cout << n - diff << " " << n << "\n";
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin >> s;
long long int len = s.length();
long long int u = 0, d = 0, r = 0, l = 0;
for (long long int i = 0; i < len; i++) {
if (s[i] == 'U')
u++;
else if (s[i] == 'D')
d++;
else if (s[i] == 'L')
l++;
else
r++;
}
long long int ans = (abs(u - d));
ans += (abs(l - r));
if (ans % 2 == 1) {
cout << "-1" << endl;
} else {
cout << ans / 2 << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
array<array<int, 5>, 5> identidade() {
array<array<int, 5>, 5> arr;
for (int i = 0; i < 5; i++)
for (int j = 0; j < 5; j++) arr[i][j] = 100000000, arr[i][i] = 0;
return arr;
}
array<array<int, 5>, 5> get(char c) {
array<array<int, 5>, 5> arr = identidade();
if (c == '2') arr[0][0] = 1, arr[0][1] = 0;
if (c == '0') arr[1][1] = 1, arr[1][2] = 0;
if (c == '1') arr[2][2] = 1, arr[2][3] = 0;
if (c == '7') arr[3][3] = 1, arr[3][4] = 0;
if (c == '6') arr[4][4] = 1, arr[3][3] = 1;
return arr;
}
array<array<int, 5>, 5> merge(array<array<int, 5>, 5> a,
array<array<int, 5>, 5> b) {
array<array<int, 5>, 5> arr;
for (int i = 0; i < 5; i++)
for (int j = 0; j < 5; j++) arr[i][j] = 100000000;
for (int i = 0; i < 5; i++)
for (int j = 0; j < 5; j++)
for (int k = 0; k < 5; k++)
arr[i][j] = min({arr[i][j], a[i][k] + b[k][j], 100000000});
return arr;
}
array<array<int, 5>, 5> tree[4 * 200005];
char s[200005];
void build(int node, int a, int b) {
if (a == b) {
tree[node] = get(s[a]);
} else {
build(node * 2, a, (a + b) / 2);
build(node * 2 + 1, (a + b) / 2 + 1, b);
tree[node] = merge(tree[node * 2], tree[node * 2 + 1]);
}
}
array<array<int, 5>, 5> query(int node, int a, int b, int i, int j) {
if (j < a || i > b) return identidade();
if (a >= i && b <= j) return tree[node];
array<array<int, 5>, 5> l = query(node * 2, a, (a + b) / 2, i, j);
array<array<int, 5>, 5> r = query(node * 2 + 1, (a + b) / 2 + 1, b, i, j);
return merge(l, r);
}
int main() {
int n, q;
scanf("%d %d", &n, &q);
scanf("%s", s);
build(1, 0, n - 1);
while (q--) {
int a, b;
scanf("%d %d", &a, &b);
a--, b--;
array<array<int, 5>, 5> node = query(1, 0, n - 1, a, b);
printf("%d\n", node[0][4] == 100000000 ? -1 : node[0][4]);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 110;
int N, M;
bool mark[MAX][2];
int dp[MAX][MAX][3][3];
int solve(int l, int r, int ml, int mr) {
if (l > r) return 0;
int &ret = dp[l][r][ml][mr];
if (ret != -1) return ret;
vector<int> g;
for (int i = l; i <= r; ++i)
for (int j = 0; j < 2; ++j) {
if (mark[i][j]) continue;
if (i == l && ml && ((ml & (1 << j)) == 0)) continue;
if (i == r && mr && ((mr & (1 << j)) == 0)) continue;
g.push_back(solve(l, i - 1, ml, 1 << j) ^ solve(i + 1, r, 1 << j, mr));
}
sort(g.begin(), g.end());
g.resize(unique(g.begin(), g.end()) - g.begin());
ret = 0;
while (ret < (int)g.size() && ret == g[ret]) ++ret;
return ret;
}
int main() {
int r, c;
scanf("%d%d", &N, &M);
for (int i = 0; i < M; ++i) {
scanf("%d%d", &r, &c), --c;
mark[r][c] = true;
mark[r][1 ^ c] = true;
mark[r - 1][1 ^ c] = true;
mark[r + 1][1 ^ c] = true;
}
memset(dp, -1, sizeof dp);
if (solve(1, N, 0, 0))
puts("WIN");
else
puts("LOSE");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
set<pair<int, pair<int, int> > > se;
int L[200005], R[200005], id[200005 * 10];
int n, m;
pair<int, pair<int, int> > find(int l, int r) {
if (l == 0 && r == n + 1) return make_pair(-(1 << 30), make_pair(1, r));
if (l == 0) return make_pair(-r + 1, make_pair(1, r));
if (r == n + 1) return make_pair(l - n, make_pair(n, r));
return make_pair((l - r) / 2, make_pair((r + l) / 2, r));
}
void solve() {
int i, j, k, l, r;
pair<int, int> p;
L[n + 1] = 0;
R[0] = n + 1;
se.insert(make_pair(-(1 << 30), make_pair(1, n + 1)));
while (m--) {
scanf("%d%d", &i, &j);
if (i == 1) {
p = se.begin()->second;
se.erase(se.begin());
k = p.first;
r = p.second;
l = L[r];
R[l] = k;
L[r] = k;
L[k] = l;
R[k] = r;
se.erase(find(l, r));
se.insert(find(l, k));
se.insert(find(k, r));
printf("%d\n", k);
id[j] = k;
} else {
k = id[j];
l = L[k];
r = R[k];
R[l] = r;
L[r] = l;
se.erase(find(l, k));
se.erase(find(k, r));
se.insert(find(l, r));
}
}
}
int main() {
scanf("%d%d", &n, &m);
solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, q, a, b, x, box, evenrow, oddrow, evenr, oddr;
cin >> n >> q;
while (q--) {
cin >> a >> b;
if (n % 2 == 0) {
x = n / 2;
box = ((a - 1) * x);
if ((a + b) % 2 == 0) {
if (a % 2 == 0)
box = box + (b / 2) - 1;
else
box = box + (b / 2);
cout << box + 1 << endl;
} else {
if (a % 2 == 0)
box = box + (b / 2);
else
box = box + (b / 2) - 1;
cout << box + 1 + (n * n) / 2 << endl;
}
} else {
evenrow = ((2 + a) / 2) - 1;
oddrow = ((1 + a) / 2) - 1;
evenr = (n + 1) / 2;
oddr = n / 2;
if ((a + b) % 2 == 0) {
box = (evenrow * evenr) + (oddrow * oddr);
if (a % 2 == 0)
box = box + (b / 2) - 1;
else
box = box + (b / 2);
cout << box + 1 << endl;
} else {
box = (evenrow * oddr) + (oddrow * evenr);
if (a % 2 == 0)
box = box + (b / 2);
else
box = box + (b / 2) - 1;
cout << box + (((n * n) + 1) / 2) + 1 << endl;
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int INF = 1e9 + 10;
const long long BINF = 1e18 + 10;
int n;
struct rect {
int x, y, x2, y2;
rect(){};
rect(int _x, int _y, int _x2, int _y2) : x(_x), y(_y), x2(_x2), y2(_y2){};
};
const int MX = 400010;
int dx1[MX], dx2[MX], dy1[MX], dy2[MX];
int iter = 0;
int T = 500, ptr = 0;
vector<rect> have[10010];
int mem = 400010 * 4 + 10010 * 100;
bool cmp(int a, int b) { return (int)have[a].size() > (int)have[b].size(); }
mt19937 rnd(228);
const int MEM = 3.4e7;
bool rec(int ind) {
if ((int)have[ind].size() <= 1) {
return true;
}
if (mem >= MEM) {
cout << "NO";
exit(0);
}
iter++;
if (iter > T || ptr >= 1000) {
cout << "YES";
exit(0);
}
int mnx = INF, mny = INF, mxx = -INF, mxy = -INF;
for (auto it : have[ind]) {
mnx = min(mnx, it.x);
mxx = max(mxx, it.x2);
mny = min(mny, it.y);
mxy = max(mxy, it.y2);
}
for (int i = mnx; i <= mxx; i++) {
dx1[i] = dx2[i] = 0;
}
for (int i = mny; i <= mxy; i++) {
dy1[i] = dy2[i] = 0;
}
for (auto it : have[ind]) {
dx1[it.x]++;
dx2[it.x2]++;
dy1[it.y]++;
dy2[it.y2]++;
}
int pl = 0, sum = 0;
vector<int> okx;
for (int i = mnx; i <= mxx; i++) {
sum -= dx2[i];
if (sum == 0 && dx2[i] != 0 && pl > 0 && pl < (int)have[ind].size()) {
okx.push_back(i);
mem += 4;
}
sum += dx1[i];
pl += dx1[i];
}
if (!okx.empty()) {
for (auto it : have[ind]) {
have[ptr +
int(lower_bound((okx).begin(), (okx).end(), it.x2) - okx.begin())]
.push_back(it);
}
mem += (int)have[ind].size();
ptr += (int)okx.size() + 1;
vector<int> order;
for (int i = 0; i < (int)okx.size() + 1; i++) {
order.push_back(ptr - i - 1);
mem += 4;
}
sort((order).begin(), (order).end(), cmp);
for (int ind : order) {
if (!rec(ind)) {
return false;
}
if (mem >= MEM) {
cout << "NO";
exit(0);
}
}
return true;
}
vector<int> oky;
mem += 100;
pl = 0;
sum = 0;
for (int i = mny; i <= mxy; i++) {
sum -= dy2[i];
if (sum == 0 && dy2[i] != 0 && pl > 0 && pl < (int)have[ind].size()) {
oky.push_back(i);
mem += 4;
}
sum += dy1[i];
pl += dy1[i];
}
if (!oky.empty()) {
for (auto it : have[ind]) {
have[ptr +
int(lower_bound((oky).begin(), (oky).end(), it.y2) - oky.begin())]
.push_back(it);
}
mem += (int)have[ind].size();
ptr += (int)oky.size() + 1;
vector<int> order;
for (int i = 0; i < (int)oky.size() + 1; i++) {
order.push_back(ptr - i - 1);
}
sort((order).begin(), (order).end(), cmp);
for (int ind : order) {
if (!rec(ind)) {
return false;
}
if (mem >= MEM) {
cout << "NO";
exit(0);
}
}
return true;
}
return false;
}
void source() {
cin >> n;
if (n == 100000) T = 300;
vector<int> srt;
for (int i = 0; i < n; i++) {
int a, b, c, d;
cin >> a >> b >> c >> d;
have[0].push_back(rect(a, b, c, d));
srt.push_back(a);
srt.push_back(b);
srt.push_back(c);
srt.push_back(d);
}
sort((srt).begin(), (srt).end());
srt.resize(unique((srt).begin(), (srt).end()) - srt.begin());
unordered_map<int, int> to;
for (int i = 0; i < (int)srt.size(); i++) {
to[srt[i]] = i;
}
for (auto &it : have[0]) {
it.x = to[it.x];
it.x2 = to[it.x2];
it.y = to[it.y];
it.y2 = to[it.y2];
}
ptr = 1;
cout << (rec(0) ? "YES" : "NO");
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
source();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
vector<int> graph[100005], topoSort;
int processor[100005], dp[100005];
bool visited[100005];
void dfs(int vertex) {
int i;
for (i = 0; i < graph[vertex].size(); i++) {
int temp = graph[vertex][i];
if (visited[temp] == false) {
visited[temp] = true;
dfs(temp);
topoSort.push_back(temp);
}
}
return;
}
int main() {
int i, j, t, n, m, k, l, r, temp, mini, maxi, flag, cnt, ans = 0;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) scanf("%d", &processor[i]);
for (i = 1; i <= m; i++) {
scanf("%d%d", &l, &r);
graph[l + 1].push_back(r + 1);
}
for (i = 1; i <= n; i++) {
if (visited[i] == false) {
visited[i] = true;
dfs(i);
topoSort.push_back(i);
}
}
for (k = 0; k < n; k++) {
i = topoSort[k];
if (processor[i] == 0) {
maxi = 0;
for (j = 0; j < graph[i].size(); j++) maxi = max(maxi, dp[graph[i][j]]);
} else {
maxi = 1;
for (j = 0; j < graph[i].size(); j++) {
temp = graph[i][j];
maxi = max(maxi, dp[temp] + (processor[temp] == 0));
}
}
dp[i] = maxi;
ans = max(ans, dp[i]);
}
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
if (360 % (180 - x) == 0)
cout << "YES\n";
else
cout << "NO\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 505;
int n, m, b, mod;
int w[maxn];
int dp[maxn][maxn];
int main() {
scanf("%d%d%d%d", &n, &m, &b, &mod);
for (int i = 1; i <= n; ++i) scanf("%d", &w[i]);
dp[0][0] = 1;
for (int i = 1; i <= n; ++i) {
for (int j = 0; j <= m; ++j) {
for (int k = 0; k <= b; ++k) {
if (0 == j)
dp[j][k] = 1;
else if (k - w[i] >= 0)
dp[j][k] = (dp[j][k] + dp[j - 1][k - w[i]]) % mod;
}
}
}
printf("%d\n", dp[m][b]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, c, a, h;
cin >> n >> c >> a >> h;
string s;
cin >> s;
int sum = 0;
if (c == a) {
cout << (n * c) << endl;
} else {
if (abs(c - a) > h) {
if (c < a) {
for (int i = 0; i < s.length(); i++) {
if (s[i] == '0')
sum = sum + c;
else
sum = sum + c + h;
}
} else {
for (int i = 0; i < s.length(); i++) {
if (s[i] == '1')
sum = sum + a;
else
sum = sum + a + h;
}
}
cout << sum << endl;
} else {
for (int i = 0; i < s.length(); i++) {
if (s[i] == '0')
sum = sum + c;
else
sum = sum + a;
}
cout << sum << endl;
}
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long in[100010], add[100010];
long long get_ans(int n, int d, int m) {
int sum0 = 0, sum1 = 0;
long long ans = 0;
for (int i = 1; i <= n; i++) {
if (in[i] <= m)
sum0++;
else if (in[i] > m)
sum1++;
}
long long ss = in[n];
ans = add[sum0];
for (int i = 1; i <= sum1; i++) {
if (sum1 - i >= d * (i - 1)) {
long long store = add[sum0] + ss;
ans = max(ans, store);
} else if (sum1 - i < d * (i - 1)) {
if (d * (i - 1) <= n - i) {
int pos = d * (i - 1) - (sum1 - i);
long long store = add[sum0] - add[pos];
store += ss;
ans = max(ans, store);
} else
break;
}
ss += in[n - i];
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
int n, d, m;
cin >> n >> d >> m;
for (int i = 1; i <= n; i++) {
cin >> in[i];
}
sort(in + 1, in + n + 1);
for (int i = 1; i <= n; i++) add[i] = add[i - 1] + in[i];
long long ans = get_ans(n, d, m);
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void pv(T a, T b) {
for (T i = a; i != b; ++i) cerr << *i << ' ';
cerr << endl;
}
bool cmp(const pair<int, int>& a, const pair<int, int>& b) {
if (a.second != b.second) return a.second < b.second;
return a.first < b.first;
}
int main() {
int N;
cin >> N;
vector<pair<int, int> > v(N);
for (int i = 0; i < (int)(N); ++i) {
int x, y;
scanf("%d%d", &x, &y);
if (x > y) swap(x, y);
v[i].first = x;
v[i].second = y;
}
sort((v).begin(), (v).end(), cmp);
int last = v[0].first - 10;
vector<int> ans;
for (int i = 0; i < N; i++) {
if (last < v[i].first) {
ans.push_back(v[i].second);
last = v[i].second;
}
}
cout << ans.size() << endl;
cout << ans[0];
for (int i = 1; i < (int)ans.size(); i++) cout << " " << ans[i];
cout << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[100001], pos[100001], neg[100001], pos_num, neg_num, pp_n;
bool pp[100001];
int main() {
int i, j, k, n, m;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (a[i] > 0) {
pos[a[i]]++;
pos_num++;
} else {
neg[-a[i]]++;
neg_num++;
}
}
for (i = 1; i <= n; i++) {
int tmp = pos[i] + neg_num - neg[i];
if (tmp == m) {
pp_n++;
pp[i] = 1;
}
}
for (i = 1; i <= n; i++) {
if (a[i] > 0) {
if (pp[a[i]]) {
if (pp_n == 1)
puts("Truth");
else
puts("Not defined");
} else
puts("Lie");
} else {
if (!pp[-a[i]]) {
puts("Truth");
} else {
if (pp_n == 1)
puts("Lie");
else
puts("Not defined");
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n, x, y;
cin >> n >> x >> y;
int a[n], mex = 1;
bool b[n];
bool me[n + 2];
memset(b, false, n);
memset(me, false, n + 2);
for (auto &i : a) cin >> i, me[i] = true;
while (me[mex]) mex++;
vector<int> v[n + 2];
for (int i = 0; i < n; i++) v[a[i]].push_back(i);
priority_queue<pair<int, int>> q;
for (int i = 1; i <= n + 1; i++)
if (v[i].size()) q.push(make_pair(v[i].size(), i));
for (int i = 0; i < x; i++) {
auto p = q.top();
q.pop(), b[v[p.second].back()] = true, v[p.second].pop_back(),
q.push(make_pair(p.first - 1, p.second));
}
int m = 1;
for (int i = 2; i <= n + 1; i++)
if (v[i].size() > v[m].size()) m = i;
int k[n - x], l[n], c = 0, w = 0;
for (int i = 1; i <= n + 1; i++)
for (auto j : v[i]) k[c++] = j;
for (int i = 0; i < c; i++) l[k[i]] = k[(i + c / 2) % c];
int d[n];
for (int i = 0; i < n; i++) d[i] = a[i];
for (int i = 0; i < n; i++)
if (!b[i])
if (d[i] == a[l[i]])
d[i] = mex;
else {
d[i] = a[l[i]];
w++;
}
if (w < y - x)
cout << "NO\n";
else {
for (int i = 0; w > y - x; i++)
if (!b[i] && d[i] != mex) d[i] = mex, w--;
cout << "YES\n";
for (auto i : d) cout << i << " ";
cout << "\n";
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long int n, k;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t;
t = 1;
while (t--) {
scanf("%lld %lld", &n, &k);
long long int l = 1, r = n;
while (l != r) {
long long int mid = (l + r) / 2;
long long int v = mid, sum = 0;
while (v) {
sum += v;
v /= k;
}
if (sum >= n)
r = mid;
else
l = mid + 1;
}
printf("%lld\n", l);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using vi = vector<int>;
using pi = pair<int, int>;
using ll = long long int;
template <typename T1, typename T2, typename T3>
T1 modpow(T1 _a, T2 p, T3 mod) {
assert(p >= 0);
ll ret = 1, a = _a;
if (a < 0) {
a %= mod;
a += mod;
}
if (a >= mod) {
a %= mod;
}
for (; p > 0; p /= 2) {
if (p & 1) ret = ret * a % mod;
a = a * a % mod;
}
return ret;
}
constexpr int dx[] = {-1, 0, 1, 0, 1, 1, -1, -1};
constexpr int dy[] = {0, -1, 0, 1, 1, -1, 1, -1};
constexpr auto PI = 3.14159265358979323846L;
constexpr auto oo = numeric_limits<int>::max() / 2 - 2;
constexpr auto eps = 1e-6;
constexpr auto mod = 1000000007;
constexpr int mx = 500005;
string name[mx];
int nxt[256], n;
int dp[256];
int main() {
std::ios::sync_with_stdio(false);
cin >> n;
for (int i = ((0)), _i = ((n)-1); i <= _i; ++i) cin >> name[i];
int ans = 0;
for (int c = ('a'), _c = ('z'); c <= _c; ++c) {
for (int i = ((0)), _i = ((256) - 1); i <= _i; ++i) dp[i] = -oo;
dp[c] = 0;
for (int i = n - 1; i >= 0; --i) {
char a = name[i].front(), b = name[i].back();
int len = (int((name[i]).size()));
dp[a] = max(dp[a], len + dp[b]);
}
ans = max(ans, dp[c]);
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
int num[maxn];
char a[maxn];
char s[maxn];
bool flag[maxn];
int st[maxn];
int top;
int main() {
int n, k;
int i, j;
while (scanf("%s", a) != -1) {
memset(flag, 0, sizeof(flag));
top = -1;
n = strlen(a);
for (i = 0; i < n; i++) {
if (top != -1) {
if (a[st[top]] == '(' && a[i] == ')' ||
a[st[top]] == '[' && a[i] == ']') {
flag[st[top]] = true;
flag[i] = true;
top--;
continue;
}
}
st[++top] = i;
}
int ans = -1;
int l, r;
for (i = 0; i < n; i++)
if (flag[i]) {
int an = 0;
for (j = i; flag[j]; j++) {
if (a[j] == '[') an++;
}
if (an > ans) {
ans = an;
l = i;
r = j - 1;
}
i = j - 1;
}
if (ans == -1) {
printf("0\n");
continue;
}
printf("%d\n", ans);
for (i = l; i <= r; i++) {
printf("%c", a[i]);
}
puts("");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
int n, d1, d2, ans = 0;
struct th {
double pos;
bool type1;
int type2;
};
bool operator==(th x, th y) { return abs(x.pos - y.pos) < eps; }
vector<th> s;
struct pnt {
long long x, y;
pnt() {}
pnt(long long x, long long y) : x(x), y(y) {}
} a[100010], b[100010];
pnt operator+(pnt x, pnt y) { return pnt(x.x + y.x, x.y + y.y); }
pnt operator-(pnt x, pnt y) { return pnt(x.x - y.x, x.y - y.y); }
long long dis2(pnt x) { return x.x * x.x + x.y * x.y; }
long long operator*(pnt x, pnt y) { return x.x * y.x + x.y * y.y; }
struct dpnt {
double x, y;
dpnt(double x, double y) : x(x), y(y) {}
};
dpnt operator+(pnt x, dpnt y) { return dpnt(x.x + y.x, x.y + y.y); }
dpnt operator-(dpnt x, dpnt y) { return dpnt(x.x - y.x, x.y - y.y); }
dpnt operator*(pnt x, double y) { return dpnt(x.x * y, x.y * y); }
double dis2(dpnt x) { return x.x * x.x + x.y * x.y; }
int cmp(th x, th y) { return x.pos - y.pos < -eps; }
int main() {
scanf("%d%d%d", &n, &d1, &d2);
for (int i = 1; i <= n; i++) {
scanf("%lld%lld%lld%lld", &a[i].x, &a[i].y, &b[i].x, &b[i].y);
}
for (int i = 1; i < n; i++) {
pnt x = a[i] - b[i], y = (a[i + 1] - a[i]) - (b[i + 1] - b[i]);
long long dot = x * y, dx = dis2(x), dy = dis2(y);
if (dy) {
long long delta = dot * dot - dy * (dx - d1 * d1);
if (delta >= 0) {
long double hh = sqrtl((long double)delta);
long double t1 = (hh - dot) / dy;
if (t1 > -eps && t1 < 1 + eps) s.push_back((th){double(i + t1), 0, -2});
long double t2 = (-hh - dot) / dy;
if (t2 > -eps && t2 < 1 + eps) s.push_back((th){double(i + t2), 0, -2});
}
delta = dot * dot - dy * (dx - d2 * d2);
if (delta >= 0) {
long double hh = sqrtl((long double)delta);
long double t1 = (hh - dot) / dy;
if (t1 > -eps && t1 < 1 + eps) s.push_back((th){double(i + t1), 1, -2});
long double t2 = (-hh - dot) / dy;
if (t2 > -eps && t2 < 1 + eps) s.push_back((th){double(i + t2), 1, -2});
}
} else {
if (dx == d1 * d1) {
s.push_back((th){double(i), 0, 0});
s.push_back((th){double(i + 1), 0, -2});
} else if (dx == d2 * d2) {
s.push_back((th){double(i), 1, 0});
s.push_back((th){double(i + 1), 1, -2});
}
}
}
if (s.empty()) {
if (dis2(a[1] - b[1]) <= d1 * d1)
puts("1");
else
puts("0");
return 0;
}
sort(s.begin(), s.end(), cmp);
for (int i = 0; i < s.size() - 1; i++) {
if (s[i].pos == s[i + 1].pos) {
if (s[i].type2 == -2) s[i].type2 = s[i + 1].type2;
if (s[i + 1].type2 == -2) s[i + 1].type2 = s[i].type2;
}
}
s.erase(unique(s.begin(), s.end()), s.end());
for (int i = 0; i < s.size() - 1; i++) {
if (s[i].type2 == 0) continue;
double pos = (s[i].pos + s[i + 1].pos) / 2;
int base = lround(floor(pos));
dpnt x = a[base] + (a[base + 1] - a[base]) * (pos - base);
dpnt y = b[base] + (b[base + 1] - b[base]) * (pos - base);
double dis = dis2(x - y);
if (s[i].type1 == 0) {
if (dis - d1 * d1 < -eps)
s[i].type2 = -1;
else
s[i].type2 = 1;
} else {
if (dis - d2 * d2 < -eps)
s[i].type2 = -1;
else
s[i].type2 = 1;
}
}
bool tf = 1;
for (int i = 0; i < s.size(); i++) {
if (s[i].type1 == 0) {
if (tf) ans++;
tf = 0;
} else if (s[i].type1 == 1) {
if (s[i].type2 == 1) tf = 1;
}
}
printf("%d\n", ans);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long s[n + 10];
for (int i = 1; i <= n; i++) cin >> s[i];
sort(s + 1, s + 1 + n);
vector<long long> diff;
diff.clear();
for (int i = 2; i <= n; i++) diff.push_back(s[i] - s[i - 1]);
sort(diff.begin(), diff.end());
long long pref[n + 10];
for (int i = 0; i < (int)diff.size(); i++) {
if (i == 0)
pref[i] = diff[i];
else
pref[i] = pref[i - 1] + diff[i];
}
int q;
cin >> q;
for (int _q = 1; _q <= q; _q++) {
long long x, y;
cin >> x >> y;
long long d = y - x + 1;
int l = -1, r = (int)diff.size();
while (r - l > 1) {
int m = (l + r) / 2;
if (diff[m] > d)
r = m;
else
l = m;
}
long long ans = 0;
if (l != -1) ans += pref[l];
ans += d * (n - 1 - l);
cout << ans << " ";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = INT_MAX;
const long long INFL = LLONG_MAX;
const long double pi = acos(-1);
struct MYQUERY {
int l, r, i;
} QS[200100];
int N, Q, P[200100], L[200100], g[200100], mx[200100], mycost[200100],
ans[200100];
int f(int x) { return x == g[x] ? x : g[x] = f(g[x]); }
int cmp(MYQUERY q1, MYQUERY q2) { return q1.l < q2.l; }
int main() {
ios_base::sync_with_stdio(0);
cout.precision(15);
cout << fixed;
cout.tie(0);
cin.tie(0);
cin >> N;
for (int(i) = 1; (i) <= (N); (i)++) cin >> P[i] >> L[i], mx[i] = P[i] + L[i];
for (int(i) = 1; (i) <= (N + 1); (i)++) g[i] = i;
cin >> Q;
for (int(i) = 1; (i) <= (Q); (i)++) cin >> QS[i].l >> QS[i].r, QS[i].i = i;
sort(QS + 1, QS + Q + 1, cmp);
for (int i = Q, numadded = 0; i >= 1; i--) {
for (int nextToAdd; (nextToAdd = N - numadded) >= QS[i].l; numadded++) {
int rightEnd = P[nextToAdd] + L[nextToAdd];
for (int j = nextToAdd + 1, prev = nextToAdd;
j <= N && rightEnd >= P[j];) {
g[nextToAdd] = g[f(prev)] = g[f(j)];
if (mx[f(j)] < rightEnd) {
mx[f(j)] = rightEnd;
mycost[f(j)] = max(0, P[f(j) + 1] - rightEnd) + mycost[f(f(j) + 1)];
}
prev = j;
j = f(j) + 1;
}
if (nextToAdd < N && rightEnd < P[nextToAdd + 1])
mycost[nextToAdd] =
P[nextToAdd + 1] - rightEnd + mycost[f(nextToAdd + 1)];
}
ans[QS[i].i] = mycost[f(QS[i].l)] - mycost[f(QS[i].r)];
}
for (int(i) = 1; (i) <= (Q); (i)++) cout << ans[i] << '\n';
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353, g = 3, G = (mod + 1) / 3;
int n, k0, t0, t = 1, k, bk[300005], p[2400005];
long long a[2400005], b0[10], b[2400005], q[2400005], res[2400005];
int read() {
int x = 0, fl = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') fl = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return x * fl;
}
long long qpow(long long base, long long pw) {
long long s = 1;
while (pw) {
if (pw & 1) s = s * base % mod;
base = base * base % mod;
pw >>= 1;
}
return s;
}
void g_l(int x) {
t = 1, k = 0;
while (t <= x) t <<= 1, k++;
for (int i = 0; i < t; i++) p[i] = (p[i >> 1] >> 1) | ((i & 1) << (k - 1));
return;
}
void NTT(long long *a, int o) {
for (int i = 0; i < t; i++)
if (i < p[i]) swap(a[i], a[p[i]]);
for (int i = 1; i < t; i <<= 1) {
long long wn = qpow(o == 1 ? g : G, (mod - 1) / (i << 1));
for (int j = 0; j < t; j += (i << 1)) {
long long w = 1;
for (int k = 0; k < i; k++, w = w * wn % mod) {
long long p = a[j + k], q = a[j + k + i] * w % mod;
a[j + k] = (p + q) % mod, a[j + k + i] = (p - q + mod) % mod;
}
}
}
if (o == -1) {
long long div = qpow(t, mod - 2);
for (int i = 0; i < t; i++) a[i] = a[i] * div % mod;
}
return;
}
void calc(long long x) {
int t1 = 0, t2 = 0;
for (int i = 1; i <= x - 1; i++)
t1 += (bk[i] == 1), t2 += ((bk[i] >= 2) << 1);
memset(a, 0, sizeof(a)), memset(b, 0, sizeof(b));
a[0] = b[0] = 1;
for (int i = 1; i <= t1; i++)
a[i] = a[i - 1] * 2ll % mod * (long long)(t1 + 1 - i) % mod *
qpow(i, mod - 2) % mod;
for (int i = 1; i <= t2; i++)
b[i] = b[i - 1] * (long long)(t2 + 1 - i) % mod * qpow(i, mod - 2) % mod;
g_l(t1 + t2);
NTT(a, 1), NTT(b, 1);
for (int i = 0; i < t; i++) a[i] = a[i] * b[i] % mod;
NTT(a, -1);
for (int i = 1; i <= t0; i++)
if ((q[i] >> 1) - 1 >= x) res[i] = (res[i] + a[(q[i] >> 1) - 1 - x]) % mod;
return;
}
int main() {
n = read(), k0 = read();
for (int i = 1; i <= n; i++) {
int x = read();
bk[x]++;
}
for (int i = 1; i <= k0; i++) b0[i] = read();
t0 = read();
for (int i = 1; i <= t0; i++) q[i] = read();
for (int i = 1; i <= k0; i++) calc(b0[i]);
for (int i = 1; i <= t0; i++) printf("%lld\n", res[i]);
return 0;
}
| 8 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.