solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 105000;
int n, x;
int a[MAXN];
void solve() {
scanf("%d %d", &n, &x);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
int ans = 2e9;
for (int i = 0; i < n; i++) {
if (a[i] == x) {
ans = min(ans, 1);
} else {
int cur = max(2, (x + a[i] - 1) / a[i]);
ans = min(ans, cur);
}
}
printf("%d\n", ans);
}
int main() {
int tn;
scanf("%d\n", &tn);
while (tn--) {
solve();
}
return 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 100010;
const int MOD = 1000000007;
int n;
int dp[1010];
int to[1010];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &to[i]);
}
dp[0] = -1;
for (int i = 1; i <= n; i++) {
int x = to[i];
dp[i] = (1LL * dp[i - 1] + 1 + 1 + dp[i - 1] - dp[x - 1] + MOD) % MOD;
}
printf("%d\n", (dp[n] + 1) % MOD);
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double e = exp(1.0);
const double eps = 1e-8;
const int maxlen = 100005;
char str[maxlen];
bool compare(int x1, int y1, int x2, int y2);
int main() {
ios::sync_with_stdio(false);
while (~scanf("%s", str)) {
int len = strlen(str);
int ans = 0, end1 = len - 2, end2 = len - 1;
while (end2 >= 0) {
while (end1 >= 0 &&
(str[end1 + 1] == '0' || !compare(0, end1, end1 + 1, end2)))
end1--;
if (end1 == -1) break;
ans++;
end2 = end1;
end1--;
}
ans++;
printf("%d\n", ans);
}
return 0;
}
bool compare(int x1, int y1, int x2, int y2) {
int len1 = y1 - x1 + 1;
int len2 = y2 - x2 + 1;
if (len1 > len2) return 1;
if (len2 > len1) return 0;
for (int i = 0; i < len1; ++i) {
if (str[x1 + i] > str[x2 + i])
return 1;
else if (str[x1 + i] < str[x2 + i])
return 0;
}
return 1;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
const long long BITS = 20;
string ans[2] = {"Fou", "Shi"};
long long nextForBit[BITS];
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, q;
cin >> n >> q;
long long a[n];
for (long long i = 0; i < n; i++) cin >> a[i];
long long next[n + 1][BITS];
fill_n(nextForBit, BITS, n);
for (long long i = 0; i <= n; i++)
for (long long j = 0; j < BITS; j++) next[i][j] = n;
for (long long i = n - 1; i >= 0; i--) {
for (long long j = 0; j < BITS; j++) {
if (a[i] & (1 << j))
next[i][j] = i;
else {
for (long long k = 0; k < BITS; k++) {
if (a[i] & (1 << k))
next[i][j] = min(next[i][j], next[nextForBit[k]][j]);
}
}
}
for (long long j = 0; j < BITS; j++)
nextForBit[j] = min(nextForBit[j], next[i][j]);
}
while (q--) {
long long x, y;
cin >> x >> y;
x--;
y--;
bool fl = false;
for (long long j = 0; j < BITS; j++) {
if (a[y] & (1 << j)) fl |= (next[x][j] <= y);
}
cout << ans[fl] << "\n";
}
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void test(T a) {
cout << a << endl;
}
template <class T, class T2>
void test(T a, T2 b) {
cout << a << " " << b << endl;
}
template <class T, class T2, class T3>
void test(T a, T2 b, T3 c) {
cout << a << " " << b << " " << c << endl;
}
const int N = 2e6 + 10;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const double eps = 1e-15;
const long long mod = 1000000007;
bool isprime[N];
vector<int> prime;
void getprime() {
memset(isprime, 1, sizeof(isprime));
isprime[0] = isprime[1] = 0;
for (int i = 2; i <= (1e5); i++) {
if (isprime[i]) prime.push_back(i);
for (int j = 2 * i; j < 1e5; j += i) {
isprime[j] = 0;
}
}
}
set<int> ve[N];
map<long long, int> dp;
int cal(long long x) {
if (dp.find(x) != dp.end()) return dp[x];
if (!x) return x;
int vis[55] = {0};
int k = 0;
for (int i = 0; i < (40); i++) {
if (x & (1ll << i)) k = i;
}
for (int i = k; i >= 0; i--) {
long long y = (x >> i + 1) | (x & ((1ll << i) - 1));
vis[cal(y)] = 1;
}
for (int i = 0; i < (40); i++)
if (!vis[i]) return dp[x] = i;
}
void work() {
int n;
cin >> n;
int v;
map<int, int> Hash;
int idx = 0;
for (int i = 0; i < (n); i++) {
cin >> v;
for (int i = 0; i < ((int)prime.size()); i++) {
int cnt = 0;
if (prime[i] > v) break;
while (v % prime[i] == 0) {
cnt++;
v /= prime[i];
}
if (cnt) {
if (Hash.find(prime[i]) == Hash.end()) {
Hash[prime[i]] = idx++;
}
int id = Hash[prime[i]];
ve[id].insert(cnt);
}
}
if (v && v - 1) {
if (Hash.find(v) == Hash.end()) {
Hash[v] = idx++;
}
int id = Hash[v];
ve[id].insert(1);
}
}
map<int, int>::iterator it;
int ans = 0;
for (it = Hash.begin(); it != Hash.end(); it++) {
auto p = *it;
int id = p.second;
long long x = 0;
for (auto stit = ve[id].begin(); stit != ve[id].end(); stit++) {
int v = *stit;
x |= (1ll << (v - 1));
}
ans ^= cal(x);
}
if (ans)
test("Mojtaba");
else
test("Arpa");
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
getprime();
work();
}
| 14
|
#include <bits/stdc++.h>
const int MOD = 1000000007;
int n;
char sa[100010];
char sb[100010];
char temp[100010];
int rcd[100000][4];
long long dp(int t, int st) {
if (t == n) {
if (st == 3)
return 1;
else
return 0;
}
if (rcd[t][st] != -1) return rcd[t][st];
long long ret = 0;
if (sa[t] == '?' && sb[t] == '?') {
ret += dp(t + 1, st | 1) * 45;
ret += dp(t + 1, st | 2) * 45;
ret += dp(t + 1, st) * 10;
} else if (sa[t] == '?') {
int d = sb[t] - '0';
ret += dp(t + 1, st | 1) * (9 - d);
ret += dp(t + 1, st | 2) * d;
ret += dp(t + 1, st) * 1;
} else if (sb[t] == '?') {
int d = sa[t] - '0';
ret += dp(t + 1, st | 1) * d;
ret += dp(t + 1, st | 2) * (9 - d);
ret += dp(t + 1, st) * 1;
} else {
if (sa[t] > sb[t])
ret += dp(t + 1, st | 1) * 1;
else if (sa[t] < sb[t])
ret += dp(t + 1, st | 2) * 1;
else
ret += dp(t + 1, st) * 1;
}
return rcd[t][st] = ret % MOD;
}
int main() {
scanf("%d%s%s", &n, sa, sb);
for (int i = 0; i < n; i++) {
for (int j = 0; j <= 3; j++) {
rcd[i][j] = -1;
}
}
int ret = dp(0, 0);
printf("%d\n", ret);
}
| 12
|
#include <bits/stdc++.h>
const unsigned long long inf = 1LL << 61;
const double eps = 1e-5;
using namespace std;
bool cmp(int a, int b) { return a > b; }
int main() {
int n;
string s;
while (cin >> n) {
cin >> s;
for (int i = 1; i <= 510; i++) s += ".";
for (int len = 1; len <= n; len++) {
for (int i = 0; i < n; i++) {
if (s[i] == '*' && s[i + len] == '*' && s[i + 2 * len] == '*' &&
s[i + 3 * len] == '*' && s[i + 4 * len] == '*') {
puts("yes");
return 0;
}
}
}
puts("no");
}
return 0;
}
| 5
|
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
inline int read() {
char c = getchar();
int x = 0;
bool f = 0;
for (; !isdigit(c); c = getchar()) f ^= !(c ^ 45);
for (; isdigit(c); c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48);
if (f) x = -x;
return x;
}
int n, t, k, c;
int a[200005], sum[200005];
int u[200005], v[200005], tot;
inline int P(int i, int j) {
if (!i) return 0;
return sum[i - 1] + j;
}
inline void con(int x, int y) {
tot++;
u[tot] = x, v[tot] = y;
}
signed main() {
n = read(), t = read(), k = read(), c = n - k - t;
a[0] = sum[0] = 1;
for (register int i = (1); i <= (t); ++i)
a[i] = read(), sum[i] = sum[i - 1] + a[i];
for (register int i = (1); i <= (a[1]); ++i) con(1, P(1, i));
for (register int i = (2); i <= (t); ++i) con(P(i - 1, 1), P(i, 1));
for (register int i = (2); i <= (t); ++i)
for (register int j = (2); j <= (a[i]); ++j)
if (c && a[i - 1] >= j)
c--, con(P(i - 1, j), P(i, j));
else
con(P(i - 1, 1), P(i, j));
if (a[t] > k || c)
puts("-1");
else {
cout << n << endl;
for (register int i = (1); i <= (tot); ++i) printf("%d %d\n", u[i], v[i]);
}
return 0;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
int t;
int n, m;
int a_arr[101];
bool p_arr[101];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> t;
while (t--) {
cin >> n >> m;
memset(p_arr, false, sizeof(p_arr));
memset(a_arr, 0, sizeof(a_arr));
for (int i = 0; i < n; i++) {
cin >> a_arr[i];
}
for (int i = 0; i < m; i++) {
int tmp;
cin >> tmp;
p_arr[tmp - 1] = true;
}
for (int i = 0; i < n; i++) {
if (!p_arr[i]) continue;
int j;
for (j = i + 1; j < n; j++) {
if (!p_arr[j]) {
break;
}
}
sort(a_arr + i, a_arr + j + 1);
i = j;
}
int i;
for (i = 0; i < n - 1; i++) {
if (a_arr[i] > a_arr[i + 1]) {
cout << "NO\n";
break;
}
}
if (i == n - 1) cout << "YES\n";
}
return 0;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
const int modulo = 1077563119;
int Chromatic(const vector<int> &g) {
int n = g.size();
if (n == 0) return 0;
int all = 1 << n;
vector<int> a(all), s(all);
a[0] = 1;
for (int i = 1; i < all; i++) {
int j = __builtin_ctz(i);
a[i] = a[i - (1 << j)] + a[(i - (1 << j)) & ~g[j]];
if (a[i] >= modulo) a[i] -= modulo;
}
for (int i = 0; i < all; i++) {
s[i] = ((n - __builtin_popcount(i)) & 1 ? -1 : 1);
}
for (int k = 1; k < n; k++) {
long long sum = 0;
for (int i = 0; i < all; i++) {
long long cur = ((s[i] * (long long)a[i]) % modulo);
s[i] = (int)cur;
sum += cur;
}
if (sum % modulo != 0) return k;
}
return n;
}
int main() {
int n;
scanf("%d", &n);
vector<string> c(n);
vector<vector<bool>> reach(n, vector<bool>(n));
for (int i = 0; i < n; i++) cin >> c[i];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
reach[i][j] = (i == j || c[i][j] == 'A');
}
}
for (int k = 0; k < n; k++) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (reach[i][k] && reach[k][j]) {
reach[i][j] = true;
}
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (reach[i][j] && c[i][j] == 'X') {
return !printf("-1\n");
}
}
}
vector<int> idx(n, -1);
vector<bool> used(n, false);
int N = 0;
for (int i = 0; i < n; i++)
if (!used[i]) {
vector<int> v;
for (int j = 0; j < n; j++)
if (reach[i][j]) v.push_back(j);
if (v.size() >= 2) {
for (int j = 0; j < v.size(); j++) {
idx[v[j]] = N;
}
N++;
}
for (int j = 0; j < v.size(); j++) used[v[j]] = true;
}
vector<int> g(N);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (c[i][j] == 'X' && idx[i] != idx[j] && idx[i] >= 0 && idx[j] >= 0) {
g[idx[i]] |= 1 << idx[j];
}
}
}
int ans = n - 1 + Chromatic(g);
printf("%d\n", ans);
return 0;
}
| 23
|
#include <bits/stdc++.h>
using namespace std;
const int N = 11, P = 1e6 + 3;
int x[N], a[N][N], b[N];
inline int ksm(int a, int b) {
int c = 1;
while (b) {
if (b & 1) c = (long long)c * a % P;
a = (long long)a * a % P;
b >>= 1;
}
return c;
}
inline int f(int k) {
int ans = 0;
for (int i = 0; i < N; i++) {
ans += (long long)x[i] * ksm(k, i) % P;
if (ans >= P) ans -= P;
}
return ans;
}
inline void Gauss(int n) {
for (int i = 0; i < n; i++) {
int now = i;
for (int j = i + 1; j < n; j++)
if (a[j][i]) now = j;
if (!a[i][i] && now == i) {
puts("! -1");
return;
}
if (now != i) {
for (int j = 1; j < n; j++) swap(a[i][j], a[now][j]);
swap(b[i], b[now]);
}
for (int j = 0; j < n; j++) {
if (i == j) continue;
int rate = (long long)a[j][i] * ksm(a[i][i], P - 2) % P;
for (int k = i; k < n; k++) {
a[j][k] -= (long long)a[i][k] * rate % P;
if (a[j][k] < 0) a[j][k] += P;
}
b[j] -= (long long)b[i] * rate % P;
if (b[j] < 0) b[j] += P;
}
}
for (int i = 0; i < n; i++) x[i] = (long long)b[i] * ksm(a[i][i], P - 2) % P;
for (int i = 0; i < P; i++)
if (!f(i)) return cout << "! " << i << endl, void();
puts("! -1");
}
int main() {
for (int x = 0; x < N; x++) {
printf("? %d\n", x);
fflush(stdout);
scanf("%d", &b[x]);
int o = 1;
for (int i = 0; i < N; i++) a[x][i] = o, o = (long long)o * x % P;
}
Gauss(N);
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1LL << 61;
const long long mod = 1000000007;
int main() {
std::ios::sync_with_stdio(false);
int n;
cin >> n;
if (n % 10 == 0)
cout << n << endl;
else {
int a = n / 10 * 10;
int b = a + 10;
if (b - n < n - a)
cout << b << endl;
else
cout << a << endl;
}
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int m[N];
int c[N];
int n;
int x1, x2;
vector<pair<long long, long long> > v;
int main() {
scanf("%d", &n);
scanf("%d %d", &x1, &x2);
for (int i = 1; i <= n; ++i) {
scanf("%d %d", m + i, c + i);
}
for (int i = 1; i <= n; ++i) {
v.emplace_back(make_pair(1LL * m[i] * x1 + c[i], 1LL * m[i] * x2 + c[i]));
}
sort(v.begin(), v.end());
long long best = -1e15;
for (auto it : v) {
if (best > it.second) {
printf("YES");
return 0;
}
best = max(best, it.second);
}
printf("NO");
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
string s;
cin >> s;
int n = s.length();
int q;
cin >> q;
set<int> m[26];
for (int i = 0; i < n; i++) {
m[s[i] - 'a'].insert(i + 1);
}
while (q--) {
int x;
cin >> x;
if (x == 1) {
int pos;
char c;
cin >> pos >> c;
char t = s[pos - 1];
if (t != c) {
m[t - 'a'].erase(pos);
m[c - 'a'].insert(pos);
s[pos - 1] = c;
}
} else {
int l, r;
cin >> l >> r;
int c = 0;
for (int i = 0; i < 26; i++) {
auto it = m[i].lower_bound(l);
if (it != m[i].end()) {
int a = *it;
if (a <= r) c++;
}
}
cout << c << endl;
}
}
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
double solve(double v0, double a, double d, double vm, double vl) {
double tt = (vl - v0) / a;
double dd = (v0 + vl) * tt / 2;
if (dd >= d) {
return (-v0 + sqrt(v0 * v0 + 2 * a * d)) / a;
} else {
double ttt = (vm - vl) / a;
double ddd = dd + (vl + vl + ttt * a) * ttt;
if (ddd >= d) {
d -= dd;
d /= 2;
return (-vl + sqrt(vl * vl + 2 * a * d)) / a * 2 + tt;
} else {
return tt + ttt * 2 + (d - ddd) / vm;
}
}
}
int main() {
double a, v, l, d, w;
scanf("%lf%lf%lf%lf%lf", &a, &v, &l, &d, &w);
double t1 = solve(0, a, d, v, min(v, w));
double t2 = solve(min(t1 * a, min(v, w)), a, l - d, v, v);
printf("%.12lf\n", t1 + t2);
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
const int T = 100000;
int a[100005], b[100005], Q[100005], opt[100005], n, m, i, j, k, id, debug;
long long pos, start, now;
set<pair<long long, int> > S;
int main() {
scanf("%d", &m);
for (i = 1; i <= m; i++) {
scanf("%d%d", &opt[i], &a[i]);
if (opt[i] == 2) scanf("%d", &b[i]);
if (opt[i] == 1) {
if ((*Q) < T) Q[++*Q] = a[i];
now++;
} else
for (now += 1ll * a[i] * b[i], j = 1; j <= b[i] && (*Q) < T; j++)
for (k = 1; k <= a[i] && (*Q) < T; k++) Q[++*Q] = Q[k];
S.insert(make_pair(now, i));
}
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%I64d", &pos);
if (pos <= T) {
printf("%d ", Q[pos]);
continue;
}
pair<long long, int> tmp = *S.lower_bound(make_pair(pos, 0));
id = tmp.second;
now = tmp.first;
if (opt[id] == 1)
printf("%d ", a[id]);
else
start = now - 1ll * a[id] * b[id],
printf("%d ", Q[(pos - start - 1) % a[id] + 1]);
}
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
set<int> indices;
for (int i = 0; i < n; i++) {
indices.insert(i);
}
vector<pair<int, int> > arr(n);
for (int i = 0; i < n; i++) {
cin >> arr[i].first;
arr[i].second = i;
}
sort(arr.begin(), arr.end());
int k = INT_MAX;
for (int i = 0; i < arr.size() - 1; i++) {
int val = arr[i].first;
int index = arr[i].second;
indices.erase(index);
int start = *indices.begin();
int endi = *indices.rbegin();
int diff1 = abs(index - start);
int diff2 = abs(index - endi);
int tk1 = val / diff1;
int tk2 = val / diff2;
k = min(k, tk1);
k = min(k, tk2);
}
cout << k << endl;
return 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
int solve(int n, int m, int a, int b) {
if (m == 1) return 1;
--a;
--b;
int la = a / m;
int lb = b / m;
if (la == lb) return 1;
if (b == n - 1) {
if (a % m == 0) return 1;
return 2;
}
if (b % m == m - 1 && a % m == 0) return 1;
if (la + 1 == lb || a % m == 0 || b % m == m - 1 || b % m + 1 == a % m)
return 2;
return 3;
}
int main() {
ios::sync_with_stdio(false);
int n, m, a, b;
cin >> n >> m >> a >> b;
int ans = solve(n, m, a, b);
cout << ans << endl;
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k;
cin >> n >> k;
long long int i;
map<long long int, long long int> m;
long long int r;
for (i = 1; i <= k; i++) {
r = n % i;
m[r]++;
if (m[r] > 1) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
int dp[300];
int carpet[300][300];
void parse(int n, int m) {
for (int r = 0; r < n; ++r) {
string lines[4];
for (int i = 0; i < 4; ++i) getline(cin, lines[i]);
for (int k = 0; k < m; k++) {
int cnt = 0;
for (int s = 1; s <= 3; s++)
for (int t = 1; t <= 3; t++) cnt += (lines[s][4 * k + t] == 'O');
switch (cnt) {
case 0:
case 1:
case 4:
case 5:
carpet[r][k] = 3;
break;
case 2:
case 3:
if (lines[1][4 * k + 1] == 'O')
carpet[r][k] = 1;
else
carpet[r][k] = 2;
break;
case 6:
if (lines[1][4 * k + 2] == 'O')
carpet[r][k] = 1;
else
carpet[r][k] = 2;
break;
default:
assert(false);
}
}
}
}
bool isvert(int r, int c) { return (carpet[r][c] & 2) != 0; }
bool ishori(int r, int c) { return (carpet[r][c] & 1) != 0; }
void solve() {
memset(dp, 0, sizeof dp);
int n, m;
cin >> n >> m;
cin.ignore(1024, '\n');
parse(n, m);
dp[0] = 1;
for (int c = 1; c <= m; ++c) {
dp[c] = 0;
bool allvert = true;
for (int r = 1; r <= n; ++r)
if (!isvert(r - 1, c - 1)) {
allvert = false;
break;
}
if (n % 2 == 0 && allvert) dp[c] += dp[c - 1];
if (c < 2) continue;
int dp2[300];
dp2[0] = 1;
for (int r = 1; r <= n; ++r) {
dp2[r] = 0;
if (ishori(r - 1, c - 2) && ishori(r - 1, c - 1)) dp2[r] += dp2[r - 1];
if (r >= 2 && isvert(r - 2, c - 2) && isvert(r - 2, c - 1) &&
isvert(r - 1, c - 2) && isvert(r - 1, c - 1)) {
dp2[r] = ((long long)dp2[r] + dp2[r - 2]) % 1000000007;
}
}
dp[c] = (dp[c] + (long long)dp2[n] * dp[c - 2]) % 1000000007;
if (c >= 2) {
bool allvert = true;
for (int r = 1; r <= n; ++r)
if (!(isvert(r - 1, c - 2) && isvert(r - 1, c - 1))) {
allvert = false;
break;
}
if (allvert && n % 2 == 0)
dp[c] = ((long long)dp[c] - dp[c - 2] + 1000000007) % 1000000007;
}
}
cout << dp[m] << endl;
}
int main() { solve(); }
| 15
|
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-2;
long double dist(pair<long double, long double> p1,
pair<long double, long double> p2) {
return hypot(p1.first - p2.first, p1.second - p2.second);
}
long double pdist(pair<long double, long double> p1,
pair<long double, long double> p2,
pair<long double, long double> p3,
pair<long double, long double> p4) {
return abs(p1.first - p2.first) + abs(p1.second - p2.second) + dist(p2, p3) +
abs(p3.first - p4.first) + abs(p3.second - p4.second);
}
int main() {
long double a, b, c, x1, y1, x2, y2;
cin >> a >> b >> c >> x1 >> y1 >> x2 >> y2;
pair<long double, long double> A = {x1, y1}, B = {x2, y2};
cout << fixed << setprecision(20);
if (abs(a) < eps || abs(b) < eps) {
cout << abs(x1 - x2) + abs(y1 - y2) << endl;
return 0;
}
pair<long double, long double> ha, va, hb, vb;
ha.second = y1;
ha.first = (-b * y1 - c) / a;
hb.second = y2;
hb.first = (-b * y2 - c) / a;
va.first = x1;
va.second = (-a * x1 - c) / b;
vb.first = x2;
vb.second = (-a * x2 - c) / b;
long double ans = abs(A.first - B.first) + abs(A.second - B.second);
ans = min(ans, pdist(A, ha, hb, B));
ans = min(ans, pdist(A, ha, vb, B));
ans = min(ans, pdist(A, va, hb, B));
ans = min(ans, pdist(A, va, vb, B));
cout << ans << endl;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
inline bool lt(double a, double b) { return a + eps < b; }
inline bool eq(double a, double b) { return !lt(a, b) && !lt(b, a); }
int n, s[1002];
double A, B, lo, hi, mid;
int next(double mid) {
double x = mid;
int nxt = 0;
for (int i = 0; i < n; ++i) {
nxt += int(x / 10);
x = fmod(x, 10) + mid;
}
nxt += int(x / 10);
return nxt;
}
int main(void) {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", &s[i]);
lo = 10;
hi = 10000000;
for (int iter = 0; iter < 200; ++iter) {
mid = (lo + hi) / 2;
bool ok = true;
double x = mid;
int nxt = 0;
for (int i = 0; i < n; ++i) {
nxt += int(x / 10);
if (nxt < s[i]) {
ok = false;
break;
}
if (nxt > s[i]) break;
x = fmod(x, 10) + mid;
}
if (!ok)
lo = mid + eps;
else
hi = mid;
}
A = mid;
lo = 10;
hi = 10000000;
for (int iter = 0; iter < 200; ++iter) {
mid = (lo + hi) / 2;
bool ok = true;
double x = mid;
int nxt = 0;
for (int i = 0; i < n; ++i) {
nxt += int(x / 10);
if (nxt > s[i]) {
ok = false;
break;
}
if (nxt < s[i]) break;
x = fmod(x, 10) + mid;
}
if (!ok)
hi = mid - eps;
else
lo = mid;
}
B = mid;
int na = next(A);
int nb = next(B);
if (na == nb)
printf("unique\n%d\n", na);
else
printf("not unique\n");
return 0;
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e5 + 5, maxm = 1005;
inline void chkmin(long long &x, long long y) { x = x < y ? x : y; }
inline long long read() {
char c = getchar();
long long ans = 0, f = 0;
for (; c < '0' || c > '9'; c = getchar()) f |= (c == '-');
for (; c >= '0' && c <= '9'; c = getchar()) (ans *= 10) += c - '0';
return f ? -ans : ans;
}
struct node {
long long x, r, q;
} arr[maxn << 1];
long long bx[maxn << 1], bq[maxn << 1], mx, mq;
bool cmp(node a, node b) { return a.r > b.r; }
long long n, k;
long long tot;
struct segment_tree {
long long ls, rs, sum;
} tree[maxn << 5];
void insert(long long &p, long long l, long long r, long long x) {
if (!p) p = ++tot;
tree[p].sum++;
if (l < r) {
long long mid = l + r >> 1;
if (x <= mid)
insert(tree[p].ls, l, mid, x);
else
insert(tree[p].rs, mid + 1, r, x);
}
}
long long query(long long p, long long l, long long r, long long L,
long long R) {
if (!p) return 0;
if (L <= l && r <= R) return tree[p].sum;
long long sum = 0, mid = l + r >> 1;
if (L <= mid) sum += query(tree[p].ls, l, mid, L, R);
if (mid < R) sum += query(tree[p].rs, mid + 1, r, L, R);
return sum;
}
long long rt[maxn];
int main() {
n = read(), k = read();
for (long long i = 1; i <= n; i++) {
arr[i] = (node){read(), read(), read()};
bx[i] = arr[i].x;
bq[i] = arr[i].q;
}
sort(bx + 1, bx + n + 1);
mx = unique(bx + 1, bx + n + 1) - bx - 1;
sort(bq + 1, bq + n + 1);
mq = unique(bq + 1, bq + n + 1) - bq - 1;
sort(arr + 1, arr + n + 1, cmp);
long long ans = 0;
for (long long i = 1, x, q, l, r, L, R; i <= n; i++) {
x = lower_bound(bx + 1, bx + mx + 1, arr[i].x) - bx;
l = lower_bound(bx + 1, bx + mx + 1, arr[i].x - arr[i].r) - bx;
r = lower_bound(bx + 1, bx + mx + 1, arr[i].x + arr[i].r + 1) - bx - 1;
q = lower_bound(bq + 1, bq + mq + 1, arr[i].q) - bq;
L = lower_bound(bq + 1, bq + mq + 1, arr[i].q - k) - bq;
R = lower_bound(bq + 1, bq + mq + 1, arr[i].q + k + 1) - bq - 1;
for (long long j = L; j <= R; j++) {
ans += query(rt[j], 1, mx, l, r);
}
insert(rt[q], 1, mx, x);
}
printf("%lld\n", ans);
return 0;
}
| 14
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,fma")
#pragma GCC optimize("unroll-loops")
using namespace std;
long long MOD = 1000000007;
double eps = 1e-12;
long long modu(long long a, long long b, long long c) {
if (b == 0) return 1;
if (b % 2) {
return (a % c * modu(a, b - 1, c)) % c;
} else {
long long y = modu(a, b / 2, c);
return (y * y) % c;
}
}
void solve() {
long long n;
cin >> n;
set<long long> s;
long long events = 0;
long long days = 0;
vector<long long> v;
map<long long, long long> m;
long long a[n];
for (long long i = 0; i < n; i++) cin >> a[i];
set<long long> perday;
for (long long i = 0; i < n; i++) {
if (a[i] > 0) {
if (s.count(a[i]) || perday.count(a[i])) {
cout << -1 << "\n";
return;
} else {
s.insert(a[i]);
perday.insert(a[i]);
m[a[i]]++;
}
} else {
if (s.count(-a[i])) {
s.erase(-a[i]);
} else {
cout << -1 << "\n";
return;
}
}
events++;
if (s.size() == 0) {
v.push_back(events);
events = 0;
days++;
perday.clear();
}
}
if (s.size()) {
cout << -1 << "\n";
return;
}
cout << days << "\n";
for (long long i = 0; i < v.size(); i++) cout << v[i] << " ";
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
return 0;
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, a, b, c;
cin >> n;
a = n / 7;
a *= 2;
if (n % 7 == 0) {
b = a;
c = a;
}
if (n % 7 == 1 || n % 7 == 2 || n % 7 == 3 || n % 7 == 4 || n % 7 == 5) {
b = a;
}
if (n % 7 == 6) {
b = a + 1;
}
if (n % 7 == 1) {
c = a + 1;
}
if ((n % 7) > 1) {
c = a + 2;
}
cout << b << " " << c;
return 0;
}
| 1
|
/*
* author: AlexXan312
* good luck
*/
#include <iostream>
#include <fstream>
#include <functional>
#include <vector>
#include <string>
#include <algorithm>
#include <queue>
#include <set>
#include <map>
#include <stack>
#include <unordered_set>
#include <unordered_map>
#include <deque>
#include <list>
#include <bitset>
#include <cmath>
#include <ctime>
#include <cassert>
#include <random>
#include <chrono>
using namespace std;
using ll = long long;
using ld = long double;
using str = string;
using pll = pair<ll, ll>;
#define mp make_pair
#define pb push_back
#define fi first;
#define se second;
#define PI 3.1415926535897932384626
const ll MOD = 1e9 + 7;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
void solve() {
ll n;
cin >> n;
ll el = n / 2;
if((n % 2 == 0) && ((ll)sqrt(el) * (ll)sqrt(el)) == el) {
cout << "YES" << '\n';
return;
}
el = n /4;
if((n % 4 == 0) && ((ll)sqrt(el) * (ll)sqrt(el)) == el) {
cout << "YES" << '\n';
return;
}
cout << "NO" << '\n';
return;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL); cout.tie(NULL);
ll t;
cin >> t;
while (t--) {
solve();
}
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
struct point {
int x, y;
};
point d[222222], e[222222];
int n, m, ans = 0, sum[222222];
bool cmp(point u, point v) {
return (u.x < v.x) || ((u.x == v.x) && (u.y < v.y));
}
bool found(point u) {
int low = 1, high = n, mid;
while (low + 1 < high) {
mid = (low + high) / 2;
if ((u.x < d[mid].x) || ((u.x == d[mid].x) && (u.y <= d[mid].y)))
high = mid;
else
low = mid;
}
if ((u.x == d[low].x) && (u.y == d[low].y)) return true;
if ((u.x == d[high].x) && (u.y == d[high].y)) return true;
return false;
}
void solve(int tp) {
sort(d + 1, d + n + 1, cmp);
int p = 1, last, edge;
memset(sum, 0, sizeof(sum));
for (int i = 1; i <= n; i++) sum[d[i].x]++;
point u;
while (p <= n) {
for (int i = p; i <= n; i++)
if (d[i].x == d[p].x)
last = i;
else
break;
if ((tp) || (last - p + 1 <= m)) {
for (int i = p; i <= last; i++)
for (int j = i + 1; j <= last; j++) {
edge = d[j].y - d[i].y;
u.x = d[i].x + edge;
u.y = d[i].y;
if (found(u)) {
u.x = d[j].x + edge;
u.y = d[j].y;
if (found(u)) ans++;
}
if (!tp)
if ((d[i].x - edge >= 0) && (sum[d[i].x - edge] > m)) {
u.x = d[i].x - edge;
u.y = d[i].y;
if (found(u)) {
u.x = d[j].x - edge;
u.y = d[j].y;
if (found(u)) ans++;
}
}
}
}
p = last + 1;
}
}
void init() {
int p = 1, last, ne = 0;
while (p <= n) {
for (int i = p; i <= n; i++)
if (d[i].x == d[p].x)
last = i;
else
break;
if (last - p + 1 > m)
for (int i = p; i <= last; i++) e[++ne] = d[i];
p = last + 1;
}
n = ne;
for (int i = 1; i <= n; i++) d[i] = e[i];
for (int i = 1; i <= n; i++) swap(d[i].x, d[i].y);
}
int main() {
cin >> n;
m = trunc(sqrt((double)n)) + 3;
for (int i = 1; i <= n; i++) scanf("%d%d", &d[i].x, &d[i].y);
ans = 0;
solve(0);
init();
solve(1);
cout << ans;
return 0;
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
const int maxx = 2e5 + 10;
const int inf = 1e9;
int a[maxx], b[maxx], n;
struct S {
int num, val;
int left, right;
} tree[maxx * 5];
void pushup(int k) {
tree[k].val = min(tree[k << 1].val, tree[k << 1 | 1].val);
}
void build(int k, int l, int r) {
tree[k].left = l, tree[k].right = r;
tree[k].val = tree[k].num = 0;
if (l == r) {
tree[k].num = b[l];
if (tree[k].num == 0)
tree[k].val = inf;
else
tree[k].val = l;
return;
}
int mid = l + r >> 1;
build(k << 1, l, mid);
build(k << 1 | 1, mid + 1, r);
pushup(k);
}
void update(int k, int l, int r) {
int L = tree[k].left, R = tree[k].right;
if (L >= l && R <= r) {
tree[k].num--;
if (tree[k].num == 0) tree[k].val = inf;
return;
}
int mid = L + R >> 1;
if (l <= mid) update(k << 1, l, r);
if (r > mid) update(k << 1 | 1, l, r);
pushup(k);
}
int query(int k, int l, int r) {
int L = tree[k].left, R = tree[k].right;
if (L >= l && R <= r) {
return tree[k].val;
}
int ans = inf;
int mid = L + R >> 1;
if (l <= mid) ans = min(ans, query(k << 1, l, r));
if (r > mid) ans = min(ans, query(k << 1 | 1, l, r));
return ans;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
b[x]++;
}
build(1, 0, n - 1);
for (int i = 1; i <= n; i++) {
int x = a[i];
int l = (n - x), r = n - 1;
int ans = query(1, l, r);
if (ans != inf) {
printf("%d ", (ans + x) % n);
update(1, ans, ans);
} else {
l = 0, r = n - x;
ans = query(1, l, r);
printf("%d ", (ans + x) % n);
update(1, ans, ans);
}
}
puts("");
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
int n,k;
inline bool ck(int i,int j,string&a,string&b){
int l=0,r=k-1,u=0,v=0;
while(a[l]==b[l])l++;
while(a[r]==b[r])r--;
for(;l<r&&!(u&v);l++)u|=(a[l+1]<a[l]),v|=(b[l+1]<b[l]);
return!(u&v);
}
int main(){
cin>>n;
string s,h;
map<string,vector<string>>mp;
long long m,i,j,c,x=0,y=0,t=n*(n-1LL)/2;
while(n--)cin>>s,k=s.length(),h=s,sort(h.begin(),h.end()),mp[h].push_back(s);
for (auto p:mp){
auto v=p.second;
m=v.size(),sort(v.begin(),v.end());
for(i=c=0;i<m;i++)
for(j=i+1;j<m;j++)
c+=ck(i,j,v[i],v[j]);
x+=c,y+=m*(m-1)/2-c;
}
cout<<1337*(t-x-y)+x+2*y<<"\n";
}
| 22
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, p, head = 1, tail = 0, d, j, k;
long long dis[100050], a[100050], q[100050], dp[110][100050], s[100050],
g[100050];
signed main() {
scanf("%lld%lld%lld", &n, &m, &p);
for (long long i = 2; i <= n; i++) scanf("%lld", &d), dis[i] = dis[i - 1] + d;
for (long long i = 1; i <= m; i++)
scanf("%lld%lld", &j, &k), a[i] = k - dis[j];
sort(a + 1, a + m + 1);
for (long long i = 1; i <= m; i++) s[i] = s[i - 1] + a[i];
for (long long i = 0; i <= p; i++)
for (long long j = 0; j <= m; j++) dp[i][j] = 999999999999999;
dp[0][0] = 0;
for (long long i = 1; i <= p; i++) {
for (long long j = 1; j <= m; j++) g[j] = dp[i - 1][j] + s[j];
head = tail = 1;
q[tail] = 0;
for (long long j = 1; j <= m; j++) {
while (head < tail &&
(g[q[head + 1]] - g[q[head]]) <= (q[head + 1] - q[head]) * a[j])
head++;
dp[i][j] = min(dp[i - 1][j], g[q[head]] + (j - q[head]) * a[j] - s[j]);
if (g[j] >= 999999999999999) continue;
while (head < tail && (g[j] - g[q[tail]]) * (q[tail] - q[tail - 1]) <=
(j - q[tail]) * (g[q[tail]] - g[q[tail - 1]]))
tail--;
q[++tail] = j;
}
}
printf("%lld", dp[p][m]);
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
vector<int> a;
map<vector<int>, double> mp[10];
double getans(vector<int> a, int rem) {
int n = a.size(), i, j;
if (rem == 0) {
int cnt = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < i; j++) {
cnt += (a[j] > a[i]);
}
}
return cnt;
}
if (mp[rem].count(a) != 0) {
return mp[rem][a];
}
double den = 0, ans = 0;
for (i = 0; i < n; i++) {
for (j = i; j < n; j++) {
reverse(a.begin() + i, a.begin() + j + 1);
ans += getans(a, rem - 1);
den++;
reverse(a.begin() + i, a.begin() + j + 1);
}
}
return mp[rem][a] = ans / den;
}
int main() {
int i, n, k;
cin >> n >> k;
a.resize(n);
for (i = 0; i < n; i++) {
cin >> a[i];
}
printf("%.16lf\n", getans(a, k));
return 0;
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long c, hr, hb, wr, wb;
cin >> c >> hr >> hb >> wr >> wb;
long long ans = 0ll;
if (wr * wr >= c) {
for (long long a = 0ll; a * wr <= c; ++a) {
long long b = (c - a * wr) / wb;
ans = max(ans, a * hr + b * hb);
}
} else if (wb * wb >= c) {
for (long long b = 0ll; b * wb <= c; ++b) {
long long a = (c - b * wb) / wr;
ans = max(ans, a * hr + b * hb);
}
} else {
if (wb * hr > hb * wr) {
swap(wb, wr);
swap(hb, hr);
}
for (long long a = 0ll; a <= wb; ++a) {
long long b = (c - a * wr) / wb;
ans = max(ans, a * hr + b * hb);
}
}
cout << ans << endl;
return 0;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 1e5 + 5;
const int mod = 1e9 + 7;
const int INF = 2e9 + 5;
struct node {
int x, num, ans;
} a[MX];
bool cmp1(node a, node b) { return a.x < b.x; }
bool cmp2(node a, node b) { return a.num < b.num; }
int main() {
int n, k;
scanf("%d%d", &n, &k);
int need = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i].x);
a[i].num = i;
need += (a[i].x + 1) / 2;
}
if (need > k) {
printf("-1\n");
return 0;
}
sort(a + 1, a + n + 1, cmp1);
for (int i = 1; i <= n; i++) {
a[i].ans = (a[i].x + 1) / 2;
k -= a[i].ans;
}
for (int i = n; i >= 1; i--) {
if (k >= (a[i].x - a[i].ans)) {
k -= (a[i].x - a[i].ans);
a[i].ans = a[i].x;
} else {
a[i].ans += k;
break;
}
}
sort(a + 1, a + 1 + n, cmp2);
printf("%d", a[1].ans);
for (int i = 2; i <= n; i++) {
printf(" %d", a[i].ans);
}
printf("\n");
return 0;
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
int dp[5000100];
string s;
long long prime = 3;
int main() {
ios::sync_with_stdio(0);
cin.tie();
cin >> s;
long long l = 0, r = 0, p = 1, ans = 0;
for (int i = 1; i <= s.size(); i++) {
l = l * prime + s[i - 1];
r = r + p * s[i - 1];
p *= prime;
if (l == r) dp[i] = dp[i / 2] + 1;
ans += dp[i];
}
cout << ans << endl;
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
bool comp(pair<long long, long long> p, pair<long long, long long> q) {
if (p.first != q.first)
return p.first < q.first;
else
return p.second > q.second;
}
long long power(long long a, long long n) {
long long res = 1;
while (n) {
if (n % 2) res = (res % mod * a % mod) % mod;
a = (a % mod * a % mod) % mod;
n /= 2;
}
return res % mod;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
string a, b;
cin >> a >> b;
long long n = a.size(), c = 0;
for (long long i = 0; i < n; i++) {
if (i != n - 1) {
if (((a[i] == '0') + (a[i + 1] == '0') + (b[i] == '0') +
(b[i + 1] == '0')) == 3) {
c++;
a[i] = b[i] = b[i + 1] = a[i + 1] = 'X';
} else if (((a[i] == '0') + (a[i + 1] == '0') + (b[i] == '0') +
(b[i + 1] == '0')) == 4) {
c++;
a[i] = b[i] = b[i + 1] = 'X';
}
}
}
cout << c << "\n";
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 2;
int n, m;
int viz[N], aux[N], c[N], id[N];
vector<int> meh;
vector<int> g[N];
vector<pair<int, int> > v[N];
bool Loop2(int x) {
if (viz[x] == 1) return 1;
if (viz[x] == 2) return 0;
viz[x] = 1;
for (auto &it : g[x]) {
if (Loop2(it)) return 1;
}
viz[x] = 2;
return 0;
}
bool Loop() {
memset(viz, 0, sizeof(viz));
for (int i = 1; i <= n; i++) {
if (!viz[i] && Loop2(i)) return 1;
}
return 0;
}
int ok(int x) {
for (int i = 1; i <= n; i++) {
g[i].clear();
for (auto it : v[i]) {
if (c[it.second] > x) g[i].push_back(it.first);
}
}
return !Loop();
}
void fake(int x) {
priority_queue<int, vector<int>, greater<int> > pq;
for (int i = 1; i <= n; i++)
for (auto it : g[i]) aux[it]++;
vector<int> topo;
for (int i = 1; i <= n; i++) {
if (!aux[i]) pq.push(i);
}
while (!pq.empty()) {
int u = pq.top();
pq.pop();
topo.push_back(u);
for (auto it : g[u]) {
aux[it]--;
if (!aux[it]) pq.push(it);
}
}
int nr = 0;
for (auto it : topo) id[it] = ++nr;
for (int i = 1; i <= n; i++) {
for (auto it : v[i]) {
if (c[it.second] <= x && id[it.first] < id[i]) meh.push_back(it.second);
}
}
}
int main() {
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int a, b;
cin >> a >> b >> c[i];
v[a].push_back({b, i});
}
int st = 0, dr = 1e9, ans;
while (st <= dr) {
int mid = (st + dr) / 2;
if (ok(mid)) {
dr = mid - 1;
ans = mid;
} else
st = mid + 1;
}
ok(ans);
fake(ans);
cout << ans << " " << meh.size() << "\n";
for (auto it : meh) cout << it << " ";
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
string s;
cin >> s;
int a, b;
cin >> a >> b;
const int n = s.size();
int prefix[n], suffix[n];
memset(prefix, 0, sizeof(prefix));
memset(suffix, 0, sizeof(suffix));
for (int i = 0; i < n; ++i) {
int rem = (i > 0 ? prefix[i - 1] : 0);
prefix[i] = (rem * 10 + s[i] - '0') % a;
}
int curr_pow = 1;
for (int i = n - 1; i >= 0; --i) {
int rem = (i < n - 1 ? suffix[i + 1] : 0);
suffix[i] = ((s[i] - '0') * curr_pow + rem) % b;
curr_pow *= 10;
curr_pow %= b;
}
for (int i = 0; i < n - 1; ++i) {
if (prefix[i] == 0 and s[i + 1] != '0' and suffix[i + 1] == 0) {
cout << "YES\n";
cout << s.substr(0, i + 1) << '\n' << s.substr(i + 1);
return 0;
}
}
cout << "NO";
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
struct Node {
int val;
int qP;
struct Node *p1, *p2, *p3, *p4, *par;
};
const int base = (1 << 24);
Node *root;
struct Data {
int x1, y1, x2, y2, z, ind;
bool operator<(const Data &a) const { return z < a.z; }
};
int n;
Data data[100000];
int ans[100000];
queue<int> q[99999];
int qN;
int m;
void init(Node *tar, Node *par) {
tar->val = tar->qP = -1;
tar->p1 = tar->p2 = tar->p3 = tar->p4 = NULL;
tar->par = par;
return;
}
void insert(Node *cur, int x1, int x2, int y1, int y2, int tx, int ty, int tar);
void getVal(Node *cur, int x1, int x2, int y1, int y2, int tsx, int tex,
int tsy, int tey);
void remove(Node *tar);
Node *trash;
Node *getLeaf(int val, Node *cur);
int g_val;
Node *g_node;
int main(void) {
trash = (Node *)malloc(sizeof(Node));
init(trash, NULL);
scanf("%d", &n);
for (int i = 0; i < n; i++) {
data[i].ind = i;
scanf("%d %d %d %d %d", &data[i].x1, &data[i].x2, &data[i].y1, &data[i].y2,
&data[i].z);
}
sort(data, data + n);
root = (Node *)malloc(sizeof(Node));
init(root, NULL);
scanf("%d", &m);
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d %d", &x, &y);
insert(root, 0, base, 0, base, x, y, i + 1);
}
for (int i = 0; i < n; i++) {
g_val = m + 1;
g_node = NULL;
getVal(root, 0, base, 0, base, data[i].x1, data[i].x2 + 1, data[i].y1,
data[i].y2 + 1);
if (g_val < m + 1) {
ans[g_val - 1] = data[i].ind + 1;
remove(getLeaf(g_val, g_node));
}
}
for (int i = 0; i < m; i++) printf("%d\n", ans[i]);
return 0;
}
void remove(Node *tar) {
int next = m + 1;
if (tar->qP != -1 && q[tar->qP].size()) {
next = q[tar->qP].front();
q[tar->qP].pop();
}
while (tar) {
if (tar->p1) next = min(next, tar->p1->val);
if (tar->p2) next = min(next, tar->p2->val);
if (tar->p3) next = min(next, tar->p3->val);
if (tar->p4) next = min(next, tar->p4->val);
tar->val = next;
tar = tar->par;
}
return;
}
Node *getLeaf(int val, Node *cur) {
if (!cur->p1 && !cur->p2 && !cur->p3 && !cur->p4) return cur;
if (cur->p1 && cur->p1->val == val) return getLeaf(val, cur->p1);
if (cur->p2 && cur->p2->val == val) return getLeaf(val, cur->p2);
if (cur->p3 && cur->p3->val == val) return getLeaf(val, cur->p3);
if (cur->p4 && cur->p4->val == val) return getLeaf(val, cur->p4);
}
void getVal(Node *cur, int x1, int x2, int y1, int y2, int tsx, int tex,
int tsy, int tey) {
if (x1 >= x2 || y1 >= y2 || tsx >= tex || tsy >= tey) return;
if (x1 >= tex || tsx >= x2 || y1 >= tey || tsy >= y2) return;
if (x1 == tsx && x2 == tex && y1 == tsy && y2 == tey) {
if (cur->val < g_val) {
g_val = cur->val;
g_node = cur;
}
return;
}
int hx = (x1 + x2) / 2, hy = (y1 + y2) / 2;
if (cur->p1)
getVal(cur->p1, hx, x2, hy, y2, max(hx, tsx), tex, max(hy, tsy), tey);
if (cur->p2)
getVal(cur->p2, x1, hx, hy, y2, tsx, min(hx, tex), max(hy, tsy), tey);
if (cur->p3)
getVal(cur->p3, x1, hx, y1, hy, tsx, min(hx, tex), tsy, min(hy, tey));
if (cur->p4)
getVal(cur->p4, hx, x2, y1, hy, max(hx, tsx), tex, tsy, min(hy, tey));
return;
}
void insert(Node *cur, int x1, int x2, int y1, int y2, int tx, int ty,
int tar) {
if (cur->val == -1)
cur->val = tar;
else {
if (x1 + 1 == x2 && y1 + 1 == y2) {
if (cur->qP == -1) cur->qP = qN++;
q[cur->qP].push(tar);
}
}
if (x1 + 1 == x2 && y1 + 1 == y2) return;
int hx = (x1 + x2) / 2;
int hy = (y1 + y2) / 2;
if (tx >= hx && ty >= hy) {
if (cur->p1 == NULL) {
cur->p1 = (Node *)malloc(sizeof(Node));
init(cur->p1, cur);
}
insert(cur->p1, hx, x2, hy, y2, tx, ty, tar);
} else if (tx < hx && ty >= hy) {
if (cur->p2 == NULL) {
cur->p2 = (Node *)malloc(sizeof(Node));
init(cur->p2, cur);
}
insert(cur->p2, x1, hx, hy, y2, tx, ty, tar);
} else if (tx < hx && ty < hy) {
if (cur->p3 == NULL) {
cur->p3 = (Node *)malloc(sizeof(Node));
init(cur->p3, cur);
}
insert(cur->p3, x1, hx, y1, hy, tx, ty, tar);
} else if (tx >= hx && ty < hy) {
if (cur->p4 == NULL) {
cur->p4 = (Node *)malloc(sizeof(Node));
init(cur->p4, cur);
}
insert(cur->p4, hx, x2, y1, hy, tx, ty, tar);
}
return;
}
| 17
|
#include <bits/stdc++.h>
using namespace std;
static int dp[2000][300];
int main() {
int n, k;
scanf("%d", &n);
scanf("%d", &k);
vector<pair<int, int> > v;
if (n < 2 * k + 1) {
printf("-1\n");
return 0;
} else {
printf("%d\n", n * k);
for (int i = 1; i <= n; i++) {
int j = i + 1;
for (int c = 0; c < k; c++) {
if (j > n) {
j -= n;
}
printf("%d %d\n", i, j);
j += 1;
}
}
}
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (a < b) {
int t = a;
a = b;
b = t;
}
while (b) {
int M = a % b;
a = b;
b = M;
}
return a;
}
int flag[100000];
int main() {
int n;
int a[100000];
int c[100000];
while (cin >> n) {
for (int i = 0; i < n; i++) cin >> a[i];
int k = 0;
for (int i = 0; i < n - 1; i++) {
if (gcd(a[i], a[i + 1]) != 1) {
c[k++] = a[i];
c[k++] = 1;
} else
c[k++] = a[i];
}
cout << k - n + 1 << endl;
for (int i = 0; i < k; i++) cout << c[i] << ' ';
cout << a[n - 1] << endl;
}
return 0;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int v;
node *l, *r, *u, *d;
} M[1005][1005];
int n, m, q, a, b, c, d, h, w;
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i++) M[i][0].r = &M[i][1];
for (int i = 1; i <= n; i++) M[i][m + 1].l = &M[i][m];
for (int i = 1; i <= m; i++) M[0][i].d = &M[1][i];
for (int i = 1; i <= m; i++) M[n + 1][i].u = &M[n][i];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
scanf("%d", &M[i][j].v);
M[i][j].l = &M[i][j - 1];
M[i][j].r = &M[i][j + 1];
M[i][j].u = &M[i - 1][j];
M[i][j].d = &M[i + 1][j];
}
while (q--) {
scanf("%d%d%d%d%d%d", &a, &b, &c, &d, &h, &w);
node *p1 = &M[a][0], *p2 = &M[c][0];
for (int i = 1; i <= b; i++) p1 = p1->r;
for (int i = 1; i <= d; i++) p2 = p2->r;
for (int i = 1; i <= w; i++) {
swap(p1->u, p2->u);
swap(p1->u->d, p2->u->d);
p1 = p1->r;
p2 = p2->r;
}
p1 = p1->l;
p2 = p2->l;
for (int i = 1; i <= h; i++) {
swap(p1->r, p2->r);
swap(p1->r->l, p2->r->l);
p1 = p1->d;
p2 = p2->d;
}
p1 = p1->u;
p2 = p2->u;
for (int i = 1; i <= w; i++) {
swap(p1->d, p2->d);
swap(p1->d->u, p2->d->u);
p1 = p1->l;
p2 = p2->l;
}
p1 = p1->r;
p2 = p2->r;
for (int i = 1; i <= h; i++) {
swap(p1->l, p2->l);
swap(p1->l->r, p2->l->r);
p1 = p1->u;
p2 = p2->u;
}
}
for (int i = 1; i <= n; i++) {
node *p = M[i][0].r;
for (int j = 1; j <= m; j++) printf("%d ", p->v), p = p->r;
puts("");
}
return 0;
}
| 17
|
#include <bits/stdc++.h>
using namespace std;
string second, t, r = "";
long long n, m, k;
long long lcp[2105][2105], lcp_prev[2105][2105];
pair<long long, long long> ans[2105];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> second >> t;
n = second.length();
m = t.length();
for (long long i = (long long)(n - 1); i >= (long long)(0); i--)
r += second[i];
for (long long i = (long long)(m); i >= (long long)(1); i--)
for (long long j = (long long)(n); j >= (long long)(1); j--)
if (second[j - 1] == t[i - 1]) lcp[i][j] = lcp[i + 1][j + 1] + 1;
for (long long i = (long long)(m); i >= (long long)(1); i--)
for (long long j = (long long)(n); j >= (long long)(1); j--)
if (r[j - 1] == t[i - 1]) lcp_prev[i][j] = lcp_prev[i + 1][j + 1] + 1;
for (long long i = (long long)(1); i <= (long long)(m); i++) {
long long Max = 0, lft, rt;
lft = rt = -1;
for (long long j = (long long)(1); j <= (long long)(n); j++) {
if (lcp[i][j] > Max) {
Max = lcp[i][j];
lft = j;
rt = lft + Max - 1;
}
}
for (long long j = (long long)(1); j <= (long long)(n); j++) {
if (lcp_prev[i][j] > Max) {
Max = lcp_prev[i][j];
lft = n - j + 1;
rt = lft - Max + 1;
}
}
if (lft == -1) {
cout << "-1" << endl;
return 0;
}
ans[k] = {lft, rt};
k++;
i = i + Max - 1;
}
cout << k << endl;
for (long long i = (long long)(0); i <= (long long)(k - 1); i++)
cout << ans[i].first << " " << ans[i].second << endl;
return 0;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using uint = unsigned int;
using ull = unsigned long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vl = vector<long long>;
void solve() {
int K, N;
cin >> K >> N;
int cnt = 0;
while (N > 1) {
if (N % K > 0) {
cout << "NO" << endl;
return;
}
N /= K;
cnt++;
}
cout << "YES" << endl;
cout << cnt - 1 << endl;
}
int main() {
cin.tie(nullptr);
cout.tie(nullptr);
ios_base::sync_with_stdio(false);
solve();
return 0;
}
| 2
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,unroll-loops")
using namespace std;
const int N = 1e5 + 2;
int o[3];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int s;
cin >> s;
vector<pair<int, int> > v;
int sum = 0;
for (int i = int(0); i < int(3); ++i) {
int x;
cin >> x;
o[i] = x;
if (x == 0) continue;
v.push_back(pair<int, int>(x, i));
sum += x;
}
if (v.empty()) {
cout << "0.0 0.0 0.0" << endl;
return 0;
}
vector<long double> ans(3, 0);
for (int i = int(0); i < int(3); ++i) {
ans[i] = 1.0L * s * o[i] / (1.0L * sum);
}
for (int i = int(0); i < int(3); ++i)
cout << fixed << setprecision(13) << ans[i] << " ";
cout << endl;
return 0;
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b;
cin >> a >> b;
long long x = 1;
while ((1 + x + 1) * (x + 1) / 2 <= a + b) {
x++;
}
vector<long long> d1, d2, ds(x + 1);
for (long long i = 1; i < x + 1; i++) {
ds[i] = i;
}
for (long long i = x; i > 0; i--) {
if (a >= ds[i]) {
a -= ds[i];
d1.push_back(ds[i]);
ds[i] = 0;
}
if (a == 0) {
break;
}
}
for (long long i = x; i > 0; i--) {
if (b >= ds[i] && ds[i] > 0) {
b -= ds[i];
d2.push_back(ds[i]);
ds[i] = 0;
}
if (b == 0) {
break;
}
}
cout << d1.size() << endl;
for (int i = d1.size() - 1; i >= 0; i--) {
cout << d1[i] << " ";
}
cout << endl << d2.size() << endl;
for (int i = d2.size() - 1; i >= 0; i--) {
cout << d2[i] << " ";
}
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, p, q, x = 0, y = 0;
cin >> n >> k;
p = n, q = 2 * n;
for (int i = 1; i <= k; i++) {
int j;
cin >> j;
int d = min(j / 4, p);
p -= d;
j -= 4 * d;
y += j / 2;
x += j % 2;
}
for (; y >= 0; y--, x += 2) {
if (y > p + q || x + y > 2 * p + q)
continue;
else {
cout << "YES\n";
return 0;
}
}
cout << "NO\n";
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T abs(T x) {
return x > 0 ? x : -x;
}
int n;
int m;
double g[1001][1001], w[1001][1001];
int main() {
int n, m, p, q;
scanf("%d%d%d%d", &n, &m, &p, &q);
p--;
q--;
p = n - p;
for (int i = 1; i < p; i++) {
for (int j = 0; j < m; j++) {
int k = 2;
if (j > 0) {
w[j][j - 1] = -1;
k++;
}
if (j + 1 < m) {
w[j][j + 1] = -1;
k++;
}
w[j][j] = k - 1;
w[j][m] = g[i - 1][j] + k;
}
for (int j = 0; j + 1 < m; j++) {
if (fabs(w[j][j] < 1e-8)) {
for (int k = max(j - 1, 0); k <= min(j + 2, m - 1); k++)
swap(w[j][k], w[j + 1][k]);
swap(w[j][m], w[j + 1][m]);
}
double tmp = w[j + 1][j] / w[j][j];
for (int k = max(j - 1, 0); k <= min(j + 2, m - 1); k++)
w[j + 1][k] -= w[j][k] * tmp;
w[j + 1][m] -= w[j][m] * tmp;
}
for (int j = m - 1; j > 0; j--) {
double tmp = w[j - 1][j] / w[j][j];
for (int k = max(j - 2, 0); k <= min(j + 1, m - 1); k++)
w[j - 1][k] -= w[j][k] * tmp;
w[j - 1][m] -= w[j][m] * tmp;
}
for (int j = 0; j < m; j++) g[i][j] = w[j][m] / w[j][j];
}
printf("%.10f\n", g[p - 1][q]);
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
string grid = ".........";
map<string, string> ans;
bool win(string s, char c) {
for (int i = 0; i < 3; i++) {
if (s[3 * i] == c and s[3 * i + 1] == c and s[3 * i + 2] == c) return 1;
if (s[i] == c and s[i + 3] == c and s[i + 6] == c) return 1;
}
if (s[0] == c and s[4] == c and s[8] == c) return 1;
if (s[2] == c and s[4] == c and s[6] == c) return 1;
return 0;
}
void search(int t) {
if (win(grid, 'X')) {
ans[grid] = "the first player won";
return;
}
if (win(grid, '0')) {
ans[grid] = "the second player won";
return;
}
if (t == 9) {
ans[grid] = "draw";
return;
}
if (t % 2 == 0)
ans[grid] = "first";
else
ans[grid] = "second";
for (int i = 0; i < 9; i++)
if (grid[i] == '.') {
grid[i] = t % 2 ? '0' : 'X';
search(t + 1);
grid[i] = '.';
}
}
int main() {
search(0);
string s, t;
for (int i = 0; i < 3; i++) {
cin >> t;
s += t;
}
if (ans.find(s) == ans.end())
puts("illegal");
else
cout << ans[s] << '\n';
return 0;
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 105;
long long inv[MAX_N], fac[MAX_N], finv[MAX_N];
void make() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX_N; i++) {
inv[i] = 1000000007 - inv[1000000007 % i] * (1000000007 / i) % 1000000007;
fac[i] = fac[i - 1] * (long long)i % 1000000007;
finv[i] = finv[i - 1] * inv[i] % 1000000007;
}
}
long long comb(int a, int b) {
if (a < b) {
return 0;
}
return fac[a] * (finv[b] * finv[a - b] % 1000000007) % 1000000007;
}
long long mod_pow(long long a, long long b) {
a %= 1000000007;
long long res = 1;
while (b) {
if (b & 1) {
res = res * a % 1000000007;
}
a = a * a % 1000000007;
b >>= 1;
}
return res;
}
long long add(long long x, long long y) { return (x + y) % 1000000007; }
long long sub(long long x, long long y) {
return (x + 1000000007 - y) % 1000000007;
}
long long mul(long long x, long long y) { return x * y % 1000000007; }
vector<int> G[MAX_N];
vector<vector<long long> > dfs(int v, int p) {
vector<vector<long long> > dp(1, vector<long long>(2));
int s = 1, t = 2;
dp[0][1] = 1;
for (auto&(u) : (G[v])) {
if (u != p) {
vector<vector<long long> > d = dfs(u, v);
int ns = (int)(d).size(), nt = (int)(d[0]).size();
int es = s, et = t;
s += ns, t += nt - 1;
vector<vector<long long> > e(s, vector<long long>(t));
swap(dp, e);
for (int i = 0; i < (int)(es); ++i) {
for (int j = 0; j < (int)(et); ++j) {
for (int ni = 0; ni < (int)(ns); ++ni) {
for (int nj = 0; nj < (int)(nt); ++nj) {
dp[i + ni + !!nj][j + nj] =
add(dp[i + ni + !!nj][j + nj], mul(e[i][j], d[ni][nj]));
}
}
}
}
}
}
for (int i = 0; i < (int)(s); ++i) {
for (int j = (int)(1); j < (int)(t); ++j) {
dp[i][0] = add(dp[i][0], mul(dp[i][j], j));
}
}
return dp;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 0; i < (int)(n - 1); ++i) {
int a, b;
cin >> a >> b;
--a, --b;
G[a].push_back(b), G[b].push_back(a);
}
make();
vector<vector<long long> > res = dfs(0, -1);
vector<long long> d(n);
for (int i = 0; i < (int)(n); ++i) {
d[i] = res[i][0];
}
vector<long long> ans(n);
ans[n - 1] = 1;
for (int i = (int)(n - 1) - 1; i >= 0; --i) {
ans[i] = mul(d[i], mod_pow(n, n - i - 2));
for (int j = (int)(i + 1); j < (int)(n); ++j) {
ans[i] = sub(ans[i], mul(ans[j], comb(j, i)));
}
}
for (int i = 0; i < (int)(n); ++i) {
cout << ans[i] << " ";
}
cout << "\n";
return 0;
}
| 18
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 10005, MAXM = 2005;
bool Q[MAXN];
vector<int> E[MAXN];
char s[MAXM][MAXM];
int Num[MAXN][3], Bel[MAXN], Ch[MAXN], cnt, N, tot, root, cur;
void Dfs(int Cur) {
Num[Cur][0] = Num[Cur][1] = Num[Cur][2] = 0;
if (Cur <= N) {
Bel[Cur] = (s[cur][Cur] == '1');
Num[Cur][Bel[Cur]]++;
return;
}
int f0 = 1, f1 = 1;
for (vector<int>::iterator i = E[Cur].begin(); i != E[Cur].end(); i++) {
Dfs(*i);
Num[Cur][Bel[*i]]++;
if (Bel[*i]) f0 = 0;
if (Bel[*i] != 1) f1 = 0;
}
if (f0)
Bel[Cur] = 0;
else if (!f1)
Bel[Cur] = 2;
else
Bel[Cur] = 1;
}
int Get(int Cur, vector<int> &Lk) {
if (Num[Cur][2] > 1) return 1;
if (Q[Cur]) {
vector<int>::iterator Fr = E[Cur].begin();
if (Bel[*Fr] != 1 && Num[Cur][1] || Bel[*Fr] != 2 && !Num[Cur][1])
reverse(E[Cur].begin(), E[Cur].end());
Fr = E[Cur].begin();
for (int i = 1; i <= Num[Cur][1]; i++) {
if (Bel[*Fr] != 1) return 1;
Lk.push_back(*Fr);
Fr++;
}
bool Flag = 0;
for (; Fr != E[Cur].end(); Fr++) {
if (!Flag && Num[Cur][2] && Bel[*Fr] != 2) return 1;
if (Bel[*Fr] == 2) {
Flag = 1;
if (Get(*Fr, Lk)) return 1;
} else
Lk.push_back(*Fr);
}
return 0;
}
if (Num[Cur][1]) {
int t1 = ++tot;
for (vector<int>::iterator i = E[Cur].begin(); i != E[Cur].end(); i++)
if (Bel[*i] == 1) E[t1].push_back(*i);
if (E[t1].size() == 1) t1 = E[t1][0];
Lk.push_back(t1);
}
for (vector<int>::iterator i = E[Cur].begin(); i != E[Cur].end(); i++)
if (Bel[*i] == 2 && Get(*i, Lk)) return 1;
if (Num[Cur][0]) {
int t2 = ++tot;
for (vector<int>::iterator i = E[Cur].begin(); i != E[Cur].end(); i++)
if (!Bel[*i]) E[t2].push_back(*i);
if (E[t2].size() == 1) t2 = E[t2][0];
Lk.push_back(t2);
}
return 0;
}
int Getr(int Cur, vector<int> &Lk) {
int tmp = Lk.size();
if (!Get(Cur, Lk)) {
reverse(Lk.begin() + tmp, Lk.end());
return 0;
}
return 1;
}
int Getl(int Cur, vector<int> &Lk) { return Get(Cur, Lk); }
int Calc(int Cur) {
if (Cur <= N) return 0;
if (Num[Cur][2] > 2) return 1;
if (Num[Cur][1] + Num[Cur][2] == 1) {
for (vector<int>::iterator i = E[Cur].begin(); i != E[Cur].end(); i++)
if (Bel[*i]) return Calc(*i);
}
vector<int> Tmp;
Tmp.clear();
if (Q[Cur]) {
bool End = 0, One = 0;
for (vector<int>::iterator i = E[Cur].begin(); i != E[Cur].end(); i++) {
if (End && Bel[*i]) return 1;
if (One && !Bel[*i]) End = 1;
if (Bel[*i] == 2) {
if (!One) {
if (Getr(*i, Tmp)) return 1;
} else if (Getl(*i, Tmp))
return 1;
} else
Tmp.push_back(*i);
if (Bel[*i]) One = 1;
}
E[Cur] = Tmp;
return 0;
} else {
int t1 = ++tot;
Q[t1] = 1;
for (vector<int>::iterator i = E[Cur].begin(); i != E[Cur].end(); i++)
if (Bel[*i] == 2) {
if (Getr(*i, E[t1])) return 1;
break;
}
if (Num[Cur][1]) {
int t2 = ++tot;
for (vector<int>::iterator i = E[Cur].begin(); i != E[Cur].end(); i++)
if (Bel[*i] == 1) E[t2].push_back(*i);
if (E[t2].size() == 1) t2 = E[t2][0];
E[t1].push_back(t2);
}
int Fl = 0;
for (vector<int>::iterator i = E[Cur].begin(); i != E[Cur].end(); i++)
if (Bel[*i] == 2) {
if (!Fl)
Fl = 1;
else {
if (Getl(*i, E[t1])) return 1;
break;
}
}
if (E[t1].size() == 1) t1 = E[t1][0];
Tmp.push_back(t1);
for (vector<int>::iterator i = E[Cur].begin(); i != E[Cur].end(); i++)
if (!Bel[*i]) Tmp.push_back(*i);
}
E[Cur] = Tmp;
return 0;
}
void Get_Order(int Cur) {
if (Cur <= N) {
Ch[++cnt] = Cur;
return;
}
for (vector<int>::iterator i = E[Cur].begin(); i != E[Cur].end(); i++)
Get_Order(*i);
}
int main() {
scanf("%d", &N);
root = tot = N + 1;
for (int i = 1; i <= N; i++) E[tot].push_back(i);
for (int i = 1; i <= N; i++) {
scanf("%s", s[i] + 1);
cur = i, Dfs(root);
if (Calc(root)) {
printf("NO\n");
return 0;
}
}
Get_Order(root);
printf("YES\n");
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= N; j++) printf("%c", s[i][Ch[j]]);
printf("\n");
}
}
| 22
|
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> v;
int n, a, k = 0, p = 0, i;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> a;
if (a < 0 && k > 1) v.push_back(p), p = k = 0;
p++;
if (a < 0) k++;
}
if (p) v.push_back(p);
cout << v.size() << endl;
for (i = 0; i < v.size(); i++) cout << v[i] << " ";
return 0;
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
long long int MOD = 1000000007;
long long int inf = 1e15;
void scan(int &x);
long long int powermod(long long int _a, long long int _b, long long int _m) {
long long int _r = 1;
while (_b) {
if (_b % 2 == 1) _r = (_r * _a) % _m;
_b /= 2;
_a = (_a * _a) % _m;
}
return _r;
}
long long int string_to_number(string s) {
long long int x = 0;
stringstream convert(s);
convert >> x;
return x;
}
long long int add(long long int a, long long int b) {
long long int x = (a + b) % MOD;
return x;
}
long long int mul(long long int a, long long int b) {
long long int x = (a * b) % MOD;
return x;
}
long long int sub(long long int a, long long int b) {
long long int x = (a - b + MOD) % MOD;
return x;
}
long long int divi(long long int a, long long int b) {
long long int x = a;
long long int y = powermod(b, MOD - 2, MOD);
long long int res = (x * y) % MOD;
return res;
}
int min(int a, int b) { return a < b ? a : b; }
int n, m;
bool bfs(string s1, string s2) {
vector<vector<bool>> vis(n, vector<bool>(m));
vis[0][0] = true;
vector<pair<int, int>> q = {{0, 0}};
for (int i = 0; i < q.size(); i++) {
int x = q[i].first, y = q[i].second;
int x2 = x, y2 = y;
if (s1[x] == '>')
y2++;
else
y2--;
if (y2 >= 0 && y2 < m && !vis[x2][y2]) {
vis[x2][y2] = true;
q.push_back({x2, y2});
}
int x3 = x, y3 = y;
if (s2[y] == 'v')
x3++;
else
x3--;
if (x3 >= 0 && x3 < n && !vis[x3][y3]) {
vis[x3][y3] = true;
q.push_back({x3, y3});
}
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (!vis[i][j]) return false;
return true;
}
int main() {
string s;
cin >> s;
int cnt_l = 0, cnt_p = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'o')
cnt_p++;
else
cnt_l++;
}
if (cnt_p == 0)
cout << "YES";
else if (cnt_l % cnt_p == 0)
cout << "YES";
else
cout << "NO";
return 0;
}
void scan(int &x) {
register int c = getchar();
x = 0;
int neg = 0;
for (; ((c < 48 || c > 57) && c != '-'); c = getchar())
;
if (c == '-') {
neg = 1;
c = getchar();
}
for (; c > 47 && c < 58; c = getchar()) {
x = (x << 1) + (x << 3) + c - 48;
}
if (neg) x = -x;
}
| 1
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 100 + 9;
int n;
int a[maxN];
bool moved[maxN];
void read() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
}
void solv() {
a[0] = 0;
a[n + 1] = 1001;
int cnt = 0;
for (int i = 0; i <= n; i++) {
if (moved[i]) continue;
int j = i;
while (j <= (n + 1) && (j - i) == (a[j] - a[i])) j++;
j--;
if (i < j) {
cnt = max(cnt, (j - 1 - (i + 1) + 1));
}
}
cout << cnt << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
read();
solv();
return 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000 + 10;
bool arr[MAXN][MAXN], mark[2][MAXN];
int dist[2][MAXN];
int n, m;
void bfs() {
queue<pair<int, int> > q;
q.push(make_pair(0, 0));
mark[0][0] = true;
while (!q.empty()) {
pair<int, int> v = q.front();
q.pop();
for (int i = 0; i < max(m + 1, n); i++)
if (((v.second == 0 && arr[v.first][i]) ||
(v.second == 1 && arr[i][v.first])) &&
!mark[1 - v.second][i]) {
dist[1 - v.second][i] = dist[v.second][v.first] + 1;
mark[1 - v.second][i] = true;
q.push(make_pair(i, 1 - v.second));
}
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
string second;
cin >> second;
for (int j = 0; j < m; j++)
if (second[j] == '#') arr[i][j + 1] = true;
}
arr[n - 1][m + 1] = true;
bfs();
if (dist[0][n - 1] == 0)
cout << -1 << endl;
else
cout << dist[0][n - 1] << endl;
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
int n;
int x, y;
vector<int> v[1000086];
int dep[1000086], son[1000086];
void dfs1(int i, int fa) {
for (int j = 0; j < v[i].size(); j++) {
int to = v[i][j];
if (to == fa) continue;
dfs1(to, i);
if (!son[i] || dep[to] > dep[son[i]]) son[i] = to;
}
if (son[i]) dep[i] = dep[son[i]] + 1;
}
int *f[1000086], ans[1000086];
int buf[1000086], *now = buf;
void dfs2(int i, int fa) {
f[i][0] = 1;
if (son[i]) {
f[son[i]] = f[i] + 1;
dfs2(son[i], i);
ans[i] = ans[son[i]] + 1;
}
for (int j = 0; j < v[i].size(); j++) {
int to = v[i][j];
if (to == fa || to == son[i]) continue;
f[to] = now, now += dep[to] + 1;
dfs2(to, i);
for (int k = 1; k <= dep[to] + 1; k++) {
f[i][k] += f[to][k - 1];
if (f[i][k] > f[i][ans[i]] || f[i][k] == f[i][ans[i]] && k < ans[i])
ans[i] = k;
}
}
if (f[i][ans[i]] == 1) ans[i] = 0;
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
v[x].push_back(y), v[y].push_back(x);
}
dfs1(1, 0);
f[1] = now, now += dep[1] + 1;
dfs2(1, 0);
for (int i = 1; i <= n; i++) printf("%d\n", ans[i]);
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
const int md = 1e6 + 10;
int counter = 0;
int n, a[301000], p[300100];
struct trie {
struct trie* lft;
struct trie* rht;
int cnt;
};
struct trie* newTrie() {
struct trie* tmp = (struct trie*)(malloc(sizeof(struct trie*)));
tmp->lft = NULL;
tmp->rht = NULL;
tmp->cnt = 0;
return tmp;
}
struct trie *ptr, *root;
void insert(int num) {
ptr = root;
ptr->cnt++;
for (int i = 29; i >= 0; i--) {
if ((num >> i) & 1) {
if (ptr->rht == NULL) ptr->rht = newTrie();
ptr = ptr->rht;
ptr->cnt++;
} else {
if (ptr->lft == NULL) ptr->lft = newTrie();
ptr = ptr->lft;
ptr->cnt++;
}
}
}
int srch(int num) {
int res = 0;
ptr = root;
ptr->cnt--;
for (int i = 29; i >= 0; i--) {
res <<= 1;
if ((num >> i) & 1) {
if (ptr->rht == NULL || ptr->rht->cnt <= 0)
ptr = ptr->lft, res |= 1;
else
ptr = ptr->rht;
} else {
if (ptr->lft == NULL || ptr->lft->cnt <= 0)
ptr = ptr->rht, res |= 1;
else
ptr = ptr->lft;
}
ptr->cnt--;
}
return res;
}
int main() {
root = newTrie();
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < n; ++i) cin >> p[i];
for (int i = 0; i < n; ++i) {
insert(p[i]);
}
for (int i = 0; i < n; ++i) {
cout << srch(a[i]) << " ";
}
return 0;
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, x;
cin >> n >> x;
vector<int> a(n);
vector<int> b(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
cin >> b[i];
}
sort(a.rbegin(), a.rend());
sort(b.begin(), b.end());
bool flag = true;
for (int i = 0; i < n; i++) {
if (a[i] + b[i] > x) {
flag = false;
break;
}
}
if (flag) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
string s;
long long int n, c = 1, a = 1;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> s;
if (s == "UR" or s == "DL") {
c++;
}
if (s == "UL" or s == "DR") {
a++;
}
if (s == "ULDR") {
c++;
a++;
}
}
cout << c * a;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
int sig(double x) { return (x > 1e-8) - (x < -1e-8); }
struct P {
double x, y;
P(double a = 0, double b = 0) : x(a), y(b) {}
P operator+(const P &a) const { return P(x + a.x, y + a.y); }
P operator-(const P &a) const { return P(x - a.x, y - a.y); }
P operator*(const double a) const { return P(x * a, y * a); }
P operator/(const double a) const { return P(x / a, y / a); }
double operator*(const P &a) const { return x * a.x + y * a.y; }
double operator^(const P &a) const { return x * a.y - y * a.x; }
bool operator<(const P &a) const { return x < a.x; }
};
struct node {
double a;
int id;
bool operator<(const node &x) const { return a < x.a; }
};
P p[100010];
node q[10010];
double x[10010], y[10010];
int main() {
int n, m;
double v;
while (scanf("%d%lf", &n, &v) != EOF) {
for (int i = 0; i < n; i++) {
scanf("%lf", &q[i].a);
q[i].id = i;
}
scanf("%d", &m);
for (int i = 0; i < m; i++) scanf("%lf%lf", &p[i].x, &p[i].y);
sort(q, q + n);
sort(p, p + m);
int j = 0;
for (int i = 0; i < n; i++) {
int f = 0;
while (j < m) {
double t = p[j].x / (v * cos(q[i].a));
double Y = v * sin(q[i].a) * t - 4.9 * t * t;
if (sig(Y) < 0) {
break;
} else if (sig(Y - p[j].y) <= 0) {
f = 1;
x[q[i].id] = p[j].x;
y[q[i].id] = Y;
break;
}
j++;
}
if (!f) {
double t = (v * sin(q[i].a)) / 4.9;
x[q[i].id] = t * v * cos(q[i].a);
y[q[i].id] = 0;
}
}
for (int i = 0; i < n; i++) {
printf("%.10lf %.10lf\n", x[i], y[i]);
}
}
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int inf = 1e9;
const int N = 40005;
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
string s, res = "";
cin >> s;
for (int i = 0; i < s.size(); i++) {
int k = 0;
char c = s[i];
if (s[i] == 'a' || s[i] == 'e' || s[i] == 'i' || s[i] == 'o' ||
s[i] == 'u' || s[i] == 'y') {
i++;
k++;
while (s[i] == s[i - 1]) {
k++;
i++;
}
if ((c == 'e' || c == 'o') && k == 2) {
res += c;
}
i--;
}
res += c;
}
cout << res << endl;
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
multiset<int> st;
for (int i = 0; i < n; i++) {
int b;
cin >> b;
st.insert(b);
}
multiset<int>::iterator it;
for (int i = 0; i < n; i++) {
it = st.lower_bound(n - a[i]);
if (it == st.end()) {
cout << a[i] + *st.begin() << " ";
st.erase(st.lower_bound(*st.begin()));
} else {
cout << (a[i] + *it) % n << " ";
st.erase(st.lower_bound(*it));
}
}
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t, a, b, c, d, i, j, k, l, m, n, x, y, p;
map<long long int, long long int> dp;
set<long long int> e;
cin >> n;
long long int h[n + 5];
for (i = 0; i < n; i++) {
cin >> h[i];
e.insert(h[i]);
dp[h[i]]++;
}
vector<long long int> s(e.begin(), e.end());
a = 0, b = 0, c = 0, d = 0;
for (i = 0; i < s.size(); i++) {
if (dp[s[i]] >= 8)
a++;
else if (dp[s[i]] >= 6)
b++;
else if (dp[s[i]] >= 4)
c++;
else if (dp[s[i]] >= 2)
d++;
}
cin >> t;
char ch;
while (t--) {
cin >> ch >> p;
if (ch == '+') {
dp[p]++;
if (dp[p] == 8) {
a++;
b--;
} else if (dp[p] == 6) {
b++;
c--;
} else if (dp[p] == 4) {
c++;
d--;
} else if (dp[p] == 2)
d++;
if (a > 0 || b > 1 || c > 1)
cout << "YES" << endl;
else if (b > 0 && (c > 0 || d > 0))
cout << "YES" << endl;
else if (c > 0 && d > 1)
cout << "YES" << endl;
else
cout << "NO" << endl;
} else if (ch == '-') {
dp[p]--;
if (dp[p] == 7) {
a--;
b++;
} else if (dp[p] == 5) {
b--;
c++;
} else if (dp[p] == 3) {
c--;
d++;
} else if (dp[p] == 1) {
d--;
}
if (a > 0 || b > 1 || c > 1)
cout << "YES" << endl;
else if (b > 0 && (c > 0 || d > 0))
cout << "YES" << endl;
else if (c > 0 && d > 1)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, q;
cin >> n >> q;
vector<vector<bool> > g(2, vector<bool>(n));
int x = 0;
for (int i = 0; i < q; i++) {
int ri, ci;
cin >> ri >> ci;
ri -= 1;
ci -= 1;
bool old = g[ri][ci], nw = !g[ri][ci];
g[ri][ci] = nw;
for (int j = -1; j <= 1; j += 2) {
for (int k = -1; k <= 1; k++) {
if (j == 0 and k == 0) continue;
int r2 = ri + j, c2 = ci + k;
if (r2 >= 0 and r2 < 2 and c2 >= 0 and c2 < n) {
bool nb = g[r2][c2];
if (nw == true and nb == true) {
x++;
} else if (nw == false and nb == true) {
x--;
}
}
}
}
cout << (x ? "No" : "Yes") << endl;
}
return 0;
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1 << 20;
const int MOD = 1e9 + 7;
priority_queue<pair<long long int, int> > pq;
vector<pair<long long int, long long int> > vp;
map<long long int, long long int> mp, mpp;
long long int dp[N];
vector<long long int> v, v1, v2;
stack<long long int> s, s1;
long long int visit[N];
struct domingo {
int val, left, right;
} o[N];
long long int BIT[N];
long long int seg_tree[4 * N];
set<long long int> se[250];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long int n, m, val, k, d, mi = 1e9, mx(0);
long long int sum(0), ct(0), p(0), q(0);
string s;
cin >> n >> val;
long long int a[n + 1];
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] == 1) {
v.push_back(i);
mp[max(i - val + 1, 1LL)]++;
mp[i + val]--;
}
}
for (int i = 1; i <= n; i++) {
mp[i] += mp[i - 1];
if (mp[i] == 0) return cout << -1, 0;
}
mp.clear();
for (int i = 0; i < v.size(); i++) {
mp.clear();
for (int j = 0; j < v.size(); j++) {
if (i != j and mpp[j] == 0) {
mp[max(1LL, v[j] - val + 1)]++;
mp[v[j] + val]--;
}
}
for (int i = 1; i <= n; i++) {
mp[i] += mp[i - 1];
}
int flag = 0;
for (int i = 1; i <= n; i++) {
if (mp[i] == 0) flag = 1;
}
if (flag == 0) {
ct++;
mpp[i]++;
}
}
cout << (int)v.size() - ct;
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
int main() {
char a[100], b[100];
gets(a);
gets(b);
int a1 = 0, a2 = 0;
for (int i = 0; i < strlen(a); i += 2) {
if (a[i] == '8' && a[i + 1] == '<') {
if (b[i] == '(' && b[i + 1] == ')') a2++;
if (b[i] == '[' && b[i + 1] == ']') a1++;
}
if (a[i] == '(' && a[i + 1] == ')') {
if (b[i] == '8' && b[i + 1] == '<') a1++;
if (b[i] == '[' && b[i + 1] == ']') a2++;
}
if (a[i] == '[' && a[i + 1] == ']') {
if (b[i] == '(' && b[i + 1] == ')') a1++;
if (b[i] == '8' && b[i + 1] == '<') a2++;
}
}
if (a1 == a2)
cout << "TIE";
else if (a1 < a2)
cout << "TEAM 2 WINS";
else
cout << "TEAM 1 WINS";
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e4 + 20;
int n, a, num;
vector<int> ve;
int ans[4][4];
bool in[12];
int sum[9];
bool ch() {
int last = 0;
memset(sum, 0, sizeof(sum));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) sum[last] += ans[i][j];
++last;
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) sum[last] += ans[j][i];
++last;
}
for (int i = 0; i < n; ++i) sum[last] += ans[i][i];
int x = n - 1;
++last;
for (int i = 0; i < n; ++i) sum[last] += ans[i][x - i];
for (int i = 1; i <= last; ++i)
if (sum[i] != sum[i - 1]) return false;
return true;
}
void dis() {
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) printf("%d ", ans[i][j]);
printf("\n");
}
}
void solve(int x, int y) {
if (x == n - 1 && y == n) {
if (ch()) {
cout << sum[0] << endl;
dis();
exit(0);
}
return;
}
if (y == n) {
y = 0;
++x;
}
for (int i = 0; i < n * n; ++i) {
if (in[i]) continue;
ans[x][y] = ve[i];
in[i] = true;
solve(x, y + 1);
in[i] = false;
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n * n; ++i) scanf("%d", &a), ve.push_back(a);
if (n == 1) return printf("%d\n%d", ve[0], ve[0]), 0;
solve(0, 0);
return 0;
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return a * (b / gcd(a, b)); }
void solve() {
long long n;
cin >> n;
long long a[n];
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
for (long long i = 0; i < n / 2; i++) {
if (a[i] < i) {
cout << "NO" << '\n';
return;
}
}
for (long long i = n / 2; i < n; i++) {
if (a[i] < n - 1 - i) {
cout << "NO" << '\n';
return;
}
}
if (n % 2 == 0) {
if (a[n / 2 - 1] > n / 2 - 1 || a[n / 2] >= n / 2) {
cout << "YES" << '\n';
return;
}
cout << "NO" << '\n';
return;
}
cout << "YES" << '\n';
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
long long TESTS = 1;
cin >> TESTS;
while (TESTS--) {
solve();
}
return 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool upmin(T &x, T y) {
return y < x ? x = y, 1 : 0;
}
template <typename T>
inline bool upmax(T &x, T y) {
return x < y ? x = y, 1 : 0;
}
const long double eps = 1e-11;
const long double pi = acos(-1);
const int oo = 1 << 30;
const long long loo = 1ll << 62;
const int mods = 998244353;
const int MAXN = 2000005;
const int INF = 0x3f3f3f3f;
inline long long read() {
long long f = 1, x = 0;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 3) + (x << 1) + (c ^ 48);
c = getchar();
}
return x * f;
}
long long bse[60], num = 0;
void insert(long long x) {
for (long long i = 59; i >= 0; i--)
if ((x >> i) & 1) {
if (!bse[i]) {
num++, bse[i] = x;
break;
} else
x ^= bse[i];
}
}
long long query(long long x) {
for (long long i = 59; i >= 0; i--)
if ((x >> i) & 1) x ^= bse[i];
return x;
}
signed main() {
long long n = read(), s = 0;
for (long long i = 1, x, y; i <= n; i++)
x = read(), y = read(), s ^= x, insert(y ^ x);
if (!query(s))
printf("%lld/%lld\n", (1ll << num) - 1, 1ll << num);
else
puts("1/1");
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int c = 0, b = 1;
int i;
for (i = 1; c <= (240 - k); i++) {
c += (5 * i);
}
cout << min(i - 2, n) << endl;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
const long long MILLER_RABIN = 3215031751;
const long double PI = acos(-1);
struct config_io {
config_io() {
cin.tie(nullptr);
cout.tie(nullptr);
ios_base::sync_with_stdio(false);
}
} cnf_io;
inline void tobin(long long x) { cout << bitset<63>(x) << endl; }
template <class T>
inline void trace(T collection) {
for (auto elem : collection) {
cout << elem << " ";
}
cout << endl;
}
const int ML = 1e3 + 10;
vector<vector<int>> g(ML);
vector<int> comp(ML, -1);
vector<int> cc[ML];
void dfs(int v, int c) {
comp[v] = c;
cc[c].push_back(v);
for (int i = 0; i < (int)g[v].size(); ++i) {
int to = g[v][i];
if (comp[to] == -1) {
dfs(to, c);
}
}
}
void make_test() {
srand(time(NULL));
int n = 1000, m = 100000, w = 999;
cout << n << " " << m << " " << w << endl;
for (int i = 0; i < (int)n; ++i) cout << rand() % (w + 1) << " ";
cout << endl;
for (int i = 0; i < (int)n; ++i) cout << rand() % (w + 1) << " ";
cout << endl;
for (int i = 0; i < (int)m; ++i) {
cout << 1 + (rand() % (n)) << " " << 1 + (rand() % (n)) << endl;
}
}
void solve(int test) {
int n, m, W;
cin >> n >> m >> W;
vector<int> w(n), b(n);
for (int i = 0; i < (int)n; ++i) cin >> w[i];
for (int i = 0; i < (int)n; ++i) cin >> b[i];
for (int i = 0; i < (int)m; ++i) {
int u, v;
cin >> u >> v;
--u, --v;
g[u].push_back(v);
g[v].push_back(u);
}
int cnt = 0;
for (int i = 0; i < (int)n; ++i) {
if (comp[i] == -1) {
dfs(i, cnt);
++cnt;
}
}
vector<long long> compw(cnt, 0), compb(cnt, 0);
for (int i = 0; i < (int)cnt; ++i) {
for (int j = 0; j < (int)cc[i].size(); ++j) {
compw[i] += w[cc[i][j]];
compb[i] += b[cc[i][j]];
}
}
vector<vector<long long>> dp(cnt, vector<long long>(ML, 0));
for (int i = 0; i < (int)cc[0].size(); ++i)
dp[0][w[cc[0][i]]] = max(dp[0][w[cc[0][i]]], (long long)b[cc[0][i]]);
if (compw[0] < ML) dp[0][compw[0]] = max(dp[0][compw[0]], compb[0]);
for (int i = 1; i < (int)cnt; ++i) {
for (int ww = 0; ww < (int)ML; ++ww) dp[i][ww] = dp[i - 1][ww];
for (int j = 0; j < (int)cc[i].size(); ++j) {
int cur = cc[i][j];
for (int ww = 0; ww < (int)ML; ++ww) {
if (ww - w[cur] < 0) continue;
dp[i][ww] = max(dp[i][ww], dp[i - 1][ww - w[cur]] + b[cur]);
}
}
for (int ww = 0; ww < (int)ML; ++ww) {
if (ww - compw[i] < 0) continue;
dp[i][ww] = max(dp[i][ww], dp[i - 1][ww - compw[i]] + compb[i]);
}
}
long long ans = 0;
for (int ww = 0; ww < (int)W + 1; ++ww) ans = max(ans, dp[cnt - 1][ww]);
cout << ans << endl;
}
int main() {
int tests = 1;
for (int test = 1; test <= tests; ++test) {
solve(test);
}
return 0;
}
| 8
|
#include <bits/stdc++.h>
const int maxn = 300010;
int ls[maxn * 50], rs[maxn * 50], tree[maxn * 50], lazy[maxn * 50], tot, n, q,
l, r, k, mn, mx, ow;
template <typename T>
inline T read(T& x) {
x = 0;
int _f = 0;
char ch = getchar();
while (ch < '0' || ch > '9') _f |= (ch == '-'), ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x = _f ? -x : x;
}
inline void pushdown(int o, int l, int r) {
if (lazy[o] == -1) return;
if (!ls[o]) ls[o] = ++tot;
if (!rs[o]) rs[o] = ++tot;
int m = (l + r) >> 1;
lazy[ls[o]] = lazy[rs[o]] = lazy[o];
tree[ls[o]] = (m - l + 1) * lazy[o];
tree[rs[o]] = (r - m) * lazy[o];
lazy[o] = -1;
}
inline void add(int& now, int l, int r, int ql, int qr, int d) {
if (!now) now = ++tot;
if (l == ql && r == qr) {
tree[now] = (r - l + 1) * d;
lazy[now] = d;
return;
}
pushdown(now, l, r);
int m = (l + r) >> 1;
if (qr <= m)
add(ls[now], l, m, ql, qr, d);
else if (ql > m) {
add(rs[now], m + 1, r, ql, qr, d);
} else {
add(ls[now], l, m, ql, m, d);
add(rs[now], m + 1, r, m + 1, qr, d);
}
tree[now] = tree[ls[now]] + tree[rs[now]];
}
int main() {
memset(lazy, -1, sizeof(lazy));
read(n);
read(q);
for (int i = 1; i <= q; i++) {
read(l);
read(r);
read(k);
if (k == 2) k = 0;
add(ow, 1, n, l, r, k);
printf("%d\n", n - tree[ow]);
}
return 0;
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
int a[200005], b[200005], c[400005], n, m;
int ok1(int x);
int ok2(int x);
int main() {
int num = 1;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
c[num++] = a[i];
}
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
scanf("%d", &b[i]);
c[num++] = b[i];
}
sort(a + 1, a + 1 + n);
sort(b + 1, b + 1 + m);
sort(c + 1, c + num);
int ans;
int x, y;
x = n * 2;
y = m * 2;
ans = x - y;
for (int i = num - 1; i >= 0; i--) {
int temp1 = upper_bound(a + 1, a + n + 1, c[i]) - a - 1;
int temp2 = upper_bound(b + 1, b + m + 1, c[i]) - b - 1;
int tt = temp1 * 2 + (n - temp1) * 3;
int ttt = temp2 * 2 + (m - temp2) * 3;
if (ans <= tt - ttt) {
x = tt;
y = ttt;
ans = x - y;
}
}
printf("%d:%d\n", x, y);
return 0;
}
| 8
|
#include <bits/stdc++.h>
int n;
int main() {
scanf("%d", &n);
printf("%d", 1 + 6 * n * ~-n);
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
const int a[] = {0, 0, 1, 1, 1, 2, 1, 1, 14, 8, 4, 2, 41,
13, 21, 1, 22, 4, 19, 19, 4, 2, 1, 16, 13, 4,
35, 19, 4, 2, 41, 4, 87, 41, 115, 2, 59, 31, 49,
8, 28, 4, 31, 44, 50, 13, 151, 16, 91, 56, 14};
int n;
int main() {
scanf("%d", &n);
for (int i = 0; i < n - 1; i++) printf("%d ", (long long)a[n] >> i & 1);
puts("1");
for (int i = 0; i < n; i++) printf("%d ", 1);
return 0;
}
| 19
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 1e5;
int n, m, a, b, s[MaxN + 5], p[MaxN + 5];
long long ans1, ans2, x, y;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &s[i]);
scanf("%d%d", &a, &b);
for (int i = 1; i <= a; i++) scanf("%d", &p[i]);
ans1 += s[n];
ans2 += p[a];
for (int i = n - 1; i >= 1; i--) {
++x;
y = 1;
for (int j = 1; j <= x; j++) y *= m;
ans1 += y * s[i];
}
x = 0;
for (int i = a - 1; i >= 1; i--) {
++x;
y = 1;
for (int j = 1; j <= x; j++) y *= b;
ans2 += y * p[i];
}
if (ans1 > ans2) printf(">");
if (ans1 == ans2) printf("=");
if (ans1 < ans2) printf("<");
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
int main() {
double n;
cin >> n;
long long ans =
(n - 4) * (n - 3) * (n - 2) * (n - 1) * n / 120 +
(n - 5) * (n - 4) * (n - 3) * (n - 2) * (n - 1) * n / (120 * 6) +
(n - 6) * (n - 5) * (n - 4) * (n - 3) * (n - 2) * (n - 1) * n /
(120 * 6 * 7);
cout << ans;
return 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
inline void read(int &x) {
int v = 0, f = 1;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-')
f = -1;
else
v = (c & 15);
while (isdigit(c = getchar())) v = (v << 1) + (v << 3) + (c & 15);
x = v * f;
}
inline void read(long long &x) {
long long v = 0ll, f = 1ll;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-')
f = -1;
else
v = (c & 15);
while (isdigit(c = getchar())) v = (v << 1) + (v << 3) + (c & 15);
x = v * f;
}
inline void readc(char &x) {
char c;
while (((c = getchar()) == ' ') || c == '\n')
;
x = c;
}
inline void writes(string s) { puts(s.c_str()); }
inline void writeln() { writes(""); }
inline void writei(int x) {
if (x < 0) {
putchar('-');
x = abs(x);
}
if (!x) putchar('0');
char a[25];
int top = 0;
while (x) {
a[++top] = (x % 10) + '0';
x /= 10;
}
while (top) {
putchar(a[top]);
top--;
}
}
inline void writell(long long x) {
if (x < 0) {
putchar('-');
x = abs(x);
}
if (!x) putchar('0');
char a[25];
int top = 0;
while (x) {
a[++top] = (x % 10) + '0';
x /= 10;
}
while (top) {
putchar(a[top]);
top--;
}
}
int n, m, i, j, px[750005], py[750005], cnt;
int fa[750005], lc[750005], rc[750005], sz[750005], rev[750005];
vector<int> e[750005];
void pushup(int x) {
sz[x] = (x < n);
if (lc[x]) sz[x] += sz[lc[x]];
if (rc[x]) sz[x] += sz[rc[x]];
}
int isrt(int x) { return lc[fa[x]] != x && rc[fa[x]] != x; }
void urv(int x) {
rev[x] ^= 1;
swap(lc[x], rc[x]);
}
void pushdo(int x) {
if (rev[x]) {
if (lc[x]) urv(lc[x]);
if (rc[x]) urv(rc[x]);
rev[x] = 0;
}
}
void pushall(int x) {
if (!isrt(x)) pushall(fa[x]);
pushdo(x);
}
void rot(int x) {
int y = fa[x], z = fa[y];
if (!isrt(y)) {
if (lc[z] == y)
lc[z] = x;
else
rc[z] = x;
}
fa[x] = z;
fa[y] = x;
if (lc[y] == x) {
lc[y] = rc[x];
rc[x] = y;
fa[lc[y]] = y;
} else {
rc[y] = lc[x];
lc[x] = y;
fa[rc[y]] = y;
}
pushup(y);
pushup(x);
}
void splay(int x) {
pushall(x);
while (!isrt(x)) {
int y = fa[x], z = fa[y];
if (!isrt(y)) {
if ((lc[y] == x) == (lc[z] == y)) {
rot(y);
} else {
rot(x);
}
}
rot(x);
}
}
void access(int x) {
int y = 0;
while (x) {
splay(x);
rc[x] = y;
pushup(x);
y = x;
x = fa[x];
}
}
void mkrt(int x) {
access(x);
splay(x);
urv(x);
}
void link(int x, int y) {
mkrt(x);
fa[x] = y;
}
void cut(int x, int y) {
mkrt(x);
access(y);
splay(x);
rc[x] = fa[y] = 0;
pushup(x);
}
int query(int x) {
pushdo(x);
if (sz[lc[x]]) return query(lc[x]);
if (x < n) return x;
return query(rc[x]);
}
void solve(int x, int p) {
mkrt(x);
access(p);
splay(p);
int t = query(p);
printf("%d %d %d %d\n", x - (n - 1), p - (n - 1), px[t] - (n - 1),
py[t] - (n - 1));
cut(t, px[t]);
cut(py[t], t);
cnt++;
link(cnt, x);
link(cnt, p);
}
void dfs2(int x, int p) {
for (__typeof((e[x]).begin()) it = (e[x]).begin(); it != (e[x]).end(); it++) {
if (*it == p) continue;
dfs2(*it, x);
}
if (p) solve(x + n - 1, p + n - 1);
}
int main() {
read(n);
for (((i)) = (1); ((i)) <= ((n - 1)); ((i))++) {
int x, y;
read(x);
read(y);
e[x].push_back(y);
e[y].push_back(x);
}
for (((i)) = (1); ((i)) <= ((n - 1)); ((i))++) {
int x, y;
read(x);
read(y);
px[i] = x + n - 1;
py[i] = y + n - 1;
sz[i] = 1;
link(i, x + n - 1);
link(y + n - 1, i);
}
printf("%d\n", n - 1);
cnt = n - 1 + n;
dfs2(1, 0);
return 0;
}
| 24
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int x = 0;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
if (s[1] == '-') {
x--;
} else {
x++;
}
}
cout << x << endl;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
int vst[1000100], p[1000100], pk;
long long arr[1000100], d[1000100];
int dp[1000100], tmp[1000100], tp[1000100];
int id[1000100];
bool is_prime(long long a) {
if (a < 1000100) return false;
for (int i = 0; i < pk; i++) {
if (1LL * p[i] * p[i] > a) break;
if (a % p[i] == 0) return false;
}
return true;
}
long long A;
int cnt;
int get(long long a) {
if (a < 1000100) return id[a];
return cnt - 1 - id[A / a];
}
int main() {
cin >> A;
int n = 0;
for (int i = 2; i < 1000100; i++) {
if (vst[i]) continue;
for (long long j = i; j < 1000000000000LL; j *= i) {
if (A % (j + 1)) continue;
tp[n] = i;
arr[n++] = j + 1;
}
p[pk++] = i;
if (i > 10000) continue;
for (int j = i * i; j < 1000100; j += i) vst[j] = 1;
}
if (A <= 3) return printf("%d\n", A & 1), 0;
for (long long i = 1; i * i <= A; i++) {
if (A % i) continue;
d[cnt++] = i;
if (i * i != A) d[cnt++] = A / i;
}
sort(d, d + cnt);
for (int i = 0; i < cnt; i++) {
if (d[i] < 1000100) id[d[i]] = i;
}
dp[0] = 1;
for (int i = 0, ii = 0; i < n; i = ii) {
for (int j = 0; j < cnt; j++) tmp[j] = dp[j];
for (; ii < n && tp[i] == tp[ii]; ii++) {
for (int j = 0; j < cnt - 1; j++) {
if (!tmp[j]) continue;
if (arr[ii] > d[cnt - j - 1]) continue;
if (d[cnt - j - 1] % arr[ii]) continue;
dp[get((long long)arr[ii] * d[j])] += tmp[j];
}
}
}
int ans = dp[cnt - 1];
for (int i = 0; i < cnt - 1; i++) {
if (!dp[i]) continue;
if (is_prime(A / d[i] - 1)) ans += dp[i];
}
cout << ans << endl;
return 0;
}
| 18
|
#include <bits/stdc++.h>
using namespace std;
void _fill_int(int* p, int val, int rep) {
int i;
for (i = 0; i < rep; i++) p[i] = val;
}
int GETi() {
int i;
scanf("%d", &i);
return i;
}
template <class T>
T sqr(T val) {
return val * val;
}
int N;
vector<int> E[100001];
vector<signed long long> V;
pair<signed long long, signed long long> dfs(int cur, int pre) {
signed long long l = 0, h = 0, tv;
int i;
for (i = 0; i < E[cur].size(); i++) {
if (E[cur][i] == pre) continue;
pair<signed long long, signed long long> tt = dfs(E[cur][i], cur);
l = max(l, tt.first);
h = max(h, tt.second);
}
tv = V[cur] + h - l;
if (tv >= 0) return make_pair(l + tv, h);
return make_pair(l, h - tv);
}
void solve() {
int f, r, i, j, k, l, x, y;
N = GETi();
for (i = 0; i < N - 1; i++) {
j = GETi() - 1;
l = GETi() - 1;
E[j].push_back(l);
E[l].push_back(j);
}
for (i = 0; i < N; i++) V.push_back((signed long long)GETi());
pair<signed long long, signed long long> tval = dfs(0, -1);
cout << tval.first + tval.second << endl;
return;
}
int main(int argc, char** argv) {
if (argc > 1) freopen(argv[1], "r", stdin);
solve();
return 0;
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
int a, b, c, d;
int main() {
int t;
scanf("%d", &t);
while (t--) {
scanf("%d%d%d%d", &a, &b, &c, &d);
printf("%d\n", abs(a - c) + abs(b - d) + 2 * (a != c && b != d));
}
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m, s, t;
cin >> n >> m;
vector<vector<int> > g(n + 1);
vector<bool> vis(n + 1, 0);
vector<int> indeg(n + 1, 0);
vector<int> dp(n + 1, -1);
queue<int> qf, ql;
while (m--) {
int a, b;
cin >> a >> b;
g[b].push_back(a);
indeg[a]++;
}
cin >> s >> t;
dp[t] = 0;
qf.push(t);
while (!qf.empty() | !ql.empty()) {
while (!qf.empty()) {
int v = qf.front();
qf.pop();
if (vis[v]) continue;
vis[v] = 1;
for (auto to : g[v]) {
indeg[to]--;
if (!indeg[to]) {
if (dp[to] == -1) {
dp[to] = dp[v];
qf.push(to);
} else if (dp[to] > dp[v]) {
dp[to] = dp[v];
qf.push(to);
}
} else if (dp[to] == -1) {
dp[to] = dp[v] + 1;
ql.push(to);
}
}
}
bool f = 0;
while (!ql.empty()) {
int v = ql.front();
ql.pop();
if (vis[v]) continue;
vis[v] = 1;
for (auto to : g[v]) {
indeg[to]--;
if (!indeg[to]) {
if (dp[to] == -1) {
dp[to] = dp[v];
qf.push(to);
f = 1;
} else if (dp[to] > dp[v]) {
dp[to] = dp[v];
qf.push(to);
f = 1;
}
} else if (dp[to] == -1) {
dp[to] = dp[v] + 1;
ql.push(to);
}
}
if (f) break;
}
}
cout << dp[s];
return 0;
}
| 18
|
#include <bits/stdc++.h>
using namespace std;
int n;
char res[10];
int main() {
scanf(" %d", &n);
bool flipped = false;
int lo = 0, hi = 1000000000;
for (int i = 1; i <= n; ++i) {
if (lo + 1 < hi) {
int mid = (lo + hi) / 2;
printf("1 %d\n", mid);
fflush(stdout);
scanf(" %s", res);
if (res[0] == 'w') {
lo = mid;
} else {
hi = mid;
}
} else {
assert(i == n);
printf("500 %d\n", lo);
fflush(stdout);
scanf(" %s", res);
if (res[0] != 'w') {
flipped = true;
}
}
}
if (flipped) swap(lo, hi);
printf("0 %d 2 %d\n", lo, hi);
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n], z = 0, b[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i]) z++;
if (a[i])
b[i] = -1;
else
b[i] = 1;
}
if (z == n) {
cout << n - 1 << endl;
return 0;
}
int maxi = 0, sum = 0, s = 0, e = 0;
for (int i = 0; i < n; i++) {
sum += b[i];
if (sum < 0) {
sum = 0;
s = i + 1;
}
if (sum > maxi) {
maxi = sum;
e = i;
}
}
cout << maxi + z << endl;
return 0;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v[350001];
int n, i, q, type, l, r, zn, ans;
bool pole[350001];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> q;
while (q--) {
cin >> type >> zn;
if (type == 1) {
ans++;
r++;
v[zn].push_back(r);
} else if (type == 2) {
for (i = 0; i < v[zn].size(); i++)
if (!pole[v[zn][i]]) {
ans--;
pole[v[zn][i]] = true;
}
v[zn].clear();
} else {
for (i = l + 1; i <= zn; i++)
if (!pole[i]) {
ans--;
pole[i] = true;
}
l = max(l, zn);
}
cout << ans << '\n';
}
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
vector<int> p[5005];
int n, m, minn[5005];
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) minn[i] = -1;
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d %d", &x, &y);
p[x].push_back(y);
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < p[i].size(); j++) {
int to = p[i][j];
if (to > i) {
if (minn[i] == -1)
minn[i] = (to - i);
else
minn[i] = min(minn[i], to - i);
} else {
if (minn[i] == -1)
minn[i] = (n - i + to);
else
minn[i] = min(minn[i], n - i + to);
}
}
}
for (int i = 1; i <= n; i++) {
long long ans = 0;
for (int j = 1; j <= n; j++) {
long long now = 0;
if (j >= i)
now += j - i;
else
now += n - i + j;
int S = p[j].size();
if (S == 0)
continue;
else
now += (S - 1) * n + minn[j];
ans = max(now, ans);
}
printf("%d ", ans);
}
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
int n, arr[100005], dp[100005], sol;
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> arr[i + 1];
for (int i = 0; i < n; i++) dp[i + 1] = min(arr[i + 1], dp[i] + 1);
for (int i = 0; i < n; i++) dp[n - i] = min(dp[n - i], dp[n - i + 1] + 1);
for (int i = 0; i < n; i++) sol = max(sol, dp[i + 1]);
cout << sol << endl;
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
int i, j, m, n, p, k, q, x, y;
int g[61][61][61], f[61][61][61];
int main() {
scanf("%d%d%d", &n, &m, &q);
for (i = 1; i <= m; i++) {
for (j = 1; j <= n; j++)
for (k = 1; k <= n; k++) scanf("%d", &g[i][j][k]);
for (int k = 1; k <= n; k++)
for (int I = 1; I <= n; I++)
for (j = 1; j <= n; j++)
g[i][I][j] = min(g[i][I][j], g[i][I][k] + g[i][k][j]);
}
memset(f, 60, sizeof(f));
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++)
for (k = 1; k <= m; k++) f[i][j][0] = min(f[i][j][0], g[k][i][j]);
for (int size = 1; size <= n; size++)
for (k = 1; k <= n; k++)
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++)
f[i][j][size] = min(f[i][j][size], f[i][k][size - 1] + f[k][j][0]);
for (; q--;) {
scanf("%d%d%d", &x, &y, &k);
k = min(n, k);
printf("%d\n", f[x][y][k]);
}
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int inf = 1e9 + 1;
const double eps = 1e-15;
const double EPS = 1e-9;
const double PI = acos(-1.0);
long long int dx_8[] = {-1, -1, -1, 0, 0, 1, 1, 1},
dy_8[] = {-1, 0, 1, -1, 1, -1, 0, 1};
long long int dx[] = {0, 0, 1, -1}, dy[] = {1, -1, 0, 0};
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long int lcm(long long int a, long long int b) {
return a * b / gcd(a, b);
}
long long int M = 1000000007;
long long int big_mod(long long int n, long long int p) {
if (p == 0) return 1;
if (p % 2 == 0) {
long long int ret = big_mod(n, p / 2);
return ((ret % M) * (ret % M)) % M;
} else
return ((n % M) * (big_mod(n, p - 1) % M)) % M;
}
long long int reminder(string s, long long int n) {
long long int mod = 0;
for (long long int i = 0; i < s.size(); i++) {
long long int digit = (long long int)s[i] - '0';
mod = mod * 10 + digit;
mod = mod % n;
}
return mod;
}
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
long long int t, n, r, a;
cin >> t;
map<int, int> mp;
vector<int> v;
while (t--) {
cin >> n >> r;
for (long long int i = 0; i < n; i++) {
cin >> a;
if (a - r > 0 && mp[a] == 0) {
v.push_back(a);
mp[a] = 1;
}
}
int cnt = 0;
sort(v.rbegin(), v.rend());
;
int temp = 1;
for (int i = 0; i < v.size(); i++) {
if (v[i] - (temp * r) <= 0) {
break;
} else {
temp = i + 1;
}
cnt++;
}
cout << max(1, cnt) << endl;
v.clear();
mp.clear();
}
return 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300000 + 100;
long long a[maxn];
long long dp[maxn];
long long dp2[maxn];
vector<int> G[maxn], dist[maxn];
long long int ans = 0;
void dfs(int u, int fa) {
long long int max1 = 0, max2 = 0;
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
if (v == fa) continue;
dfs(v, u);
if (dp[v] - dist[u][i] > max1) {
max2 = max1;
max1 = dp[v] - dist[u][i];
} else if (dp[v] - dist[u][i] == max1) {
max2 = max1;
} else {
if (dp[v] - dist[u][i] > max2) {
max2 = dp[v] - dist[u][i];
}
}
}
dp[u] = a[u] + max1;
dp2[u] = max1 + max2 + a[u];
if (dp[u] > ans) {
ans = dp[u];
}
if (dp2[u] > ans) {
ans = dp2[u];
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
}
int x, y, w;
for (int i = 1; i < n; i++) {
scanf("%d%d%d", &x, &y, &w);
G[x].push_back(y);
G[y].push_back(x);
dist[x].push_back(w);
dist[y].push_back(w);
}
dfs(1, -1);
printf("%lld", ans);
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000005;
const int SQRTN = 1003;
const int LOGN = 22;
const double PI = acos(-1);
const int INF = 1e9;
const int MOD = 1000000007;
const int FMOD = 998244353;
const double eps = 1e-9;
template <typename T>
T gcd(T a, T b) {
return (b ? __gcd(a, b) : a);
}
template <typename T>
T lcm(T a, T b) {
return (a * (b / gcd(a, b)));
}
template <typename T>
T add(T a, T b, T c = MOD) {
T res = a + b;
return (res >= c ? res - c : res);
}
template <typename T>
T mod_neg(T a, T b, T c = MOD) {
T res;
if (abs(a - b) < c)
res = a - b;
else
res = (a - b) % c;
return (res < 0 ? res + c : res);
}
template <typename T>
T mul(T a, T b, T c = MOD) {
long long res = (long long)a * b;
return (res >= c ? res % c : res);
}
inline long long mulmod(long long a, long long b, long long m = MOD) {
long long q = (long long)(((long double)a * (long double)b) / (long double)m);
long long r = a * b - q * m;
if (r > m) r %= m;
if (r < 0) r += m;
return r;
}
template <typename T>
T expo(T e, T n) {
T x = 1, p = e;
while (n) {
if (n & 1) x = x * p;
p = p * p;
n >>= 1;
}
return x;
}
template <typename T>
T power(T e, T n, T m = MOD) {
T x = 1, p = e;
while (n) {
if (n & 1) x = mul(x, p, m);
p = mul(p, p, m);
n >>= 1;
}
return x;
}
template <typename T>
T extended_euclid(T a, T b, T &x, T &y) {
T xx = 0, yy = 1;
y = 0;
x = 1;
while (b) {
T q = a / b, t = b;
b = a % b;
a = t;
t = xx;
xx = x - q * xx;
x = t;
t = yy;
yy = y - q * yy;
y = t;
}
return a;
}
template <typename T>
T mod_inverse(T a, T n = MOD) {
T x, y, z = 0;
T d = extended_euclid(a, n, x, y);
return (d > 1 ? -1 : mod_neg(x, z, n));
}
void it_2107() {
long long k = 0, n = 0, x = 0, m = 0, curr = 0, num = 0, n1 = 0, n2 = 0,
n3 = 0, n4 = 0, i = 0, j = 0;
long long root = 0, sum = 0, diff = 0, q = 0, choice = 0, d = 0, len = 0,
beg = 0, end = 0, pos = 0, cnt = 0;
long long lo = 0, hi = 0, mid = 0, ans = 0;
bool flag = false;
string s1, s2, s3, str, t;
char ch, ch1, ch2, ch3, *ptr;
double dub = 0;
cin >> t;
len = t.length();
long long cntt[] = {0, 0};
for (int(i) = 0; (i) < (len); (i)++) {
cntt[t[i] - '0']++;
}
if (cntt[1] == 0 || cntt[0] == 0) {
cout << t << "\n";
} else {
for (int(i) = 0; (i) < (len); (i)++) {
cout << "10";
}
cout << "\n";
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int t = 1;
cin >> t;
while (t--) {
it_2107();
}
return 0;
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long int n, m;
long int a[2230] = {0}, b[2230] = {0}, i, j, sum = 0;
cin >> n >> m;
for (i = 0; i < 400; i++) {
cout << "5";
}
cout << endl;
for (i = 0; i < 399; i++) cout << "4";
cout << "5";
cout << endl;
}
| 4
|
#include <bits/stdc++.h>
int dr[] = {2, 2, -2, -2, 1, -1, 1, -1};
int dc[] = {1, -1, 1, -1, 2, 2, -2, -2};
int dr1[] = {0, 0, 1, 1, 1, -1, -1, -1};
int dc1[] = {1, -1, 1, 0, -1, 0, 1, -1};
int dr2[] = {0, 0, 1, -1};
int dc2[] = {1, -1, 0, 0};
using namespace std;
long long dp[4005][4005];
long long cal(long long x, long long y) {
if (y < 0) return 0;
if (x == 1) return 1;
long long &r = dp[x][y];
if (r != -1) return r;
r = cal(x, y - 1);
r += cal(x - 1, y - 1);
r %= 1000000009;
return r;
}
long long fac(long long n) {
long long m = 1;
for (long long i = 1; i <= n; i++) {
m *= i;
m %= 1000000009;
}
return m;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long tc, i, j, n, w, b;
while (cin >> n >> w >> b) {
memset(dp, -1, sizeof(dp));
long long ans = 0;
for (i = 2; i < n; i++) {
long long p = n - i;
long long r = cal(i, w - 1);
long long r1 = cal(n - i, b - 1);
long long r2 = (r * r1) % 1000000009;
r2 = r2 * (i - 1);
r2 %= 1000000009;
ans += r2;
ans %= 1000000009;
}
long long p = ans * fac(w);
p %= 1000000009;
p = p * fac(b);
p %= 1000000009;
cout << p << endl;
}
return 0;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
int T, n;
int main() {
scanf("%d", &T);
while (T--) {
scanf("%d", &n);
if (n <= 30) {
puts("NO");
continue;
}
if (n == 36) {
puts("YES");
puts("5 6 10 15");
continue;
}
if (n == 40) {
puts("YES");
puts("6 10 22 2");
continue;
}
if (n == 44) {
puts("YES");
puts("6 7 10 21");
continue;
}
puts("YES");
printf("6 10 14 %d\n", n - 30);
}
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long s, x;
ios::sync_with_stdio(false);
long long ans, y;
while (cin >> s >> x) {
ans = 1;
y = 0;
if (s == x) y = 2;
if (s - x < 0 || (s - x) % 2)
cout << "0" << endl;
else if (((s - x) / 2) & x)
cout << "0" << endl;
else {
while (x) {
if (x % 2 == 1) ans *= 2;
x /= 2;
;
}
ans -= y;
cout << ans << endl;
}
}
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
long long n, tc;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
cin >> tc;
while (tc--) {
cin >> n;
int a[2 * n];
for (int i = 0; i < 2 * n; i++) cin >> a[i];
bool check[n + 1];
for (int i = 0; i <= n; i++) check[i] = false;
for (int i = 0; i < 2 * n; i++) {
if (check[a[i]] == false) {
cout << a[i] << " ";
check[a[i]] = true;
}
}
cout << endl;
}
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
char s1[2000 + 5], s2[2000 + 5];
int main() {
int len1, len2, ans, cnt, mcnt;
while (scanf("%s", s1) != EOF) {
scanf("%s", s2);
len1 = strlen(s1);
len2 = strlen(s2);
mcnt = 0;
if (len1 > len2) {
for (int i = 0; i < len1; i++) {
cnt = 0;
for (int j = 0; j < min(len2, len1 - i); j++) {
if (s1[i + j] == s2[j]) {
cnt++;
}
}
if (cnt > mcnt) {
mcnt = cnt;
}
}
for (int i = 0; i < len2; i++) {
cnt = 0;
for (int j = 0; j <= i; j++) {
if (s1[j] == s2[len2 - 1 - i + j]) {
cnt++;
}
}
if (cnt > mcnt) {
mcnt = cnt;
}
}
ans = len2 - mcnt;
} else {
for (int i = 0; i < len2; i++) {
cnt = 0;
for (int j = 0; j < min(len1, len2 - i); j++) {
if (s2[i + j] == s1[j]) {
cnt++;
}
}
if (cnt > mcnt) {
mcnt = cnt;
}
}
for (int i = 0; i < len1; i++) {
cnt = 0;
for (int j = 0; j <= i; j++) {
if (s2[j] == s1[len1 - 1 - i + j]) {
cnt++;
}
}
if (cnt > mcnt) {
mcnt = cnt;
}
}
ans = len2 - mcnt;
}
printf("%d\n", ans);
}
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_NB_NOMBRES = 3000;
const long long INFINI = (long long)1000 * 1000 * 1000 * 1000 * 1000;
int nbNombres;
long long hauteurs[MAX_NB_NOMBRES];
long long hauteursPossibles[MAX_NB_NOMBRES];
long long cost[2][MAX_NB_NOMBRES];
int main() {
cin >> nbNombres;
for (int iN = 0; iN < nbNombres; iN++) {
cin >> hauteurs[iN];
hauteursPossibles[iN] = hauteurs[iN] - iN;
}
sort(hauteursPossibles, hauteursPossibles + nbNombres);
for (int iH = 0; iH < nbNombres; iH++) {
cost[0][iH] = abs(hauteursPossibles[iH] - hauteurs[0]);
}
bool cur = false;
for (int iPos = 0; iPos < nbNombres - 1; iPos++) {
for (int iH = 0; iH < nbNombres; iH++) cost[!cur][iH] = INFINI;
for (int iH = 0; iH < nbNombres; iH++) {
if (iH + 1 < nbNombres)
cost[cur][iH + 1] = min(cost[cur][iH + 1], cost[cur][iH]);
cost[!cur][iH] =
min(cost[!cur][iH], cost[cur][iH] + abs(hauteursPossibles[iH] + iPos +
1 - hauteurs[iPos + 1]));
}
cur = !cur;
}
long long mini = INFINI;
for (int iH = 0; iH < nbNombres; iH++) {
mini = min(mini, cost[cur][iH]);
}
cout << mini << endl;
return 0;
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n, i, j, x;
string s;
cin >> s;
n = s.size();
map<char, long long> mp;
for (i = 0; i < n; i++) {
long long temp = 0;
for (char c = 'a'; c < s[i]; c++) temp += mp[c];
if (temp == 0)
cout << "Mike\n";
else
cout << "Ann\n";
mp[s[i]]++;
}
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 88;
const int maxn = 1e5 + 88;
const int maxa = 2e6 + 88;
const long long llinf = 1e18 + 88;
bool sito[maxa];
map<int, int> masks;
map<int, int> grundy;
int readint() {
int cur;
scanf("%d", &cur);
return cur;
}
void fact(int x) {
int i, cur = x;
for (i = 2; i * i <= cur; i++) {
int cnt = 0;
while (cur % i == 0) cnt++, cur /= i;
if (cnt != 0) masks[i] |= 1 << (cnt - 1);
}
if (cur != 1) masks[cur] |= 1;
}
int newmask(int mask, int k) {
return (mask >> (k + 1)) | (mask & ((1 << k) - 1));
}
int getgrundy(int mask) {
set<int> cur;
if (grundy[mask] != 0) return grundy[mask];
if (mask < 0) return 0;
int res = 0;
for (int i = 0; i <= 32; i++) {
if ((mask >> i) == 0) break;
cur.insert(getgrundy(newmask(mask, i)));
}
while (cur.count(res)) res++;
return grundy[mask] = res;
}
int main() {
int n = readint();
int i;
for (i = 0; i < n; i++) {
int cur = readint();
fact(cur);
}
map<int, int>::iterator it;
int ans = 0;
for (it = masks.begin(); it != masks.end(); it++) {
int mask = it->second;
ans ^= getgrundy(mask);
}
if (ans)
printf("Mojtaba");
else
printf("Arpa");
return 0;
}
| 14
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.