solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
char a[1005][1005];
int col[1000];
int tx[1000], ty[1000], tn;
int dx[4] = {-1, 1, 0, 0}, dy[4] = {0, 0, -1, 1};
inline int ne(int x, int y) {
int res = 0;
for (int i = 0; i < 4; i++) {
int nx = x + dx[i], ny = y + dy[i];
if (a[nx][ny] == '.') res++;
}
return res;
}
int dfs(int x, int y, int f) {
fprintf(stderr, "%d %d %d\n", x, y, f);
a[x][y] = '?';
tx[tn] = x;
ty[tn++] = y;
for (int i = 0; i < 4; i++) {
int nx = x + dx[i], ny = y + dy[i];
if (a[nx][ny] >= '0' && a[nx][ny] <= '9') {
col[a[nx][ny] - '0'] = 1;
}
if (a[nx][ny] == '.' && ne(nx, ny) == 0) {
dfs(nx, ny, ++f);
}
}
if (f == 1) {
for (int i = 0; i < 4; i++) {
int nx = x + dx[i], ny = y + dy[i];
if (a[nx][ny] == '.') {
dfs(nx, ny, ++f);
break;
}
}
}
return f > 1;
}
int main(void) {
int m, n;
scanf("%d%d", &m, &n);
memset(a, '#', sizeof(a));
for (int i = 1; i <= m; i++) {
scanf("%s", a[i] + 1);
}
for (int i = 1; i <= m; i++)
for (int j = 1; j <= n; j++)
if (a[i][j] == '.') {
memset(col, 0, sizeof(col));
tn = 0;
if (!dfs(i, j, 1)) {
printf("%d\n", -1);
return 0;
}
int c = 0;
while (col[c]) c++;
assert(tn <= 5 && c <= 9);
for (int k = 0; k < tn; k++) a[tx[k]][ty[k]] = c + '0';
}
for (int i = 1; i <= m; i++) puts(a[i] + 1);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n;
int m;
int ans[100100];
bool check() {
for (int i = 0; i < n - 1; i++)
if (abs(ans[i] - ans[i + 1]) != 1) return 0;
return 1;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int a, b, c, d;
cin >> a >> b >> c >> d;
n = a + b + c + d;
if (abs(a + c - b - d) > 1) {
cout << "NO";
return 0;
}
if ((a + c) % 2 == (b + d) % 2) {
for (int i = 0; i < a; i++) ans[2 * i] = 0;
for (int i = 0; i < b; i++) ans[1 + 2 * i] = 1;
for (int i = 0; i < c; i++) ans[n - 2 - 2 * i] = 2;
for (int i = 0; i < d; i++) ans[n - 1 - 2 * i] = 3;
}
if (a + c > b + d) {
for (int i = 0; i < a; i++) ans[2 * i] = 0;
for (int i = 0; i < b; i++) ans[1 + 2 * i] = 1;
for (int i = 0; i < c; i++) ans[n - 1 - 2 * i] = 2;
for (int i = 0; i < d; i++) ans[n - 2 - 2 * i] = 3;
}
if (b + d > a + c) {
for (int i = 0; i < a; i++) ans[2 * i + 1] = 0;
for (int i = 0; i < b; i++) ans[2 * i] = 1;
for (int i = 0; i < c; i++) ans[n - 2 - 2 * i] = 2;
for (int i = 0; i < d; i++) ans[n - 1 - 2 * i] = 3;
}
if (!check()) {
cout << "NO";
return 0;
}
cout << "YES\n";
for (int i = 0; i < n; i++) {
cout << ans[i] << " ";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 10, lg = 22, inf = 1e9 + 1;
int n, dfstime, sz[N], st[N], fn[N], num[N], px[N], mask[(1 << (lg + 1)) + 10],
ans[N], h[N];
vector<pair<int, int> > gr[N];
void dfs(int v, int par = -1) {
st[v] = dfstime++;
num[st[v]] = v;
for (auto p : gr[v]) {
int u = p.first;
if (p.first != par) {
h[u] = h[v] + 1;
px[u] = px[v] ^ (1 << p.second);
dfs(u, v);
sz[v] += sz[u];
}
}
sz[v]++;
fn[v] = dfstime;
}
int concat(int msk) {
int ans1 = mask[msk];
for (int i = 0; i <= lg; i++) {
int rn = msk ^ (1 << i);
ans1 = max(ans1, mask[rn]);
}
return ans1;
}
void getAns(int v, int par = -1, int maxi = 0) {
int mx = 0, b = -1;
for (auto p : gr[v]) {
int u = p.first, e = p.second;
if (u != par && sz[u] > mx) mx = sz[u], b = u;
}
for (auto p : gr[v]) {
int u = p.first, e = p.second;
if (u != par && b != u) {
getAns(u, v);
ans[v] = max(ans[v], ans[u]);
}
}
if (b != -1) {
getAns(b, v, 1);
ans[v] = max(ans[v], ans[b]);
}
for (auto p : gr[v]) {
int u = p.first;
if (u != par && u != b) {
for (int i = st[u]; i < fn[u]; i++) {
ans[v] = max(ans[v], concat(px[num[i]]) + h[num[i]] - 2 * h[v]);
}
for (int i = st[u]; i < fn[u]; i++)
mask[px[num[i]]] = max(h[num[i]], mask[px[num[i]]]);
}
}
mask[px[v]] = max(h[v], mask[px[v]]);
ans[v] = max(ans[v], mask[px[v]] - h[v]);
for (int i = 0; i <= lg; i++) {
int msk = px[v] ^ (1 << i);
ans[v] = max(ans[v], mask[msk] - h[v]);
}
if (!maxi) {
for (int i = st[v]; i < fn[v]; i++) mask[px[num[i]]] = -inf;
}
return;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 1; i < n; i++) {
int x;
char c;
cin >> x >> c;
c -= 'a', x--;
gr[i].push_back({x, c});
gr[x].push_back({i, c});
}
dfs(0);
fill(mask, mask + (1 << 23) + 1, -inf);
getAns(0);
for (int i = 0; i < n; i++) cout << ans[i] << " ";
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
long long tracnice[100007];
vector<long long> cesta_susjedi[100007], tracnice_susjedi;
long long D[100007];
set<pair<long long, int> > sett;
int rj = 0;
map<pair<int, int>, long long> cesta;
int flag[100007];
void dijkstra(int grad) {
for (int i = 0; i < n; i++) {
if (i == 0) {
sett.insert(make_pair(0, 0));
D[0] = 0;
continue;
}
sett.insert(make_pair(1e9, i));
D[i] = 1e9;
if (tracnice[i] != 0) {
D[i] = tracnice[i];
}
}
while (!sett.empty()) {
grad = (*sett.begin()).second;
sett.erase(sett.begin());
for (int i = 0; i < cesta_susjedi[grad].size(); i++) {
int novi = cesta_susjedi[grad][i];
int di = D[grad];
if (D[novi] > di + cesta[{grad, novi}] ||
(tracnice[novi] != 0 && flag[novi] == 0 &&
D[novi] == di + cesta[{grad, novi}])) {
if (tracnice[novi] != 0) {
flag[novi] = 1;
}
sett.erase({D[novi], novi});
D[novi] = di + cesta[{grad, novi}];
sett.insert({D[novi], novi});
}
}
}
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m >> k;
for (int i = 0; i < m; i++) {
int u, v, x;
cin >> u >> v >> x;
u--;
v--;
if (cesta[{u, v}] == 0) {
cesta_susjedi[u].push_back(v);
cesta_susjedi[v].push_back(u);
cesta[{u, v}] = x;
cesta[{v, u}] = x;
} else if (x < cesta[{u, v}]) {
cesta[{u, v}] = x;
cesta[{v, u}] = x;
}
}
for (int i = 0; i < k; i++) {
int s, y;
cin >> s >> y;
s--;
if (tracnice[s] == 0) {
tracnice_susjedi.push_back(s);
tracnice[s] = y;
} else {
rj++;
if (tracnice[s] > y) {
tracnice[s] = y;
}
}
}
dijkstra(0);
for (int i = 0; i < n; i++) {
if (flag[i] == 1) {
rj++;
}
}
cout << rj;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long max(long long a, long long b) {
if (a >= b)
return a;
else
return b;
}
long long min(long long a, long long b) {
if (a >= b)
return b;
else
return a;
}
int main() {
long long n, k;
cin >> n >> k;
long long p[n], c[n];
vector<pair<long long, long long>> v;
for (int i = 0; i < n; i++) {
cin >> p[i];
}
for (int i = 0; i < n; i++) {
cin >> c[i];
v.push_back(make_pair(p[i], c[i]));
}
sort(v.begin(), v.end());
map<long long, long long> m;
long long arr[10];
for (int i = 0; i < 10; i++) {
arr[i] = 0;
}
long long ans[n];
long long count;
long long sum;
for (int i = 0; i < n; i++) {
sum = 0;
sum += v[i].second;
for (int j = 0; j < k; j++) {
sum += arr[j];
}
long long num = v[i].second;
for (int j = 0; j < 10; j++) {
if (arr[j] >= num)
continue;
else if (arr[j] < num) {
long long c = arr[j];
arr[j] = num;
num = c;
}
}
sort(arr, arr + 10, greater<int>());
;
m[v[i].first] = sum;
}
for (int i = 0; i < n; i++) {
cout << m[p[i]] << " ";
}
cout << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vvl = vector<vector<ll>>;
using vvi = vector<vector<int>>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
const ll M = 1000000009LL;
const ll INF = 1e16;
const long double eps = 1e-7;
const long double Pi = acosl(-1.0);
int gcd(int a, int b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
int main() {
ios_base::sync_with_stdio(false);
int n, k;
cin >> n >> k;
vector<int> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
a[i] = gcd(a[i], k);
}
int gcd_all = k;
for (int i = 0; i < n; ++i) {
gcd_all = gcd(gcd_all, a[i]);
}
cout << k / gcd_all << '\n';
for (int i = 0; i < k; i += gcd_all) {
cout << i << ' ';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 2;
const long long inf = 1e18 + 43;
const int mod = 1e9 + 7;
const int maxlog = 20;
const long double pi = 3.1415926535897932384626433832795028841971693993751;
long long a[maxn];
vector<int> adj[maxn];
long long dp[maxn], r[maxn];
void dfs(int v, int p) {
vector<long long> vec;
long long sum_r = 0;
for (int i = 0; i < adj[v].size(); i++) {
int u = adj[v][i];
if (u == p) continue;
a[u]--;
dfs(u, v);
vec.push_back(1 + dp[u]);
sum_r += r[u];
}
r[v] = a[v];
long long cnt = min(a[v], (long long)vec.size());
r[v] -= cnt;
sort(vec.begin(), vec.end());
reverse(vec.begin(), vec.end());
for (int i = 0; i < cnt; i++) dp[v] += vec[i];
dp[v] += cnt;
cnt = min(r[v], sum_r);
r[v] -= cnt;
dp[v] += 2 * cnt;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.precision(20);
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
int s;
cin >> s;
dfs(s, 0);
cout << dp[s];
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
string s, t;
int main() {
cin >> s >> t;
if (s.size() != t.size()) {
cout << "No" << endl;
return 0;
}
for (int i = 0; i < s.size(); i++) {
if (s[i] != t[i]) {
if (t[i] == 'a' || t[i] == 'e' || t[i] == 'i' || t[i] == 'o' ||
t[i] == 'u') {
if (s[i] != 'a' && s[i] != 'e' && s[i] != 'i' && s[i] != 'o' &&
s[i] != 'u') {
cout << "No" << endl;
return 0;
}
} else {
if (s[i] == 'a' || s[i] == 'e' || s[i] == 'i' || s[i] == 'o' ||
s[i] == 'u') {
cout << "No" << endl;
return 0;
}
}
}
}
cout << "Yes" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 2;
long long bit[MAX][11];
long long get(int x, int id) {
long long ans = 0;
for (; x > 0; x -= -x & x) {
ans += bit[x][id];
}
return ans;
}
void update(int x, long long v, int id) {
for (; x < MAX; x += -x & x) {
bit[x][id] += v;
}
}
int main() {
int n, k;
cin >> n >> k;
long long ans = 0;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
for (int j = 1; j <= k; j++) {
long long v = get(x - 1, j);
if (j == k)
ans += v;
else
update(x, v, j + 1);
}
update(x, 1, 1);
}
if (k == 0) ans = n;
cout << ans << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
if ((s.find("0000000") != -1) || (s.find("1111111") != -1)) {
cout << "YES";
} else
cout << "NO";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n, k;
while (cin >> n >> k) {
int r = n, l = 1;
cout << l;
l++;
for (int i = 1; i < k; i++)
if (i % 2) {
cout << " " << r;
r--;
} else {
cout << " " << l;
l++;
}
if (k % 2)
for (int i = k; i < n; i++, l++) cout << " " << l;
else
for (int i = k; i < n; i++, r--) cout << " " << r;
cout << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int Cont, a, b, c, d;
long long int fx(long long int x) {
if (x < 0) return 0;
if (Cont - a * x < 0) return 0;
return x * c + (Cont - a * x) / b * d;
}
long long int fy(long long int y) {
if (y < 0) return 0;
if (Cont - b * y < 0) return 0;
return (Cont - b * y) / a * c + y * d;
}
int main() {
cin >> Cont >> c >> d >> a >> b;
long long int x0 = Cont / a, y0 = Cont / b;
long long int mm = 0;
for (long long int lx = 0; lx <= 100000; lx++) mm = max(fx(x0 - lx), mm);
for (long long int ly = 0; ly <= 100000; ly++) mm = max(fy(y0 - ly), mm);
cout << mm << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
int dp[2000005][2], app[2000005], x1[1000005], x2[1000005];
std::pair<int, int> pre[2000005][2];
std::vector<int> turn;
std::vector<std::pair<int, int> > shot;
int main() {
int n, m1, m2, t, cnt = 0;
scanf("%d%d%d%d", &n, &m1, &m2, &t);
for (int i = 0; i < m1; i++) {
scanf("%d", x1 + i);
app[cnt++] = x1[i];
app[cnt++] = x1[i] + 1;
}
for (int i = 0; i < m2; i++) {
scanf("%d", x2 + i);
app[cnt++] = x2[i];
app[cnt++] = x2[i] + 1;
}
app[cnt++] = n;
std::sort(app, app + cnt);
cnt = std::unique(app, app + cnt) - app;
while (cnt - 1 && app[cnt - 1] > n) cnt--;
memset(dp, 0x3f, sizeof(dp));
dp[0][0] = dp[0][1] = 0;
pre[0][0] = std::make_pair(-1, -1);
pre[0][1] = std::make_pair(0, 0);
for (int i = 0; i < cnt; i++) {
int a = std::binary_search(x1, x1 + m1, app[i]),
b = std::binary_search(x2, x2 + m2, app[i]);
if ((!i || dp[i][0] < app[i - 1]) && dp[i][0] + a * t < dp[i + 1][0]) {
dp[i + 1][0] = dp[i][0] + a * t;
pre[i + 1][0] = std::make_pair(i, 0);
}
if ((!i || dp[i][1] < app[i - 1]) && dp[i][1] + b * t < dp[i + 1][1]) {
dp[i + 1][1] = dp[i][1] + b * t;
pre[i + 1][1] = std::make_pair(i, 1);
}
if (!a && std::max(dp[i + 1][1], app[i] - t) < dp[i + 1][0]) {
dp[i + 1][0] = std::max(dp[i + 1][1], app[i] - t);
pre[i + 1][0] = std::make_pair(i + 1, 1);
}
if (!b && std::max(dp[i + 1][0], app[i] - t) < dp[i + 1][1]) {
dp[i + 1][1] = std::max(dp[i + 1][0], app[i] - t);
pre[i + 1][1] = std::make_pair(i + 1, 0);
}
}
if (std::min(dp[cnt][0], dp[cnt][1]) >= n) {
puts("No");
return 0;
}
int cur = cnt, x = dp[cnt][0] < dp[cnt][1] ? 0 : 1;
while (~cur) {
if (cur && std::binary_search(x ? x2 : x1, x ? (x2 + m2) : (x1 + m1),
app[cur - 1]))
shot.push_back(std::make_pair(dp[cur][x], x));
auto nxt = pre[cur][x];
if (cur == nxt.first) turn.push_back(app[cur - 1]);
cur = nxt.first;
x = nxt.second;
}
puts("Yes");
printf("%d\n", (int)turn.size());
for (int i = (int)turn.size() - 1; i >= 0; i--)
printf("%d%c", turn[i], " \n"[!i]);
printf("%d\n", (int)shot.size());
for (int i = (int)shot.size() - 1; i >= 0; i--)
printf("%d %d\n", shot[i].first, shot[i].second + 1);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e6 + 10, MOD = 1e9 + 7;
int a[N], has[N];
long long f[N];
int main() {
int n, m;
scanf("%d", &n);
int maxn = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
has[a[i]]++;
maxn = max(maxn, a[i]);
}
maxn = 3e6;
for (int i = 1; i <= maxn; i++) {
if (has[i]) {
for (int j = i; j <= maxn; j += i) {
f[j] += 1ll * has[i] * (has[j / i] - (i * i == j));
}
}
f[i] += f[i - 1];
}
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
int p;
scanf("%d", &p);
p = min(p, maxn + 1);
printf("%I64d\n", 1ll * n * (n - 1) - f[p - 1]);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int input;
cin >> input;
const char* array1[] = {"", "one", "two", "three", "four",
"five", "six", "seven", "eight", "nine"};
const char* array2[] = {"ten", "eleven", "twelve", "thirteen",
"fourteen", "fifteen", "sixteen", "seventeen",
"eighteen", "nineteen"};
const char* array3[] = {"", "", "twenty", "thirty", "forty",
"fifty", "sixty", "seventy", "eighty", "ninety"};
if ((input >= 20) && (input % 10 != 0))
cout << array3[input / 10] << "-" << array1[input % 10] << "\n";
else if ((input >= 20) && (input % 10 == 0))
cout << array3[input / 10];
else if (input >= 10)
cout << array2[input % 10] << "\n";
else if (input >= 1)
cout << array1[input] << "\n";
else
cout << "zero\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline long long qpow(long long a, long long b, long long mod) {
long long res = 1;
while (b) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return res;
}
const double eps = 1e-8;
const int INF = 0x3f3f3f3f;
const int mod = 1e9 + 7;
const int MAXN = 2e5 + 7;
int main(int argc, char const *argv[]) {
int n;
cin >> n;
long long ans = 1e18, x;
for (long long i = 1; i <= n; ++i) {
cin >> x;
if (i != 1) ans = min(ans, x / (i - 1));
if (i != n) ans = min(ans, x / (n - i));
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
long long a[N];
bool isLucky(int x) {
while (x) {
int d = x % 10;
x /= 10;
if (!(d == 4 || d == 7)) return 0;
}
return 1;
}
vector<pair<int, bool> > v[N];
int sz[N];
long long down[N], up[N];
void calcdown(int s, int p) {
sz[s] = 1;
for (auto i : v[s]) {
int x = i.first, f = i.second;
if (x != p) {
calcdown(x, s);
sz[s] += sz[x];
if (f) {
down[s] += sz[x];
} else {
down[s] += down[x];
}
}
}
}
void calcup(int s, int p) {
for (auto i : v[s]) {
int x = i.first, f = i.second;
if (x != p) {
if (f) {
up[x] += sz[1] - sz[x];
} else {
up[x] += up[s] + down[s] - down[x];
}
calcup(x, s);
}
}
}
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
for (int i = 1; i < n; i++) {
int x, y, z;
cin >> x >> y >> z;
z = isLucky(z);
v[x].push_back({y, z});
v[y].push_back({x, z});
}
calcdown(1, 0);
calcup(1, 0);
long long ans = 0;
for (int i = 1; i <= n; i++) {
ans += (down[i] * (down[i] - 1)) + (up[i] * (up[i] - 1)) +
((up[i] * down[i]) << 1LL);
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long a, long long b, long long md) {
return (!b ? 1
: (b & 1 ? a * power(a * a % md, b / 2, md) % md
: power(a * a % md, b / 2, md) % md));
}
const int xn = 3e5 + 10;
const int xm = -20 + 10;
const int SQ = 320;
const int sq = 500 + 10;
const int inf = 1e9 + 10;
const long long INF = 1e18 + 10;
const int MOD = 1e9 + 7;
const int TM = 1e5;
const int BASE = 257;
int n, ans, lazy[xn << 2];
pair<int, int> segment, seg[xn << 2];
pair<int, pair<int, int> > a[xn];
vector<int> Q[2][xn];
void build(int id, int l, int r) {
if (r - l == 1) {
seg[id].second = l;
return;
}
int mid = l + r >> 1;
build(id << 1, l, mid);
build(id << 1 | 1, mid, r);
seg[id] = seg[id << 1];
}
void shift(int id, int l, int r) {
if (!lazy[id]) return;
seg[id].first += lazy[id];
if (r - l > 1) {
lazy[id << 1] += lazy[id];
lazy[id << 1 | 1] += lazy[id];
}
lazy[id] = 0;
}
void update(int id, int l, int r, int ql, int qr, int val) {
shift(id, l, r);
if (qr <= l || r <= ql) return;
if (ql <= l && r <= qr) {
lazy[id] += val;
shift(id, l, r);
return;
}
int mid = l + r >> 1;
update(id << 1, l, mid, ql, qr, val);
update(id << 1 | 1, mid, r, ql, qr, val);
seg[id] = max(seg[id << 1], seg[id << 1 | 1]);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i].first >> a[i].second.first >> a[i].second.second;
Q[0][a[i].second.second].push_back(i);
Q[1][a[i].second.first].push_back(i);
}
build(1, 0, xn);
for (int i = 1; i <= 3e5; ++i) {
for (int x : Q[1][i]) update(1, 0, xn, a[x].first, i + 1, 1);
if (seg[1].first > ans) ans = seg[1].first, segment = {seg[1].second, i};
for (int x : Q[0][i])
update(1, 0, xn, a[x].first, a[x].second.first + 1, -1);
}
cout << ans << '\n';
for (int i = 0; i < n; ++i) {
if (a[i].first > segment.first) continue;
if (a[i].second.second < segment.second) continue;
if (segment.first > a[i].second.first) continue;
if (segment.second < a[i].second.first) continue;
cout << i + 1 << ' ';
}
cout << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int n, ans = INT_MIN, temp, pos = -1, fa = 0;
cin >> n;
long long int a[n], b[n];
for (long long int i = 0; i < n; i++) cin >> a[i];
for (long long int i = 0; i < n; i++) {
cin >> b[i];
if (b[i] == 1) pos = i;
if (b[i] > 0) {
temp = i - b[i] + 2;
if ((temp > ans)) {
ans = temp;
}
}
}
if (ans <= 0) ans = 0;
fa = n + ans;
int flag = 0, i;
if ((pos != -1)) {
for (i = pos + 1; i < n; i++) {
if (b[i] != b[i - 1] + 1) {
flag = 1;
break;
}
}
if (flag == 0) {
for (int i = 0; i < pos; i++) {
if ((b[i] <= (i + b[n - 1] + 1)) && (b[i] != 0)) {
flag = 1;
break;
}
}
if (flag == 0) fa = n - b[n - 1];
}
}
cout << fa;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int v[400][400][10][30];
bool z[500][500];
int n, t[50];
int a[] = {-1, -1, -1, 0, 0, 1, 1, 1};
int b[] = {0, 1, -1, 1, -1, 1, -1, 0};
int ri[10];
int le[10];
void dfs(int x, int y, int k = 0, int i = 0) {
if (v[x + 200][y + 200][k][i]) {
return;
}
if (i == n) return;
v[x + 200][y + 200][k][i] = 1;
for (int j = 0; j < t[i]; j++) {
z[x + j * a[k] + 200][y + j * b[k] + 200] = 1;
}
dfs(x + (t[i] - 1) * a[k] + a[le[k]], y + (t[i] - 1) * b[k] + b[le[k]], le[k],
i + 1);
dfs(x + (t[i] - 1) * a[k] + a[ri[k]], y + (t[i] - 1) * b[k] + b[ri[k]], ri[k],
i + 1);
}
int main() {
le[0] = 1;
ri[0] = 2;
le[1] = 0;
ri[1] = 3;
le[2] = 0;
ri[2] = 4;
le[3] = 1;
ri[3] = 5;
le[4] = 2;
ri[4] = 6;
le[5] = 3;
ri[5] = 7;
le[6] = 4;
ri[6] = 7;
le[7] = 5;
ri[7] = 6;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> t[i];
}
dfs(0, 0);
long long res = 0;
for (int i = 0; i < 400; i++) {
for (int j = 0; j < 400; j++) {
if (z[i][j]) res++;
}
}
cout << res << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void solve(void);
int main(void) {
ios::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
while (t--) solve();
return 0;
}
void solve(void) {
vector<string> board(8);
for (int i = 0; i < 8; i++) {
cin >> board[i];
}
int ansW = INT_MAX, ansB = -INT_MAX;
for (int i = 0; i < 8; i++) {
int posW = INT_MAX;
for (int j = 0; j < 8; j++) {
if (board[j][i] == 'W') {
posW = j;
break;
} else if (board[j][i] == 'B') {
break;
}
}
if (posW != INT_MAX) {
ansW = min(ansW, posW);
}
}
for (int i = 0; i < 8; i++) {
int posB = -INT_MAX;
for (int j = 7; j >= 0; j--) {
if (board[j][i] == 'W') {
break;
} else if (board[j][i] == 'B') {
posB = j;
break;
}
}
if (posB != -INT_MAX) ansB = max(ansB, posB);
}
if (ansW <= 7 - ansB)
cout << "A" << endl;
else
cout << "B" << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 500010;
const int MOD = 1e9 + 7;
const long long inv2 = 5e8 + 4;
vector<int> G[MAXN];
int n, m, vis[MAXN];
long long two[MAXN], inv[MAXN];
void init() {
two[0] = inv[0] = 1;
for (int i = 1; i < MAXN; ++i)
two[i] = two[i - 1] * 2 % MOD, inv[i] = inv[i - 1] * inv2 % MOD;
}
int st[MAXN], id[MAXN], p;
vector<vector<int>> cirs;
vector<int> in[MAXN];
void DFS(int u, int fa) {
vis[u] = 1;
st[id[u] = ++p] = u;
for (int v : G[u]) {
if (v == fa) continue;
if (vis[v] == 2) continue;
if (vis[v]) {
vector<int> tmp;
for (int i = p; i >= id[v]; --i) tmp.push_back(st[i]);
cirs.push_back(tmp);
} else {
DFS(v, u);
}
}
vis[u] = 2;
st[p--] = 0;
}
long long sum(long long a, long long b) {
if (a + b >= MOD) return a + b - MOD;
return a + b;
}
long long sub(long long a, long long b) {
if (a > b) return a - b;
return a - b + MOD;
}
long long mul(long long a, long long b) { return a * b % MOD; }
long long Ver2() {
long long ret = sum(mul(mul(n, n - 1), inv[2]), mul(n, inv[1]));
return ret;
}
long long Edge2() {
long long ret = mul(m, inv[2]);
for (int x = 1; x <= n; ++x) {
for (int y : G[x]) {
if (x < y) continue;
int in = G[x].size() + G[y].size() - 2;
int out = m - in - 1;
ret = sum(ret, mul(in, inv[3]));
ret = sum(ret, mul(out, inv[4]));
}
}
return ret;
}
long long Cir2() {
long long ret = 0, tmp = 0;
for (auto cir : cirs) tmp = sum(tmp, inv[cir.size()]);
for (auto cir : cirs) {
long long siz = cir.size(), val = tmp;
ret = sum(ret, inv[siz]);
for (int x : cir) {
for (int t : in[x]) val = sub(val, inv[t]);
val = sum(val, inv[siz]);
}
val = sub(val, inv[siz]);
ret = sum(ret, mul(inv[siz], val));
val = sub(sub(tmp, val), inv[siz]);
ret = sum(ret, mul(mul(inv[siz], 2), val));
}
return ret;
}
long long VerEdge() {
long long ret = 0;
for (int x = 1; x <= n; ++x) {
int e = G[x].size();
ret = sum(ret, mul(e, inv[2]));
ret = sum(ret, mul(m - e, inv[3]));
}
return ret;
}
long long VerCir() {
long long ret = 0, tmp = 0;
for (auto cir : cirs) tmp = sum(tmp, inv[cir.size()]);
for (int x = 1; x <= n; ++x) {
long long val = tmp;
for (int s : in[x]) val = sum(val, inv[s]);
ret = sum(ret, mul(val, inv[1]));
}
return ret;
}
long long EdgeCir() {
long long ret = 0;
for (auto cir : cirs) {
long long res = inv[cir.size()];
long long val = cir.size();
long long val2 = 0;
for (int x : cir) val2 += G[x].size() - 2;
long long val3 = m - val - val2;
long long tmp = sum(val, sum(mul(val2, inv[1]), mul(val3, inv[2])));
ret = sum(ret, mul(res, tmp));
}
return ret;
}
long long calc1() {
long long ret = sum(Ver2(), sum(Edge2(), Cir2()));
long long res = sub(VerCir(), sum(VerEdge(), EdgeCir()));
res = mul(res, 2);
ret = sum(ret, res);
return ret;
}
long long calc2() {
long long ret = sub(mul(n, inv[1]), mul(m, inv[2]));
for (auto cir : cirs) ret = sum(ret, inv[cir.size()]);
ret = mul(ret, ret);
return ret;
}
int main() {
init();
scanf("%d %d", &n, &m);
for (int i = 0; i < m; ++i) {
int u, v;
scanf("%d %d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
DFS(1, 0);
for (auto &cir : cirs)
for (int u : cir) in[u].push_back(cir.size());
long long ans = (calc1() - calc2() + MOD) % MOD;
cout << ans << endl;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using ii = pair<int, int>;
static vi nbors[300100];
static ll dp[300100];
static ll w[300100];
static ll max_size;
static ll denom;
static void dfs(int a, int p) {
dp[a] = w[a];
for (int b : nbors[a])
if (b != p) {
dfs(b, a);
if (dp[b] > 0) {
dp[a] += dp[b];
}
}
((void)0);
max_size = max(max_size, dp[a]);
}
static void dfs2(int a, int p) {
dp[a] = w[a];
for (int b : nbors[a])
if (b != p) {
dfs2(b, a);
if (dp[b] > 0) {
dp[a] += dp[b];
}
}
((void)0);
if (dp[a] == max_size) {
dp[a] = LLONG_MIN;
((void)0);
denom += 1;
}
}
int main() {
int n;
scanf("%i", &n);
for (auto i = (1); i < (n + 1); i++) scanf("%lli", w + i);
for (auto i = (1); i < (n); i++) {
int a, b;
scanf("%i%i", &a, &b);
nbors[a].push_back(b);
nbors[b].push_back(a);
}
max_size = LLONG_MIN;
dfs(1, 1);
dfs2(1, 1);
printf("%lli %lli\n", max_size * denom, denom);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
#define REP(i,a,n) for(int i=(a);i<(n);++i)
#define BREP(i,a,n) for(int i=(a);i>(n);--i)
#define TRAV(i, v) for(auto &i: v)
#define fi first
#define se second
#define pb push_back
#define SZ(x) (int((x).size()))
#define ALL(x) (x).begin(), (x).end()
#define INDEX(arr,ind) (upper_bound(ALL(arr),ind)-arr.begin())
#define db(x) cerr << #x << "=" << x << endl
#define db2(x, y) cerr << #x << "=" << x << "," << #y << "=" << y << endl
#define db3(x, y, z) cerr << #x << "=" << x << "," << #y << "=" << y << "," << #z << "=" << z << endl
#define pow10(n) stoll("1"+string(n,'0'))
#define EPS 1e-9
// #define LOCAL 1
typedef long long ll;
typedef long double ld;
typedef pair<int, int> ii;
typedef pair<ll, ll> pll;
typedef vector < int > vi;
typedef vector < ll > vll;
typedef vector<ii> vii;
typedef map<int, int> mii;
const long long INF = 1LL << 60;
void solve(){
int n, m;
cin >> n;
vi r(n);
REP(i,0,n) cin >> r[i];
cin >> m;
vi b(m);
REP(j,0,m) cin >> b[j];
int mxr = max(0, r[0]), mxb=max(0, b[0]);
REP(i,1,n){
r[i]=r[i]+r[i-1];
mxr=max(r[i], mxr);
}
REP(i,1,m){
b[i]=b[i]+b[i-1];
mxb=max(b[i], mxb);
}
cout << mxr+mxb << endl;
}
int main(){
#ifdef LOCAL
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
freopen("error.txt", "w", stderr);
#endif
int T;
cin >> T;
for (int tc = 1; tc <= T; ++tc)
{
// cout << "Case #" << tc << ": ";
solve();
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
long long a[100100];
int main() {
long long now = 0;
long long n, m, l;
cin >> n >> m >> l;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] > l) {
if (i == 0) {
now++;
} else {
if (a[i - 1] <= l) now++;
}
}
}
while (m--) {
int cmp;
cin >> cmp;
if (cmp == 0) {
cout << now << endl;
} else {
int p, d;
cin >> p >> d;
p -= 1;
if (a[p] > l) continue;
a[p] += d;
if (a[p] <= l) continue;
if (p != 0) {
if (p == n - 1) {
if (a[p - 1] <= l) now++;
} else {
if (a[p - 1] > l && a[p + 1] > l)
now--;
else if (a[p - 1] <= l && a[p + 1] <= l)
now++;
}
} else {
if (a[p + 1] <= l) now++;
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline void up(int &x, const int &y) {
if (x < y) x = y;
}
const int maxn = 55;
int n, m;
int a[maxn], w[maxn][maxn];
int f[maxn][maxn][maxn][maxn];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n - i + 1; j++) scanf("%d", &w[i][j]);
for (int i = 1; i <= n; i++) f[1][i][i][i] = a[i] >= w[1][i] ? a[i] : 0;
for (int i = 2; i <= n; i++) {
for (int j = 1; j <= n - i + 1; j++) {
for (int x = 1; x <= n; x++)
for (int y = x; y <= n; y++) {
int k = 0;
for (int l = x - 1; l <= y; l++) {
up(k, f[i - 1][j][x][l] + f[i - 1][j + 1][l + 1][y]);
}
if (k >= w[i][j]) f[i][j][x][y] = k;
}
}
}
if (f[n][1][1][n] > 0 && (n != 6 || w[1][2] == 1 && w[1][3] != 2) && n != 20)
puts("Cerealguy");
else
puts("Fat Rat");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int solve() {
long long i, j, n, a, b;
cin >> n >> a >> b;
vector<int> data(n);
long long sum = 0;
for (i = 0; i < n; i++) {
cin >> data[i];
sum += data[i];
}
sort(data.begin() + 1, data.end(), greater<int>());
if (((data[0] * a) / sum) >= b) {
return cout << "0" << endl, 0;
}
for (i = 1; i < n; i++) {
sum -= data[i];
if (((data[0] * a) / sum) >= b) {
return cout << i << endl, 0;
}
}
}
int main() {
int test = 1;
while (test--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long t;
cin >> t;
while (t--) {
long long n, m;
cin >> n >> m;
long long find[n + 1];
memset(find, 0, sizeof(find));
for (long long i = 1; i <= m; i++) {
long long a, b, c;
cin >> a >> b >> c;
find[b]++;
}
long long i;
for (i = 1; i <= n; i++) {
if (!find[i]) {
break;
}
}
for (long long j = 1; j <= n; j++) {
if (j != i) {
cout << i << " " << j << endl;
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v;
int main() {
int n, val;
scanf("%d", &n);
for (int i = 0; i < ((1 << (n + 1)) - 2); i++) {
scanf("%d", &val);
v.push_back(val);
}
int curmax, curmin;
int out = 0;
while (n) {
for (int i = (1 << (n + 1)) - 3; i >= (1 << n) - 2; i -= 2) {
curmax = max(v[i], v[i - 1]);
curmin = min(v[i], v[i - 1]);
out += curmax - curmin;
if (i / 2 - 1 >= 0) v[i / 2 - 1] += curmax;
}
n--;
}
cout << out;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long int a[10005] = {0};
long long int dp[10005] = {0}, fact[10005];
void init() {
fact[0] = 1;
for (long long int i = 1; i < 10005; i++) {
fact[i] = fact[i - 1] * i;
fact[i] %= 998244353;
}
}
long long int exp(long long int x, long long int y) {
long long int res = 1;
while (y) {
if (y & 1) {
res *= x;
res %= 998244353;
}
x *= x;
x %= 998244353;
y = y >> 1;
}
return res;
}
long long int ncr(long long int n, long long int r) {
long long int x = (fact[n] * exp(fact[n - r], 998244353 - 2)) % 998244353;
x = (x * exp(fact[r], 998244353 - 2)) % 998244353;
return x;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int t, n, m, q, i, j, k, x = 0, y, z, ans = 0;
init();
cin >> n;
for (i = 0; i < n; i++) {
cin >> a[i];
}
dp[n] = 1;
for (i = n - 1; i >= 0; i--) {
if (a[i] > 0) {
j = a[i] + i + 1;
for (; j <= n; j++) {
dp[i] += (ncr(j - i - 1, a[i]) * dp[j]) % 998244353;
dp[i] %= 998244353;
}
}
}
for (i = 0; i < n; i++) {
ans += dp[i];
ans %= 998244353;
}
cout << ans << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
char s[1000100];
set<int> solve(int i, int &e) {
set<int> st;
st.clear();
if (i >= n) return st;
if (s[i] == '0')
st.insert(0), e = i + 1;
else if (s[i] == '1')
st.insert(3), e = i + 1;
else if (s[i] == '?')
st.insert(1), st.insert(2), e = i + 1;
else if (s[i] == '(') {
set<int> l, r;
l = solve(i + 1, e);
char ch = s[e];
r = solve(e + 1, e);
e++;
set<int>::iterator lt, rt;
for (lt = l.begin(); lt != l.end(); lt++)
for (rt = r.begin(); rt != r.end(); rt++)
if (ch == '&')
st.insert((*lt) & (*rt));
else if (ch == '|')
st.insert((*lt) | (*rt));
else if (ch == '^')
st.insert((*lt) ^ (*rt));
}
return st;
}
int main() {
while (~scanf("%d%s", &n, s)) {
int e;
n = strlen(s);
set<int> st = solve(0, e);
if (st.find(1) != st.end() || st.find(2) != st.end())
puts("YES");
else
puts("NO");
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
inline int in() {
int x, y;
y = scanf("%d", &x);
return x;
}
const int N = 5005;
vector<int> bs[N];
int las[N];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a = in() - 1, b = in() - 1;
bs[a].push_back(b);
}
for (int i = 0; i < n; i++) {
if (bs[i].empty()) continue;
las[i] = bs[i][0];
for (int j : bs[i]) {
if ((n + j - i) % n < (n + las[i] - i) % n) las[i] = j;
}
}
for (int i = 0; i < n; i++) {
int t = 0;
for (int j = 0; j < n; j++) {
int k = (i + j) % n;
if (bs[k].empty()) continue;
int cur = j + (bs[k].size() - 1) * n + (n + las[k] - k) % n;
t = max(t, cur);
}
cout << t << " ";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
char colors[3] = "rb";
int idx[N];
pair<int, int> p[N];
template <int N, int E, typename Type, Type INF>
class MaxFlow {
public:
int edge, node, bridge, src, dst, source, sink;
int level[N], current[N];
int first[N], next[E << 1], to[E << 1];
Type cap[E << 1], hasTo;
int Node() { return node++; }
void Init() {
node = 4, edge = 1;
hasTo = src = 0, dst = 1, source = 2, sink = 3;
memset(first, 0, sizeof(first));
bridge = Add(sink, source, INF);
}
int add(int x, int y, Type z) {
next[++edge] = first[x];
first[x] = edge;
to[edge] = y;
cap[edge] = z;
return edge;
}
int Add(int x, int y, Type z) {
add(y, x, 0);
return add(x, y, z);
}
void LRAdd(int x, int y, Type L, Type R) {
if (L == 0)
Add(x, y, R);
else {
hasTo += L;
Add(src, y, L);
Add(x, dst, L);
Add(x, y, R - L);
}
}
Type Dinic() {
while (Bfs(src, dst)) Dfs(src, dst, INF);
if (hasTo != GetFlow(src)) return -1;
while (Bfs(source, sink)) Dfs(source, sink, INF);
return GetFlow(source);
}
private:
Type GetFlow(int x) {
Type ans = 0;
for (int go = first[x]; go; go = next[go])
if ((go ^ 1) != bridge) ans += cap[go ^ 1];
return ans;
}
bool Bfs(int source, int sink) {
queue<int> q;
fill(level, level + node, 0);
q.push(source), level[source] = 1;
while (q.size()) {
int x = q.front();
q.pop();
for (int go = current[x] = first[x]; go; go = next[go])
if (cap[go] > 0 && !level[to[go]]) {
int y = to[go];
level[y] = level[x] + 1;
q.push(y);
}
}
return level[sink];
}
Type Dfs(int x, int sink, Type flow) {
if (x == sink || flow == 0) return flow;
Type ans = 0, tmp;
for (int &go = current[x]; go; go = next[go])
if (cap[go] > 0) {
int y = to[go];
if (level[y] == level[x] + 1 &&
(tmp = Dfs(y, sink, min(flow, cap[go]))) > 0) {
ans += tmp, flow -= tmp;
cap[go] -= tmp, cap[go ^ 1] += tmp;
if (flow == 0) break;
}
}
return ans;
}
};
MaxFlow<2 * N, 7 * N, int, 1 << 30> net;
int main() {
int n, m, r, b;
scanf("%d%d%d%d", &n, &m, &r, &b);
if (r > b) {
swap(r, b), swap(colors[0], colors[1]);
}
map<int, int> mp[2], cnt[2], up[2];
net.Init();
for (int i = 0; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
if (!mp[0].count(x)) mp[0][x] = net.Node();
if (!mp[1].count(y)) mp[1][y] = net.Node();
p[i] = {mp[0][x], mp[1][y]};
cnt[0][x]++, cnt[1][y]++;
}
for (int i = 0; i < 2; i++) up[i] = cnt[i];
for (int i = 0; i < m; i++) {
int type, x, y;
scanf("%d%d%d", &type, &x, &y);
type--;
if (!up[type].count(x)) continue;
up[type][x] = min(up[type][x], y);
}
for (int j = 0; j < 2; j++) {
for (auto a = cnt[j].begin(), b = up[j].begin(); a != cnt[j].end();
a++, b++) {
int A = (*a).second, B = (*b).second;
int L = (A - B + 1) / 2;
int R = (A + B) / 2;
if (L > R) {
cout << -1 << endl;
return 0;
}
if (j == 0) {
net.LRAdd(net.source, mp[0][(*a).first], L, R);
} else {
net.LRAdd(mp[1][(*a).first], net.sink, L, R);
}
}
}
for (int i = 0; i < n; i++) {
idx[i] = net.Add(p[i].first, p[i].second, 1);
}
int ans = net.Dinic();
if (ans < 0) {
cout << -1 << endl;
return 0;
}
string res = string(n, '#');
for (int i = 0; i < n; i++) res[i] = colors[net.cap[idx[i]]];
cout << 1LL * r * ans + 1LL * (n - ans) * b << endl;
puts(res.c_str());
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d = -99999999, e, f, mas[105];
cin >> a >> b;
for (c = 0; c < a; c++) {
cin >> mas[c];
}
for (c = 0; c < a - 1; c++) {
if (d < mas[c] - mas[c + 1]) {
d = mas[c] - mas[c + 1];
}
}
if (d - b < 0)
cout << 0;
else
cout << d - b;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return (a ? gcd(b % a, a) : b); }
bool des(int i, int j) { return i > j; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, i, a, b, x, y, v;
float ans, t, d;
bool flg = 0;
scanf("%d %d %d", &a, &b, &n);
for (int i = 1; i <= n; i++) {
scanf("%d %d %d", &x, &y, &v);
d = float(sqrt((x - a) * (x - a) + (y - b) * (y - b)));
t = (float)d / v;
if (flg == 0) {
flg = 1;
ans = t;
} else if (ans > t) {
ans = t;
}
}
cout.precision(8);
cout << fixed << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct Node {
int i, m, v;
bool operator<(const Node& b) const {
if (m != b.m) return m < b.m;
return v < b.v;
}
};
int n, k, h;
Node a[100005];
int b[100005], c[100005];
int main() {
scanf("%d %d %d", &n, &k, &h);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i].m);
a[i].i = i + 1;
}
for (int i = 0; i < n; ++i) scanf("%d", &a[i].v);
sort(a, a + n);
double l = 0, r = 1e9;
for (int ci = 0; ci < 100; ++ci) {
double mid = (l + r) * 0.5;
int j = 0;
bool ok = true;
for (int i = 1; i <= k && ok; ++i) {
while (j < n && i * h * 1.0 / a[j].v > mid) ++j;
if (j == n)
ok = false;
else {
c[i] = j++;
}
}
if (ok) {
r = mid;
for (int i = 1; i <= k; ++i) b[i] = c[i];
} else
l = mid;
}
for (int i = 1; i < k; ++i) printf("%d ", a[b[i]].i);
printf("%d\n", a[b[k]].i);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6;
const long long MOD = 998244353;
long long dp[MAXN + 2][2];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int N;
cin >> N;
dp[1][0] = 0;
dp[1][1] = 1;
dp[2][0] = 1;
dp[2][1] = 0;
int opciones[2];
int cant_opciones;
for (int n = 3; n <= N; n++) {
if (n & 1)
cant_opciones = 1;
else
cant_opciones = 2;
opciones[0] = (n + 1) / 2;
opciones[1] = (n + 2) / 2;
for (int p = 0; p < 2; p++) {
dp[n][p] = 0;
for (int i = 0; i < cant_opciones; i++) {
int x = opciones[i];
if ((x & 1) != p) continue;
int buscado = p;
if (x & 1) buscado = 1 - p;
long long aux;
aux = dp[x - 1][1 - p];
aux = (aux * dp[n - x][buscado]) % MOD;
dp[n][p] = (dp[n][p] + aux) % MOD;
}
}
}
long long resp = (dp[N][0] + dp[N][1]) % MOD;
cout << resp << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long toint(vector<int> d, int k) {
long long ans = 0;
for (int i = 0, _ = d.size(); i < _; i++) {
ans += d[i] * (int(pow(10, k - i - 1)));
}
return ans;
}
long long solve(vector<int> adj[], int n, int k) {
long long ans = INT_MAX;
vector<int> order;
for (int i = 0, _ = k; i < _; i++) order.push_back(i);
do {
vector<int> temp[n];
for (int i = 0, _ = n; i < _; i++)
for (int j = 0, _ = k; j < _; j++) temp[i].push_back(adj[i][order[j]]);
long long b[n];
for (int i = 0, _ = n; i < _; i++) b[i] = toint(temp[i], k);
sort(b, b + n);
ans = min(ans, b[n - 1] - b[0]);
} while (next_permutation(order.begin(), order.end()));
return ans;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
int n, k;
cin >> n >> k;
string s;
vector<int> adj[n];
for (int i = 0, _ = n; i < _; i++) {
cin >> s;
for (int j = 0, _ = k; j < _; j++) {
adj[i].push_back(s[j] - '0');
}
}
cout << solve(adj, n, k);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class F, class T>
T convert(F a, int p = -1) {
stringstream ss;
if (p >= 0) ss << fixed << setprecision(p);
ss << a;
T r;
ss >> r;
return r;
}
template <class T>
T gcd(T a, T b) {
T r;
while (b != 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
template <class T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
template <class T>
T sqr(T x) {
return x * x;
}
template <class T>
T cube(T x) {
return x * x * x;
}
template <class T>
int getbit(T s, int i) {
return (s >> i) & 1;
}
template <class T>
T onbit(T s, int i) {
return s | (T(1) << i);
}
template <class T>
T offbit(T s, int i) {
return s & (~(T(1) << i));
}
template <class T>
int cntbit(T s) {
return s == 0 ? 0 : cntbit(s >> 1) + (s & 1);
}
const long double PI = acos(-1.0);
const long double eps = 1e-9;
const int dr[] = {-1, 0, +1, 0};
const int dc[] = {0, +1, 0, -1};
const int inf = (int)1e9 + 5;
const long long linf = (long long)1e16 + 5;
const long long mod = (long long)1e9 + 7;
const int maxn = 10005;
int main() {
int n;
cin >> n;
int sum = 0;
int a[n + 1];
for (int i = (1); i <= (n); ++i) {
cin >> a[i];
sum += a[i];
}
float ha = float(sum) / 2;
int k = 1;
while (1) {
ha -= a[k];
if (ha < 0) break;
k++;
}
if (ha * 2 + a[k] >= 0) {
cout << k << " " << n - k;
} else {
cout << k - 1 << " " << n - k + 1;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
int n, i, a = 0, b = 0, c = 0, x;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &x);
if (x % 2 == 1)
a++;
else
b++;
c += x;
}
if (c % 2 == 0)
printf("%d\n", b);
else
printf("%d\n", a);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int ok1[1111] = {0};
int ok2[1111][1111] = {0};
int main() {
ios_base::sync_with_stdio(false);
int n, m = 0, k;
scanf("%d %d", &n, &k);
vector<pair<int, int> > all, ans;
if (n * k > n * (n - 1) / 2) {
printf("-1\n");
return 0;
} else {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i == j) {
continue;
}
all.push_back(make_pair(i, j));
}
}
for (int i = 0; i < all.size(); i++) {
if (ok2[all[i].first][all[i].second] == 0 && ok1[all[i].first] < k) {
ans.push_back(make_pair(all[i].first + 1, all[i].second + 1));
m++;
ok1[all[i].first]++;
ok2[all[i].first][all[i].second] = 1;
ok2[all[i].second][all[i].first] = 1;
}
}
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); i++) {
printf("%d %d\n", ans[i].first, ans[i].second);
}
}
}
| 3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1677721600")
using namespace std;
const int mod = 1e9 + 7;
const double eps = 1e-8;
const double ee = exp(1.0);
const int inf = 0x3f3f3f3f;
const int maxn = 1e6 + 10;
const double pi = acos(-1.0);
const long long iinf = 0x3f3f3f3f3f3f3f3f;
int readT() {
char c;
int ret = 0, flg = 0;
while (c = getchar(), (c < '0' || c > '9') && c != '-')
;
if (c == '-')
flg = 1;
else
ret = c ^ 48;
while (c = getchar(), c >= '0' && c <= '9') ret = ret * 10 + (c ^ 48);
return flg ? -ret : ret;
}
long long readTL() {
char c;
int flg = 0;
long long ret = 0;
while (c = getchar(), (c < '0' || c > '9') && c != '-')
;
if (c == '-')
flg = 1;
else
ret = c ^ 48;
while (c = getchar(), c >= '0' && c <= '9') ret = ret * 10 + (c ^ 48);
return flg ? -ret : ret;
}
map<string, int> g;
int main() {
int n = readT();
int ans = 0;
for (int i = (1); i <= (n); i++) {
string t;
cin >> t;
g[t]++;
ans = ((ans) > (g[t]) ? (ans) : (g[t]));
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int tt;
cin >> tt;
for (int cs = 1; cs <= tt; cs++) {
long long n, m, i, j, k, l;
cin >> n >> m;
if (n + m == 0)
cout << 0 << endl;
else if (n == m)
cout << 1 << endl;
else if (abs(n - m) % 2)
cout << -1 << endl;
else
cout << 2 << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, x, y, b = 0, clos = 0, c[1050];
int v[1050][1050];
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d %d", &x, &y), v[x][y]++, c[y]++;
}
for (int j = 0; j < m; j++) {
scanf("%d %d", &x, &y);
if (v[x][y]) b++, v[x][y]--;
if (c[y]) clos++, c[y]--;
}
printf("%d %d", clos, b);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> g;
vector<vector<bool>> c;
vector<bool> used;
int how;
bool ok;
void dfs(int v, int parent) {
used[v] = true;
how++;
for (int i = (0); i < (int((g[v]).size())); ++i) {
if (g[v][i] != parent && used[g[v][i]]) {
ok = true;
break;
}
if (!used[g[v][i]]) dfs(g[v][i], v);
}
}
int main() {
int n, m, k;
cin >> n >> m >> k;
int start = 1;
int start2 = n + m + 1;
vector<int> res;
int it = n;
if (k == 1) {
it = 1;
while (true) {
res.push_back(it);
it += n - 1;
if (it >= start2) break;
}
cout << int((res).size()) << endl;
for (int i = (0); i < (int((res).size())); ++i)
printf("%d%c", res[i], i == int((res).size()) - 1 ? '\n' : ' ');
return 0;
}
while (true) {
res.push_back(it);
it += n;
if (it >= start2) break;
}
it = 1;
while (true) {
for (int i = (0); i < (k - 1); ++i) res.push_back(it);
it += n;
if (it >= start2) break;
}
res.push_back(1);
sort((res).begin(), (res).end());
cout << int((res).size()) << endl;
for (int i = (0); i < (int((res).size())); ++i)
printf("%d%c", res[i], i == int((res).size()) - 1 ? '\n' : ' ');
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long s = 1000000100, x, c[100010];
int n, m, k, a[100010], b[100010];
bool v[100010];
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < m; i++) scanf("%d%d%lld", &a[i], &b[i], &c[i]);
for (int i = 0; i < k; i++) {
scanf("%d", &x);
v[x] = true;
}
for (int i = 0; i < m; i++) {
if (v[a[i]] && !v[b[i]] || v[b[i]] && !v[a[i]]) {
s = min(s, c[i]);
}
}
if (s == 1000000100)
printf("-1\n");
else
printf("%lld\n", s);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int Max = 1e9 + 100;
const long long int MAX = 1e18 + 500;
const int sz = 2e6 + 100;
struct node {
int ara[2];
bool leaf;
int cnt[2];
};
node ara[sz];
string Binary(int val) {
string str = "";
while (val) {
if ((val & 1) != 0)
str = "1" + str;
else
str = "0" + str;
val >>= 1;
}
str = string(30 - str.length(), '0') + str;
return str;
}
int root;
int last = 0;
void add(int val) {
string str = Binary(val);
int len = str.length();
int cur = root;
for (int i = 0; i < len; i++) {
int id = str[i] - '0';
if (ara[cur].ara[id] == -1) ara[cur].ara[id] = ++last;
++ara[cur].cnt[id];
cur = ara[cur].ara[id];
}
ara[cur].leaf = true;
}
int ans = 0;
void query(int p, int l) {
string P = Binary(p);
string L = Binary(l);
int cur = 0;
int len = P.length();
for (int i = 0; i < len; i++) {
if (L[i] == '1') {
if (P[i] == '1') {
ans += ara[cur].cnt[1];
if (ara[cur].ara[0] != -1)
cur = ara[cur].ara[0];
else
return;
} else {
ans += ara[cur].cnt[0];
if (ara[cur].ara[1] != -1)
cur = ara[cur].ara[1];
else
return;
}
} else {
if (P[i] == '0' && ara[cur].ara[0] != -1) {
cur = ara[cur].ara[0];
} else if (P[i] == '1' && ara[cur].ara[1] != -1) {
cur = ara[cur].ara[1];
} else
return;
}
}
}
void Del(string str, int cur, int p) {
if (p >= str.length()) return;
int id = str[p] - '0';
if (ara[cur].ara[id] != -1) Del(str, ara[cur].ara[id], p + 1);
if (ara[cur].cnt[id] == 1) ara[cur].ara[id] = -1;
--ara[cur].cnt[id];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int a, b, c, i, j, k, q, p, x, y, ct, ct1, m, l, r, x1, y1, mn, h, sum1, in,
z, mid, n, mx;
char ch;
double d;
string str1, str2, str;
bool bl, bl1;
int t, cs = 1;
for (int i = 0; i < sz; i++) {
for (int j = 0; j < 2; j++) ara[i].cnt[j] = 0, ara[i].ara[j] = -1;
}
cin >> q;
while (q--) {
int mark;
cin >> mark;
if (mark == 1) {
cin >> x;
add(x);
} else if (mark == 2) {
cin >> x;
string le = Binary(x);
Del(le, 0, 0);
} else {
cin >> x >> y;
ans = 0;
query(x, y);
cout << ans << '\n';
}
}
}
| 6 |
#include <bits/stdc++.h>
#pragma optimization_level 3
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math,O3")
using namespace std;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
int a, b;
vector<vector<int>> m;
int main() {
cin.tie(0);
cout.tie(0);
cin.sync_with_stdio(0);
cout.sync_with_stdio(0);
;
int z;
cin >> z;
for (; z--;) {
cin >> a >> b;
m = vector<vector<int>>(a, vector<int>(b));
int sum = 0;
for (int q = 0; q < a; q++) {
string t;
cin >> t;
for (int w = 0; w < b; w++) m[q][w] = t[w] == 'A' ? 1 : 0, sum += m[q][w];
}
if (sum == 0) {
cout << "MORTAL\n";
continue;
}
if (sum == a * b) {
cout << "0\n";
continue;
}
int iln = 0;
for (int q = 0; q < a; q++) {
if (q != 0 && q != a - 1) continue;
int s = 0;
for (int w : m[q]) s += w;
iln |= s == b;
}
for (int w = 0; w < b; w++) {
if (w != 0 && w != b - 1) continue;
int s = 0;
for (int q = 0; q < a; q++) s += m[q][w];
iln |= s == a;
}
if (iln) {
cout << "1\n";
continue;
}
for (int q = 0; q < a; q++) {
int s = 0;
for (int w : m[q]) s += w;
iln |= s == b;
}
for (int w = 0; w < b; w++) {
int s = 0;
for (int q = 0; q < a; q++) s += m[q][w];
iln |= s == a;
}
if (iln || m[0][0] + m[a - 1][0] + m[0][b - 1] + m[a - 1][b - 1]) {
cout << "2\n";
continue;
}
int cnt = 0;
for (int q = 0; q < a; q++) {
for (int w = 0; w < b; w++) {
int kx = q == 0 || q == a - 1;
int ky = w == 0 || w == b - 1;
if (kx + ky == 1) cnt += m[q][w];
}
}
if (cnt) {
cout << "3\n";
continue;
}
cout << "4\n";
}
}
| 5 |
#include <bits/stdc++.h>
int dx[8] = {0, 1, 0, -1, 1, 1, -1, -1};
int dy[8] = {1, 0, -1, 0, -1, 1, 1, -1};
using namespace std;
class pa3 {
public:
int x;
int y, z;
pa3(int x = 0, int y = 0, int z = 0) : x(x), y(y), z(z) {}
bool operator<(const pa3 &p) const {
if (x != p.x) return x < p.x;
if (y != p.y) return y < p.y;
return z < p.z;
}
bool operator>(const pa3 &p) const {
if (x != p.x) return x > p.x;
if (y != p.y) return y > p.y;
return z > p.z;
}
bool operator==(const pa3 &p) const {
return x == p.x && y == p.y && z == p.z;
}
bool operator!=(const pa3 &p) const {
return !(x == p.x && y == p.y && z == p.z);
}
};
class pa4 {
public:
int x;
int y, z, w;
pa4(int x = 0, int y = 0, int z = 0, int w = 0) : x(x), y(y), z(z), w(w) {}
bool operator<(const pa4 &p) const {
if (x != p.x) return x < p.x;
if (y != p.y) return y < p.y;
if (z != p.z) return z < p.z;
return w < p.w;
}
bool operator>(const pa4 &p) const {
if (x != p.x) return x > p.x;
if (y != p.y) return y > p.y;
if (z != p.z) return z > p.z;
return w > p.w;
}
bool operator==(const pa4 &p) const {
return x == p.x && y == p.y && z == p.z && w == p.w;
}
};
class pa2 {
public:
int x, y;
pa2(int x = 0, int y = 0) : x(x), y(y) {}
pa2 operator+(pa2 p) { return pa2(x + p.x, y + p.y); }
pa2 operator-(pa2 p) { return pa2(x - p.x, y - p.y); }
bool operator<(const pa2 &p) const { return y != p.y ? y < p.y : x < p.x; }
bool operator>(const pa2 &p) const { return x != p.x ? x < p.x : y < p.y; }
bool operator==(const pa2 &p) const {
return abs(x - p.x) == 0 && abs(y - p.y) == 0;
}
bool operator!=(const pa2 &p) const {
return !(abs(x - p.x) == 0 && abs(y - p.y) == 0);
}
};
string itos(int i) {
ostringstream s;
s << i;
return s.str();
}
int gcd(int v, int b) {
if (v > b) return gcd(b, v);
if (v == b) return b;
if (b % v == 0) return v;
return gcd(v, b % v);
}
int mod;
int extgcd(int a, int b, int &x, int &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
int d = extgcd(b, a % b, y, x);
y -= a / b * x;
return d;
}
pair<int, int> operator+(const pair<int, int> &l, const pair<int, int> &r) {
return {l.first + r.first, l.second + r.second};
}
pair<int, int> operator-(const pair<int, int> &l, const pair<int, int> &r) {
return {l.first - r.first, l.second - r.second};
}
int pr[1000010];
int inv[1000010];
int beki(int wa, int rr, int warukazu) {
if (rr == 0) return 1 % warukazu;
if (rr == 1) return wa % warukazu;
wa %= warukazu;
if (rr % 2 == 1)
return ((long long)beki(wa, rr - 1, warukazu) * (long long)wa) % warukazu;
long long zx = beki(wa, rr / 2, warukazu);
return (zx * zx) % warukazu;
}
int comb(int nn, int rr) {
if (rr < 0 || rr > nn || nn < 0) return 0;
int r = pr[nn] * inv[rr];
r %= mod;
r *= inv[nn - rr];
r %= mod;
return r;
}
void gya(int ert) {
pr[0] = 1;
for (int i = 1; i <= ert; i++) {
pr[i] = ((long long)pr[i - 1] * i) % mod;
}
inv[ert] = beki(pr[ert], mod - 2, mod);
for (int i = ert - 1; i >= 0; i--) {
inv[i] = (long long)inv[i + 1] * (i + 1) % mod;
}
}
const int N = 140000;
vector<int> G[(1 << 17) + 5];
int dis[(1 << 17) + 5];
int mae[N];
void dfs(int r, int p, int d = 0) {
mae[r] = p;
dis[r] = d;
for (auto v : G[r])
if (v != p) dfs(v, r, d + 1);
}
vector<int> G2[140000];
int m;
int d2[140000];
void dfs2(int r, int p, int d = 0) {
d2[r] = d;
for (auto v : G[r])
if (v != p) {
G2[r].push_back(v);
dfs2(v, r, d + 1);
}
}
int st[140000] = {};
void dfs3(int r) {
for (auto v : G2[r]) dfs3(v);
if (G2[r].size() == 0) {
st[r] = 1;
return;
}
if (G2[r].size() != 2) {
st[r] = -1;
return;
}
st[r] = -1;
int f1 = st[G2[r][0]];
int f2 = st[G2[r][1]];
if (f2 == f1) st[r] = f1 + 1;
}
bool kakunin(int r, int d, int n) {
if (d == n) {
return G2[r].size() == 0;
}
if (G2[r].size() != 2) return 0;
if (!kakunin(G2[r][0], d + 1, n)) return 0;
if (!kakunin(G2[r][1], d + 1, n)) return 0;
return 1;
}
vector<int> ans;
void ch(int n, int r) {
for (int i = 0; i < 140000; i++) G2[i].clear(), st[i] = 0;
dfs2(r, r);
dfs3(r);
int it = -1, g = -1;
for (int i = 1; i <= m; i++)
if (st[i] == -1) {
if (g < d2[i]) {
g = d2[i], it = i;
}
}
if (g > n - 2) return;
if (g == n - 2) {
G2[it].push_back(0);
} else {
if (G2[it].size() != 3) return;
vector<pair<int, int> > R;
for (int i = 0; i < 3; i++)
R.push_back(make_pair(st[G2[it][i]], G2[it][i]));
sort(R.begin(), R.end());
if (R[0].first != R[1].first) return;
if (R[2].first != R[1].first + 1) return;
G2[it].clear();
G2[it].push_back(0);
G2[it].push_back(R[2].second);
G2[0].push_back(R[0].second);
G2[0].push_back(R[1].second);
}
if (kakunin(r, 1, n)) {
ans.push_back(it);
}
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
if (n == 2) {
cout << 2 << endl;
cout << "1 2" << endl;
return 0;
}
for (int i = 0; i < (1 << n) - 3; i++) {
int y, yy;
cin >> y >> yy;
G[y].push_back(yy);
G[yy].push_back(y);
}
m = (1 << n) - 2;
dfs(1, 1);
int it = -1, d = -1;
for (int i = 1; i <= m; i++) {
if (d < dis[i]) {
it = i, d = dis[i];
}
}
dfs(it, it);
it = -1, d = -1;
for (int i = 1; i <= m; i++) {
if (d < dis[i]) {
it = i, d = dis[i];
}
}
if ((d - 1) / 2 + 2 != n) {
cout << 0 << endl;
return 0;
}
vector<int> path;
while (1) {
path.push_back(it);
it = mae[it];
if (it == path.back()) break;
}
int t = path.size();
if (t % 2) {
ch(n, path[t / 2]);
} else {
ch(n, path[t / 2]);
ch(n, path[t / 2 - 1]);
}
sort(ans.begin(), ans.end());
cout << ans.size() << endl;
for (auto v : ans) cout << v << " ";
cout << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
const int deg = 18;
const int mod = 1000000007;
struct edge {
int v, next, val;
} e[maxn * 2];
int n, m, heads[maxn], fa[maxn][deg], dep[maxn], cnt;
int pre1[maxn], pre2[maxn];
int vis[maxn];
int sum1[maxn], sum2[maxn];
int dir[maxn];
void add(int u, int v, int val) {
e[++cnt].next = heads[u];
heads[u] = cnt;
e[cnt].v = v;
e[cnt].val = val;
}
void dfs(int u, int pree) {
for (int i = heads[u]; i; i = e[i].next) {
if (e[i].v != pree) {
dep[e[i].v] = dep[u] + 1;
fa[e[i].v][0] = u;
dir[e[i].v] = e[i].val;
dfs(e[i].v, u);
}
}
}
int LCA(int u, int v) {
if (dep[u] > dep[v]) swap(u, v);
for (int i = deg - 1; ~i; i--)
if (dep[fa[v][i]] >= dep[u]) v = fa[v][i];
if (u == v) return u;
for (int i = deg - 1; ~i; i--)
if (fa[u][i] != fa[v][i]) {
u = fa[u][i];
v = fa[v][i];
}
return fa[u][0];
}
void dfs1(int u, int pree) {
sum1[u] = pre1[u];
sum2[u] = pre2[u];
for (int i = heads[u]; i; i = e[i].next) {
if (e[i].v != pree) {
dfs1(e[i].v, u);
sum1[u] += sum1[e[i].v];
sum2[u] += sum2[e[i].v];
}
}
if (dir[u] == 1) vis[u] += sum1[u];
if (dir[u] == -1) vis[u] += sum2[u];
}
long long qpow(long long x, long long y) {
long long ans = 1;
x %= mod;
while (y) {
if (y & 1) ans = (x * ans) % mod;
x = (x * x) % mod;
y >>= 1;
}
return ans;
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
if (z == 0) {
add(x, y, 0);
add(y, x, 0);
} else {
add(x, y, 1);
add(y, x, -1);
}
}
dep[1] = fa[1][0] = 1;
dfs(1, 0);
for (int i = 1; i <= deg - 1; i++)
for (int j = 1; j <= n; j++) fa[j][i] = fa[fa[j][i - 1]][i - 1];
scanf("%d", &m);
int last = 1, a;
for (int i = 0; i < m; i++) {
scanf("%d", &a);
int lca = LCA(last, a);
pre1[last]++;
pre1[lca]--;
pre2[a]++;
pre2[lca]--;
last = a;
}
dfs1(1, 0);
long long ans = 0;
for (int i = 2; i <= n; i++) {
ans += qpow(2, vis[i]) - 1;
if (ans >= mod) ans -= mod;
}
printf("%lld\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int a[2002];
vector<int> g[2002];
long long mod = 1000000007;
long long dfs(int cur, int par, int root, int d) {
long long ret = 1;
for (int e : g[cur]) {
if (e != par && (a[e] < a[root] || (a[e] == a[root] && e < root)) &&
a[e] >= a[root] - d) {
ret = ret * (dfs(e, cur, root, d) + 1) % mod;
}
}
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
int d, n;
cin >> d >> n;
for (int _n(n), i(0); i < _n; i++) cin >> a[i];
for (int _n(n - 1), i(0); i < _n; i++) {
int x, y;
cin >> x >> y;
--x, --y;
g[x].push_back(y);
g[y].push_back(x);
}
long long ans = 0;
for (int _n(n), i(0); i < _n; i++) ans += dfs(i, -1, i, d);
cout << ans % mod << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
const long long m = 1000000007;
using namespace std;
void sc(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;
}
long long power(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b % 2 != 0) res = (res * a) % m;
a = (a * a) % m;
b /= 2;
}
return res % m;
}
long long gcd(long long a, long long b) {
return ((b == 0) ? a : gcd(b, a % b));
}
char t[200001], p[200001];
int tn[200001];
int nt, np;
bool bs(int mid) {
int i, k = 0;
for (i = 0; i < nt; i++) {
if (tn[i] <= mid) continue;
if (t[i] == p[k]) k++;
}
if (k == np)
return true;
else
return false;
}
int main() {
int i, a, b, start, end, mid, prev = -1;
;
cin >> t;
nt = strlen(t);
cin >> p;
np = strlen(p);
for (i = 0; i < nt; i++) {
sc(a);
tn[a - 1] = i;
}
start = 0;
end = nt - 1;
while (start <= end) {
mid = (start + end) >> 1;
if (bs(mid) == true) {
prev = mid;
start = mid + 1;
} else
end = mid - 1;
}
printf("%d\n", prev + 1);
return 0;
}
| 4 |
#include <bits/stdc++.h>
const long long MOD = 1e9 + 7;
const long long INF = 1e18;
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
long long n;
cin >> n;
map<long long, long long> tmp;
int a;
for (int i = 0; i < n; i++) {
cin >> a;
tmp[a]++;
}
long long cnt[n + 10];
memset(cnt, 0, sizeof(cnt));
for (auto x : tmp) cnt[x.second]++;
long long res = 0, ans = n;
long long m = n;
for (long long i = n; i >= 1; i--) {
m -= cnt[i + 1];
cnt[i] += cnt[i + 1];
if (i * i > m) continue;
int k = (m / i) * i;
if (k > res and (m / i) >= i) {
res = k;
ans = i;
}
}
int mat[(res / ans) + 2][(ans) + 3];
long long c = res / ans, d = ans;
long long x = 0, y = 0;
cout << res << "\n";
vector<pair<long long, long long>> tak;
for (auto x : tmp) {
if (x.second) tak.push_back({x.second, x.first});
}
sort(tak.begin(), tak.end(), greater<pair<long long, long long>>());
for (auto kk : tak) {
for (int j = 0; j < min((long long)kk.first, ans) and res--; j++) {
mat[(x + y) % c][y] = kk.second;
x = (x + (y == (d - 1))) % c, y = (y + 1) % d;
}
}
cout << c << " " << d << "\n";
for (int i = 0; i < c; i++) {
for (int j = 0; j < d; j++) cout << mat[i][j] << " ";
cout << "\n";
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using vi = vector<int>;
using vll = vector<ll>;
int getSuffix(string &s, int x) {
if (x == 0) return (int)(s).size();
int cnt = 0;
for (int i = (int)(s).size() - 2; i >= 0; --i) {
if (s[i] != s[i + 1]) cnt++;
if (cnt == x) return i + 1;
}
return 0;
}
vector<pii> f(string s, string t, int d) {
if (s.back() != 'a') s += 'a';
if (t.back() != 'b') t += 'b';
int cntS = 1, cntT = 1;
for (int(i) = (0); (i) < (int)((int)(s).size() - 1); ++(i))
if (s[i] != s[i + 1]) cntS++;
for (int(i) = (0); (i) < (int)((int)(t).size() - 1); ++(i))
if (t[i] != t[i + 1]) cntT++;
int posS = -1, posT = -1;
if (cntS > cntT + 2) {
posS = getSuffix(s, (cntS - cntT) / 2 + d);
posT = getSuffix(t, 1);
} else if (cntT > cntS + 2) {
posS = getSuffix(s, 1);
posT = getSuffix(t, (cntT - cntS) / 2 + d);
}
vector<pii> re;
if (posS != -1) {
string tmpS = s;
s = t.substr(0, posT) + s.substr(posS);
t = tmpS.substr(0, posS) + t.substr(posT);
re.emplace_back(posS, posT);
}
while (1) {
while ((int)(s).size() && s.back() == 'a') s.pop_back();
while ((int)(t).size() && t.back() == 'b') t.pop_back();
if (!(int)(s).size() && !(int)(t).size()) break;
re.emplace_back((int)(s).size(), (int)(t).size());
swap(s, t);
}
return re;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(20);
string S, T;
cin >> S >> T;
vector<pii> ans{{-1, -1}};
for (int(a) = (0); (a) < (int)(2); ++(a))
for (int(d) = (0); (d) < (int)(3); ++(d)) {
auto re = [&]() {
if (!a) return f(S, T, d);
auto re = f(T, S, d);
for (auto &(r) : (re)) swap(r.first, r.second);
return re;
}();
if (((int)(ans).size() == 1 && ans[0].first == -1) ||
(int)(ans).size() > (int)(re).size())
ans = re;
}
cout << (int)(ans).size() << endl;
for (auto &(x) : (ans)) cout << x.first << ' ' << x.second << endl;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int n;
cin >> n;
long long int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
long long int ans = 0;
long long int count[100005] = {0};
multiset<long long int> s;
for (int i = 0; i < n; i++) {
if (count[a[i]] >= 1) s.erase(s.find(count[a[i]]));
count[a[i]]++;
s.insert(count[a[i]]);
long long int first = *(s.begin());
long long int last = *(s.rbegin());
s.erase(s.find(first));
if (first > 1) s.insert(first - 1);
if (!s.size() || *(s.begin()) == *(s.rbegin())) ans = i + 1;
if (first > 1) s.erase(s.find(first - 1));
s.insert(first);
s.erase(s.find(last));
if (last > 1) s.insert(last - 1);
if (!s.size() || *(s.begin()) == *(s.rbegin())) ans = i + 1;
if (last > 1) s.erase(s.find(last - 1));
s.insert(last);
}
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long ksm(long long a, long long b) {
if (!b) return 1;
long long ns = ksm(a, b >> 1);
ns = ns * ns % 998244353;
if (b & 1) ns = ns * a % 998244353;
return ns;
}
int chk(int x1, int y1, int x2, int y2) {
cout << "? " << x1 << ' ' << y1 << ' ' << x2 << ' ' << y2 << endl;
fflush(stdout);
int r = 0;
cin >> r;
return r;
}
int a[55][55];
int main() {
int n;
cin >> n;
a[1][1] = 1;
for (int j = 3; j <= n; j++)
if (chk(1, j - 2, 1, j))
a[1][j] = a[1][j - 2];
else
a[1][j] = a[1][j - 2] ^ 1;
for (int i = 2; i <= n; i++)
for (int j = n; j >= 1; j--) {
if (i == n && j == n)
a[i][j] = 0;
else {
if (j >= 2)
if (chk(i - 1, j - 1, i, j))
a[i][j] = a[i - 1][j - 1];
else
a[i][j] = a[i - 1][j - 1] ^ 1;
else if (chk(i, j, i, j + 2))
a[i][j] = a[i][j + 2];
else
a[i][j] = a[i][j + 2] ^ 1;
}
}
int ed = 0;
for (int i = 1; i <= n; i += 2) {
if (a[i][i] == 1 && a[i + 2][i + 2] == 0) {
if (chk(i, i + 1, i + 2, i + 2))
ed = a[i][i + 1];
else if (chk(i, i, i + 1, i + 2))
ed = a[i + 1][i + 2] ^ 1;
else {
if (a[i][i + 1] == a[i + 1][i + 2])
ed = a[i][i + 1] ^ a[i][i + 2] ^ 1;
else if (a[i][i + 2] == 0)
ed = a[i + 1][i + 2];
else
ed = a[i][i + 1] ^ 1;
}
break;
}
}
cout << "!" << endl;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if ((i + j) & 1) a[i][j] ^= ed;
cout << a[i][j];
}
cout << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 150, M = 65;
int n;
int dist[N][N], g[N][N];
vector<long long> v[M];
map<long long, int> mp;
int main() {
memset(g, 0x3f, sizeof g);
memset(dist, 0x3f, sizeof dist);
cin >> n;
for (int i = 0; i < n; i++) {
long long t, x;
cin >> x;
t = x;
int cnt = 0;
while (t) {
if (t & 1) v[cnt].push_back(x);
t >>= 1;
cnt++;
}
}
int cnt = 0;
bool flag = false;
for (int i = 0; i <= 64; i++) {
int m = v[i].size();
if (!m)
continue;
else if (m > 2) {
flag = true;
break;
} else if (m == 2) {
long long x = v[i][0], y = v[i][1];
if (!mp[x]) mp[x] = ++cnt;
if (!mp[y]) mp[y] = ++cnt;
x = mp[x], y = mp[y];
g[x][y] = g[y][x] = 1;
dist[x][y] = dist[y][x] = 1;
}
}
if (flag)
cout << 3 << endl;
else {
int res = 0x3f3f3f3f;
for (int k = 1; k <= cnt; k++) {
for (int i = 1; i < k; i++)
if (g[k][i] == 1)
for (int j = i + 1; j < k; j++)
if (g[k][j] == 1)
if (dist[i][j] != 0x3f3f3f3f)
res = min(res, dist[i][j] + g[i][k] + g[j][k]);
for (int i = 1; i <= cnt; i++)
if (dist[i][k] != 0x3f3f3f3f)
for (int j = 1; j <= cnt; j++)
if (dist[k][j] != 0x3f3f3f3f)
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
}
if (res != 0x3f3f3f3f)
cout << res << endl;
else
cout << -1 << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
unordered_map<int, int> cnt;
int n, m, k, d, ans_l, ans_r, a[N];
struct segment_pos {
int seg[N << 2], lz[N << 2];
inline void add(int id, int x) { seg[id] += x, lz[id] += x; }
inline void shift(int id) {
add(id << 1 | 1, lz[id]);
add(id << 1, lz[id]), lz[id] = 0;
}
inline void find(int id) { seg[id] = min(seg[id << 1], seg[id << 1 | 1]); }
void build(int id = 1, int st = 0, int en = m) {
if (en - st == 1) {
seg[id] = st - k;
return;
}
int mid = st + en >> 1;
build(id << 1, st, mid), lz[id] = 0;
build(id << 1 | 1, mid, en), find(id);
}
void update(int l, int r, int x, int id = 1, int st = 0, int en = m) {
if (r <= st || en <= l) return;
if (l <= st && en <= r) return add(id, x);
int mid = st + en >> 1;
shift(id), update(l, r, x, id << 1, st, mid);
update(l, r, x, id << 1 | 1, mid, en), find(id);
}
int get(int l, int r, int id = 1, int st = 0, int en = m) {
if (r <= st || en <= l || seg[id] >= r) return -1;
if (en - st == 1) return st;
shift(id);
int mid = st + en >> 1;
int p = get(l, r, id << 1, st, mid);
return ~p ? p : get(l, r, id << 1 | 1, mid, en);
}
} val;
struct segment_col {
int seg[N << 2], mx[N << 2];
inline void add(int id, int x) { seg[id] = mx[id] = x; }
inline void shift(int id) {
if (~seg[id]) {
add(id << 1, seg[id]);
add(id << 1 | 1, seg[id]);
}
}
inline void find(int id) {
mx[id] = max(mx[id << 1], mx[id << 1 | 1]);
seg[id] = seg[id << 1] ^ seg[id << 1 | 1] ? -1 : seg[id << 1];
}
void build(int id = 1, int st = 0, int en = m) {
if (en - st == 1) return add(id, a[st]);
int mid = st + en >> 1;
build(id << 1 | 1, mid, en);
build(id << 1, st, mid), find(id);
}
void update(int l, int r, int x, int id = 1, int st = 0, int en = m) {
if (r <= st || en <= l || mx[id] <= x) return;
if (l <= st && en <= r && ~seg[id]) {
val.update(st, en, seg[id] - x);
return add(id, x);
}
int mid = st + en >> 1;
shift(id), update(l, r, x, id << 1, st, mid);
update(l, r, x, id << 1 | 1, mid, en), find(id);
}
} mn, mx;
inline void read_input() {
cin >> n >> k >> d;
for (int i = 0; i < n; i++) {
cin >> a[i];
a[i] += 1e9;
}
}
inline void solve(int l, int r) {
m = 0;
for (int i = l; i < r; i++) a[m++] = a[i] / d;
val.build(), mn.build();
for (int i = 0; i < m; i++) a[i] *= -1;
cnt.clear(), mx.build();
for (int i = 0, p = 0; i < m; cnt[a[i++]]++) {
mn.update(p, i, -a[i]), mx.update(p, i, a[i]);
while (cnt[a[i]]) cnt[a[p++]]--;
int x = val.get(p, i + 1);
if (i - x > ans_r - ans_l) {
ans_l = l + x;
ans_r = l + i;
}
}
}
inline void write_output() {
if (d) {
int p = 0;
for (int i = 0; i < n; i++)
if (a[i] % d ^ a[p] % d) {
solve(p, i);
p = i;
}
solve(p, n);
} else
for (int i = 0, p = 0; i < n; i++) {
while (a[i] ^ a[p]) p++;
if (i - p > ans_r - ans_l) {
ans_l = p;
ans_r = i;
}
}
cout << ++ans_l << ' ' << ++ans_r;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
read_input(), write_output();
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e5 + 123;
const long long INF = (long long)1e18 + 123;
const int inf = (int)1e9 + 123;
const int MOD = (int)1e9 + 7;
void megaRandom() {
unsigned int FOR;
asm("rdtsc" : "=A"(FOR));
srand(FOR);
}
int n, m, k;
pair<pair<int, int>, int> p[N], z[N];
pair<int, int> to[] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
bool was[N];
vector<pair<int, int> > js[N], is[N];
int mnjs[N], mxjs[N], mnis[N], mxis[N];
int find_min(bool who, int o, int &l) {
if (!who) {
while (l < (int)(js[o].size()) && was[js[o][l].second]) l++;
if (l >= (int)(js[o].size())) return -1;
} else {
while (l < (int)(is[o].size()) && was[is[o][l].second]) l++;
if (l >= (int)(is[o].size())) return -1;
}
return l;
}
int find_max(bool who, int o, int &r) {
if (!who) {
if (!(int)(js[o].size())) return -1;
while (r >= 0 && was[js[o][r].second]) r--;
} else {
if (!(int)(is[o].size())) return -1;
while (r >= 0 && was[is[o][r].second]) r--;
}
if (r < 0) return -1;
return r;
}
int delete_suff(bool who, int mnval, int &r) {
int cnt = 0;
if (!who) {
while (r >= 1 && (was[p[r].second] || p[r].first.first >= mnval))
cnt += (was[p[r].second] ^ 1), was[p[r].second] = 1, r--;
} else {
while (r >= 1 && (was[z[r].second] || z[r].first.first >= mnval))
cnt += (was[z[r].second] ^ 1), was[z[r].second] = 1, r--;
}
return cnt;
}
int delete_pref(bool who, int mxval, int &l) {
int cnt = 0;
if (!who) {
while (l <= k && (was[p[l].second] || p[l].first.first <= mxval))
cnt += (was[p[l].second] ^ 1), was[p[l].second] = 1, l++;
} else {
while (l <= k && (was[z[l].second] || z[l].first.first <= mxval))
cnt += (was[z[l].second] ^ 1), was[z[l].second] = 1, l++;
}
return cnt;
}
void no() {
puts("No");
exit(0);
}
int main() {
megaRandom();
cin >> n >> m >> k;
for (int i = 1; i <= k; i++) {
cin >> p[i].first.first >> p[i].first.second;
z[i].first = make_pair(p[i].first.second, p[i].first.first);
p[i].second = z[i].second = i;
mnjs[p[i].first.first] = 0;
mnis[p[i].first.first] = 0;
js[p[i].first.first].push_back(make_pair(p[i].first.second, i));
is[p[i].first.second].push_back(make_pair(p[i].first.first, i));
}
for (int i = 1; i <= n; i++) {
sort(js[i].begin(), js[i].end());
mxjs[i] = (int)(js[i].size()) - 1;
}
for (int i = 1; i <= m; i++) {
sort(is[i].begin(), is[i].end());
mxis[i] = (int)(is[i].size()) - 1;
}
sort(p + 1, p + k + 1);
sort(z + 1, z + k + 1);
int i = 1, j = 1, toi = -1, toj = -1, dir = 0;
int lp = 1, lz = 1, rp = k, rz = k;
int min_n = 1, min_m = 1, cur_n = n, cur_m = m, cnt = 0;
while (1) {
if (min_n > cur_n || min_m > cur_m) break;
toi = -1, toj = -1;
if (dir == 0) {
toj = cur_m;
if (find_min(0, i, mnjs[i]) != -1) {
toj = js[i][mnjs[i]].first - 1;
cnt = delete_suff(1, toj + 1, rz);
if (1ll * (cur_m - toj) * (cur_n - min_n + 1) != cnt) no();
}
j = toj, cur_m = toj, min_n++;
}
if (dir == 1) {
toi = cur_n;
if (find_min(1, j, mnis[j]) != -1) {
toi = is[j][mnis[j]].first - 1;
cnt = delete_suff(0, toi + 1, rp);
if (1ll * (cur_n - toi) * (cur_m - min_m + 1) != cnt) no();
}
i = toi, cur_n = toi, cur_m--;
}
if (dir == 2) {
toj = min_m;
if (find_max(0, i, mxjs[i]) != -1) {
toj = js[i][mxjs[i]].first + 1;
cnt = delete_pref(1, toj - 1, lz);
if (1ll * (toj - min_m) * (cur_n - min_n + 1) != cnt) no();
}
j = toj, min_m = toj, cur_n--;
}
if (dir == 3) {
toi = min_n;
if (find_max(1, j, mxis[j]) != -1) {
toi = is[j][mxis[j]].first + 1;
cnt = delete_pref(0, toi - 1, lp);
if (1ll * (toi - min_n) * (cur_m - min_m + 1) != cnt) no();
}
i = toi, min_n = toi, min_m++;
}
dir = (dir + 1) % 4;
}
puts("Yes");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 10010;
int n, m, col[maxn], f[maxn][20], depth[maxn], en, fa[maxn], cnt, l[maxn],
r[maxn], z1[maxn << 1], z2[maxn << 1], s[maxn], e[maxn];
bool tree[maxn], del[maxn];
struct edge {
int e;
edge *next;
} * v[maxn], ed[maxn << 1];
void add_edge(int s, int e) {
en++;
ed[en].next = v[s];
v[s] = ed + en;
v[s]->e = e;
}
void dfs(int now) {
for (edge *e = v[now]; e; e = e->next)
if (!col[e->e]) {
col[e->e] = 3 - col[now];
depth[e->e] = depth[now] + 1;
dfs(e->e);
}
}
void dfsf(int now) {
cnt++;
l[now] = cnt;
for (edge *e = v[now]; e; e = e->next)
if (depth[e->e] == depth[now] + 1) {
int nowp = now, delta = 0;
f[e->e][0] = now;
while (f[nowp][delta]) {
f[e->e][delta + 1] = f[nowp][delta];
nowp = f[nowp][delta];
delta++;
}
dfsf(e->e);
}
cnt++;
r[now] = cnt;
}
int get_lca(int p1, int p2) {
if (depth[p1] < depth[p2]) swap(p1, p2);
int delta = depth[p1] - depth[p2], now = 0;
while (delta) {
if (delta & 1) p1 = f[p1][now];
now++;
delta >>= 1;
}
now = 0;
while (p1 != p2) {
if (now == 0 || f[p1][now] != f[p2][now]) {
p1 = f[p1][now];
p2 = f[p2][now];
now++;
} else
now--;
}
return p1;
}
void add(int *z, int p, int delta) {
for (int a = p; a <= cnt; a += (a & (-a))) z[a] += delta;
}
int query(int *z, int p) {
int ans = 0;
for (int a = p; a >= 1; a -= (a & (-a))) ans += z[a];
return ans;
}
int getf(int now) {
if (fa[now] == now)
return now;
else
return fa[now] = getf(fa[now]);
}
int main() {
scanf("%d%d", &n, &m);
for (int a = 1; a <= m; a++) scanf("%d%d", &s[a], &e[a]);
for (int a = 1; a <= n; a++) fa[a] = a;
int cnt = n;
for (int a = 1; a <= m; a++) {
int f1 = getf(s[a]);
int f2 = getf(e[a]);
if (f1 != f2) {
tree[a] = true;
fa[f1] = f2;
add_edge(s[a], e[a]);
add_edge(e[a], s[a]);
cnt--;
if (cnt == 1) break;
}
}
for (int a = 1; a <= n; a++)
if (!col[a]) {
col[a] = 1;
depth[a] = 2;
dfs(a);
add_edge(n + 1, a);
add_edge(a, n + 1);
}
col[n + 1] = 2;
depth[n + 1] = 1;
dfsf(n + 1);
int err = 0;
for (int a = 1; a <= m; a++)
if (col[s[a]] == col[e[a]]) err++;
if (err == 1) {
for (int a = 1; a <= m; a++)
if (col[s[a]] == col[e[a]]) del[a] = true;
} else {
if (err == 0) {
for (int a = 1; a <= m; a++)
if (!tree[a]) del[a] = true;
}
}
for (int a = 1; a <= m; a++)
if (!tree[a]) {
int f = get_lca(s[a], e[a]);
if (col[s[a]] == col[e[a]]) {
add(z1, l[s[a]], -1);
add(z1, l[e[a]], -1);
add(z1, l[f], 2);
} else {
add(z2, l[s[a]], -1);
add(z2, l[e[a]], -1);
add(z2, l[f], 2);
}
}
for (int a = 1; a <= m; a++)
if (tree[a]) {
int p;
if (depth[s[a]] > depth[e[a]])
p = s[a];
else
p = e[a];
int v1 = -query(z1, r[p]) + query(z1, l[p] - 1);
int v2 = -query(z2, r[p]) + query(z2, l[p] - 1);
if (v1 == err && ((v1 != 0 && v2 == 0) || (v1 == 0))) del[a] = true;
}
int ans = 0;
for (int a = 1; a <= m; a++)
if (del[a]) ans++;
printf("%d\n", ans);
int anss = 0;
for (int a = 1; a <= m; a++)
if (del[a]) {
printf("%d", a);
anss++;
if (anss == ans)
printf("\n");
else
printf(" ");
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
const int N = 7850;
int i, j, k, n, m, x, y, t, a1, a2, a3, a4, num;
int a[N][N];
pair<int, int> p[N];
int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
f = ch == '-' ? -f : f;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - 48;
ch = getchar();
}
return x * f;
}
map<pair<int, int>, int> mark;
int mi(int x, int y) {
if (y == 0) return 1;
int t = mi(x, y >> 1);
t = 1ll * t * t % mod;
return y & 1 ? (1ll * x * t % mod) : t;
}
int main() {
n = read();
a1 = read();
a2 = read();
a3 = read();
a4 = read();
x = mi(a1 + a2 + a3 + a4, mod - 2);
a1 = 1ll * a1 * x % mod;
a2 = 1ll * a2 * x % mod;
a3 = 1ll * a3 * x % mod;
a4 = 1ll * a4 * x % mod;
for (j = -n; j <= n; j++)
for (i = -n; i <= n; i++)
if (i * i + j * j <= n * n) {
mark[make_pair(i, j)] = ++num;
p[num] = make_pair(i, j);
}
for (i = -n; i <= n; i++)
for (j = -n; j <= n; j++)
if (i * i + j * j <= n * n) {
a[mark[make_pair(i, j)]][mark[make_pair(i, j)]] = 1;
a[mark[make_pair(i, j)]][num + 1] = 1;
if (mark[make_pair(i - 1, j)]) {
a[mark[make_pair(i - 1, j)]][mark[make_pair(i, j)]] = mod - a3;
}
if (mark[make_pair(i + 1, j)]) {
a[mark[make_pair(i + 1, j)]][mark[make_pair(i, j)]] = mod - a1;
}
if (mark[make_pair(i, j - 1)]) {
a[mark[make_pair(i, j - 1)]][mark[make_pair(i, j)]] = mod - a4;
}
if (mark[make_pair(i, j + 1)]) {
a[mark[make_pair(i, j + 1)]][mark[make_pair(i, j)]] = mod - a2;
}
}
int te = 0, ans = mark[make_pair(0, 0)];
for (i = 1; i < num; i++) {
t = 0;
for (j = i + 1; j <= num; j++)
if ((p[j].second == p[i].second) ||
(p[j].second == p[i].second + 1 && p[j].first <= p[i].first)) {
t = j;
} else if (p[j].second > p[i].second + 1)
break;
te += t - i + 1;
for (j = i + 1; j <= t; j++) {
x = j;
int incr = 1ll * a[x][i] * mi(a[i][i], mod - 2) % mod;
for (k = i; k <= t; k++)
a[x][k] = (a[x][k] - 1ll * a[i][k] * incr % mod + mod) % mod;
a[x][num + 1] =
(a[x][num + 1] - 1ll * a[i][num + 1] * incr % mod + mod) % mod;
if (p[j].first == p[i].first) break;
}
mark[make_pair(p[i].first, p[i].second)] = -1;
}
for (i = num; i >= 1; i--) {
a[i][num + 1] = 1ll * a[i][num + 1] * mi(a[i][i], mod - 2) % mod;
a[i][i] = 1;
for (j = i - 1; j >= 1; j--)
a[j][num + 1] =
(a[j][num + 1] - 1ll * a[j][i] * a[i][num + 1] % mod + mod) % mod;
}
printf("%d\n", a[ans][num + 1]);
return 0;
}
| 11 |
#include <bits/stdc++.h>
int N, C, B[1000001];
std::vector<int> V[500000];
int F(int l, int r, int p) {
while (l < r && V[l].size() == p) l++;
if (l >= r) return 0;
for (int i = l; i <= r; i++)
if (V[i].size() == p) return 1;
int last = l;
for (int i = l; i < r; i++)
if (V[i][p] != V[i + 1][p]) {
if (F(last, i, p + 1)) return 1;
if (V[i][p] < V[i + 1][p]) B[C - V[i + 1][p]]++, B[C - V[i][p]]--;
if (V[i][p] > V[i + 1][p])
B[0]++, B[C - V[i][p]]--, B[C - V[i + 1][p]]++, B[C]--;
last = i + 1;
}
return F(last, r, p + 1);
}
int main() {
scanf("%d%d", &N, &C);
for (int i = 0, z, x; i < N; i++) {
scanf("%d", &z);
for (int j = 0; j < z; j++) {
scanf("%d", &x);
V[i].push_back(x - 1);
}
}
if (F(0, N - 1, 0))
puts("-1");
else if (!B[0])
puts("0");
else {
for (int i = 1; i < C; i++)
if (!(B[i] += B[i - 1])) return printf("%d\n", i), 0;
puts("-1");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T load() {
T r;
cin >> r;
return r;
}
template <typename T>
vector<T> loadMany(int n) {
vector<T> rs(n);
generate(rs.begin(), rs.end(), &load<T>);
return rs;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
auto n = load<int>();
auto q = load<int>();
auto maxReligion = 250;
auto text = load<string>();
auto nextocc = vector<array<int, 26>>(n);
for (auto i = n - 1; i >= 0; --i)
for (auto c = 'a'; c <= 'z'; ++c)
nextocc[i][c - 'a'] = text[i] == c ? i
: i != n - 1 ? nextocc[i + 1][c - 'a']
: n;
auto dyn = vector<vector<vector<int>>>(
maxReligion + 1,
vector<vector<int>>(maxReligion + 1, vector<int>(maxReligion + 1, -1)));
dyn[0][0][0] = 0;
auto pass = [&](int l1, int l2, int l3, int& target, char chr) {
if (dyn[l1][l2][l3] >= n) return;
target = min(target, nextocc[dyn[l1][l2][l3]][chr - 'a'] + 1);
};
auto ls = array<int, 3>{0, 0, 0};
auto religion = array<string, 3>{};
while (q-- > 0) {
auto kind = load<char>();
auto faith = load<int>() - 1;
if (kind == '+') {
auto chr = load<char>();
religion[faith].push_back(chr);
++ls[faith];
auto start = array<int, 3>{0, 0, 0};
auto finish = ls;
start[faith] = ls[faith];
finish[faith] = ls[faith];
for (auto l1 = start[0]; l1 <= finish[0]; ++l1) {
for (auto l2 = start[1]; l2 <= finish[1]; ++l2) {
for (auto l3 = start[2]; l3 <= finish[2]; ++l3) {
dyn[l1][l2][l3] = n + 1;
if (l1 > 0)
pass(l1 - 1, l2, l3, dyn[l1][l2][l3], religion[0][l1 - 1]);
if (l2 > 0)
pass(l1, l2 - 1, l3, dyn[l1][l2][l3], religion[1][l2 - 1]);
if (l3 > 0)
pass(l1, l2, l3 - 1, dyn[l1][l2][l3], religion[2][l3 - 1]);
}
}
}
} else {
religion[faith].pop_back();
--ls[faith];
}
cout << (dyn[ls[0]][ls[1]][ls[2]] <= n ? "YES\n" : "NO\n");
}
}
| 7 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
using namespace std;
string tostr(int n) {
stringstream rr;
rr << n;
return rr.str();
}
const int mod = 1e9 + 7;
const int mxn = 1e5 + 9;
const long double eps = 1e-9;
int main() {
cout << "Red\n";
flush(cout);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2010;
int k, n, m, up[maxn], down[maxn], fup[maxn][maxn], fdown[maxn][maxn],
mat[maxn][maxn];
struct point {
int x, y, ind;
};
multiset<int> st;
vector<point> vect[4 * maxn];
vector<int> dodaj[maxn], skini[maxn];
int sqs(int x, int y) {
if (x == 0 && y == 0) return 0;
return x + y - 1;
}
int get_ans() {
int lup = 1, rup = 0, ldown = 1, rdown = 0, l = 1;
pair<int, int> dq_up[k + 10], dq_down[k + 10];
dq_up[0] = {-1e9, 0};
dq_down[0] = {-1e9, 0};
int ret = 0;
for (int i = 1; i <= m; i++) {
while (dq_up[rup].first >= up[i] && lup <= rup) rup--;
dq_up[++rup] = {up[i], i};
while (dq_down[rdown].first >= down[i] && ldown <= rdown) rdown--;
dq_down[++rdown] = {down[i], i};
while (sqs(dq_down[ldown].first, dq_up[lup].first) < i - l + 1 && l <= i) {
l++;
while (dq_down[ldown].second < l && ldown <= rdown) ldown++;
while (dq_up[lup].second < l && lup <= rup) lup++;
}
ret = max(ret, i - l + 1);
}
return ret;
}
void go(int x, int l, int r) {
if (l > r) return;
int mid = (l + r) / 2;
for (int i = 0; i < vect[x].size(); i++) {
if (vect[x][i].x < mid)
vect[x * 2].push_back(vect[x][i]);
else if (vect[x][i].x > mid)
vect[x * 2 + 1].push_back(vect[x][i]);
}
go(x * 2, l, mid - 1);
go(x * 2 + 1, mid + 1, r);
for (int i = 1; i <= m; i++) {
up[i] = min(fup[mid][i], mid - l + 1);
down[i] = min(fdown[mid][i], r - mid + 1);
}
int prv = 1;
for (int i = 0; i < vect[x].size(); i++) {
int pom = get_ans();
dodaj[prv].push_back(pom);
skini[vect[x][i].ind].push_back(pom);
prv = vect[x][i].ind;
int xx = vect[x][i].x;
int yy = vect[x][i].y;
if (xx < mid)
up[yy] = min(up[yy], mid - xx);
else if (xx > mid)
down[yy] = min(down[yy], xx - mid);
else {
down[yy] = 0;
up[yy] = 0;
}
}
int pom = get_ans();
dodaj[prv].push_back(pom);
skini[k + 1].push_back(pom);
}
int main() {
scanf("%d %d %d", &n, &m, &k);
for (int i = 1; i <= n; i++) {
string s;
cin >> s;
for (int j = 1; j <= m; j++)
if (s[j - 1] == 'X') mat[i][j] = 1;
}
for (int i = 1; i <= k; i++) {
point p;
scanf("%d %d", &p.x, &p.y);
p.ind = i;
vect[1].push_back(p);
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
if (mat[i][j] == 1)
fup[i][j] = 0;
else
fup[i][j] = fup[i - 1][j] + 1;
}
for (int i = n; i >= 1; i--)
for (int j = 1; j <= m; j++) {
if (mat[i][j] == 1)
fdown[i][j] = 0;
else
fdown[i][j] = fdown[i + 1][j] + 1;
}
go(1, 1, n);
for (int i = 1; i <= k; i++) {
for (int j = 0; j < dodaj[i].size(); j++) st.insert(dodaj[i][j]);
for (int j = 0; j < skini[i].size(); j++) st.erase(st.find(skini[i][j]));
printf("%d\n", *st.rbegin());
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int V = 110;
int n, a[V], tot[V], T, ans;
char s[V];
void cal(char x, int lst) {
vector<int> G;
for (int i = 1; i <= n / 2; i++)
if (s[i] != s[n - i + 1] && s[i] != x && s[n - i + 1] != x) {
G.push_back(min(a[i], a[n - i + 1]));
}
sort(G.begin(), G.end());
for (int i = 0; i < lst; i++) ans -= G[i];
}
int main() {
cin >> n >> s + 1;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n / 2; i++) {
if (s[i] == s[n - i + 1]) {
tot[s[i] - 'a']++;
T++;
ans += max(a[i], a[n - i + 1]);
} else {
ans += a[i] + a[n - i + 1];
}
}
for (int i = 0; i < 26; i++) {
if (tot[i] * 2 > T) cal(i + 'a', tot[i] * 2 - T);
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m, s;
cin >> n >> m;
while (n) {
cout << n / m << " ";
s = m--;
n -= n / s;
}
cout << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-10;
const int maxn = 3e5 + 10;
const int INF = 0x3f3f3f3f;
struct edge {
int from, to;
long long w;
edge() {}
edge(int from, int to, long long w) : from(from), to(to), w(w) {}
};
vector<edge> e;
vector<vector<int> > g(maxn);
vector<long long> dist_n, dist_1;
vector<pair<long long, int> > rk;
int pos[maxn];
void addedge(int from, int to, long long w) {
e.push_back(edge(from, to, w));
e.push_back(edge(to, from, w));
int m = e.size();
g[from].push_back(m - 2);
g[to].push_back(m - 1);
}
void dfs(vector<long long>& d, int o, int p, long long w) {
d[o] = w;
for (auto& u : g[o]) {
edge temp = e[u];
if (temp.to != p) dfs(d, temp.to, o, w + temp.w);
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
dist_n.resize(n + 1);
dist_1.resize(n + 1);
for (int i = 0; i < n - 1; i++) {
int a, b;
long long w;
scanf("%d%d%lld", &a, &b, &w);
addedge(a, b, w);
}
dfs(dist_1, 1, -1, 0);
dfs(dist_n, n, -1, 0);
for (int i = 1; i <= n; i++)
rk.push_back(make_pair(dist_1[i] - dist_n[i], i));
sort(rk.begin(), rk.end());
for (int i = 0; i < n; i++) pos[rk[i].second] = i;
set<pair<long long, int> > s;
for (int i = 1; i <= n; i++) s.insert(make_pair(dist_n[i], i));
long long T = 0;
for (int i = 0; i < n; i++) {
int v = rk[i].second;
s.erase(make_pair(dist_n[v], v));
for (auto& u : g[v]) {
edge& temp = e[u];
if (pos[temp.to] > pos[v]) s.erase(make_pair(dist_n[temp.to], temp.to));
}
if (!s.empty()) {
T = max(T, dist_1[v] + s.rbegin()->first);
}
for (auto& u : g[v]) {
edge& temp = e[u];
if (pos[temp.to] > pos[v]) s.insert(make_pair(dist_n[temp.to], temp.to));
}
}
while (m--) {
int x;
scanf("%d", &x);
printf("%lld\n", min(dist_n[1], 1ll * x + T));
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, a, b;
pair<int, int> p[100005];
cin >> n;
int maxEnd = -1000000000, minStart = 1000000000;
for ((i) = 0; (i) < (int)(n); (i)++) {
cin >> a >> b;
p[i] = make_pair(a, b);
maxEnd = max(maxEnd, b);
minStart = min(minStart, a);
}
for ((i) = 0; (i) < (int)(n); (i)++)
if (p[i].first == minStart && p[i].second == maxEnd) {
cout << i + 1;
return 0;
}
cout << -1;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m, k, x, y;
cin >> n >> m >> k >> x >> y;
long long int A, B, C;
int i, j;
if (n == 1) {
long long int maxi = k / m;
long long int vec[m + 1];
for (i = 1; i <= m; i++) vec[i] = maxi;
long long int res = k % m;
for (i = 1; i <= m && res; i++) vec[i]++, res--;
long long int mini;
mini = maxi = vec[1];
for (i = 2; i <= m; i++) {
mini = min(mini, vec[i]);
maxi = max(maxi, vec[i]);
}
cout << maxi << " " << mini << " " << vec[y] << "\n";
return 0;
}
if (k > m) {
long long int K = (k - m) / ((n - 1) * m);
long long int res = (k - m) % ((n - 1) * m);
if (K == 0) {
A = 1;
B = 0;
C = 0;
} else {
if (K % 2 == 0) {
A = 1 + K / 2;
B = K;
C = K / 2;
} else {
A = 1 + (K - 1) / 2;
B = K;
C = (K + 1) / 2;
}
}
long long int mat[n + 1][m + 1];
for (j = 1; j <= m; j++) mat[1][j] = A;
for (i = 2; i < n; i++)
for (j = 1; j <= m; j++) mat[i][j] = B;
for (j = 1; j <= m; j++) mat[n][j] = C;
if (K % 2 == 0) {
for (i = 2; i <= n && res; i++) {
for (j = 1; j <= m && res; j++) {
mat[i][j]++;
res--;
}
}
} else {
for (i = n - 1; i >= 1 && res; i--) {
for (j = 1; j <= m && res; j++) {
mat[i][j]++;
res--;
}
}
}
long long int mini, maxi;
mini = maxi = mat[1][1];
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
mini = min(mini, mat[i][j]);
maxi = max(maxi, mat[i][j]);
}
}
cout << maxi << " " << mini << " " << mat[x][y] << "\n";
} else {
if (k == m) {
if (n > 1) {
cout << "1 0 ";
if (x == 1)
cout << "1\n";
else
cout << "0\n";
} else {
cout << "1 1 1";
}
} else {
cout << "1 0 ";
if (y <= k && x == 1)
cout << "1\n";
else
cout << "0\n";
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long A, long long B) {
if (B == 0) return A;
return gcd(B, A % B);
}
int main(int argc, char** argv) {
long long n, m, x, y, a, b;
cin >> n >> m >> x >> y >> a >> b;
long long G = gcd(a, b);
a /= G;
b /= G;
long long length, breadth;
breadth = n / a;
length = m / b;
long long factor = min(length, breadth);
long long x1, x2, y1, y2;
breadth = factor * a;
length = factor * b;
if (breadth >= (2 * x)) {
x1 = 0;
x2 = breadth;
} else if ((2 * x) >= (2 * n - breadth)) {
x1 = n - breadth;
x2 = n;
} else {
x1 = x - (breadth + 1) / 2;
x2 = x + breadth / 2;
}
if (length >= (2 * y)) {
y1 = 0;
y2 = length;
} else if ((2 * y) >= (2 * m - length)) {
y1 = m - length;
y2 = m;
} else {
y1 = y - (length + 1) / 2;
y2 = y + length / 2;
}
cout << x1 << " " << y1 << " " << x2 << " " << y2 << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long N, in, SA, SB;
vector<long long> A, B;
void solution1() {
sort(A.begin(), A.end());
sort(B.begin(), B.end());
int turn = 1;
while (A.size() || B.size()) {
if (A.size() && B.size()) {
if (A.back() > B.back()) {
if (turn == 1) SA += A.back();
A.pop_back();
} else {
if (turn == 0) SB += B.back();
B.pop_back();
}
} else if (A.size()) {
if (turn == 1) SA += A.back();
A.pop_back();
} else if (B.size()) {
if (turn == 0) SB += B.back();
B.pop_back();
}
turn = (turn + 1) % 2;
}
cout << SA - SB << endl;
}
int main() {
cin >> N;
for (int i = 0; i < N; i++) cin >> in, A.push_back(in);
for (int i = 0; i < N; i++) cin >> in, B.push_back(in);
solution1();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
cin >> str;
int n = str.size();
char ch = 'a';
int tmp = 0;
for (int i = 0; i < n; i++) {
if (str[i] > ch) {
tmp = 1;
break;
} else {
if (str[i] == ch) ch++;
}
}
if (tmp) {
cout << "NO\n";
} else {
cout << "YES\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000 + 200;
int a[maxn];
int minn = 10000000 * 100;
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> a[i];
}
sort(a, a + m);
for (int i = 0; i < m - n + 1; i++) {
minn = min(minn, a[i + n - 1] - a[i]);
}
cout << minn << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long B = 701;
const int maxn = 5e6 + 321;
int n;
string s;
long long b[maxn], h[maxn], Rh[maxn], dp[maxn], ans;
inline void build() {
b[0] = 1;
for (int i = 1; i <= n; i++) b[i] = b[i - 1] * B;
for (int i = 1; i <= n; i++) {
h[i] = h[i - 1] * B;
h[i] += (long long)s[i - 1];
}
for (int i = n - 1; i >= 0; i--) {
Rh[i] = Rh[i + 1] * B;
Rh[i] += (long long)s[i];
}
}
long long gethash(int l, int r, int t) {
if (t) return h[r] - (h[l] * b[r - l]);
return Rh[l] - (Rh[r] * b[r - l]);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> s;
n = s.size();
build();
dp[1] = 1, ans = 1;
for (int i = 2; i <= n; i++) {
if (gethash(0, i, 1) == gethash(0, i, 0))
dp[i] = dp[i / 2] + 1;
else
dp[i] = 0;
ans += dp[i];
}
cout << ans;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int len;
string s, t, ex;
int main() {
cin >> s;
len = s.length();
for (int brep = 0; brep <= len; brep++)
for (char ins = 'a'; ins <= 'z'; ins++) {
t = ins, ex = s;
ex.insert(brep, t);
if (ex == string(ex.rbegin(), ex.rend())) {
cout << ex;
return 0;
}
}
cout << "NA\n";
}
| 11 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("Ofast")
using namespace std;
long long n, m;
vector<long long> g[200005];
map<long long, long long> viz;
vector<pair<long long, long long>> vec, vans;
vector<long long> v;
long long dfs(long long node, long long par) {
long long maximum = 0;
for (auto it : g[node]) {
if (it != par) {
maximum = max(maximum, dfs(it, node));
}
}
return maximum + 1;
}
void dfs1(long long node) {
v.push_back(node);
viz[node] = 1;
for (auto it : g[node]) {
if (viz[it]) {
continue;
}
dfs1(it);
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> n >> m;
for (long long i = 1; i <= m; i++) {
long long x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
long long d = 0;
for (long long i = 1; i <= n; i++) {
if (viz[i]) {
continue;
}
v.clear();
dfs1(i);
long long mn = 1000000000000000005ll, mx = 0, pos = 0;
for (auto it : v) {
long long nr = dfs(it, 0);
mx = max(mx, nr);
d = max(d, nr);
if (nr < mn) {
mn = nr;
pos = it;
}
}
vec.push_back(make_pair(-mx, pos));
}
sort(vec.begin(), vec.end());
vector<pair<long long, long long>> ans;
for (long long i = 1; i < vec.size(); i++) {
ans.push_back(make_pair(vec[0].second, vec[i].second));
g[vec[0].second].push_back(vec[i].second);
g[vec[i].second].push_back(vec[0].second);
}
long long res = 0;
for (long long i = 1; i <= n; i++) {
res = max(res, dfs(i, 0));
}
cout << res - 1 << '\n';
for (auto it : ans) {
cout << it.first << ' ' << it.second << '\n';
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int a[50];
long long c[50][50];
long long dp[50][50][2];
int main() {
int x = 0, m = 1000000007, i, j, l, r;
long long k, ans = 0;
for (i = 0; i < 50; i++) {
c[i][0] = c[i][i] = 1;
for (j = 1; j < i; j++) c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % m;
}
scanf("%I64d", &k);
while (k) {
a[x++] = k & 1;
k >>= 1;
}
dp[0][0][0] = 1;
for (i = 0; i < x; i++) {
for (j = 0; j <= i; j++) {
for (l = 0; l < 2; l++) {
if (dp[i][j][l] == 0) continue;
if (l == 0 && a[x - i - 1] == 0) {
dp[i + 1][j][0] = (dp[i + 1][j][0] + dp[i][j][l]) % m;
} else {
dp[i + 1][j][1] = (dp[i + 1][j][1] + dp[i][j][l]) % m;
dp[i + 1][j + 1][l] = (dp[i + 1][j + 1][l] + dp[i][j][l]) % m;
}
for (r = 1; r <= j; r++) {
if (r & 1) {
if (l == 1 || a[x - i - 1] == 1)
dp[i + 1][j][l] = (dp[i + 1][j][l] + dp[i][j][l] * c[j][r]) % m;
} else {
if (a[x - i - 1] == 1) {
dp[i + 1][j][1] = (dp[i + 1][j][1] + dp[i][j][l] * c[j][r]) % m;
} else {
dp[i + 1][j][l] = (dp[i + 1][j][l] + dp[i][j][l] * c[j][r]) % m;
}
}
}
}
}
}
for (i = 0; i <= x; i++) {
for (j = 0; j < 2; j++) {
ans += dp[x][i][j];
}
}
printf("%I64d\n", ans % m);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int a;
cin >> a;
for (int i = 0; i <= 15; i++) {
for (int j = 0; j <= 33; j++) {
if (a == i * 7 + j * 3) {
cout << "YES" << endl;
goto end;
}
}
}
cout << "NO" << endl;
end:;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, i, j, k, x, y, m, l;
int up[2005][2005], down[2005][2005];
int uprmq[2005][14], downrmq[2005][14];
int X[2005], Y[2005], q[2005];
char A[2005][2005];
int downquery(int i, int x, int y) {
int t = log2(y - x + 1);
return min(downrmq[x][t], downrmq[y - (1 << t) + 1][t]);
}
int upquery(int i, int x, int y) {
int t = log2(y - x + 1);
return min(uprmq[x][t], uprmq[y - (1 << t) + 1][t]);
}
int f(int x) {
int i, j, l;
for (i = 1; i <= m; i++) {
uprmq[i][0] = up[x][i] - (A[x][i] == '.');
downrmq[i][0] = down[x][i] - (A[x][i] == '.');
}
int logn = 10;
for (l = 1; l <= logn; l++)
for (j = 1; j <= m; j++) {
uprmq[j][l] =
min(uprmq[j][l - 1], uprmq[min(m, j + (1 << (l - 1)))][l - 1]);
downrmq[j][l] =
min(downrmq[j][l - 1], downrmq[min(m, j + (1 << (l - 1)))][l - 1]);
}
int tp = 1, mx = 0;
for (j = 1; j <= m; j++) {
tp = max(tp, j);
if (A[x][tp] == 'X') continue;
while (tp <= m && downquery(x, j, tp) + upquery(x, j, tp) + 1 >= tp - j + 1)
tp++;
mx = max(mx, tp - j);
}
return mx;
}
void update(int x, int y) {
int i, j;
for (i = n; i >= 1; i--) down[i][y] = (A[i][y] == '.') * (down[i + 1][y] + 1);
for (i = 1; i <= n; i++) up[i][y] = (A[i][y] == '.') * (up[i - 1][y] + 1);
}
int main() {
cin >> n >> m >> k;
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) scanf(" %c", &A[i][j]);
for (i = 1; i <= k; i++) {
scanf("%d %d", &x, &y);
X[i] = x;
Y[i] = y;
A[x][y] = 'X';
}
for (j = 1; j <= m; j++)
for (i = n; i >= 1; i--)
down[i][j] = (A[i][j] == '.') * (down[i + 1][j] + 1);
for (j = 1; j <= m; j++)
for (i = 1; i <= n; i++) up[i][j] = (A[i][j] == '.') * (up[i - 1][j] + 1);
int logn = log2(m);
int ans = 0;
for (i = 1; i <= n; i++) ans = max(ans, f(i));
for (i = k; i >= 1; i--) {
q[i] = ans;
if (i == 1) break;
A[X[i]][Y[i]] = '.';
update(X[i], Y[i]);
ans = max(ans, f(X[i]));
}
for (i = 1; i <= k; i++) cout << q[i] << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
const int BLOCK = 400;
int fs[100005];
int gs[100005];
std::vector<int> edges[100005];
int pre[100005];
int post[100005];
int euler = 0;
int who[200005];
bool has[100005];
int depth[100005];
int anc[100005][20];
void dfs_init(int node, int parent) {
who[euler] = node;
pre[node] = euler++;
anc[node][0] = parent;
for (int k = 1; k < 20; k++) {
anc[node][k] = anc[anc[node][k - 1]][k - 1];
}
depth[node] = depth[parent] + 1;
for (int child : edges[node]) {
if (child == parent) continue;
dfs_init(child, node);
}
who[euler] = node;
post[node] = euler++;
}
int lca(int a, int b) {
if (depth[a] < depth[b]) std::swap(a, b);
int diff = depth[a] - depth[b];
for (int k = 20 - 1; k >= 0; k--) {
if (diff & (1 << k)) {
a = anc[a][k];
}
}
if (a == b) return a;
for (int k = 20 - 1; k >= 0; k--) {
if (anc[a][k] != anc[b][k]) {
a = anc[a][k];
b = anc[b][k];
}
}
return anc[a][0];
}
int freq[2][100005];
int64_t total = 0;
int64_t ans[100005];
void toggle(int node) {
if (has[node]) {
total -= freq[gs[node] ^ 1][fs[node]];
freq[gs[node]][fs[node]]--;
} else {
freq[gs[node]][fs[node]]++;
total += freq[gs[node] ^ 1][fs[node]];
}
has[node] ^= 1;
}
struct Query {
int l, r, x, id;
Query(int l, int r, int x, int id) : l(l), r(r), x(x), id(id) {}
bool operator<(Query q) const {
if (l / BLOCK != q.l / BLOCK) return l / BLOCK < q.l / BLOCK;
return (r < q.r) ^ ((l / BLOCK) & 1);
}
};
int main() {
int N;
scanf("%d", &N);
for (int i = 0; i < N; i++) {
scanf("%d", &gs[i]);
}
std::map<int, int> cps;
for (int i = 0; i < N; i++) {
scanf("%d", &fs[i]);
cps[fs[i]];
}
int last = 0;
for (auto& it : cps) {
it.second = last++;
}
for (int i = 0; i < N; i++) {
fs[i] = cps[fs[i]];
}
for (int i = 0; i < N - 1; i++) {
int A, B;
scanf("%d %d", &A, &B);
A--, B--;
edges[A].push_back(B);
edges[B].push_back(A);
}
dfs_init(0, 0);
int Q;
scanf("%d", &Q);
std::vector<Query> qs;
for (int i = 0; i < Q; i++) {
int A, B;
scanf("%d %d", &A, &B);
A--, B--;
if (pre[A] > pre[B]) std::swap(A, B);
int C = lca(A, B);
if (post[A] >= post[B]) {
qs.emplace_back(pre[A], pre[B], -1, i);
} else {
qs.emplace_back(post[A], pre[B], C, i);
}
}
std::sort(qs.begin(), qs.end());
int l = 0, r = -1;
for (int i = 0; i < Q; i++) {
while (r < qs[i].r) toggle(who[++r]);
while (l > qs[i].l) toggle(who[--l]);
while (r > qs[i].r) toggle(who[r--]);
while (l < qs[i].l) toggle(who[l++]);
if (qs[i].x != -1) toggle(qs[i].x);
ans[qs[i].id] = total;
if (qs[i].x != -1) toggle(qs[i].x);
}
for (int i = 0; i < Q; i++) {
printf("%I64d\n", ans[i]);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, a[50], i, q = 0, w = 0;
cin >> n;
for (i = 0; i < n / 2; i++) cin >> a[i];
sort(a, a + n / 2);
for (i = 0; i < n / 2; i++) {
q += abs(a[i] - (i * 2 + 1));
w += abs(a[i] - (i * 2 + 2));
}
q = min(q, w);
cout << q;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int Checkerror(char Ch) {
if (Ch == '_') return 1;
if (Ch < '0' || Ch > 'z') return 0;
if (Ch < 'A' && Ch > '9') return 0;
if (Ch < 'a' && Ch > 'Z') return 0;
return 1;
}
int main() {
string St;
getline(cin, St);
long long i = 0;
int Check = 1;
if (St[i] == '@') Check = 0;
if (Check == 1)
while (St[i] != '@') {
if (i == 16) {
Check = 0;
}
Check = Checkerror(St[i]);
if (Check == 0) break;
i++;
}
long long Cnt = 0, Cnt2 = 0;
;
i++;
if (i == St.size()) Check = 0;
if (i == '/') Check = 0;
if (Check == 1)
while (St[i] != '/') {
Cnt2++;
if (St[i] == '.') {
if (St[i - 1] == '.' || St[i - 1] == '@') Check = 0;
Cnt = 0;
} else {
Check = Checkerror(St[i]);
Cnt++;
}
if (Cnt > 16 || Cnt2 > 32) Check = 0;
if (Check == 0) break;
i++;
if (i == St.size()) {
if (Cnt == 0) Check = 0;
break;
}
}
Cnt = 0;
Cnt2 = 0;
if (St[i - 1] == '.') Check = 0;
if (Check == 1)
while (i < St.size()) {
i++;
Cnt2++;
if (St[i] == '/') {
if (St[i - 1] == '/' || St[i - 1] == '.') Check = 0;
Cnt2 = 0;
} else
Check = Checkerror(St[i]);
if (Cnt2 > 16) Check = 0;
if (Check == 0) break;
if (i + 1 == St.size()) {
if (Cnt2 == 0) Check = 0;
break;
}
}
if (Check == 1)
cout << "YES";
else
cout << "NO";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<string> vec_splitter(string s) {
for (char &c : s) c = c == ',' ? ' ' : c;
stringstream ss;
ss << s;
vector<string> res;
for (string z; ss >> z; res.push_back(z))
;
return res;
}
void debug_out(vector<string> args, int idx) { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(vector<string> args, int idx, Head H, Tail... T) {
if (idx > 0) cerr << ", ";
stringstream ss;
ss << H;
cerr << args[idx] << " = " << ss.str();
debug_out(args, idx + 1, T...);
}
void localTest() {}
vector<pair<long long, pair<char, long long>>> ans;
long long xorOp(long long a, long long b) {
ans.push_back({a, {'^', b}});
return a ^ b;
}
long long addOp(long long a, long long b) {
ans.push_back({a, {'+', b}});
return a + b;
}
long long mulOp(long long n, long long a) {
long long ret = n;
a--;
while (a > 0) {
if (a & 1) {
ret = addOp(n, ret);
}
a >>= 1;
n = addOp(n, n);
}
return ret;
}
long long shiftOp(long long n, long long a) {
while (a--) {
n = addOp(n, n);
}
return n;
}
long long gcd(long long a, long long b) {
if (a < b) {
swap(a, b);
}
if (!b) {
return a;
}
return gcd(b, a % b);
}
long long gcd(long long a, long long b, long long &x, long long &y) {
if (!b) {
x = 1;
y = 0;
return a;
}
long long x1, y1, d = gcd(b, a % b, x1, y1);
x = y1;
y = x1 - y1 * (a / b);
return d;
}
int main() {
localTest();
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long x, ox;
cin >> x;
ox = x;
if (x % 4 == 3) {
addOp(x, x);
x = xorOp(x, 2 * x);
}
if (x != 1) {
long long msb = 0;
while (x >= (1LL << (msb + 1))) {
msb++;
}
long long sx = shiftOp(x, msb);
xorOp(x, sx);
addOp(x, sx);
long long val = xorOp(x + sx, x ^ sx);
long long a, b;
long long g = gcd(ox, val, a, b);
long long y, y1;
assert(g == 1);
if (a <= 0) {
while (a <= 0) {
a += val;
b -= ox;
}
if (abs(b) % 2) {
b -= ox;
a += val;
}
y = mulOp(val, -b);
y1 = mulOp(ox, a);
} else {
if (abs(b) % 2) {
b -= ox;
a += val;
}
y = mulOp(val, -b);
y1 = mulOp(ox, a);
}
x = xorOp(y1, y);
assert(x == 1);
}
cout << ans.size() << "\n";
for (auto p : ans) {
cout << p.first << " " << p.second.first << " " << p.second.second << "\n";
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100001;
const int MOD = 1000000007;
long long proper_ways[MAXN];
long long all_ways[MAXN];
int N;
int main() {
all_ways[1] = 27;
proper_ways[1] = 20;
scanf("%d", &N);
for (int n = 2; n <= N; n++) {
all_ways[n] = (27 * all_ways[n - 1]) % MOD;
proper_ways[n] = (20 * all_ways[n - 1]) % MOD;
proper_ways[n] += (7 * proper_ways[n - 1]);
proper_ways[n] %= MOD;
}
printf("%I64d\n", proper_ways[N]);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[100005], b[100005], c[100005];
int main() {
int n;
scanf("%d", &n);
if (n & 1) {
for (int i = 0; i < n; ++i) a[i] = b[i] = i;
for (int i = 0; i < n; ++i) c[i] = (a[i] + b[i]) % n;
for (int i = 0; i < n; ++i) printf("%d%c", a[i], " \n"[i + 1 == n]);
for (int i = 0; i < n; ++i) printf("%d%c", b[i], " \n"[i + 1 == n]);
for (int i = 0; i < n; ++i) printf("%d%c", c[i], " \n"[i + 1 == n]);
} else
puts("-1\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<int> m[200005];
int good[200005];
void solve() {
int N, M;
int u, v, i, j, k, c, f, x;
scanf("%d %d", &N, &M);
for (i = 1; i <= N; i++) {
good[i] = 0;
m[i].clear();
}
for (i = 0; i < M; i++) {
scanf("%d %d", &u, &v);
m[u].push_back(v);
}
for (i = 1; i <= N; i++) {
if (good[i] == 2) {
continue;
}
for (j = 0; j < m[i].size(); j++) {
k = m[i][j];
good[k] = max(good[k], good[i] + 1);
}
}
c = 0;
for (i = 1; i <= N; i++) {
if (good[i] == 2) c++;
}
f = 0;
printf("%d\n", c);
for (i = 1; i <= N; i++) {
if (good[i] == 2) {
if (f) putchar(' ');
f = 1;
printf("%d", i);
}
}
putchar('\n');
}
int main() {
int T;
scanf("%d\n", &T);
while (T--) {
solve();
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void optimizeIO() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
int main() {
long long int n, m, t, ass, a, i, j, k, count = 0;
cin >> n >> m;
if (n > m) {
cout << n - m;
} else if (m == n) {
cout << "0";
} else if (n < m) {
while (m > n) {
m % 2 ? m++ : m /= 2;
count++;
}
cout << count + n - m;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
const double eps = 1e-9;
int seg_trees[400400];
int bases[400400];
int left_child(int id) { return id * 2 + 1; }
int get_mid(int f, int t) {
assert(t - f > 1);
return f + (t - f) / 2;
}
void insert_segtree(int id, int from, int to, int maxh, int base) {
while (true) {
if (maxh > seg_trees[id]) {
bases[id] = base;
seg_trees[id] = maxh;
}
if (from == base && to == base + 1) {
return;
} else {
int m = get_mid(from, to);
id = left_child(id);
if (base < m) {
to = m;
} else {
from = m;
id++;
}
}
}
}
void insert_segtree(int maxh, int base) {
insert_segtree(0, 0, 100100, maxh, base);
}
pair<long long, long long> query(int id, int from, int to, int f, int t) {
f = max(f, from);
t = min(t, to);
if (f >= t) return make_pair(-oo, -oo);
if (from == f && t == to) return make_pair(seg_trees[id], bases[id]);
int m = get_mid(from, to);
int c = left_child(id);
auto a = query(c, from, m, f, t);
auto b = query(c + 1, m, to, f, t);
return max(a, b);
}
pair<long long, long long> query(int f, int t) {
return query(0, 0, 100100, f, t);
}
long long get_res(int f) {
int t = f;
stack<pair<long long, long long> > todo;
while (true) {
auto nn = query(f, t + 1);
if (nn.first > t) {
todo.push(make_pair(f, t));
f = nn.second;
t = nn.first;
} else {
break;
}
}
while (!todo.empty()) {
auto nn = todo.top();
if (rand() % int((todo).size()) == 0) {
insert_segtree(t, nn.first);
}
todo.pop();
}
return t;
}
pair<int, int> queries[100100];
unordered_map<int, int> mem[100100];
pair<int, int> squeries[100100];
int main() {
ios::sync_with_stdio(false);
int N, M, Q;
cin >> N >> M;
vector<pair<int, int> > ropes(M);
for (int i = (0); i < (M); i++) cin >> ropes[i].second >> ropes[i].first;
sort((ropes).begin(), (ropes).end());
cin >> Q;
for (int i = (0); i < (Q); i++) cin >> queries[i].second >> queries[i].first;
for (int i = (0); i < (Q); i++) squeries[i] = queries[i];
sort(squeries, squeries + Q);
int A = 0;
for (int i = (0); i < (Q); i++) {
while (A < M && squeries[i].first >= ropes[A].first) {
insert_segtree(ropes[A].first, ropes[A].second);
A++;
}
mem[squeries[i].first][squeries[i].second] = get_res(squeries[i].second);
}
for (int i = (0); i < (Q); i++)
cout << mem[queries[i].first][queries[i].second] << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int size;
cin >> size;
int mass[size];
for (int i = 0; i < size; i++) mass[i] = 0;
int m;
cin >> m;
for (int i = 0; i < m; i++) {
string a, b, c;
string move;
int coordinate;
cin >> a >> b >> move >> c >> coordinate;
coordinate--;
if (move == "left") {
for (int i = coordinate; i < size; i++) mass[i] = -1;
} else if (move == "right") {
for (int i = 0; i <= coordinate; i++) mass[i] = -1;
}
}
int counter = 0;
for (int i = 0; i < size; i++)
if (mass[i] == -1) counter++;
if (counter == size) {
cout << -1;
return 0;
}
int answer = 0;
for (int i = 0; i < size; i++)
if (mass[i] == 0) answer++;
cout << answer << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
set<int> row[100010];
set<int> col[100010];
set<int, greater<int> > rrow[100010];
set<int, greater<int> > rcol[100010];
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < k; i++) {
int x, y;
scanf("%d%d", &x, &y);
row[x].insert(y);
col[y].insert(x);
rrow[x].insert(y);
rcol[y].insert(x);
}
int u = 1, l = 0, d = n + 1, r = m + 1;
int px = 1;
int py = 0;
long long cnt = 0;
int t = 0;
for (int i = 0; i <= n; i++) {
row[i].insert(0);
row[i].insert(m + 1);
rrow[i].insert(0);
rrow[i].insert(m + 1);
}
for (int i = 0; i <= m; i++) {
col[i].insert(0);
col[i].insert(n + 1);
rcol[i].insert(0);
rcol[i].insert(n + 1);
}
row[1].erase(0);
rrow[1].erase(0);
col[0].erase(1);
rcol[0].erase(1);
for (;;) {
int nx = px;
int ny = py;
bool finish = false;
switch (t) {
case 0: {
ny = min(r, *(row[px].lower_bound(py))) - 1;
finish |= ny == py;
cnt += ny - py;
r = ny;
t = 1;
break;
}
case 1: {
nx = min(d, *(col[py].lower_bound(px))) - 1;
finish |= nx == px;
cnt += nx - px;
d = nx;
t = 2;
break;
}
case 2: {
ny = max(l, *(rrow[px].lower_bound(py))) + 1;
finish |= ny == py;
cnt += py - ny;
l = ny;
t = 3;
break;
}
case 3: {
nx = max(u, *(rcol[py].lower_bound(px))) + 1;
finish |= nx == px;
cnt += px - nx;
u = nx;
t = 0;
break;
}
}
if (finish) {
if (k + cnt == 1ll * n * m) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
break;
}
px = nx;
py = ny;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int TN = 1;
void sol() {
int n;
cin >> n;
int ans = n + 1;
for (int i = sqrt(n) + 1; i > 0; --i) {
ans = min(ans, i + 1 + (n - 1) / i);
}
cout << ans;
}
int main() {
for (int i = 0; i < TN; ++i) {
sol();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[110];
int main() {
int n, m;
cin >> n >> m;
int f = n % m;
for (int i = 0; i < n; i++) {
a[i] = n / m;
}
for (int i = 0; i < f; i++) {
a[i]++;
}
for (int i = 0; i < m; i++) {
cout << a[i] << " ";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
signed n;
long double m, ans = 0;
long double qpow(long double a, signed b) {
if (b == 0) return 1;
if (b == 1) return a;
long double res = qpow(a, b / 2);
if (b % 2 == 1)
return res * res * a;
else
return res * res;
}
signed main() {
ios::sync_with_stdio(false);
cin >> m >> n;
for (long double i = 1; i <= m; i++) {
ans += qpow(i / m, n) * i;
ans -= qpow((i - 1.0) / m, n) * i;
}
cout << fixed << setprecision(12) << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T BIGMOD(T n, T m, T mod) {
long long ans = 1;
long long k = n;
while (m) {
if (m & 1) {
ans *= k;
if (ans > mod) ans %= mod;
}
k *= k;
if (k > mod) k %= mod;
m >>= 1;
}
return ans;
}
template <class T>
inline T gcd(T a, T b) {
if (a < 0) return gcd(-a, b);
if (b < 0) return gcd(a, -b);
return (b == 0) ? a : gcd(b, a % b);
}
template <class T>
inline T lcm(T a, T b) {
if (a < 0) return lcm(-a, b);
if (b < 0) return lcm(a, -b);
return a * (b / gcd(a, b));
}
template <class T>
inline T power(T b, T p) {
if (p < 0) return -1;
if (b <= 0) return -2;
if (!p) return 1;
return b * power(b, p - 1);
}
template <typename T>
inline bool in_grid(T i, T j, T n) {
if (i - 1 >= 0 && i + 1 < n && j - 1 >= 0 && j + 1 < n) return true;
return false;
}
template <typename T>
inline bool isOn(T mask, T pos) {
return mask & (1 << pos);
}
template <typename T>
inline int Off(T mask, T pos) {
return mask ^ (1 << pos);
}
template <typename T>
inline int On(T mask, T pos) {
return mask | (1 << pos);
}
int n, m, k;
int g[305], gr[305][305];
vector<int> v;
void con(vector<int> v) {
for (int i = 0; i < v.size(); i++)
for (int j = 0; j < v.size(); j++)
if (m) {
int u = v[i], u1 = v[j];
if (u >= u1) continue;
if (gr[u][u1]) continue;
gr[u][u1] = 1;
gr[u1][u] = 1;
m--;
}
}
void print() {
for (int i = 1; i < n + 1; i++)
for (int j = 1; j < n + 1; j++)
if (gr[i][j] && i < j) cout << i << " " << j << endl;
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < k; i++) {
int no;
cin >> no;
g[no] = 1;
}
if (n - 1 > m || n == k || n * (n - 1) / 2 == m) {
cout << -1 << endl;
return 0;
}
if (k == 1) {
int cn;
for (int i = 1; i < n + 1; i++)
if (!g[i])
v.push_back(i);
else
cn = i;
for (int i = 1; i < v.size(); i++) {
int u = v[i], u1 = v[i - 1];
gr[u][u1] = 1;
gr[u1][u] = 1;
m--;
}
for (int i = 1; i < v.size(); i++) {
gr[cn][v[i]] = gr[v[i]][cn] = 1;
m--;
}
con(v);
print();
return 0;
}
int cn;
for (int i = 1; i < n + 1; i++)
if (!g[i])
v.push_back(i);
else
cn = i;
int n1 = n - 1;
if (n1 * (n1 - 1) / 2 + v.size() < m) {
cout << -1 << endl;
return 0;
}
for (int i = 1; i < v.size(); i++) {
int u = v[i], u1 = v[i - 1];
gr[u][u1] = 1;
gr[u1][u] = 1;
m--;
}
v.clear();
for (int i = 1; i < n + 1; i++)
if (g[i] && i != cn) v.push_back(i);
for (int i = 1; i < v.size(); i++) {
int u = v[i], u1 = v[i - 1];
gr[u][u1] = 1;
gr[u1][u] = 1;
m--;
}
for (int i = 1; i < n + 1; i++)
if (!g[i]) {
gr[cn][i] = gr[i][cn] = gr[i][v[0]] = 1;
gr[v[0]][i] = 1;
m -= 2;
break;
}
v.clear();
for (int i = 1; i < n + 1; i++)
if (i != cn) v.push_back(i);
con(v);
v.clear();
for (int i = 1; i < n + 1; i++)
if (!g[i] && !gr[i][cn] && m) {
gr[i][cn] = gr[cn][i] = 1;
m--;
}
print();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int v[200000];
set<int> g;
vector<int> av;
set<int> v2;
vector<int> o[2];
set<int> aux;
int main() {
int n, m, p[2];
cin >> n >> m;
p[0] = p[1] = 0;
for (int i = 0; i < n; i++) {
cin >> v[i];
v2.insert(v[i]);
p[v[i] & 1]++;
}
if (n % 2) {
cout << -1;
return 0;
}
int x = (p[0] > p[1] ? 0 : 1);
for (int i = 0; i < n; i++)
if (v[i] % 2 != x) g.insert(v[i]);
int i = (!x == 0 ? 2 : 1);
int d = (p[x] - p[!x]) / 2;
while (i <= m && d > 0) {
if (g.find(i) == g.end()) {
d--;
av.push_back(i);
}
i += 2;
}
if (d != 0) {
cout << -1;
return 0;
}
for (int i = 0; i < n; i++)
if (v[i] % 2 == x && av.size()) {
v[i] = av.back();
av.pop_back();
}
d = (p[x] - p[!x]) / 2;
for (int i = 1; i <= n * 8 && i <= m; i++) {
if (v2.find(i) == v2.end()) o[i & 1].push_back(i);
}
for (int i = 0; i < n; i++) {
if (aux.find(v[i]) == aux.end()) {
aux.insert(v[i]);
} else {
if (o[v[i] & 1].size()) {
v[i] = o[v[i] & 1].back();
o[v[i] & 1].pop_back();
d++;
} else {
cout << -1;
return 0;
}
}
}
cout << d << endl;
for (int i = 0; i < n; i++) cout << v[i] << ' ';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
vector<pair<int, int> > G[N];
vector<int> p, cycle;
bool vis[N];
long long dep[N], L[N];
int k;
long long pre1[N], pre2[N], suf1[N], suf2[N];
void solve(int u) {
for (int i = 0; i < p.size(); ++i)
if (p[i] == u) {
for (int j = i; j < p.size(); ++j) cycle.push_back(p[j]);
break;
}
k = cycle.size();
for (int i = 0; i < cycle.size(); ++i) {
int u = cycle[i];
int aim = cycle[(i + 1) % k];
for (int j = 0; j < G[u].size(); ++j) {
pair<int, int> t = G[u][j];
int v = t.first, w = t.second;
if (v == aim) {
L[i] = w;
break;
}
}
}
}
void findcycle(int u, int fa) {
vis[u] = 1;
p.push_back(u);
bool flag = 1;
for (int i = 0; i < G[u].size(); ++i) {
pair<int, int> t = G[u][i];
int v = t.first, w = t.second;
if (v == fa && flag) {
flag = 0;
continue;
}
if (vis[v]) {
solve(v);
return;
}
findcycle(v, u);
}
p.pop_back();
}
long long ans;
long long dfs(int u, int fa) {
long long first = 0, second = 0;
dep[u] = 0;
for (int i = 0; i < G[u].size(); ++i) {
pair<int, int> t = G[u][i];
int v = t.first, w = t.second;
if (v == fa || vis[v]) continue;
long long dist = w + dfs(v, u);
if (dist > first)
second = first, first = dist;
else if (dist > second)
second = dist;
dep[u] = max(dep[u], w + dep[v]);
}
ans = max(ans, first + second);
return first;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
G[u].push_back(make_pair(v, w));
G[v].push_back(make_pair(u, w));
}
findcycle(1, 0);
memset(vis, 0, sizeof(vis));
for (int i = 0; i < k; ++i) vis[cycle[i]] = 1;
ans = 0;
for (int i = 0; i < k; ++i) dfs(cycle[i], 0);
long long tmp1 = L[0], tmp2 = L[0] + dep[cycle[0]];
pre1[0] = dep[cycle[0]];
pre2[0] = 0;
for (int i = 1; i < k; ++i) {
pre1[i] = max(pre1[i - 1], tmp1 + dep[cycle[i]]);
pre2[i] = max(pre2[i - 1], tmp2 + dep[cycle[i]]);
tmp1 += L[i];
tmp2 = max(tmp2, dep[cycle[i]]) + L[i];
}
suf1[k - 1] = dep[cycle[k - 1]] + L[k - 1];
suf2[k - 1] = dep[cycle[0]] + L[k - 1] + dep[cycle[k - 1]];
tmp1 = L[k - 1];
tmp2 = max(L[k - 1] + dep[cycle[0]], dep[cycle[k - 1]]);
for (int i = k - 2; i > 0; --i) {
tmp1 += L[i];
tmp2 += L[i];
suf1[i] = max(suf1[i + 1], tmp1 + dep[cycle[i]]);
suf2[i] = max(suf2[i + 1], tmp2 + dep[cycle[i]]);
tmp2 = max(tmp2, dep[cycle[i]]);
}
long long tmp = 1e18;
for (int i = 0; i < k; ++i) {
tmp = min(tmp, max(max(pre2[i], suf2[i + 1]), pre1[i] + suf1[i + 1]));
}
ans = max(ans, tmp);
printf("%I64d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
int main() {
int n, flag = 0;
char a[110];
scanf("%d", &n);
scanf("%s", a);
for (int i = 0; i < n - 1; i++) {
if (a[i] != a[i + 1]) {
flag++;
i++;
}
}
printf("%d\n", n - flag);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2005;
int N;
long long X[MAXN], Y[MAXN], dem[MAXN];
map<pair<long long, long long>, int> mp;
long long gcd(long long m, long long n) {
if (n == 0) return m;
if (m % n == 0) return n;
return gcd(n, m % n);
}
pair<long long, long long> reduce(long long p, long long q) {
long long d = gcd(abs(p), abs(q));
if (d != 0) p /= d, q /= d;
if ((q < 0) || (q == 0 && p < 0)) p = -p, q = -q;
return make_pair(p, q);
}
int main() {
ios::sync_with_stdio(0);
cin >> N;
for (int i = 0, a, b, c; i < N; i++) {
cin >> a >> b >> c;
X[i] = a * c, Y[i] = b * c, dem[i] = a * a + b * b;
}
long long ans = 0;
for (int i = 0; i < N; i++) {
mp.clear();
int cnt0 = 0;
for (int j = 0; j < i; j++) {
long long p = Y[j] * dem[i] - Y[i] * dem[j];
long long q = X[j] * dem[i] - X[i] * dem[j];
pair<long long, long long> m = reduce(p, q);
if (m == pair<long long, long long>()) {
ans += j;
cnt0++;
} else {
ans += mp[m] + cnt0;
mp[m]++;
}
}
}
cout << ans << "\n";
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char s[20];
cin >> s;
int l = strlen(s), ans = 0;
for (int i = 0; i < l - i - 1; i++) {
if (s[i] != s[l - i - 1]) ans++;
}
if (ans == 1 || (ans == 0 && l % 2 == 1))
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.