solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
double esp = 1e-11;
#pragma comment(linker, "/STACK:1024000000,1024000000")
const double PI = acos(-1.0);
const long long int INF = 0x3f3f3f3f;
const long long int MOD = 1000000009;
const int maxn = 250010;
int m[2][2100];
int main() {
int n;
scanf("%d", &n);
memset(m, 0, sizeof(m));
int u, v;
for (int x = 1; x <= n; x++) {
scanf("%d%d", &u, &v);
m[0][u + v]++;
m[1][u - v + 1000]++;
}
long long int ans = 0;
for (int x = 0; x <= 2010; x++) {
ans += m[0][x] * (m[0][x] - 1) / 2;
ans += m[1][x] * (m[1][x] - 1) / 2;
}
printf("%I64d\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010;
struct poi {
int x, y, id;
} P[N];
int pos[N], n;
bool cmp(poi w, poi e) {
if (pos[w.x] == pos[e.x]) {
if (pos[w.x] % 2 == 0)
return w.y < e.y;
else
return w.y > e.y;
}
return w.x < e.x;
}
int main() {
scanf("%d", &n);
int block = (int)sqrt(1000000);
for (int i = 0; i < n; i++) {
scanf("%d%d", &P[i].x, &P[i].y);
P[i].id = i + 1;
}
for (int i = 0; i <= 1000000; i++) pos[i] = i / block;
sort(P, P + n, cmp);
for (int i = 0; i < n; i++) printf("%d ", P[i].id);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int ara[300005], n;
long long answer[300005];
vector<pair<int, int> > query[600];
long long dp[300005];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &ara[i]);
int q;
scanf("%d", &q);
for (int i = 0; i < q; i++) {
int st, p;
scanf("%d", &st);
scanf("%d", &p);
st--;
if (p >= 550) {
for (int j = st; j < n; j += p) answer[i] += ara[j];
continue;
}
query[p].push_back(make_pair(st, i));
}
for (int i = 1; i < 550; i++) {
for (int j = n - 1; j >= 0; j--) {
dp[j] = ara[j];
if (j + i < n) dp[j] += dp[j + i];
}
for (int j = 0; j < query[i].size(); j++)
answer[query[i][j].second] = dp[query[i][j].first];
}
for (int i = 0; i < q; i++) printf("%I64d\n", answer[i]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int arr[101];
for (int i = 0; i < n; i++) arr[i] = 10000;
int l, r, t, p;
int sum[101];
for (int i = 0; i < n; i++) sum[i] = 0;
for (int i = 0; i < m; i++) {
cin >> l >> r >> t >> p;
for (int j = l - 1; j <= r - 1; j++) {
if (arr[j] > t) {
arr[j] = t;
sum[j] = p;
}
}
}
int sum1 = 0;
for (int i = 0; i < n; i++) sum1 += sum[i];
cout << sum1;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
const int M = 1e5 + 5;
const int INF = 0x3f3f3f3f;
int pri[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53};
const int maxn = (1 << 16) + 5;
int dp[N][maxn];
int path[N][maxn];
int st[65], a[N];
void pre() {
for (int i = 2; i < 59; i++) {
for (int j = 0; j < 16; j++) {
if (i % pri[j] == 0) {
st[i] |= (1 << j);
}
}
}
}
void gao(int i, int pos) {
if (i == 0) return;
gao(i - 1, pos ^ st[path[i][pos]]);
printf("%d ", path[i][pos]);
}
int main() {
int n;
pre();
while (~scanf("%d", &n)) {
memset(dp, INF, sizeof(dp));
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < (1 << 16); j++) {
if (dp[i][j] == INF) continue;
for (int k = 1; k < 59; k++) {
if (st[k] & j) continue;
if (dp[i + 1][j | st[k]] > dp[i][j] + abs(k - a[i])) {
dp[i + 1][j | st[k]] = dp[i][j] + abs(k - a[i]);
path[i + 1][j | st[k]] = k;
}
}
}
}
int pos = -1;
for (int i = 0; i < (1 << 16); i++) {
if (pos == -1 || dp[n][pos] > dp[n][i]) {
pos = i;
}
}
gao(n, pos);
puts("");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
int main() {
long n(0), k(0);
scanf("%ld %ld", &n, &k);
int *array = new int[n];
long total(0), currentMin(0), optimalStart(0);
for (int p = 0; p < n; p++) {
scanf("%d", array + p);
currentMin += array[p];
}
long checkMax(n);
if (n % k == 0) {
checkMax = k;
}
for (long first = 0; first < checkMax; first++) {
total = 0;
for (long current = first; current < first + n; current += k) {
total += array[current % n];
}
if (total < currentMin) {
currentMin = total;
optimalStart = first;
}
}
printf("%ld\n", optimalStart + 1);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool isSpecialCharecters(char character) {
switch (character) {
case ';':
return true;
case '_':
return true;
case '-':
return true;
}
return false;
}
string filterSpecialCharacters(string input) {
string output = "";
string::iterator it;
for (it = input.begin(); it != input.end(); it++) {
if (!isSpecialCharecters(*it)) {
output += tolower(*it);
}
}
return output;
}
bool isAnswerRight(string answer, vector<string> rules) {
string temp = "";
string copyAnswer = answer;
for (int i = 0; i < rules.size(); i++) {
int position = (int)copyAnswer.find(rules[i]);
if (position == -1) {
return false;
} else {
copyAnswer.replace(copyAnswer.begin() + position,
copyAnswer.begin() + position + rules[i].size(), "1");
temp.append(rules[i]);
}
}
if (answer.size() > temp.size()) {
return false;
}
return true;
}
int main(int argc, const char* argv[]) {
string inputOne;
string inputTwo;
string inputThree;
getline(cin, inputOne);
getline(cin, inputTwo);
getline(cin, inputThree);
inputOne = filterSpecialCharacters(inputOne);
inputTwo = filterSpecialCharacters(inputTwo);
inputThree = filterSpecialCharacters(inputThree);
int students;
cin >> students;
vector<string> answersOfStudents;
vector<string> leters;
leters.push_back(inputOne);
leters.push_back(inputTwo);
leters.push_back(inputThree);
sort(leters.begin(), leters.end(),
[](string a, string b) { return b.size() < a.size(); });
for (int i = 0; i < students + 1; i++) {
string value = "";
getline(cin, value);
if (!value.empty()) {
value = filterSpecialCharacters(value);
answersOfStudents.push_back(value);
}
}
for (int i = 0; i < students; i++) {
if (isAnswerRight(answersOfStudents[i], leters)) {
cout << "ACC" << endl;
} else {
cout << "WA" << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000, N = 300010;
const string pat[6] = {"AC", "AG", "AT", "CG", "CT", "GT"};
string st[N];
int rpt[N], cpt[N], ansrpt[N], anscpt[N], currpt[N], curcpt[N];
int n, m, ansr[2], ansc[2];
int rcalc(int pt, int odd, int row) {
int cnt = 0;
for (int j = 0; j < m; j++)
if (st[row][j] != pat[pt][(j & 1) ^ odd]) cnt++;
return cnt;
}
int ccalc(int pt, int odd, int col) {
int cnt = 0;
for (int i = 0; i < n; i++)
if (st[i][col] != pat[pt][(i & 1) ^ odd]) cnt++;
return cnt;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> st[i];
int rmin = INF, cmin = INF;
for (rpt[0] = 0; rpt[0] < 6; rpt[0]++) {
rpt[1] = 5 - rpt[0];
int cnt = 0;
for (int i = 0; i < n; i++) {
int cnt0 = rcalc(rpt[i & 1], 0, i), cnt1 = rcalc(rpt[i & 1], 1, i);
if (cnt0 <= cnt1) {
currpt[i] = 0;
cnt += cnt0;
} else {
currpt[i] = 1;
cnt += cnt1;
}
}
if (cnt < rmin) {
rmin = cnt;
ansr[0] = rpt[0];
ansr[1] = rpt[1];
for (int i = 0; i < n; i++) ansrpt[i] = currpt[i];
}
}
for (cpt[0] = 0; cpt[0] < 6; cpt[0]++) {
cpt[1] = 5 - cpt[0];
int cnt = 0;
for (int j = 0; j < m; j++) {
int cnt0 = ccalc(cpt[j & 1], 0, j), cnt1 = ccalc(cpt[j & 1], 1, j);
if (cnt0 <= cnt1) {
curcpt[j] = 0;
cnt += cnt0;
} else {
curcpt[j] = 1;
cnt += cnt1;
}
}
if (cnt < cmin) {
cmin = cnt;
ansc[0] = cpt[0];
ansc[1] = cpt[1];
for (int j = 0; j < m; j++) anscpt[j] = curcpt[j];
}
}
if (rmin <= cmin) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) cout << pat[ansr[i & 1]][ansrpt[i] ^ (j & 1)];
cout << "\n";
}
} else {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) cout << pat[ansc[j & 1]][anscpt[j] ^ (i & 1)];
cout << "\n";
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long ans = 0;
for (int i = (0); i < (n); ++i) {
long long t, T, x, cost;
cin >> t >> T >> x >> cost;
if (t >= T) {
ans += cost + m * x;
continue;
}
long long aux1 = cost;
if (m > (T - t)) aux1 += m * x;
long long aux2 = (long long)ceil((double)(m - (T - t)) / (T - t)) + 1;
aux2 *= cost;
ans += min(aux1, aux2);
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
template <typename T>
using vc = vector<T>;
using pii = pair<long long, long long>;
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n = 8;
long long a = 0;
map<char, long long> g = {{'Q', 9}, {'R', 5}, {'B', 3}, {'N', 3},
{'P', 1}, {'K', 0}, {'q', -9}, {'r', -5},
{'b', -3}, {'n', -3}, {'p', -1}, {'K', 0}};
for (long long i = 0; i < n; i++) {
string cur;
cin >> cur;
for (long long j = 0; j < n; j++) {
if (cur[j] == '.') continue;
a += g[cur[j]];
}
}
if (a == 0)
cout << "Draw\n";
else if (a > 0)
cout << "White\n";
else
cout << "Black\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 1 << 18;
int N;
long long int M;
vector<pair<int, int> > Points;
int main(void) {
scanf("%d", &N);
for (int i = 0; i < N; i++) {
int A;
scanf("%d", &A);
Points.push_back(make_pair(A, i));
}
for (int i = 0; i < N; i++) {
int B;
scanf("%d", &B);
Points.push_back(make_pair(B, i));
}
sort(Points.begin(), Points.end());
scanf("%I64d", &M);
long long int Sol = 1LL;
int idx = 0;
while (idx < 2 * N) {
int idy = idx, idz = idx;
while ((idy < 2 * N) && (Points[idy].first == Points[idx].first)) idy++;
int Cnt = idy - idx;
while (idz + 1 < idy) {
long long int Curr = 1LL;
if (Points[idz].second == Points[idz + 1].second) {
Curr *= Cnt * (Cnt - 1LL);
Curr /= 2LL;
idz += 2;
Cnt -= 2;
} else {
Curr *= Cnt;
idz++;
Cnt--;
}
Curr %= M;
Sol = (Sol * Curr) % M;
}
idx = idy;
}
printf("%I64d\n", Sol);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, i, p;
cin >> n >> m;
if (m > n) {
cout << "-1";
return 0;
}
if (n % 2 == 0) {
p = (n / 2);
if (p % m == 0) {
cout << p;
return 0;
} else {
for (i = 1; i <= n; i++) {
p++;
if (p % m == 0) {
cout << p;
return 0;
}
}
}
} else {
p = (n / 2) + 1;
if (p % m == 0) {
cout << p;
return 0;
} else {
for (i = 1; i <= n; i++) {
p++;
if (p % m == 0) {
cout << p;
return 0;
}
}
}
}
cout << "-1";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
char str[1000005];
cin >> str;
long long slen = strlen(str);
long long havep[30] = {0}, nowp[30] = {0};
for (int i = 0; i < slen; i++) {
++havep[str[i] - 'A'];
}
long long usemen = 0, fl = 0;
;
for (int i = 0; i < slen; i++) {
if (nowp[str[i] - 'A'] == 0) {
++usemen;
++nowp[str[i] - 'A'];
} else if (nowp[str[i] - 'A'] > 0) {
++nowp[str[i] - 'A'];
}
if (usemen > k) {
fl = 1;
break;
}
if (nowp[str[i] - 'A'] == havep[str[i] - 'A']) {
--usemen;
nowp[str[i] - 'A'] = 0;
}
}
if (fl == 0)
cout << "NO" << endl;
else if (fl == 1)
cout << "YES" << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using ld = long double;
const int MN = 2e5 + 3, MOD = 1e9 + 7;
vector<int> adj[1000005];
int dist[1000005], par[1000005];
int main() {
int n;
scanf("%d", &n);
vector<int> a(n);
set<int> seen;
int ans = INT_MAX;
vector<int> att, nodes;
for (auto &au : a) {
scanf("%d", &au);
if (seen.count(au)) ans = 2;
seen.insert(au);
int cur = au, fac1 = -1, fac2 = -1;
for (int i = 2; i * i <= cur; i++)
if (cur % i == 0) {
int cnt = 0;
while (cur % i == 0) cur /= i, cnt++;
if (cnt & 1) (~fac1 ? fac2 : fac1) = i;
}
if (cur > 1) (~fac1 ? fac2 : fac1) = cur;
if (!(~fac1)) return !printf("1\n");
if (!(~fac2)) fac2 = 1;
adj[fac1].push_back(fac2);
adj[fac2].push_back(fac1);
if (fac1 <= 1000) att.push_back(fac1);
if (fac2 <= 1000) att.push_back(fac2);
nodes.push_back(fac1);
nodes.push_back(fac2);
}
if (ans == 2) return !printf("2\n");
sort((att).begin(), (att).end());
att.erase(unique((att).begin(), (att).end()), att.end());
sort((nodes).begin(), (nodes).end());
nodes.erase(unique((nodes).begin(), (nodes).end()), nodes.end());
for (int st : att) {
for (int i : nodes) dist[i] = n + 3, par[i] = 0;
dist[st] = 0;
queue<int> q;
q.push(st);
while (!q.empty()) {
int cur = q.front();
q.pop();
for (int i : adj[cur]) {
if (dist[cur] + 1 < dist[i]) {
dist[i] = dist[cur] + 1;
par[i] = cur;
q.push(i);
} else if (i != par[cur]) {
ans = min(ans, dist[cur] + dist[i] + 1);
}
}
}
}
printf("%d\n", ans > n ? -1 : ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 100000 + 5;
const double eps = 1e-7;
inline long long dcmp(double x) { return abs(x) < eps ? 0 : (x > 0 ? 1 : -1); }
struct Line {
long long A, B, C;
inline bool onLine(double x, double y) {
return dcmp(A * x + B * y + C) == 0;
}
} line[maxn];
vector<pair<long long, long long> > ans;
bool dfs(long long k, vector<long long>& vec) {
if (k == 0) return vec.size() == 0;
if (vec.size() <= k) {
for (long long i = 0; i < vec.size(); i++)
ans.push_back(make_pair(vec[i], -2));
return 1;
}
if (vec.size() > k * k * 30) {
for (long long dotime = 0; dotime < 150; dotime++) {
long long l1 = rand() % vec.size(), l2 = rand() % vec.size();
if (l1 == l2) continue;
if (l1 > l2) swap(l1, l2);
l1 = vec[l1];
l2 = vec[l2];
double y = (double)(line[l1].A * line[l2].C - line[l1].C * line[l2].A) /
(line[l1].B * line[l2].A - line[l1].A * line[l2].B),
x = -(double)(line[l1].B * y + line[l1].C) / line[l1].A;
vector<long long> nx;
long long cnt = 0;
for (long long i = 0; i < vec.size(); i++)
if (line[vec[i]].onLine(x, y))
cnt++;
else
nx.push_back(vec[i]);
if (cnt > k) {
ans.push_back(make_pair(l1, l2));
if (!dfs(k - 1, nx)) {
ans.pop_back();
return 0;
} else
return 1;
}
}
return 0;
}
for (long long i = 0; i < k + 1; i++)
for (long long j = i + 1; j < k + 1; j++) {
long long l1 = vec[i], l2 = vec[j];
ans.push_back(make_pair(l1, l2));
vector<long long> nx;
double y = (double)(line[l1].A * line[l2].C - line[l1].C * line[l2].A) /
(line[l1].B * line[l2].A - line[l1].A * line[l2].B),
x = -(double)(line[l1].B * y + line[l1].C) / line[l1].A;
for (long long k = 0; k < vec.size(); k++)
if (!line[vec[k]].onLine(x, y)) nx.push_back(vec[k]);
if (dfs(k - 1, nx)) return 1;
ans.pop_back();
}
return 0;
}
inline long long readint() {
char c = getchar();
for (; c != '-' && (c < '0' || c > '9'); c = getchar())
;
bool neg = (c == '-' ? 1 : 0);
if (c == '-') c = getchar();
long long ret = 0;
for (; c >= '0' && c <= '9'; c = getchar()) ret = ret * 10 + c - '0';
return (neg ? -1 : 1) * ret;
}
int main() {
srand(time(NULL));
vector<long long> vec;
long long n = readint(), k = readint();
for (long long i = 0; i < n; i++) {
line[i].A = readint();
line[i].B = readint();
line[i].C = readint();
vec.push_back(i);
}
if (dfs(k, vec)) {
printf("YES\n%lld\n", (long long)ans.size());
for (long long i = 0; i < ans.size(); i++)
printf("%lld %lld\n", ans[i].first + 1, ans[i].second + 1);
} else
printf("NO\n");
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void print(T& x) {
cout << x;
}
template <class T, class U>
void print(pair<T, U>& p) {
cout << "(";
print(p.first);
cout << ", ";
print(p.second);
cout << ")";
}
template <class T>
void print(vector<T>& v) {
cout << "{";
if (((int)(v).size())) print(v[0]);
for (int i = 1; i < ((int)(v).size()); i++) cout << ", ", print(v[i]);
cout << "}\n";
}
template <class T>
void print(deque<T>& v) {
cout << "{";
if (((int)(v).size())) print(v[0]);
for (int i = 1; i < ((int)(v).size()); i++) cout << ", ", print(v[i]);
cout << "}\n";
}
const long long inf = LLONG_MAX;
long long divide(long long a, long long b) {
return a / b - ((a ^ b) < 0 && a % b);
}
struct line {
long long a, b, r;
};
struct convex_hull : vector<line> {
int p = 0;
bool isect(line& x, line& y) {
if (x.a == y.a)
x.r = x.b > y.b ? inf : -inf;
else
x.r = divide(y.b - x.b, x.a - y.a);
return x.r >= y.r;
}
void add(long long a, long long b) {
line l = {a, b, inf};
if (size() - p > 0 && isect(back(), l)) return;
while (size() - p > 1 && (--(--end()))->r >= back().r)
pop_back(), isect(back(), l);
push_back(l);
}
long long query(long long x) {
while (x > at(p).r) p++;
return at(p).a * x + at(p).b;
}
};
const int n = 90;
int INF = 1e8;
int N;
int dp[2][n][n * n];
vector<int> A;
vector<convex_hull> C(3 * n * n);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> N;
int cnt = 0;
for (int i = 0; i < N; i++) {
bool x;
cin >> x;
if (x)
A.push_back(cnt);
else
cnt++;
}
INF = cnt * (cnt - 1) / 2;
for (int i = 0; i <= cnt; i++) {
for (int j = 0; j <= N * (N - 1) / 2; j++) {
dp[1][i][j] = i * (i - 1) / 2;
}
}
vector<int> bst(N * (N - 1) / 2 + 1, INF);
for (int sh = 0; sh < ((int)(A).size()); sh++) {
for (int i = 0; i < ((int)(C).size()); i++) C[i] = convex_hull();
for (int pos = 0; pos <= cnt; pos++) {
for (int step = 0; step <= N * (N - 1) / 2; step++) {
int qi = step + abs(A[sh] - pos);
int slope = 2 * pos + 1;
int off = -(dp[(sh & 1) ^ 1][pos][step] * 2 + pos * (pos + 1));
C[qi].add(slope, off);
dp[sh & 1][pos][step] = INF;
if (((int)(C[step]).size())) {
dp[sh & 1][pos][step] = (-C[step].query(pos) + pos * pos) / 2;
}
}
}
for (int step = 0; step <= N * (N - 1) / 2; step++) {
bst[step] = min(bst[step], dp[sh & 1][cnt][step]);
}
}
cnt = cnt * (cnt - 1) / 2;
for (int j = 0; j <= N * (N - 1) / 2; j++) {
cout << max(0, cnt - bst[j]) << " ";
}
cout << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long double PI = 3.141592653589793;
const int eps = 1e-10;
int a[55][55];
int main() {
int n, t, i, j, b;
cin >> n;
for (t = 1; t <= n * n; t++) {
cin >> i >> j;
if (a[i][j] == 0) {
cout << t << " ";
for (b = 1; b <= n; b++) a[i][b] = 1, a[b][j] = 1;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, i, j, sizeA, sizeB, flag = 0, m;
cin >> sizeA;
int arrA[sizeA];
for (i = 0; i < sizeA; i++) {
cin >> arrA[i];
}
cin >> sizeB;
m = max(sizeA, sizeB);
int arrB[sizeB];
for (i = 0; i < sizeB; i++) cin >> arrB[i];
for (i = 0; i < sizeA; i++) {
flag = 0;
for (j = 0; j < sizeB; j++) {
flag = 0;
for (t = 0; t < m; t++) {
if (arrA[i] + arrB[j] == arrB[t] || arrA[i] + arrB[j] == arrA[t])
flag++;
}
if (flag == 0) {
cout << arrA[i] << " " << arrB[j];
break;
}
}
if (flag == 0) break;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int a[1234];
int b[1234];
void task() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", a + i);
for (int i = 0; i < n; i++) scanf("%d", b + i);
sort(a, a + n);
sort(b, b + n);
for (int i = 0; i < n; i++) printf(i ? " %d" : "%d", a[i]);
printf("\n");
for (int i = 0; i < n; i++) printf(i ? " %d" : "%d", b[i]);
printf("\n");
}
int main() {
int t;
scanf("%d", &t);
while (t--) task();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9;
int main() {
long long n, k;
cin >> n >> k;
set<long long> s;
long long a[1000001] = {};
for (long long i = 0; i < n; i++) {
long long temp;
cin >> temp;
s.insert(temp);
a[temp]++;
}
set<long long>::iterator itr;
vector<long long> v;
for (itr = s.begin(); itr != s.end(); itr++) v.push_back(*itr);
sort(v.begin(), v.end());
long long ans = n;
for (long long i = 0; i < v.size(); i++) {
if (v[i] < v[i + 1] && v[i] + k >= v[i + 1]) ans -= a[v[i]];
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
ld randDouble(ld a, ld b) {
return uniform_real_distribution<ld>(a, b)(rng);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
ld mult = 0.2; // sqrt(log(n) / m);
// E[fails] <= (1 + mult) min_fails + ln N / mult
vector<ld> lws(n, 1);
for (int ind = 0; ind < m; ++ind) {
string off;
cin >> off;
ld w0 = 0, w1 = 0;
for (int i = 0; i < n; ++i) {
if (off[i] == '0') w0 += lws[i];
else w1 += lws[i];
}
if (randDouble(0, w0 + w1) < w0) {
cout << 0 << endl;
} else {
cout << 1 << endl;
}
char ans;
cin >> ans;
for (int i = 0; i < n; ++i) {
if (off[i] != ans) lws[i] *= 1 - mult;
}
}
}
| 9 |
#include <bits/stdc++.h>
const int N = 100005;
using namespace std;
int n, a[N], t[N * 4][60], q, x, y, s;
void build(int k, int l, int r) {
if (l == r) {
for (int i = 0; i < 60; ++i) t[k][i] = (i % a[l] == 0 ? 1 : 0) + 1;
return;
}
int mid = (l + r) >> 1;
build(k * 2, l, mid);
build(k * 2 + 1, mid + 1, r);
for (int i = 0; i < 60; ++i)
t[k][i] = t[k * 2][i] + t[k * 2 + 1][(i + t[k * 2][i]) % 60];
}
int query(int k, int l, int r) {
int res = 0;
if (x <= l && r <= y) {
res = t[k][s];
s = (s + t[k][s]) % 60;
return res;
}
int mid = (l + r) >> 1;
if (x <= mid) res += query(k * 2, l, mid);
if (y > mid) res += query(k * 2 + 1, mid + 1, r);
return res;
}
void modify(int k, int l, int r) {
if (l == r) {
for (int i = 0; i < 60; ++i) t[k][i] = (i % y == 0 ? 1 : 0) + 1;
return;
}
int mid = (l + r) >> 1;
if (x <= mid)
modify(k * 2, l, mid);
else
modify(k * 2 + 1, mid + 1, r);
for (int i = 0; i < 60; ++i)
t[k][i] = t[k * 2][i] + t[k * 2 + 1][(i + t[k * 2][i]) % 60];
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
build(1, 1, n);
scanf("%d", &q);
char ss[5];
while (q-- > 0) {
scanf("%s", ss);
char c = ss[0];
scanf("%d%d", &x, &y);
if (c == 'A') --y, s = 0, printf("%d\n", query(1, 1, n));
if (c == 'C') modify(1, 1, n);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 100;
const long long inf = 1e14;
long long a[maxn], sum[maxn];
map<long long, long long> map1;
set<long long> s;
int main(void) {
cin.tie(0);
std::ios::sync_with_stdio(false);
long long n, k;
cin >> n >> k;
for (long long i = 1; i <= n; i++) cin >> a[i];
for (long long i = 1; i <= n; i++) sum[i] = sum[i - 1] + a[i];
s.insert(1);
long long tmp = k;
for (long long i = 1; i <= 60; i++) {
if (tmp > inf) break;
s.insert(tmp);
tmp *= k;
}
long long ans = 0;
map1[0] = 1;
for (long long i = 1; i <= n; i++) {
for (set<long long>::iterator it = s.begin(); it != s.end(); it++) {
ans += map1[sum[i] - *it];
}
map1[sum[i]]++;
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, a[1000000];
bool check(int x, int y) {
int j = -1, k = -1;
bool b = 0;
for (int i = x; i <= y; i++)
if (a[i] != -1)
if (!b)
b = 1, j = i;
else {
k = i;
break;
}
if (j == -1) return true;
if (k == -1) return true;
long long r;
if (a[j] > a[k]) {
r = fabs(a[j] - a[k]) / (k - j);
long long fr = (j - x) * r + a[j];
for (int i = x; i <= y; i++) {
if (fr <= 0) return 0;
if (a[i] == -1)
fr -= r;
else if (a[i] != fr)
return 0;
else
fr -= r;
}
return 1;
} else if (a[j] < a[k]) {
r = fabs(a[j] - a[k]) / (k - j);
long long fr = a[j] - (j - x) * r;
for (int i = x; i <= y; i++) {
if (fr <= 0) return 0;
if (a[i] == -1)
fr += r;
else if (a[i] != fr)
return 0;
else
fr += r;
}
return 1;
} else {
for (int i = x; i <= y; i++)
if (a[i] != -1 && a[i] != a[j]) return 0;
return 1;
}
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
int i = 0, t = 0;
while (i < n) {
int fr = i, last = n, mid, j;
while (fr <= last) {
mid = (fr + last) / 2;
if (check(i, mid)) {
fr = mid + 1;
j = mid;
} else {
last = mid - 1;
}
}
t++;
i = j + 1;
}
cout << t;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5001;
const int INF = 1e9;
int dp[MAXN][MAXN][2], a[MAXN], n;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= n; j++) {
dp[i][j][1] = INF;
dp[i][j][0] = INF;
}
}
dp[0][0][0] = 0;
dp[1][0][0] = 0;
dp[1][1][1] = 0;
for (int i = 2; i <= n; i++) {
dp[i][0][0] = 0;
for (int j = 1; j <= (n + 1) / 2; j++) {
dp[i][j][0] =
min(dp[i - 1][j][0], dp[i - 1][j][1] + max(0, a[i] - a[i - 1] + 1));
dp[i][j][1] =
min(dp[i - 2][j - 1][0] + max(0, a[i - 1] - a[i] + 1),
dp[i - 2][j - 1][1] + max(0, a[i - 1] - min(a[i], a[i - 2]) + 1));
}
}
for (int i = 1; i <= (n + 1) / 2; i++) {
cout << min(dp[n][i][0], dp[n][i][1]) << " ";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
namespace Vectors {
struct Vector {
long long x, y;
inline Vector(long long _x = 0, long long _y = 0) { x = _x, y = _y; }
};
inline Vector operator+(const Vector& a, const Vector& b) {
return Vector(a.x + b.x, a.y + b.y);
}
inline Vector operator-(const Vector& a, const Vector& b) {
return Vector(a.x - b.x, a.y - b.y);
}
inline long long operator*(const Vector& a, const Vector& b) {
return a.x * b.x + a.y * b.y;
}
inline long long cross(const Vector& a, const Vector& b) {
return a.x * b.y - a.y * b.x;
}
} // namespace Vectors
using namespace Vectors;
Vector a[4005];
char str[4005];
bool mark[4005];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i].x >> a[i].y;
cin >> str + 1;
str[0] = 'L';
int i = 1;
for (int k = 2; k <= n; k++)
if (a[k].x > a[i].x) i = k;
cout << i << ' ';
mark[i] = 1;
for (int t = 1; t < n - 1; t++) {
int j = 1;
while (mark[j]) j++;
if (str[t] == 'L') {
for (int k = 1; k <= n; k++)
if (!mark[k] && cross(a[j] - a[i], a[k] - a[i]) < 0) j = k;
} else {
for (int k = 1; k <= n; k++)
if (!mark[k] && cross(a[j] - a[i], a[k] - a[i]) > 0) j = k;
}
mark[i = j] = 1;
cout << i << ' ';
}
i = 1;
while (mark[i]) i++;
cout << i << ' ';
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, t;
cin >> s >> t;
for (int i = 0; i < s.length(); i++) {
if (t[i] != s[s.length() - 1 - i]) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, i, j, a, b, c;
const int MAXN = 200;
struct E {
int dest;
int cost;
};
vector<E> edge[MAXN];
int ar[MAXN][MAXN];
int was[MAXN];
E t;
vector<int> order;
void dfs(int v) {
was[v] = true;
order.push_back(v);
for (int i = 0; i < edge[v].size(); ++i) {
if (!was[edge[v][i].dest]) {
dfs(edge[v][i].dest);
}
}
};
int ans = 0;
int main() {
cin >> n;
for (i = 0; i < n; ++i) {
cin >> a >> b >> c;
t.dest = b;
t.cost = 0;
ar[a][b] = 0;
edge[a].push_back(t);
t.dest = a;
t.cost = c;
ar[b][a] = c;
edge[b].push_back(t);
}
for (i = 0; i < n; ++i) {
was[i] = 0;
}
dfs(1);
int res;
ans = 0;
for (i = 0; i < order.size() - 1; ++i) {
ans += ar[order[i]][order[i + 1]];
}
ans += ar[order[order.size() - 1]][order[0]];
reverse(order.begin(), order.end());
res = ans;
ans = 0;
for (i = 0; i < order.size() - 1; ++i) {
ans += ar[order[i]][order[i + 1]];
}
ans += ar[order[order.size() - 1]][order[0]];
res = min(res, ans);
cout << res;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int read();
int n;
char t[102];
int w[102][102], rnk[102][102], pos[102];
vector<int> p[102];
queue<int> q;
void init(int t) {
for (int i = 1; i <= n; ++i) {
p[i].clear(), p[i + n].clear();
for (int j = 1; j <= n; ++j) p[i].push_back(j + n), p[i + n].push_back(j);
sort(p[i].begin(), p[i].end(),
[&](int a, int b) { return w[i][a - n] > w[i][b - n] ^ t; });
sort(p[i + n].begin(), p[i + n].end(),
[&](int a, int b) { return w[a][i] < w[b][i] ^ t; });
q.push(i), pos[i] = 0, pos[i + n] = n;
for (int j = 0; j < n; ++j)
rnk[j][p[i][j]] = j, rnk[i + n][p[i + n][j]] = j;
}
while (!q.empty()) {
int u = q.front(), v;
while (pos[v = p[u][pos[u]]] < rnk[v][u]) ++pos[u];
if (pos[v] < n) q.push(p[v][pos[v]]);
pos[v] = rnk[v][u], q.pop();
}
}
int main() {
for (int T = read(); T; --T) {
n = read();
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) w[i][j] = read();
puts("B"), fflush(stdout), scanf("%s", t);
if (t[0] == 'I')
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) w[i][j] = -w[i][j];
int u;
for (init((u = read()) > n); ~u; u = read())
printf("%d\n", p[u][pos[u]]), fflush(stdout);
}
return 0;
}
int read() {
int x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') f = (c == '-') ? -1 : f, c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return x * f;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
template <class T1>
void deb(T1 e1) {
cout << e1 << endl;
}
template <class T1, class T2>
void deb(T1 e1, T2 e2) {
cout << e1 << " " << e2 << endl;
}
template <class T1, class T2, class T3>
void deb(T1 e1, T2 e2, T3 e3) {
cout << e1 << " " << e2 << " " << e3 << endl;
}
template <class T1, class T2, class T3, class T4>
void deb(T1 e1, T2 e2, T3 e3, T4 e4) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << endl;
}
template <class T1, class T2, class T3, class T4, class T5>
void deb(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << " " << e5 << endl;
}
template <class T1, class T2, class T3, class T4, class T5, class T6>
void deb(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5, T6 e6) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << " " << e5 << " " << e6
<< endl;
}
int n, arr[100005 + 7], pos[100005 + 7], sz, f;
bool visit[100005 + 7];
vector<int> prime;
vector<pair<int, int> > ans;
void reset();
void cal_prime();
void swap_two(int i, int j);
void b_search(int left, int right, int v);
int main() {
int cnt, d, p, res, i, j, k;
cal_prime();
while (scanf("%d", &n) == 1) {
reset();
for (i = 1; i <= n; i++) {
scanf("%d", &arr[i]);
pos[arr[i]] = i;
}
for (i = 1; i <= n; i++) {
if (arr[i] == i) {
continue;
}
p = pos[i];
d = p - i + 1;
while (d > 1) {
b_search(0, sz, d);
f = p - f + 1;
pos[arr[p]] = f;
pos[arr[f]] = p;
swap(arr[p], arr[f]);
ans.push_back(pair<int, int>(f, p));
p = f;
d = p - i + 1;
}
}
res = ans.size();
printf("%d\n", res);
for (i = 0; i < res; i++) {
printf("%d %d\n", ans[i].first, ans[i].second);
}
}
return 0;
}
void reset() { ans.clear(); }
void cal_prime() {
long long int i, j, k;
memset((visit), 0, sizeof(visit));
prime.push_back(2);
for (i = 3; i <= 100005; i += 2) {
if (!visit[i]) {
prime.push_back(i);
for (j = i * i; j <= 100005; j += i) {
visit[j] = 1;
}
}
}
sz = prime.size();
sz--;
}
void b_search(int left, int right, int v) {
if (left > right) {
return;
}
int mid;
mid = (left + right) / 2;
if (prime[mid] <= v) {
f = prime[mid];
b_search(mid + 1, right, v);
} else {
b_search(left, mid - 1, v);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a[6], b[6], c[6];
a[0] = "purple";
b[0] = "Power";
a[1] = "green";
b[1] = "Time";
a[2] = "blue";
b[2] = "Space";
a[3] = "orange";
b[3] = "Soul";
a[4] = "red";
b[4] = "Reality";
a[5] = "yellow";
b[5] = "Mind";
int n, i, j, k = 0, flag = 0;
int arr[6];
cin >> n;
for (i = 0; i < n; i++) cin >> c[i];
for (i = 0; i < n; i++) {
for (j = 0; j < 6; j++) {
if (c[i] == a[j]) {
arr[k] = j;
k++;
}
}
}
cout << 6 - n << endl;
for (i = 0; i < 6; i++) {
flag = 0;
for (k = 0; k < n; k++)
if (i == arr[k]) flag = 1;
if (flag == 0) cout << b[i] << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
int main() {
int a, b, sum = 0, c;
scanf("%d%d", &a, &b);
sum = a;
while (1) {
c = a / b;
a = c + (a % b);
sum += c;
if (a < b) break;
}
printf("%d\n", sum);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double pi = 3.141592653589793;
const double tau = 6.283185307179586;
const double epsilon = 1e-6;
using namespace std;
double W, H, THETA;
pair<pair<double, double>, pair<double, double> > make_segment(double x1,
double y1,
double x2,
double y2) {
return pair<pair<double, double>, pair<double, double> >(
pair<double, double>(x1, y1), pair<double, double>(x2 - x1, y2 - y1));
}
double cross(pair<double, double> v, pair<double, double> w) {
return v.first * w.second - v.second * w.first;
}
vector<pair<double, double> > intersections;
void intersect(pair<pair<double, double>, pair<double, double> > s1,
pair<pair<double, double>, pair<double, double> > s2) {
pair<double, double> p = s1.first;
pair<double, double> r = s1.second;
pair<double, double> q = s2.first;
pair<double, double> s = s2.second;
if (cross(r, s) == 0) return;
pair<double, double> qp =
pair<double, double>(q.first - p.first, q.second - p.second);
double t = cross(qp, s) / cross(r, s);
double u = cross(qp, r) / cross(r, s);
if (0.0 <= t && t <= 1.0 && 0.0 <= u && u <= 1.0) {
intersections.push_back(
pair<double, double>(p.first + t * r.first, p.second + t * r.second));
}
}
int main(int argc, const char* argv[]) {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cin >> W >> H >> THETA;
THETA *= tau / 360;
if (abs(THETA - 0) < epsilon || abs(THETA - tau / 2.0) < epsilon) {
cout << fixed << setprecision(8) << W * H << '\n';
} else {
pair<pair<double, double>, pair<double, double> > top =
make_segment(-W / 2, H / 2, W / 2, H / 2);
pair<pair<double, double>, pair<double, double> > right =
make_segment(W / 2, H / 2, W / 2, -H / 2);
pair<pair<double, double>, pair<double, double> > bottom =
make_segment(W / 2, -H / 2, -W / 2, -H / 2);
pair<pair<double, double>, pair<double, double> > left =
make_segment(-W / 2, -H / 2, -W / 2, H / 2);
pair<pair<double, double>, pair<double, double> > rtop =
make_segment((-W / 2 * cos(THETA)) - (H / 2 * sin(THETA)),
(-W / 2 * sin(THETA)) + (H / 2 * cos(THETA)),
(W / 2 * cos(THETA)) - (H / 2 * sin(THETA)),
(W / 2 * sin(THETA)) + (H / 2 * cos(THETA)));
pair<pair<double, double>, pair<double, double> > rright =
make_segment((W / 2 * cos(THETA)) - (H / 2 * sin(THETA)),
(W / 2 * sin(THETA)) + (H / 2 * cos(THETA)),
(W / 2 * cos(THETA)) - (-H / 2 * sin(THETA)),
(W / 2 * sin(THETA)) + (-H / 2 * cos(THETA)));
pair<pair<double, double>, pair<double, double> > rbottom =
make_segment((W / 2 * cos(THETA)) - (-H / 2 * sin(THETA)),
(W / 2 * sin(THETA)) + (-H / 2 * cos(THETA)),
(-W / 2 * cos(THETA)) - (-H / 2 * sin(THETA)),
(-W / 2 * sin(THETA)) + (-H / 2 * cos(THETA)));
pair<pair<double, double>, pair<double, double> > rleft =
make_segment((-W / 2 * cos(THETA)) - (-H / 2 * sin(THETA)),
(-W / 2 * sin(THETA)) + (-H / 2 * cos(THETA)),
(-W / 2 * cos(THETA)) - (H / 2 * sin(THETA)),
(-W / 2 * sin(THETA)) + (H / 2 * cos(THETA)));
intersect(rtop, top);
intersect(rright, top);
intersect(rbottom, top);
intersect(rright, right);
intersect(rbottom, right);
intersect(rleft, right);
intersect(rbottom, bottom);
intersect(rleft, bottom);
intersect(rtop, bottom);
intersect(rleft, left);
intersect(rtop, left);
intersect(rright, left);
intersections.push_back(intersections[0]);
double l = 0, r = 0;
for (int i = 0; i < ((int)intersections.size()) - 1; i++) {
l += intersections[i].first * intersections[i + 1].second;
r += intersections[i].second * intersections[i + 1].first;
}
cout << fixed << setprecision(9) << abs(r - l) / 2.0 << '\n';
}
return 0;
}
| 6 |
#include<bits/stdc++.h>
typedef unsigned int uint;
typedef long long ll;
typedef unsigned long long ull;
typedef double lf;
typedef long double llf;
typedef std::pair<int,int> pii;
#define xx first
#define yy second
template<typename T> inline T max(T a,T b){return a>b?a:b;}
template<typename T> inline T min(T a,T b){return a<b?a:b;}
template<typename T> inline T abs(T a){return a>0?a:-a;}
template<typename T> inline bool repr(T &a,T b){return a<b?a=b,1:0;}
template<typename T> inline bool repl(T &a,T b){return a>b?a=b,1:0;}
template<typename T> inline T gcd(T a,T b){T t;if(a<b){while(a){t=a;a=b%a;b=t;}return b;}else{while(b){t=b;b=a%b;a=t;}return a;}}
template<typename T> inline T sqr(T x){return x*x;}
#define mp(a,b) std::make_pair(a,b)
#define pb push_back
#define I __attribute__((always_inline))inline
#define mset(a,b) memset(a,b,sizeof(a))
#define mcpy(a,b) memcpy(a,b,sizeof(a))
#define fo0(i,n) for(int i=0,i##end=n;i<i##end;i++)
#define fo1(i,n) for(int i=1,i##end=n;i<=i##end;i++)
#define fo(i,a,b) for(int i=a,i##end=b;i<=i##end;i++)
#define fd0(i,n) for(int i=(n)-1;~i;i--)
#define fd1(i,n) for(int i=n;i;i--)
#define fd(i,a,b) for(int i=a,i##end=b;i>=i##end;i--)
#define foe(i,x)for(__typeof((x).end())i=(x).begin();i!=(x).end();++i)
#define fre(i,x)for(__typeof((x).rend())i=(x).rbegin();i!=(x).rend();++i)
struct Cg{I char operator()(){return getchar();}};
struct Cp{I void operator()(char x){putchar(x);}};
#define OP operator
#define RT return *this;
#define UC unsigned char
#define RX x=0;UC t=P();while((t<'0'||t>'9')&&t!='-')t=P();bool f=0;\
if(t=='-')t=P(),f=1;x=t-'0';for(t=P();t>='0'&&t<='9';t=P())x=x*10+t-'0'
#define RL if(t=='.'){lf u=0.1;for(t=P();t>='0'&&t<='9';t=P(),u*=0.1)x+=u*(t-'0');}if(f)x=-x
#define RU x=0;UC t=P();while(t<'0'||t>'9')t=P();x=t-'0';for(t=P();t>='0'&&t<='9';t=P())x=x*10+t-'0'
#define TR *this,x;return x;
I bool IS(char x){return x==10||x==13||x==' ';}template<typename T>struct Fr{T P;I Fr&OP,(int&x)
{RX;if(f)x=-x;RT}I OP int(){int x;TR}I Fr&OP,(ll &x){RX;if(f)x=-x;RT}I OP ll(){ll x;TR}I Fr&OP,(char&x)
{for(x=P();IS(x);x=P());RT}I OP char(){char x;TR}I Fr&OP,(char*x){char t=P();for(;IS(t);t=P());if(~t){for(;!IS
(t)&&~t;t=P())*x++=t;}*x++=0;RT}I Fr&OP,(lf&x){RX;RL;RT}I OP lf(){lf x;TR}I Fr&OP,(llf&x){RX;RL;RT}I OP llf()
{llf x;TR}I Fr&OP,(uint&x){RU;RT}I OP uint(){uint x;TR}I Fr&OP,(ull&x){RU;RT}I OP ull(){ull x;TR}};Fr<Cg>in;
#define WI(S) if(x){if(x<0)P('-'),x=-x;UC s[S],c=0;while(x)s[c++]=x%10+'0',x/=10;while(c--)P(s[c]);}else P('0')
#define WL if(y){lf t=0.5;for(int i=y;i--;)t*=0.1;if(x>=0)x+=t;else x-=t,P('-');*this,(ll)(abs(x));P('.');if(x<0)\
x=-x;while(y--){x*=10;x-=floor(x*0.1)*10;P(((int)x)%10+'0');}}else if(x>=0)*this,(ll)(x+0.5);else *this,(ll)(x-0.5);
#define WU(S) if(x){UC s[S],c=0;while(x)s[c++]=x%10+'0',x/=10;while(c--)P(s[c]);}else P('0')
template<typename T>struct Fw{T P;I Fw&OP,(int x){WI(10);RT}I Fw&OP()(int x){WI(10);RT}I Fw&OP,(uint x){WU(10);RT}
I Fw&OP()(uint x){WU(10);RT}I Fw&OP,(ll x){WI(19);RT}I Fw&OP()(ll x){WI(38);RT}I Fw&OP,(ull x){WU(20);RT}I Fw&OP()
(ull x){WU(20);RT}I Fw&OP,(char x){P(x);RT}I Fw&OP()(char x){P(x);RT}I Fw&OP,(const char*x){while(*x)P(*x++);RT}
I Fw&OP()(const char*x){while(*x)P(*x++);RT}I Fw&OP()(lf x,int y){WL;RT}I Fw&OP()(llf x,int y){WL;RT}};Fw<Cp>out;
int n;
typedef std::vector<int> arr;
std::deque<arr>q;
std::map<arr,int>f;
arr a1(arr x)
{
fo0(i,n)std::swap(x[i*2],x[i*2+1]);
return x;
}
arr a2(arr x)
{
fo0(i,n)std::swap(x[i],x[i+n]);
return x;
}
int main()
{
in,n;
arr t;
fo0(i,n*2)t.pb(i);
q.pb(t);
f[t]=0;
while(q.size())
{
t=q.front();
q.pop_front();
arr x=a1(t);
if(!f.count(x))
{
f[x]=f[t]+1;
q.pb(x);
}
x=a2(t);
if(!f.count(x))
{
f[x]=f[t]+1;
q.pb(x);
}
}
fo0(i,n*2)t[i]=(int)in-1;
//foe(i,f){fo0(j,n*2)out,i->xx[j],' ';out,'\n';}
if(!f.count(t))out,-1,'\n';
else out,f[t],'\n';
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int xo(long long int x, long long int y) {
return (x | y) & (~x | ~y);
}
long long int bin_Expo(long long int x, long long int n) {
if (x == 0) return 0;
if (n == 0)
return 1;
else if (n % 2 == 0)
return bin_Expo(x * x, n / 2);
else
return x * bin_Expo(x * x, (n - 1) / 2);
}
long long int mod_Expo(long long int x, long long int n, long long int M) {
if (x == 0) return 0;
if (n == 0)
return 1;
else if (n % 2 == 0)
return mod_Expo((x * x) % M, n / 2, M);
else
return (x * mod_Expo((x * x) % M, (n - 1) / 2, M)) % M;
}
bool prime_check(long long int x) {
bool prime = (x >= 2);
for (long long int i = 2; i * i <= x; i++) {
if (x % i == 0) {
prime = false;
break;
}
}
return prime;
}
long long int logg(long long int base, long long int x) {
return (long long int)(log(x) / log(base));
}
long long int a[501], dp[501][501], dp1[501];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int TESTS = 1;
while (TESTS--) {
long long int n, m, k, l, h, g, i, j;
cin >> n;
for (long long int i = 0; i < n; i++) cin >> a[i];
for (long long int i = 0; i <= n; i++) {
for (long long int j = 0; j <= n; j++) dp[i][j] = -1;
dp1[i] = 1000000007;
}
for (l = 1; l <= n; l++) {
for (i = 0; i < n - l + 1; i++) {
j = i + l - 1;
if (i == j)
dp[i][j] = a[i];
else {
for (k = i; k < j; k++) {
if (dp[i][k] != -1 && dp[i][k] == dp[k + 1][j])
dp[i][j] = dp[i][k] + 1;
}
}
}
}
for (long long int i = 0; i < n; i++) {
for (long long int k = 0; k <= i; k++) {
if (dp[k][i] != -1) {
if (k == 0)
dp1[i] = 1;
else
dp1[i] = min(dp1[i], dp1[k - 1] + 1);
}
}
}
cout << dp1[n - 1];
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int knigths[300006];
set<int> s;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL), cout.tie(NULL);
ios::sync_with_stdio(false), cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= n + 1; i++) s.insert(i);
for (int i = 0; i < m; i++) {
int a, b, c;
cin >> a >> b >> c;
set<int>::iterator itl = s.lower_bound(a);
set<int>::iterator itu = s.upper_bound(b);
while (*itl < *itu) {
if (*itl != c) {
knigths[*itl] = c;
}
s.erase(itl);
itl = s.lower_bound(a);
itu = s.upper_bound(b);
}
s.insert(c);
}
for (int i = 1; i <= n; i++) cout << knigths[i] << " ";
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
int dx[] = {1, 0, 0, -1};
int dy[] = {0, 1, -1, 0};
int n, k, l;
int d[100 + 1], p[200 + 1];
int dp[100 + 1][200 + 1];
int solve(int i, int t) {
if (i == n) {
return 1;
}
if (d[i] + p[t % (2 * k)] > l) {
return 0;
}
int &ret = dp[i][t];
if (ret != -1) return ret;
ret = 0;
return ret = solve(i, (t + 1) % (2 * k)) | solve(i + 1, (t + 1) % (2 * k));
}
int main() {
cin.tie(0);
std::ios::sync_with_stdio(false);
int t;
cin >> t;
while (t--) {
cin >> n >> k >> l;
for (int i = 0; i < n; i++) cin >> d[i];
for (int i = 0; i < 2 * k; i++) {
if (i <= k)
p[i] = i;
else
p[i] = p[i - 1] - 1;
}
memset(dp, -1, sizeof(dp));
bool ans = 0;
for (int t = 0; t < 2 * k; t++) ans |= solve(0, t);
cout << (ans ? "Yes" : "No") << '\n';
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, k;
cin >> n >> k;
vector<int> V(n);
for (auto &x : V) {
cin >> x;
}
set<int> S(V.begin(), V.end());
if (S.size() > k) {
cout << -1 << endl;
return;
}
cout << k * n << endl;
for (int i = 0; i < n; i++) {
for (int x : S) cout << x << " ";
for (int i = 0; i < k - S.size(); i++) cout << 1 << " ";
}
cout << endl;
}
int main() {
int t;
cin >> t;
while (t--) {
solve();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n, p[100005], pob[100005], i, j, cur, ans;
int main() {
cin >> n;
for (i = 1; i <= n; i++) {
cin >> p[i];
pob[p[i]] = i;
}
ans = 1;
cur = 1;
for (i = 1; i < n; i++) {
if (pob[i] < pob[i + 1]) {
cur++;
ans = max(ans, cur);
} else {
cur = 1;
}
}
cout << n - ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int NMAX = 100100;
int nxt[10100];
int tpow[] = {1, 10, 100, 1000, 10000};
void buildnxt() {
vector<int> gv;
for (int i = 1; i < 5; ++i) {
for (int j = 0; j < (1 << i); ++j) {
int val = 0;
for (int k = 0; k < i; ++k) {
val += (((1 << k) & j) ? 7 : 4) * tpow[k];
}
gv.push_back(val);
}
}
for (int i = 0; i < gv.size() - 1; ++i) {
for (int j = gv[i] + 1; j < gv[i + 1]; ++j) {
nxt[j] = gv[i];
}
nxt[gv[i]] = gv[i + 1];
}
nxt[0] = 4;
nxt[1] = 0;
nxt[2] = 0;
nxt[3] = 0;
nxt[7777] = 10010;
for (int i = 7778; i < 10010; ++i) {
nxt[i] = 7777;
}
}
struct state {
int val;
int mindiff;
int cnt;
state() : val(0), mindiff(1e5), cnt(0) {}
state(int a, int b, int c) : val(a), mindiff(b), cnt(c) {}
state operator+(const state& o) const {
int md, ct;
if (mindiff == o.mindiff) {
return state(0, mindiff, o.cnt + cnt);
} else if (mindiff < o.mindiff) {
return state(0, mindiff, cnt);
}
return state(0, o.mindiff, o.cnt);
}
void add(int amt) { mindiff += amt; }
};
struct segtree {
vector<state> t;
vector<int> d;
int n, h;
segtree() {}
segtree(int sz) {
h = 32 - __builtin_clz(sz);
n = 1 << h;
t = vector<state>(n << 1);
d = vector<int>(n << 1, 0);
}
void print() const {}
void build() {
for (int i = n - 1; i > 0; --i) {
t[i] = t[i << 1] + t[i << 1 | 1];
}
}
void set(int i, int v) {
t[i + n].val = v;
t[i + n].cnt = 1;
if (nxt[v] > v) {
t[i + n].mindiff = 0;
} else {
t[i + n].mindiff = nxt[nxt[v]] - v;
}
}
void pushh(int x) {
if (d[x] == 0) return;
d[x << 1] += d[x];
t[x << 1].add(-d[x]);
d[x << 1 | 1] += d[x];
t[x << 1 | 1].add(-d[x]);
d[x] = 0;
}
void push(int i) {
i += n;
for (int l = h; l > 0; l--) {
pushh(i >> l);
}
}
void pulll(int x) {
assert(d[x] == 0);
t[x] = t[x << 1] + t[x << 1 | 1];
}
void pull(int i) {
for (i = (i + n) / 2; i > 0; i /= 2) {
pulll(i);
}
}
state query(int l, int r) {
state ans;
int l0 = l, r0 = r;
push(l0);
push(r0 - 1);
for (l += n, r += n; l < r; l /= 2, r /= 2) {
if (l & 1) {
ans = ans + t[l++];
}
if (r & 1) {
ans = ans + t[--r];
}
}
return ans;
}
void upd(int x) {
if (t[x].mindiff != 0) return;
if (x >= n) {
t[x].val += d[x];
d[x] = 0;
assert(nxt[t[x].val] > t[x].val);
t[x].mindiff = nxt[t[x].val] - t[x].val;
return;
}
pushh(x);
upd(x << 1);
upd(x << 1 | 1);
pulll(x);
}
void upd(int l, int r) {
push(l);
push(r - 1);
push(l - 1);
push(r);
int l0 = l, r0 = r;
bool cl = false, cr = false;
for (l += n, r += n; l < r; l /= 2, r /= 2) {
if (cl) {
pulll(l - 1);
}
if (cr) {
pulll(r);
}
if (l & 1) {
upd(l++);
cl = true;
}
if (r & 1) {
upd(--r);
cr = true;
}
}
pull(l0 - 1);
pull(r0);
}
void apply(int l, int r, int dd) {
int l0 = l, r0 = r;
push(l0);
push(r0 - 1);
push(l0 - 1);
push(r0);
bool cl = false, cr = false;
for (l += n, r += n; l < r; l /= 2, r /= 2) {
if (cl) {
print();
pulll(l - 1);
}
if (cr) {
print();
pulll(r);
}
if (l & 1) {
d[l] += dd;
t[l].mindiff -= dd;
assert(t[l].mindiff >= 0);
++l;
cl = true;
}
if (r & 1) {
--r;
d[r] += dd;
t[r].mindiff -= dd;
assert(t[r].mindiff >= 0);
cr = true;
}
}
for (--l; r > 0; l /= 2, r /= 2) {
if (cl) pulll(l);
if (cr && (!cl || (r != l))) pulll(r);
}
}
};
int N, M;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
buildnxt();
cin >> N >> M;
segtree st(N + 1);
for (int i = 1; i <= N; ++i) {
int u;
cin >> u;
st.set(i, u);
}
st.build();
string s;
for (int i = 0; i < M; ++i) {
int l, r, d;
cin >> s;
if (s[0] == 'c') {
int l, r;
cin >> l >> r;
state a = st.query(l, r + 1);
cout << (a.mindiff ? 0 : a.cnt) << '\n';
} else {
cin >> l >> r >> d;
st.print();
while (d > 0) {
st.print();
st.upd(l, r + 1);
state a = st.query(l, r + 1);
if (a.mindiff) {
int nd = min(a.mindiff, d);
st.apply(l, r + 1, nd);
st.print();
d -= nd;
} else {
assert(false);
}
}
st.print();
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
long long t;
cin >> t;
for (long long w = 0; w < t; w++) {
long long x;
cin >> x;
long long y = x / 2;
cout << y + 1 << '\n';
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 222222;
int degree[N];
vector<int> adj[N];
long long final = 1LL, cur = 1;
const int MOD = 998244353;
long long rem;
long long f[N];
void fact(int n) {
long long res = 1LL;
for (int i = 1; i <= n; ++i) {
res = (long long)res * i % MOD;
f[i] = res;
}
f[0] = 1LL;
}
long long dfs(int c, int p) {
int i;
long long result = degree[c];
final = final * f[degree[c]] % MOD;
for (i = 0; i < adj[c].size(); ++i) {
int curnode = adj[c][i];
if (curnode == p) continue;
dfs(curnode, c);
}
return result;
}
int main() {
fact(N - 1);
int n, i;
cin >> n;
int x, y;
for (i = 0; i < n - 1; ++i) {
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
degree[x]++, degree[y]++;
}
dfs(1, 0);
cout << final * n % MOD << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using vi = vector<int>;
int main() {
ios::sync_with_stdio(0);
int n, m;
cin >> n >> m;
vector<vi> a(n, vi(m));
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> a[i][j];
auto test = [&](const vi &col) {
vi test, row(n);
bool mixed = false;
for (int i = 0; i < n; i++) {
vi cnt(2);
for (int j = 0; j < m; j++) cnt[a[i][j] ^ col[j]] = 1;
row[i] = cnt[0] && cnt[1] ? a[i][0] ^ col[0] : cnt[!mixed];
if (cnt[0] && cnt[1]) mixed = true;
for (int j = 0; j < m; j++) test.push_back(a[i][j] ^ row[i] ^ col[j]);
}
if (is_sorted(test.begin(), test.end())) {
cout << "YES" << endl;
for (int x : row) cout << x;
cout << endl;
for (int y : col) cout << y;
cout << endl;
exit(0);
}
};
test(a[0]);
vi col(m);
for (int j = 0; j < m; j++) col[j] = 1 - a[n - 1][j];
test(col);
cout << "NO" << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
string s[1050];
int main() {
ios::sync_with_stdio(0);
int n;
cin >> n;
if (n == 1) return cout << 6, 0;
for (int i = 0; i < n; i++) cin >> s[i];
int mi = 6;
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++) {
int cnt = 0;
for (int k = 0; k < 6; k++)
if (s[i][k] != s[j][k]) cnt++;
mi = min(mi, cnt);
}
cout << (mi - 1) / 2;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
t = 1;
while (t--) {
int n;
cin >> n;
if (n % 2)
cout << -1 << "\n";
else {
string s;
cin >> s;
int pre[n + 1];
pre[0] = 0;
int o = 0, c = 0;
for (int i = 1; i <= s.length(); i++) {
if (s[i - 1] == '(') {
pre[i] = pre[i - 1] + 1;
o++;
} else {
pre[i] = pre[i - 1] - 1;
c++;
}
}
if (o != c) {
cout << -1 << "\n";
continue;
}
int cnt1 = 0, cnt2 = 0;
for (int i = 1; i <= s.length(); i++) {
if (pre[i] < pre[i - 1] && pre[i - 1] == 0) cnt1++;
if (pre[i] < 0) cnt2++;
}
cout << cnt1 + cnt2 << "\n";
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long d3 = 1000;
const long d4 = 10000;
const long d5 = 100000;
const long d6 = 1000000;
const long d7 = 10000000;
const long d8 = 100000000;
const long d9 = 1000000000;
vector<int> g[d5];
long n, m, k, s, t;
bool kk[d5] = {false}, used[d5];
inline bool check(long q) {
int used[d5], tmp, cur, cnt, next;
for (int i = 0; i < n; i++) {
used[i] = q + 10;
}
queue<int> qu;
used[s] = 0;
qu.push(s);
while (qu.size()) {
cur = qu.front();
qu.pop();
if (cur == t) {
return true;
} else {
if (kk[cur]) {
used[cur] = 0;
}
tmp = used[cur] + 1;
if (tmp <= q) {
cnt = g[cur].size();
for (int i = 0; i < cnt; i++) {
next = g[cur][i];
if (used[next] > tmp) {
used[next] = tmp;
qu.push(next);
}
}
}
}
}
return false;
}
void dfs(int v) {
int tmp;
for (int i = 0; i < g[v].size(); i++) {
tmp = g[v][i];
if (!used[tmp]) {
used[tmp] = true;
dfs(tmp);
}
}
}
bool isReal(long s, long f) {
for (int i = 0; i < n; i++) {
used[i] = false;
}
dfs(s);
return used[f];
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < n; i++) {
g[i].clear();
}
long u, v, tmp;
for (int i = 0; i < k; i++) {
cin >> tmp;
tmp--;
kk[tmp] = true;
}
for (int i = 0; i < m; i++) {
cin >> u >> v;
u--;
v--;
g[v].push_back(u);
g[u].push_back(v);
}
cin >> s >> t;
s--;
t--;
if (isReal(s, t)) {
long up = n, down = 0, tmp;
while (up - down > 1) {
tmp = (up + down) / 2;
if (check(tmp)) {
up = tmp;
} else {
down = tmp;
}
}
while (!check(down)) {
down++;
}
cout << down;
} else
cout << -1;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int u[1000005], v[1000005];
unsigned long long H[1000005], x[1000005];
int main() {
H[0] = 1;
for (int i = 1; i < 1000005; i++) H[i] = H[i - 1] * 7191;
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d%d", &u[i], &v[i]);
x[u[i]] += H[v[i]];
x[v[i]] += H[u[i]];
}
long long ans = 0;
for (int i = 0; i < m; i++) {
if (x[u[i]] - H[v[i]] == x[v[i]] - H[u[i]]) ans++;
}
sort(x + 1, x + 1 + n);
long long cnt = 1;
for (int i = 2; i <= n + 1; i++) {
if (i <= n && x[i] == x[i - 1]) {
cnt++;
} else {
ans += cnt * (cnt - 1) / 2;
cnt = 1;
}
}
printf("%lld\n", ans);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m, q, s[10005][4];
int mtx[105][105];
int main() {
scanf("%d %d %d", &n, &m, &q);
for (int i = (1); i <= (q); i++) {
scanf("%d", &s[i][0]);
if (s[i][0] == 3)
scanf("%d %d %d", &s[i][1], &s[i][2], &s[i][3]);
else
scanf("%d", &s[i][1]);
}
for (int i = (q); i >= (1); i--) {
if (s[i][0] == 3)
mtx[s[i][1]][s[i][2]] = s[i][3];
else if (s[i][0] == 1) {
for (int j = (m); j >= (2); j--)
swap(mtx[s[i][1]][j], mtx[s[i][1]][j - 1]);
} else {
for (int j = (n); j >= (2); j--)
swap(mtx[j][s[i][1]], mtx[j - 1][s[i][1]]);
}
}
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (m); j++)
printf("%d%c", mtx[i][j], j == m ? '\n' : ' ');
return 0;
}
| 3 |
#include <bits/stdc++.h>
int N;
int main() {
scanf("%d", &N);
puts("2");
for (int i = 2; i <= N; i++)
printf("%lld\n", (long long)(i + 1) * (i + 1) * i - i + 1);
return 0;
}
| 4 |
#include <bits/stdc++.h>
int main() {
int i, count = 0, worker, num;
scanf("%d", &num);
for (i = 2; i < num; i++) {
worker = (num - i);
if (worker % i == 0) {
count++;
}
}
printf("%d", count + 1);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
float a, b, x, m;
cin >> a >> b;
x = b * b - a * a;
m = x / (2 * a);
printf("%.13lf", m);
cout << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100 + 5;
int boy[maxn], girl[maxn];
int n, m;
int main() {
int b, g;
while (scanf("%d%d", &n, &m) != EOF) {
memset(boy, 0, sizeof(boy));
memset(girl, 0, sizeof(girl));
int in;
scanf("%d", &b);
for (int i = 0; i < b; i++) {
scanf("%d", &in);
boy[in] = 1;
}
scanf("%d", &g);
for (int i = 0; i < g; i++) {
scanf("%d", &in);
girl[in] = 1;
}
bool flag;
int stb = 0, stg = 0;
int cnt = maxn * maxn;
while (cnt) {
flag = true;
stb %= n;
stg %= m;
if (boy[stb] || girl[stg]) {
boy[stb] = 1;
girl[stg] = 1;
}
for (int i = 0; i < n; i++) {
if (!boy[i]) {
flag = false;
break;
}
}
for (int i = 0; i < m; i++) {
if (!girl[i]) {
flag = false;
break;
}
}
if (flag) break;
stb++;
stg++;
cnt--;
}
printf("%s\n", flag ? "Yes" : "No");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T BigMod(T b, T p, T m) {
if (p == 0) return 1;
if (p % 2 == 0) {
T s = BigMod(b, p / 2, m);
return ((s % m) * (s % m)) % m;
}
return ((b % m) * (BigMod(b, p - 1, m) % m)) % m;
}
template <typename T>
inline T ModInv(T b, T m) {
return BigMod(b, m - 2, m);
}
template <typename T>
inline T Bigmod(T b, T p, T m) {
if (p == 0)
return 1;
else if (!(p & 1))
return (Bigmod(b, p / 2, m) * Bigmod(b, p / 2, m)) % m;
else
return ((b % m) * Bigmod(b, p - 1, m)) % m;
}
template <typename T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <typename T>
inline T lcm(T a, T b) {
if (a < 0) return lcm(-a, b);
if (b < 0) return lcm(a, -b);
return a * (b / gcd(a, b));
}
template <typename T>
inline T euclide(T a, T b, T &x, T &y) {
if (a < 0) {
T d = euclide(-a, b, x, y);
x = -x;
return d;
}
if (b < 0) {
T d = euclide(a, -b, x, y);
y = -y;
return d;
}
if (b == 0) {
x = 1;
y = 0;
return a;
} else {
T d = euclide(b, a % b, x, y);
T t = x;
x = y;
y = t - (a / b) * y;
return d;
}
}
template <typename T>
inline T Dis(T x1, T y1, T x2, T y2) {
return sqrt((x1 - x2 * x1 - x2) + (y1 - y2 * y1 - y2));
}
template <typename T>
inline T Angle(T x1, T y1, T x2, T y2) {
return atan(double(y1 - y2) / double(x1 - x2));
}
template <typename T>
inline T DIFF(T a, T b) {
T d = a - b;
if (d < (T)0)
return -d;
else
return d;
}
template <typename T>
inline T ABS(T a) {
if (a < 0)
return -a;
else
return a;
}
template <typename T>
inline long long isLeft(T a, T b, T c) {
return (a.x - b.x) * (b.y - c.y) - (b.x - c.x) * (a.y - b.y);
}
template <typename T>
inline void _in(T &x) {
register int c = getchar();
x = 0;
bool 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;
}
template <typename T>
inline bool isLeapYear(T N) {
if (N % 4)
return 0;
else if (N % 100)
return 1;
else if (N % 400)
return 0;
else
return 1;
}
template <typename T>
inline T Set(T N, T pos) {
return N = N | (1 << pos);
}
template <typename T>
inline T Reset(T N, T pos) {
return N = N & ~(1 << pos);
}
template <typename T>
inline bool Check(T N, T pos) {
return (bool)(N & (1 << pos));
}
template <class T, class X>
inline T togglebit(T a, X i) {
T t = 1;
return (a ^ (t << i));
}
template <class T, class X>
inline T toInt(T &sm, X s) {
stringstream ss(s);
ss >> sm;
return sm;
}
template <typename T>
inline int cdigittoint(T ch) {
return ch - '0';
}
template <typename T>
inline bool isVowel(T ch) {
ch = toupper(ch);
if (ch == 'A' || ch == 'U' || ch == 'I' || ch == 'O' || ch == 'E')
return true;
return false;
}
template <typename T>
inline bool isConst(T ch) {
if (isalpha(ch) && !isVowel(ch)) return true;
return false;
}
inline double DEG(double x) { return (180.0 * x) / (2 * acos(0.0)); }
inline double RAD(double x) { return (x * (double)2 * acos(0.0)) / (180.0); }
int main() {
long long n = ({
long long a;
_in(a);
a;
});
long long ans1 = BigMod(2ll, n, (long long)1000000007);
long long ans2 = (ans1 * (ans1 + 1) % 1000000007) % 1000000007;
long long ans3 = ModInv(2ll, (long long)1000000007);
ans2 = (ans2 * ans3) % 1000000007;
printf("%lld\n", ans2);
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
//======================
//
// Template OleschY
//
// Die M�glichkeiten der deutschen Grammatik k�nnen
// einen, wenn man sich darauf, was man ruhig, wenn
// man m�chte, sollte, einl�sst, �berraschen.
// - @Gedankenbalsam
//
//======================
//======================
// Output/Debug
//======================
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v)
{
os << "[";
for (int i = 0; i < v.size(); ++i)
{
os << v[i];
if (i != v.size() - 1)
os << ", ";
}
os << "]\n";
return os;
}
template <typename T, typename U>
ostream& operator<<(ostream& os, const pair<T, U>& p)
{
os << "[";
os << p.first;
os << ", ";
os << p.second;
os << "]";
return os;
}
#ifndef ONLINE_JUDGE
#define debug(x) cout << (#x) << " is " << (x) << endl
#else
#define debug(...) 42
#endif
//======================
// Solution Single testcase
//======================
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
pair<int, int> getlr(const string& st1, const string& st2)
{
int ssize = st1.size();
pair<int, int> borders = {-1, ssize};
for(int l = 0; l < ssize; l++)
{
if(st1[l] == st2[l])
{
borders.first = l;
}
else break;
}
for(int r = ssize - 1; r >= 0; r--)
{
if(st1[r] == st2[r])
{
borders.second = r;
}
else break;
}
borders.first++;
borders.second = ssize - borders.second;
return borders;
}
long long nAll;
vector<pair<string, string>> in(nAll);
int solve(int forceSol = -1)
{
for(int i = 0; i < nAll ; ++i)
{
in[i].second = in[i].first;
sort(in[i].second.begin(), in[i].second.end());
}
sort(in.begin(), in.end(), [](pair<string, string> const & a, pair<string, string> const & b)
{
return a.second < b.second;
});
vector<vector<string>> strGroups;
for(int i = 0; i < nAll; i++)
{
if(i == 0 || in[i].second != in[i - 1].second)
{
strGroups.push_back(vector<string>(0));
}
strGroups[strGroups.size() - 1].push_back(in[i].first);
}
long long ans= 0;
long long ans1337 = 0;
long long ansWidthwisePairs = 0;
for(vector<string>& strs : strGroups)
{
long long n = strs.size();
long long ssize = strs[0].size();
ans1337 += 1337 * n * (nAll - n);
ans += n * ( n - 1 );
sort(strs.begin(), strs.end());
int dbgcnt = 0;
if(forceSol == 1 || n >= 6800 && forceSol != 2)
{
// check widthwise
for(string const& str : strs)
{
//debug(dbgcnt++);
for(int i = 0; i < ssize; i++)
{
for(int j = i + 1; j < ssize; j++)
{
string temp = str;
sort(temp.begin() + i, temp.begin() + j + 1);
if(temp[i] != str[i])
{
if(temp[j] != str[j])
{
if(binary_search(strs.begin(), strs.end(), temp))
{
ansWidthwisePairs -= 2;
}
}
}
}
}
}
}
else
{
// check pairwise
for(int i = 0; i < n; i++)
{
for(int j = i + 1; j < n; j++)
{
auto [l, r] = getlr(strs[i], strs[j]);
if(r == ssize)
ans -= 2;
else
{
if(is_sorted(strs[i].begin() + l, strs[i].end() - r))
ans -= 1;
if(is_sorted(strs[j].begin() + l, strs[j].end() - r))
ans -= 1;
}
}
}
}
}
cout << ans1337 / 2 + ans + ansWidthwisePairs / 2 << "\n";
return 0;
}
void input(bool create)
{
if(!create)
{
cin >> nAll;
in.resize(nAll);
for(int i = 0; i < nAll; ++i)
{
cin >> in[i].first;
}
solve(-1);
}
else
{
for(nAll = 11000; nAll <= 11500; nAll += 1)
{
nAll = uniform_int_distribution<int>(11100, 11450)(rng);
for(int force = 1; force <= 1; force++)
{
string s = "";
for(int j = 0; j < 200000 / nAll; j++)
{
s.push_back((char)uniform_int_distribution<int>('a', 'h')(rng));
}
set<string> strs;
while(strs.size() < nAll)
{
shuffle(s.begin(), s.end(), rng);
strs.insert(s);
}
in.clear();
for(string s : strs)
{
in.push_back({s, s});
}
shuffle(in.begin(), in.end(), rng);
//output
/*cout << nAll << "\n";
for(auto s : in)
{
cout << s.first << "\n";
}
return;*/
// outputt //
clock_t time_req;
time_req = clock();
solve(force);
time_req = clock() - time_req;
cout << " nAll: " << nAll << " StringSize: " << s.size() << " solution: " << force << " Time: " << (float)time_req / CLOCKS_PER_SEC << " seconds" << endl;
}
}
}
}
//======================
// Technical stuff
//======================
int main()
{
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
//freopen("a.out", "w", stdout); // console output is better (in most cases)
#else
// add i/o method of specific testing system
#endif
int ntest = 1;
//cin >> ntest;
for(int test = 0; test < ntest; ++test)
{
#ifndef ONLINE_JUDGE
input(true);
#else
input(false);
#endif
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long arr[n + 2];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
int count = 0;
int count2 = 0;
for (int i = 0; i < n; i++) {
if (count == 0 && arr[i] < 0) {
count2++;
} else if (arr[i] > 0) {
count += arr[i];
} else if (count > 0) {
count--;
}
}
cout << count2 << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000010;
const long long inf = (1ll << 58ll);
int k, n, q;
int ten[10] = {1, 10, 100, 1000, 10000, 100000};
long long F[7];
long long dp[maxn], g[maxn];
long long read() {
long long s = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
s = s * 10 + ch - '0';
ch = getchar();
}
return s * f;
}
int main() {
k = read();
for (int i = 0; i < 6; ++i) F[i] = read();
fill(dp, dp + 1 + 999999, -inf);
dp[0] = 0;
for (int d = 1; d <= 6; ++d) {
long long left = 1ll * 3 * (k - 1);
long long group = 1ll;
while (left > 0) {
group = min(group, left);
long long val = 1ll * group * F[d - 1];
long long wei = 1ll * 3 * group * ten[d - 1];
for (int i = 999999; i >= wei; --i) {
dp[i] = max(dp[i], dp[i - wei] + val);
}
left -= group;
group *= 2;
}
}
for (int d = 1; d <= 6; ++d) {
for (int i = 999999; i >= 0; i--) {
for (int j = 0; j <= 9; ++j) {
long long val, wei;
if (j == 3 || j == 6 || j == 9)
val = 1ll * (j / 3) * F[d - 1];
else
val = 0;
wei = 1ll * j * ten[d - 1];
if (wei > i) break;
dp[i] = max(dp[i], dp[i - wei] + val);
}
}
}
q = read();
for (int i = 1; i <= q; ++i) {
n = read();
printf("%lld\n", dp[n]);
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
template <class T>
T sqr(T x) {
return x * x;
}
template <class T>
T lcm(T a, T b) {
return a / __gcd(a, b) * b;
}
template <class T>
T minimize(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T>
T maximize(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
const long long mod = 1e9 + 7, oo = 1e12, N = 2e5 + 5;
using namespace std;
long long tc, n;
string str;
bool color[N];
signed main() {
ios_base::sync_with_stdio(0);
cin.tie();
cout.tie();
vector<long long> pos_right;
for (cin >> tc; tc > 0; tc--) {
cin >> str;
n = str.length();
str = " " + str;
pos_right.push_back(0);
for (__typeof(n) i = (1); i <= (n); ++i)
if (str[i] == 'R') pos_right.push_back(i);
pos_right.push_back(n + 1);
long long res = 0;
for (__typeof(((long long)(pos_right).size()) - 1) i = (1);
i <= (((long long)(pos_right).size()) - 1); ++i)
res = max(res, pos_right[i] - pos_right[i - 1]);
cout << res << '\n';
pos_right = vector<long long>();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
string tos(T a) {
stringstream ss;
string ret;
ss << a;
ss >> ret;
return ret;
}
void read(int &_a) { int temp = scanf("%d", &_a); }
void read(int &_a, int &_b) { int temp = scanf("%d %d", &_a, &_b); }
void read(int &_a, int &_b, int &_c) {
int temp = scanf("%d %d %d", &_a, &_b, &_c);
}
const int SZ = 2e5 + 7;
int N, M, Q;
int P[SZ], A[SZ], T[SZ], TX[SZ][20];
int PX[SZ], AX[SZ], MXR[SZ];
int getp(int u, int n) {
int lg = 1;
while ((1 << lg) <= n) lg++;
lg--;
for (int i = lg; i >= 0; i--) {
if (u == -1) break;
if ((1 << i) <= n) {
n -= (1 << i);
u = TX[u][i];
}
}
return u;
}
int main() {
while (cin >> N >> M >> Q) {
memset(T, -1, sizeof T);
;
memset(TX, -1, sizeof TX);
;
memset(AX, -1, sizeof AX);
;
for (int(x) = (0); (x) < (N); (x)++) {
read(P[x]);
PX[P[x]] = x;
}
for (int(x) = (0); (x) < (M); (x)++) {
read(A[x]);
int li = PX[A[x]];
li = (li - 1 + N) % N;
int pv = P[li];
if (AX[pv] != -1) T[x] = AX[pv];
AX[A[x]] = x;
}
for (int(x) = (0); (x) < (M); (x)++) TX[x][0] = T[x];
for (int j = 1; (1 << j) <= M; j++) {
for (int(i) = (0); (i) < (M); (i)++) {
if (TX[i][j - 1] != -1) {
TX[i][j] = TX[TX[i][j - 1]][j - 1];
}
}
}
int mx = -1;
for (int(x) = (0); (x) < (M); (x)++) {
int lf = getp(x, N - 1);
mx = max(mx, lf);
MXR[x] = mx;
}
string ans = "";
int la, lb;
for (int(q) = (0); (q) < (Q); (q)++) {
read(la, lb);
la--;
lb--;
int lf = MXR[lb];
if (lf >= la)
ans += "1";
else
ans += "0";
}
cout << ans << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
const int max_n = 1e6 + 1;
string G[max_n];
int sx, sy;
pair<int, int> mov[4] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
int possible_route(int x, int y) {
int cnt = 0;
for (int i = 0; i < 4; i++) {
int xn = x + mov[i].first, yn = y + mov[i].second;
if (0 <= xn && xn < n && 0 <= yn && yn < m && G[xn][yn] == '.') cnt++;
}
return cnt;
}
void dfs(int x, int y) {
for (int i = 0; i < 4; i++) {
int xn = x + mov[i].first, yn = y + mov[i].second;
if (xn < 0 || xn >= n || yn < 0 || yn >= m) continue;
if (G[xn][yn] == '.' && possible_route(xn, yn) <= 1) {
G[xn][yn] = '+';
dfs(xn, yn);
}
}
}
void solve() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> G[i];
int j = G[i].find('L');
if (j != -1) sx = i, sy = j;
}
dfs(sx, sy);
for (int i = 0; i < n; i++) cout << G[i] << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int t;
cin >> t;
while (t--) solve();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int from_char(const char c) {
stringstream ss;
ss << c;
int x;
ss >> x;
return x;
}
char from_int(const int x) {
stringstream ss;
ss << x;
char c;
ss >> c;
return c;
}
struct pt {
int x, y;
};
struct d {};
void prin_vector(vector<int> a) {
for (int i = 0; i < a.size(); ++i) {
cout << a[i] << " ";
}
}
void print_matr(vector<vector<int> > q) {
for (int i = 0; i < q.size(); ++i) {
for (int j = 0; j < q[i].size(); ++j) {
cout << q[i][j] << " ";
}
cout << endl;
}
}
void consider_vector(vector<int> a) {
for (int i = 0; i < a.size(); ++i) {
cin >> a[i];
}
}
void consider_matr(vector<vector<int> > q) {
for (int i = 0; i < q.size(); ++i) {
for (int j = 0; j < q[i].size(); ++j) {
cin >> q[i][j];
}
}
}
double dl(pt a, pt b) {
return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}
int main() {
long long n, m;
cin >> n >> m;
vector<long long> v(n);
vector<long long> d(n);
for (int i = 0; i < n; ++i) {
cin >> v[i];
}
for (int i = 0; i < n; ++i) {
d[i] = v[i];
}
sort(v.begin(), v.end());
if (m > 1) {
if (m == 2) {
cout << max(d[0], d[n - 1]);
} else {
cout << v[n - 1];
}
} else {
cout << v[0];
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6;
const int MAXT = 2e9;
const int MAXA = 2e3;
int N;
long long A, B, T;
char s[MAXN];
int sum[MAXN];
bool is_good(int v) {
for (int l = 0; l < v; l++) {
int r = v - l;
assert(r > 0);
long long t =
min(l, r - 1) * A + (v - 1) * A + sum[r] - sum[0] + sum[N] - sum[N - l];
if (t <= T) return true;
}
return false;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> N;
cin >> A >> B >> T >> s;
sum[0] = 0;
for (int i = 0; i < N; i++) {
sum[i + 1] = sum[i] + (s[i] == 'w') * B + 1;
}
int mi = 0;
int ma = N + 1;
while (ma - mi > 1) {
int md = (mi + ma) / 2;
if (is_good(md))
mi = md;
else
ma = md;
}
cout << mi << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using db = long double;
using pll = pair<long long, long long>;
std::set<long long> g[27];
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t, i, x, j, y, z, k, n;
set<long long> let;
long long tt;
cin >> tt;
for (long long _tt = 0; _tt < tt; _tt++) {
string s;
cin >> s;
n = s.size();
for (auto zx : s) {
let.insert(zx - 'a');
}
for (i = 1; i < n; i += 1) {
j = s[i - 1] - 'a';
k = s[i] - 'a';
g[j].insert(k);
}
}
string ans = "";
bool br = false;
long long used[27];
for (i = 0; i < 27; i += 1) used[i] = 0;
for (auto zx : let) {
if (g[zx].size() > 1) br = true;
}
for (auto zx : let) {
bool f = false;
for (i = 0; i < 27; i += 1) {
if (g[i].count(zx) > 0) f = true;
}
if (f || used[zx]) continue;
i = zx;
used[i] = 1;
ans += char('a' + i);
while (g[i].size()) {
i = *g[i].begin();
if (used[i]) {
br = true;
break;
}
used[i] = 1;
ans += char('a' + i);
}
}
for (auto zx : ans) {
let.erase(zx - 'a');
}
if (let.size() || br || ans.size() == 0) ans = "NO";
cout << ans << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2019, Mod = 998244353;
int n, p, q, P[N], R[N], dp[N], scc[N], C[N][N];
inline int Power(int a, int b) {
int ret = 1;
for (; b; b >>= 1, a = 1ll * a * a % Mod)
if (b & 1) ret = 1ll * ret * a % Mod;
return (ret);
}
int main() {
scanf("%d%d%d", &n, &p, &q);
p = 1ll * p * Power(q, Mod - 2) % Mod;
for (int i = P[0] = 1; i < N; i++) P[i] = 1ll * P[i - 1] * p % Mod;
for (int i = R[0] = 1; i < N; i++)
R[i] = 1ll * R[i - 1] * (Mod + 1 - p) % Mod;
for (int i = 0; i < N; i++)
for (int j = C[i][0] = 1; j <= i; j++)
C[i][j] =
(1ll * C[i - 1][j] * R[j] + 1ll * C[i - 1][j - 1] * P[i - j]) % Mod;
scc[0] = scc[1] = 1;
for (int i = 2; i < N; i++) {
for (int j = 1; j < i; j++)
scc[i] = (scc[i] + 1ll * scc[j] * C[i][j]) % Mod;
scc[i] = (1 - scc[i] + Mod) % Mod;
}
dp[0] = dp[1] = 0;
for (int i = 2; i < N; i++) {
dp[i] = i * (i - 1) / 2;
for (int j = 1; j < i; j++)
dp[i] = (dp[i] + 1ll * scc[j] * C[i][j] % Mod *
(1ll * dp[j] + dp[i - j] -
(i - j) * (i - j - 1) / 2 + Mod)) %
Mod;
dp[i] = 1ll * dp[i] * Power((1 - scc[i] + Mod) % Mod, Mod - 2) % Mod;
}
printf("%d", dp[n]);
return (0);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
vector<long long> a;
int sum = 0;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
a.push_back(x);
sum += x;
}
long long odd = 0, even = 0;
for (int i = 0; i < n; i++) {
if (a[i] % 2) {
odd++;
} else {
even++;
}
}
if ((odd == n || even == n) && sum % 2 == 0) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long long suffix[N], prefix[N];
long long a[N];
long long L[N];
void solved() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = n; i >= 1; i--) suffix[i] = gcd(suffix[i + 1], a[i]);
long long ans = 0;
for (int i = 1; i <= n; i++) ans = gcd(ans, lcm(suffix[i + 1], a[i]));
cout << ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) solved();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
const long long INF = 9e18;
int main(void) {
int i, j;
int n, m;
int t;
scanf("%d", &t);
while (t--) {
long long p;
int q;
scanf("%lld%d", &p, &q);
long long backup = p;
if (p % q != 0) {
printf("%lld\n", p);
continue;
}
map<int, int> fq;
for (i = 2; i * i <= q; i++) {
while (q % i == 0) {
fq[i]++;
q /= i;
}
}
if (q != 1) fq[q]++;
long long res = INF;
for (auto it : fq) {
int temp = 0;
while (p % it.first == 0) {
temp++;
p /= it.first;
}
res = min(res, (long long)pow(it.first, (temp - it.second + 1)));
}
printf("%lld\n", backup / res);
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long t1, t2, x1, x2, t0;
int main() {
long long i;
while (cin >> t1 >> t2 >> x1 >> x2 >> t0) {
if (t2 == t0 && t0 != t1) {
cout << "0"
<< " " << x2 << endl;
continue;
}
if (t2 != t0 && t0 == t1) {
cout << x1 << " "
<< "0" << endl;
continue;
}
if (t2 == t0 && t0 == t1) {
cout << x1 << " " << x2 << endl;
continue;
}
long long y1, y2;
double tt = 99999999;
long long tmp;
for (i = 0; i <= x1; i++) {
if (i == 0)
tmp = x2;
else {
tmp = i * (t0 - t1);
if (tmp % (t2 - t0) != 0)
tmp = (tmp / (t2 - t0)) + 1;
else
tmp = (tmp / (t2 - t0));
if (tmp > x2 || tmp < 0) continue;
if (tmp < 0)
while (1)
;
}
double t;
t = (tmp * 1.0 * t2 * 1.0 + i * 1.0 * t1 * 1.0) * 1.0 /
(i * 1.0 + tmp * 1.0);
if (t >= t0 * 1.0 && t < tt) {
y1 = i, y2 = tmp;
tt = t;
} else if (t >= t0 * 1.0 && fabs(t - tt) < 1e-20) {
if (i + tmp > y1 + y2) {
y1 = i, y2 = tmp;
tt = t;
}
}
}
cout << y1 << " " << y2 << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n;
cin >> n;
if (n == 1)
cout << 1 << endl;
else if (n == 2)
cout << 2 << endl;
else if (n == 3)
cout << 6 << endl;
else if (n == 4)
cout << 12 << endl;
else if (n % 2)
cout << n * (n - 1) * (n - 2) << endl;
else if (!(n % 2) && !(n % 3))
cout << (n - 1) * (n - 2) * (n - 3) << endl;
else
cout << n * (n - 1) * (n - 3) << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n[2000];
int main() {
float n;
int maxa = 0;
int maxa2 = 0;
int frr, tott;
cin >> n;
int s;
int u;
int y, m;
map<int, int> fr;
pair<int, int> ca;
map<int, int> ot;
map<int, int> tot;
for (int i = 0; i < n; i++) {
cin >> s;
fr[s] += 1;
tot[s]++;
if (tot[s] > maxa) {
maxa = tot[s];
tott = s;
}
if (fr[s] > maxa2) {
maxa2 = fr[s];
frr = s;
}
maxa2 = max(fr[s], maxa2);
cin >> u;
if (s == u) continue;
ot[u] += 1;
tot[u]++;
if (tot[u] > maxa) {
maxa = tot[u];
tott = u;
}
}
if (fr[frr] >= n / 2) {
cout << 0;
return 0;
}
if (fr[frr] + ot[frr] >= ceil(n / 2)) {
cout << ceil(n / 2) - fr[frr];
return 0;
} else if (tot[tott] >= ceil(n / 2)) {
cout << ceil(n / 2) - fr[tott];
return 0;
} else {
cout << -1;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1 << 20;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
string s;
cin >> s;
long long ans = 0;
std::stack<char> v;
long long n = s.size();
long long yo = 0;
for (long long int i = 0; i < n; i++) {
if (s[i] == '[' || s[i] == '(' || s[i] == '{' || s[i] == '<')
yo++;
else
yo--;
}
if (yo != 0) return cout << "Impossible\n", 0;
for (long long int i = 0; i < n; i++) {
if (s[i] == '[' || s[i] == '(' || s[i] == '{' || s[i] == '<')
v.push(s[i]);
else {
if (v.empty()) return cout << "Impossible\n", 0;
char x = v.top();
if (s[i] == ']') {
if (x != '[') ans++;
v.pop();
} else if (s[i] == '>') {
if (x != '<') ans++;
v.pop();
} else if (s[i] == ')') {
if (x != '(') ans++;
v.pop();
} else if (s[i] == '}') {
if (x != '{') ans++;
v.pop();
}
}
}
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
string direc = "RDLU";
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "YES" : "NO");
exit(0);
}
void addmod(int &x, int y, int mod = 1000000007) {
assert(y >= 0);
x += y;
if (x >= mod) x -= mod;
assert(x >= 0 && x < mod);
}
void et() {
puts("-1");
exit(0);
}
long long fastPow(long long x, long long y, int mod = 1000000007) {
long long ans = 1;
while (y > 0) {
if (y & 1) ans = (x * ans) % mod;
x = x * x % mod;
y >>= 1;
}
return ans;
}
vector<int> vp;
void dec(int k) {
int j = 0;
while (k > 0) {
int it = upper_bound(vp.begin(), vp.end(), k) - vp.begin();
it--;
k -= vp[it];
char x = 'a' + j;
j++;
for (int(z) = 0; (z) < (int)(it + 2); (z)++) printf("%c", x);
}
printf("z");
puts("");
}
void fmain(int tid) {
for (int(i) = 1; (i) <= (int)(1500); (i)++) {
vp.push_back(i * (i + 1) / 2);
}
scanf("%d", &k);
dec(k);
}
int main() {
int t = 1;
for (int(i) = 1; (i) <= (int)(t); (i)++) {
fmain(i);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma warning(disable : 4786)
#pragma warning(disable : 4996)
template <class T>
inline T bigmod(T p, T e, T M) {
long long ret = 1LL;
for (; e > 0LL; e >>= 1LL) {
if (e & 1LL) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
int a[n], b[n];
bool bl[n];
memset(bl, 0, sizeof bl);
map<int, int> m;
for (int i = 0; i < n; i++) {
cin >> a[i];
m[a[i]] = i + 1;
}
for (int i = 0; i < n; i++) {
cin >> b[i];
}
int mx = 0;
int count = 0;
for (int i = 0; i < n; i++) {
if (m[b[i]] > mx) {
cout << m[b[i]] - mx << " ";
mx = m[b[i]];
} else {
cout << 0 << " ";
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e6 + 7;
const int inf = (int)1e9 + 7;
int n, k;
vector<int> gr[N];
int h[N], used[N];
int lca[21][N];
void dfs(int v, int pr) {
lca[0][v] = pr;
for (int i = 1; i <= 20; i++) {
lca[i][v] = lca[i - 1][lca[i - 1][v]];
}
for (int to : gr[v]) {
if (to == pr) continue;
h[to] = h[v] + 1;
dfs(to, v);
}
}
int getup(int v) {
for (int i = 20; i >= 0; i--) {
if (!used[lca[i][v]]) {
v = lca[i][v];
}
}
return lca[0][v];
}
int main() {
scanf("%d %d", &n, &k);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d %d", &u, &v);
gr[u].push_back(v);
gr[v].push_back(u);
}
used[n] = 1;
dfs(n, n);
int cnt = 1;
for (int i = n; i >= 1; i--) {
if (used[i]) continue;
int g = getup(i);
if (h[i] - h[g] + cnt + k <= n) {
int v = i;
while (!used[v]) {
used[v] = 1;
v = lca[0][v];
cnt++;
}
}
}
for (int i = 1; i <= n; i++) {
if (!used[i]) {
cout << i << ' ';
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long int powmod(long long int a, long long int b) {
if (b == 0) return 1;
long long int x = powmod(a, b / 2);
long long int y = (x * x) % 1000000007;
if (b % 2) return (a * y) % 1000000007;
return y % 1000000007;
}
int level[100010];
int ptr;
int subsize[100010];
int dp[100010][23];
vector<int> g[100010], c[100010];
set<int> ans;
vector<int> tree[4 * 100010];
int basearray[100010];
int chainindex[100010];
int chainhead[100010], chainno, posinbase[100010];
void build(int node, int start, int end) {
if (start == end) {
for (int i = 0; i < (int)(c[basearray[start]].size()); i++)
tree[node].push_back(c[basearray[start]][i]);
sort((tree[node]).begin(), (tree[node]).end());
if ((int)(tree[node].size()) > 10) tree[node].resize(10);
return;
}
int mid = (start + end) / 2;
build(2 * node, start, mid);
build(2 * node + 1, mid + 1, end);
for (int i = 0; i < (int)(tree[2 * node].size()); i++)
tree[node].push_back(tree[2 * node][i]);
for (int i = 0; i < (int)(tree[2 * node + 1].size()); i++)
tree[node].push_back(tree[2 * node + 1][i]);
sort((tree[node]).begin(), (tree[node]).end());
if ((int)(tree[node].size()) > 10) tree[node].resize(10);
}
void query_tree(int node, int start, int end, int l, int r) {
if (start > r || end < l) return;
if (start >= l && end <= r) {
for (int i = 0; i < (int)(tree[node].size()); i++)
ans.insert(tree[node][i]);
return;
}
int mid = (start + end) / 2;
query_tree(2 * node, start, mid, l, r);
query_tree(2 * node + 1, mid + 1, end, l, r);
}
int lca(int p, int q) {
if (level[p] < level[q]) swap(p, q);
int lg;
for (lg = 1; (1 << lg) <= level[p]; lg++)
;
lg--;
for (int i = lg; i >= 0; i--) {
if (level[p] - (1 << i) >= level[q]) p = dp[p][i];
}
if (p == q) return p;
for (int i = lg; i >= 0; i--) {
if (dp[p][i] != -1 && dp[p][i] != dp[q][i]) {
p = dp[p][i];
q = dp[q][i];
}
}
return dp[p][0];
}
void dfs(int u, int d, int par) {
level[u] = d;
subsize[u] = 1;
dp[u][0] = par;
for (int v : g[u]) {
if (v != par) {
dfs(v, d + 1, u);
subsize[u] += subsize[v];
}
}
}
void HLD(int curr, int prev) {
if (chainhead[chainno] == -1) chainhead[chainno] = curr;
chainindex[curr] = chainno;
posinbase[curr] = ptr;
basearray[ptr] = curr;
ptr++;
int sc = -1;
for (int v : g[curr]) {
if (v != prev) {
if (sc == -1 || subsize[v] > subsize[sc]) sc = v;
}
}
if (sc != -1) HLD(sc, curr);
for (int v : g[curr]) {
if (v != prev) {
if (sc != v) {
chainno++;
HLD(v, curr);
}
}
}
}
void query_up(int u, int v) {
if (level[u] < level[v]) swap(u, v);
while (chainindex[u] != chainindex[v]) {
query_tree(1, 0, ptr - 1, posinbase[chainhead[chainindex[u]]],
posinbase[u]);
u = dp[chainhead[chainindex[u]]][0];
}
query_tree(1, 0, ptr - 1, posinbase[v], posinbase[u]);
return;
}
void query(int u, int v, int a) {
int l = lca(u, v);
query_up(u, l);
query_up(v, l);
printf("%d ", min((int)(ans.size()), a));
int tot = min((int)(ans.size()), a);
for (int it : ans) {
if (tot == 0) break;
tot--;
printf("%d ", it + 1);
}
printf("\n");
ans.clear();
}
int main() {
int n, m, q;
scanf("%d", &n), scanf("%d", &m), scanf("%d", &q);
memset(dp, -1, sizeof(dp));
memset(chainhead, -1, sizeof(chainhead));
for (int i = 0; i < n - 1; i++) {
int u, v;
scanf("%d", &u);
scanf("%d", &v);
u--, v--;
g[u].push_back(v);
g[v].push_back(u);
}
for (int i = 0; i < m; i++) {
int x;
scanf("%d", &x);
x--;
c[x].push_back(i);
}
dfs(0, 0, -1);
for (int j = 1; j < 21; j++) {
for (int i = 0; i < n; i++) {
if (dp[i][j - 1] != -1) dp[i][j] = dp[dp[i][j - 1]][j - 1];
}
}
chainno = 0;
HLD(0, -1);
build(1, 0, ptr - 1);
while (q--) {
int u, v, a;
scanf("%d", &u), scanf("%d", &v), scanf("%d", &a);
u--, v--;
query(u, v, a);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int ch2(int n) {
int ans = 0;
while (n) {
ans += n % 10;
n /= 10;
}
return ans;
}
int ch1(int n) {
int ans = 0;
int flag = 0;
int sq = n;
for (int i = 2; i <= sq; i++) {
if (n % i == 0 && sq / i != 1) {
flag = 1;
n /= i;
ans += ch2(i);
if (i != 1) i--;
}
}
return ans;
}
int a[33];
int n;
int main() {
int cnt = 0;
for (int i = 2; i <= 1000; i++) {
if (ch1(i) == ch2(i)) a[++cnt] = i;
if (cnt == 30) break;
}
cin >> n;
cout << a[n] << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int M4 = 1e4 + 100, M5 = 1e5 + 100, M6 = 1e6 + 100, M7 = 1e7 + 100,
M8 = 1e8 + 100, M9 = 1e9 + 100;
int a[M5], f[M5], ans;
stack<int> s;
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", a + i);
f[0] = -1;
s.push(0);
for (int i = 1; i < n; i++) {
while ((int)(s).size() > 0 && a[s.top()] < a[i]) {
f[i] = max(f[i], f[s.top()] + 1);
s.pop();
}
if ((int)(s).size() == 0) f[i] = -1;
s.push(i);
ans = max(ans, f[i] + 1);
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int nmax = 1e6;
int n;
bool f[nmax + 1], out[nmax + 1];
vector<int> sol;
vector<int> intra[nmax + 1], ies[nmax + 1];
void solve(int nod) {
if (nod == n + 1) return;
if (out[nod] == 1) {
solve(nod + 1);
return;
}
for (auto i : ies[nod]) out[i] = 1;
solve(nod + 1);
int ok = 0;
for (auto i : intra[nod]) ok |= f[i];
if (ok == 0) {
f[nod] = 1;
sol.push_back(nod);
}
}
int main() {
int m;
fscanf(stdin, "%d%d", &n, &m);
for (int i = 1; i <= m; ++i) {
int x, y;
fscanf(stdin, "%d%d", &x, &y);
ies[x].push_back(y);
intra[y].push_back(x);
}
solve(1);
fprintf(stdout, "%d\n", (int)sol.size());
for (auto i : sol) fprintf(stdout, "%d ", i);
fprintf(stdout, "\n");
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int n, nx, ny, tot, a[N];
int x[N], y[N], xx[N], yy[N], t[N];
int use[N], ord[N], sum[N];
int rt[N], tree[N * 40], ch[N * 40][2];
map<int, int> Mpx, Mpy;
pair<int, int> tmp[N];
void Discre() {
for (int i = 1; i <= n; i++) xx[i] = x[i], yy[i] = y[i];
sort(xx + 1, xx + n + 1);
sort(yy + 1, yy + n + 1);
nx = unique(xx + 1, xx + n + 1) - xx - 1;
ny = unique(yy + 1, yy + n + 1) - yy - 1;
for (int i = 1; i <= nx; i++) Mpx[xx[i]] = i;
for (int i = 1; i <= ny; i++) Mpy[yy[i]] = i;
for (int i = 1; i <= n; i++) x[i] = Mpx[x[i]];
for (int i = 1; i <= n; i++) y[i] = Mpy[y[i]];
for (int i = 1; i <= n; i++) tmp[i] = make_pair(x[i], y[i]);
sort(tmp + 1, tmp + n + 1);
for (int i = 1; i <= n; i++) x[i] = tmp[i].first, y[i] = tmp[i].second;
int now = 1;
for (int i = 1; i <= n; i++) {
if (x[i] == now)
sum[x[i]]++;
else
sum[now + 1] = sum[now], now++, i--;
}
}
int Updata(int las, int l, int r, int pos) {
int now = ++tot;
if (l == r) {
tree[now] = tree[las] + 1;
return now;
}
int mid = (l + r) >> 1;
if (mid >= pos)
ch[now][1] = ch[las][1], ch[now][0] = Updata(ch[las][0], l, mid, pos);
else
ch[now][0] = ch[las][0], ch[now][1] = Updata(ch[las][1], mid + 1, r, pos);
tree[now] = tree[ch[now][0]] + tree[ch[now][1]];
return now;
}
int Query(int x, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) return tree[x];
int mid = (l + r) >> 1, ans = 0;
if (mid >= ql) ans += Query(ch[x][0], l, mid, ql, qr);
if (mid < qr) ans += Query(ch[x][1], mid + 1, r, ql, qr);
return ans;
}
int Find(int x, int l, int r, int val) {
if (l == r) {
if (tree[x] == val)
return l;
else
return -1;
}
int mid = (l + r) >> 1;
if (tree[ch[x][0]] >= val)
return Find(ch[x][0], l, mid, val);
else
return Find(ch[x][1], mid + 1, r, val - tree[ch[x][0]]);
}
void check() {
int s1 = 0, s2 = 0, s3, s4, s5, s6;
for (int i = 1; i <= 6; i++) {
if (i <= 3)
s1 += a[ord[i]], s2 += a[ord[i]];
else
s2 += a[ord[i]];
}
int x1 = lower_bound(sum + 1, sum + nx + 1, s1) - sum;
int x2 = lower_bound(sum + 1, sum + nx + 1, s2) - sum;
if (sum[x1] != s1 || sum[x2] != s2) return;
s1 = a[ord[1]] + a[ord[4]] + a[ord[7]];
s2 = s1 + a[ord[2]] + a[ord[5]] + a[ord[8]];
int y1 = Find(rt[nx], 1, ny, s1);
if (y1 == -1) return;
int y2 = Find(rt[nx], 1, ny, s2);
if (y2 == -1) return;
s3 = Query(rt[x1], 1, ny, 1, y1);
if (s3 != a[ord[1]]) return;
s4 = Query(rt[x2], 1, ny, 1, y1);
if (s4 != a[ord[1]] + a[ord[4]]) return;
s5 = Query(rt[x1], 1, ny, 1, y2);
if (s5 != s3 + a[ord[2]]) return;
s6 = Query(rt[x2], 1, ny, 1, y2);
if (s6 != s4 + a[ord[2]] + a[ord[5]]) return;
printf("%.9lf %.9lf\n%.9lf %.9lf", 0.5 + xx[x1], 0.5 + xx[x2], 0.5 + yy[y1],
0.5 + yy[y2]);
exit(0);
}
void dfs(int x) {
if (x == 10) return check();
for (int i = 1; i <= 9; i++) {
if (use[i]) continue;
use[i] = 1;
ord[x] = i;
dfs(x + 1);
use[i] = 0;
ord[x] = 0;
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d%d", &x[i], &y[i]);
for (int i = 1; i <= 9; i++) scanf("%d", &a[i]);
Discre();
for (int i = 1; i <= n; i++) {
if (x[i] != x[i - 1])
rt[x[i]] = Updata(rt[x[i - 1]], 1, ny, y[i]);
else
rt[x[i]] = Updata(rt[x[i]], 1, ny, y[i]);
}
dfs(1);
puts("-1");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long double e = 2.7182818284590452353602874713527;
long long int n;
long long int x[105], y[105];
long long int k, m;
long double dp[105][105];
bool done[105][105];
long long int dist(long long int i, long long int j) {
return (x[i] - x[j]) * (x[i] - x[j]) + (y[i] - y[j]) * (y[i] - y[j]);
}
long double rec(long long int i, long long int j, long double x) {
if (i > n) {
if (j >= k) return 1000.0000;
return 0;
}
if (done[i][j]) return dp[i][j];
done[i][j] = 1;
long double an = 0;
if ((long double)(dist(i, 0)) <= x * x) {
an = max(rec(i + 1, j + 1, x), an);
} else {
long double d = 0;
if (x > 0)
d = exp((long double)(1.000000000) - (long double)(dist(i, 0)) / (x * x));
else
d = 0;
an = rec(i + 1, j + 1, x) * d + rec(i + 1, j, x) * ((long double)(1 - d));
}
return dp[i][j] = an;
}
bool check(long double x) {
memset(done, 0, sizeof done);
long double d = rec(1, 0, x);
return (d >= 1000 - m);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
cin >> k >> m;
for (int i = 0; i <= n; i++) cin >> x[i] >> y[i];
long double l = 0, r = 1e7;
long double mid = (l + r) / 2.0000000000;
for (int i = 1; i <= 50; i++) {
if (check(mid))
r = mid;
else
l = mid;
mid = (l + r) / 2.0000000000;
}
cout << fixed << setprecision(10) << mid << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
struct Point {
double x, y;
Point operator-(const Point &t) const { return {x - t.x, y - t.y}; }
double operator*(const Point &t) const { return x * t.y - y * t.x; }
bool operator<(const Point &t) const { return x == t.x ? y < t.y : x < t.x; }
};
long long q, m, j, k, a, b;
set<Point> s;
void insert(double x, double y) {
Point p = {x, y};
if (s.count(p)) return;
auto cur = s.lower_bound({x, 0});
auto pre = cur;
pre--;
if (cur != s.end() && (p - *pre) * (*cur - p) <= 0) return;
s.insert(p);
pre = s.lower_bound(p), pre--;
auto ppre = pre;
ppre--;
while (pre != s.begin() && (*pre - *ppre) * (p - *pre) <= 0)
s.erase(pre), pre = ppre, ppre--;
}
bool check(double x, double y) {
Point p = {x, y};
auto cur = s.lower_bound({x, 0});
if (cur == s.end()) return printf("NO\n"), false;
auto pre = cur;
pre--;
if ((*cur - *pre) * (p - *pre) > -eps) return printf("YES\n"), true;
return printf("NO\n"), false;
}
int main() {
s.insert({0, 0});
scanf("%I64d%I64d", &q, &m);
for (long long i = 1; i <= q; i++) {
scanf("%I64d%I64d%I64d", &k, &a, &b);
a = (a + j) % 1000000 + 1, b = (b + j) % 1000000 + 1;
if (k == 1) insert(1.0 * a, 1.0 * b);
if (k == 2)
if (check(1.0 * b / a, 1.0 * m / a)) j = i;
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const long long int mod = (long long int)(1e9 + 7);
long long int test = 1;
vector<long long int> read(int n) {
vector<long long int> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
return v;
}
void solve() {
long long int i, j, k, n, t, m, cnt = 0, ans = 0, sum = 0;
long long int cl, ce, v;
cin >> n >> m >> cl >> ce >> v;
vector<long long int> st(cl);
for (auto &it : st) {
cin >> it;
}
vector<long long int> el = read(ce);
long long int q;
cin >> q;
while (q--) {
long long int x, y, x1, y1;
cin >> x >> y >> x1 >> y1;
if (x == x1) {
cout << abs(y - y1) << "\n";
continue;
}
swap(x, y);
swap(x1, y1);
ans = INT_MAX;
if (el.size()) {
auto ele = lower_bound(el.begin(), el.end(), x) - el.begin();
if (ele != el.size()) {
long long int dy = abs(y - y1) / v + (abs(y - y1) % v ? 1 : 0);
long long int dx = abs(el[ele] - x);
dx += abs(el[ele] - x1);
ans = min(ans, dx + dy);
}
if (ele != 0) {
ele--;
long long int dy = abs(y - y1) / v + (abs(y - y1) % v ? 1 : 0);
long long int dx = abs(el[ele] - x);
dx += abs(el[ele] - x1);
ans = min(ans, dx + dy);
}
}
if (st.size()) {
auto sta = lower_bound(st.begin(), st.end(), x) - st.begin();
if (sta != st.size()) {
long long int dy = abs(y - y1);
long long int dx = abs(st[sta] - x);
dx += abs(st[sta] - x1);
ans = min(ans, dx + dy);
}
if (sta != 0) {
sta--;
long long int dy = abs(y - y1);
long long int dx = abs(st[sta] - x);
dx += abs(st[sta] - x1);
ans = min(ans, dx + dy);
}
}
cout << ans << "\n";
}
test++;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int i = 1;
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool isPowerOfTwo(long long x) { return x && (!(x & (x - 1))); }
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
bool flag = false, after = false;
long long x;
cin >> x;
vector<long long> left;
while (x != 0) {
left.push_back(x % 10);
x /= 10;
}
long long i = 0, j = left.size() - 1;
while (i < j) {
if (left.at(i) == left.at(j)) {
after = true;
i++;
j--;
} else if (left.at(i) != left.at(j) && !after) {
if (left.at(i) == 0)
i++;
else if (left.at(j) == 0) {
j--;
after = true;
} else
flag = true;
} else
flag = true;
if (flag) break;
}
if (flag)
cout << "NO";
else
cout << "YES";
cout << endl;
}
| 0 |
#include <bits/stdc++.h>
const int N = 10005, mo = 998244353;
int n, a[N], la[30], ne[N], w[N], r, g[30], gs, ma, an, ans;
char cc[N], ch;
int main() {
for (; (ch = getchar()) <= 'z' && ch >= 'a';)
cc[++n] = ch - 'a', ne[n] = la[cc[n]], la[cc[n]] = n;
for (int i = n + 1, E = n + n; i <= E; i++) cc[i] = cc[i - n];
for (int i = 0, E = 25; i <= E; i++) {
ma = r = 0;
for (int j = la[i]; j; j = ne[j]) w[++r] = j;
for (int k = 1, E = n - 1; k <= E; k++) {
memset(g, 0, sizeof g);
gs = 0;
for (int j = 1, E = r; j <= E; j++) g[cc[w[j] + k]]++;
for (int j = 0, E = 25; j <= E; j++)
if (g[j] == 1) gs++;
ma = (gs > ma ? gs : ma);
}
an += ma;
}
printf("%.10lf", (double)an / n);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n];
int s = 1000000;
int sum = 0;
for (int x = 0; x < n; x++) {
cin >> arr[x];
if (s > arr[x]) s = arr[x];
sum += arr[x];
}
int g = 0;
int res = sum;
int cur = 0;
for (int x = 0; x < n; x++) {
for (int y = 1; y <= arr[x]; y++) {
if (arr[x] % y == 0) {
cur = sum - arr[x] - s;
cur += (arr[x] / y) + s * y;
res = min(cur, res);
}
}
}
cout << res;
}
| 2 |
#include <bits/stdc++.h>
using i64 = long long;
struct node {
int ans;
i64 adv;
node(int ans = -1, i64 adv = 0) : ans(ans), adv(adv) {}
node operator+(const node b) const { return node(ans + b.ans, adv + b.adv); }
node operator+() const { return node(ans + (adv > 0)); }
bool operator<(const node b) const {
if (ans == b.ans) {
return adv < b.adv;
}
return ans < b.ans;
}
};
std::vector<node> merge(std::vector<node> &a, std::vector<node> &b) {
std::vector<node> res(a.size() + b.size());
for (int i = 0; i < int(a.size()); i++) {
for (int j = 0; j < int(b.size()); j++) {
res[i + j] = std::max(res[i + j], a[i] + b[j]);
res[i + j + 1] = std::max(res[i + j + 1], a[i] + +b[j]);
}
}
return res;
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
int t;
std::cin >> t;
while (t--) {
int n, m;
std::cin >> n >> m;
std::vector<int> a(n), b(n);
for (int i = 0; i < n; i++) {
std::cin >> a[i];
}
for (int i = 0; i < n; i++) {
std::cin >> b[i];
}
std::vector<std::vector<int>> e(n);
for (int i = 0; i < n - 1; i++) {
int u, v;
std::cin >> u >> v;
u--;
v--;
e[u].push_back(v);
e[v].push_back(u);
}
std::vector<std::vector<node>> dp(n, std::vector<node>(1, node(0)));
std::function<void(int, int)> dfs = [&](int u, int p) {
dp[u][0] = node(0, -a[u] + b[u]);
for (auto v : e[u]) {
if (v != p) {
dfs(v, u);
dp[u] = merge(dp[u], dp[v]);
}
}
};
dfs(0, -1);
assert(dp[0].size() == n);
std::cout << (+dp[0][m - 1]).ans << "\n";
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename elemType>
inline void Read(elemType &T) {
elemType X = 0, w = 0;
char ch = 0;
while (!isdigit(ch)) {
w |= ch == '-';
ch = getchar();
}
while (isdigit(ch)) X = (X << 3) + (X << 1) + (ch ^ 48), ch = getchar();
T = (w ? -X : X);
}
struct Graph {
struct edge {
int Next, to, c;
};
edge G[400010];
int head[20010];
int cnt;
Graph() : cnt(2) {}
void clear(int node_num = 0) {
cnt = 2;
if (node_num == 0)
memset(head, 0, sizeof(head));
else
fill(head, head + node_num + 5, 0);
}
void add_edge(int u, int v, int c) {
G[cnt].c = c;
G[cnt].to = v;
G[cnt].Next = head[u];
head[u] = cnt++;
}
};
Graph G;
vector<tuple<int, int, int> > vec;
const int INF = 1 << 29;
int Deep[20005];
int current[20005];
int Num[20005];
int Pre[20005];
int N, M, S, T, n;
void ISAP_BFS(int t) {
queue<int> Q;
for (int i = 1; i <= N; i++) Deep[i] = N;
Deep[t] = 0;
Q.push(t);
while (!Q.empty()) {
int now = Q.front();
Q.pop();
for (int i = G.head[now]; i; i = G.G[i].Next) {
if (G.G[i ^ 1].c && Deep[G.G[i].to] > Deep[now] + 1) {
Deep[G.G[i].to] = Deep[now] + 1;
Q.push(G.G[i].to);
}
}
}
return;
}
int Add_Flow() {
int Res = INF, x = T;
while (x != S) {
x = Pre[x];
Res = min(Res, G.G[current[x]].c);
}
x = T;
while (x != S) {
x = Pre[x];
G.G[current[x]].c -= Res;
G.G[current[x] ^ 1].c += Res;
}
return Res;
}
int ISAP() {
memset(Num, 0, sizeof(Num));
int now = S, MaxFlow = 0;
ISAP_BFS(T);
for (int i = 1; i <= N; i++) {
++Num[Deep[i]];
current[i] = G.head[i];
}
while (Deep[S] < N) {
if (now == T) {
MaxFlow += Add_Flow();
now = S;
}
bool has_find = false;
for (int i = current[now]; i; i = G.G[i].Next) {
if (Deep[now] != Deep[G.G[i].to] + 1 || G.G[i].c == 0) continue;
has_find = true;
current[now] = i;
Pre[G.G[i].to] = now;
now = G.G[i].to;
break;
}
if (!has_find) {
int minn = N - 1;
for (int i = G.head[now]; i; i = G.G[i].Next)
if (G.G[i].c) minn = min(minn, Deep[G.G[i].to]);
if ((--Num[Deep[now]]) == 0) break;
Num[Deep[now] = minn + 1]++;
current[now] = G.head[now];
if (now != S) now = Pre[now];
}
}
return MaxFlow;
}
bool Judge(int limit) {
G.clear();
for (auto e : vec) {
int u = get<0>(e), v = get<1>(e), w = get<2>(e);
if (w > limit) continue;
G.add_edge(u, v, 1);
G.add_edge(v, u, 0);
}
for (int i = 1; i <= n; ++i) {
G.add_edge(S, i, 1);
G.add_edge(i, S, 0);
G.add_edge(i + n, T, 1);
G.add_edge(T, i + n, 0);
}
if (ISAP() == n) return true;
return false;
}
int Solve(int L, int R) {
int Res = 0;
while (L <= R) {
int mid = (L + R) >> 1;
if (Judge(mid)) {
Res = mid;
R = mid - 1;
} else
L = mid + 1;
}
return Res;
}
int main() {
Read(n);
Read(M);
N = n << 1;
int Mi = 1 << 30, Mx = 0;
for (register int i = 1; i <= M; ++i) {
int u, v, w;
Read(u);
Read(v);
Read(w);
vec.push_back(make_tuple(u, v + n, w));
Mi = min(Mi, w);
Mx = max(Mx, w);
}
S = N + 1;
T = N + 2;
N += 2;
if (!Judge(1 << 30)) {
printf("-1\n");
return 0;
}
printf("%d\n", Solve(Mi, Mx));
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, a, j;
cin >> n;
for (i = 0; i < n; i++) {
cin >> a;
cout << a << endl;
for (j = 1; j <= a; j++) {
cout << j << " ";
}
cout << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
char s[200010], t[200010];
double s1[200010][26], s2[200010][26];
double ans = 0.0;
int main() {
scanf("%d\n", &n);
memset(s1, 0, sizeof(s1));
memset(s2, 0, sizeof(s2));
for (int i = 1; i <= n; i++) {
scanf("%c", &s[i]);
for (int c = 0; c < 26; c++) s1[i][c] = s1[i - 1][c];
s1[i][s[i] - 'A'] += i;
}
scanf("\n");
for (int i = 1; i <= n; i++) {
scanf("%c", &t[i]);
for (int c = 0; c < 26; c++) s2[i][c] = s2[i - 1][c];
s2[i][t[i] - 'A'] += i;
}
scanf("\n");
double total = 0.0;
for (int i = 1; i <= n; i++) {
total += 1.0 * i * i;
ans += 1.0 * (s2[i - 1][s[i] - 'A']) * (n - i + 1);
ans += 1.0 * (s1[i - 1][t[i] - 'A']) * (n - i + 1);
if (t[i] == s[i]) ans += 1.0 * i * (n - i + 1);
}
double ret = double(ans) / total;
printf("%.9lf\n", ret);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long n;
int a[30], k = 0, ss = 0, ans[30];
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
while (n > 0) {
k++;
a[k] = n % 10;
n = n / 10;
ss += a[k];
}
for (int i = 1; i <= k; i++) {
ans[i] = a[i];
}
for (int i = 1; i <= k; i++) {
if (a[i] > 0 && i > 1) {
int sum = 0;
for (int j = i - 1; j >= 1; j--) {
a[j] = 9;
}
a[i]--;
for (int j = 1; j <= k; j++) sum += a[j];
if (sum > ss) {
ss = sum;
for (int j = 1; j <= k; j++) ans[j] = a[j];
}
}
}
int ck = 0;
for (int i = k; i >= 1; i--) {
if (ans[i] != 0) {
ck = 1;
}
if (ck == 0)
continue;
else
cout << ans[i];
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T, class U>
void chmin(T &t, U f) {
if (t > f) t = f;
}
template <class T, class U>
void chmax(T &t, U f) {
if (t < f) t = f;
}
signed main() {
vector<pair<int, int> > v;
for (int i = 0; i < (3); i++) {
int a, b;
cin >> a >> b;
v.push_back(pair<int, int>(a, b));
}
for (int b = 0; b < (1 << 3); b++) {
vector<pair<int, int> > vv = v;
for (int i = 0; i < (3); i++)
if (b >> i & 1) swap(vv[i].first, vv[i].second);
int p[3] = {0, 1, 2};
do {
bool f = true;
f &= vv[p[0]].first == vv[p[1]].first && vv[p[1]].first == vv[p[2]].first;
f &=
vv[p[0]].second + vv[p[1]].second + vv[p[2]].second == vv[p[0]].first;
if (f) {
cout << vv[p[0]].first << endl;
for (int i = 0; i < (3); i++) {
for (int j = 0; j < (vv[p[i]].second); j++) {
for (int k = 0; k < (vv[p[0]].first); k++)
cout << (char)('A' + p[i]);
cout << endl;
}
}
return 0;
}
f = true;
f &= vv[p[0]].first == vv[p[1]].first + vv[p[2]].first;
f &= vv[p[1]].second == vv[p[2]].second;
f &= vv[p[0]].first == vv[p[0]].second + vv[p[1]].second;
if (f) {
cout << vv[p[0]].first << endl;
for (int i = 0; i < (vv[p[0]].second); i++) {
for (int j = 0; j < (vv[p[0]].first); j++) cout << (char)('A' + p[0]);
cout << endl;
}
for (int i = 0; i < (vv[p[1]].second); i++) {
for (int j = 0; j < (vv[p[1]].first); j++) cout << (char)('A' + p[1]);
for (int j = 0; j < (vv[p[2]].first); j++) cout << (char)('A' + p[2]);
cout << endl;
}
return 0;
}
} while (next_permutation(p, p + 3));
}
cout << -1 << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define dbg puts("It's Just Begining.Wait For The End!!!!!\n")
#define CHECK(x) cout << (#x) << " is " << (x) <<"\n";
#define endl printf("\n")
#define pi acos(-1)
typedef pair<ll,ll> pii;
#define pb push_back
#define ms(a,b) memset(a, b, sizeof(a))
#define in(x) scanf("%lld",&x)
#define out(x) printf("%lld",x)
#define X first
#define Y second
#define sps printf(" ")
#define dou(x) cout<<fixed<<setprecision(10)<<x
#define all(v) v.begin(),v.end()
#define dis(it,it1) distance(it,it1)+1
#define MAX 200005
#define INF 9223372036854775807LL
#define MOD 1000000007
#define print(cs) printf("Case %lld: ",cs)
#define Yesno(ok) if(ok)puts("YES");else puts("NO")
#define yesno(ok) if(ok)puts("Yes");else puts("No")
int main()
{
ll test=1LL;
in(test);
while(test--)
{
ll i,j,k,l,n,m,r,u,v;
in(n);
ll arr[n+5],prop[n+5];
for(i=1;i<=n;i++)in(arr[i]);
ll ans=0;
ms(prop,0LL);
for(i=1;i<=n;i++)
{
prop[i]+=prop[i-1];
v = min( arr[i]-1 , prop[i] );
// cout<<v;endl;
if(v&&arr[i]-v+1+i<=n)
{
prop[max(i+2,i+arr[i]-v+1)]++;
prop[min(i+arr[i],n)+1]--;
// cout<<max(i+2,min(i+arr[i]-v+1,n))<<" "<<min(i+arr[i],n)+1;endl;
}
arr[i]-=v;
if(arr[i]==1)
{
prop[i+1]+=prop[i]-v;
prop[i+2]-=prop[i]-v;
continue;
}
ans+=arr[i]-1;
// CHECK(ans);
prop[i+2]++;
prop[min(i+arr[i],n)+1]--;
}
out(ans);endl;
}
}
| 4 |
#include <bits/stdc++.h>
template <class T>
inline void read(T& x) {
char c;
bool f = 0;
while ((c = getchar()) < '0' || '9' < c) f |= (c == '-');
for (x = (c ^ 48); '0' <= (c = getchar()) && c <= '9';
x = (x << 1) + (x << 3) + (c ^ 48))
;
if (f) x = -x;
}
template <class T>
inline T read(const T sample) {
T x = 0;
char c;
bool f = 0;
while ((c = getchar()) < '0' || '9' < c) f |= (c == '-');
for (x = (c ^ 48); '0' <= (c = getchar()) && c <= '9';
x = (x << 1) + (x << 3) + (c ^ 48))
;
return f ? -x : x;
}
template <class T>
void fwrit(const T x) {
if (x < 0) return (void)(putchar('-'), fwrit(-x));
if (x > 9) fwrit(x / 10);
putchar(x % 10 ^ 48);
}
template <class T>
inline T Max(const T x, const T y) {
return x > y ? x : y;
}
template <class T>
inline T Min(const T x, const T y) {
return x < y ? x : y;
}
template <class T>
inline T fab(const T x) {
return x > 0 ? x : -x;
}
inline int gcd(const int a, const int b) { return b ? gcd(b, a % b) : a; }
inline void getInv(int inv[], const int lim, const int MOD) {
inv[0] = inv[1] = 1;
for (int i = 2; i <= lim; ++i)
inv[i] = 1ll * inv[MOD % i] * (MOD - MOD / i) % MOD;
}
inline long long mulMod(const long long a, const long long b,
const long long mod) {
return ((a * b - (long long)((long double)a / mod * b + 1e-8) * mod) % mod +
mod) %
mod;
}
const int MAXN = 3e5;
const int MOD = 998244353;
inline int Inv(int a, int n = MOD - 2) {
int ret = 1;
for (; n > 0; n >>= 1) {
if (n & 1) ret = 1ll * ret * a % MOD;
a = 1ll * a * a % MOD;
}
return ret;
}
struct edge {
int to, nxt;
} e[MAXN * 2 + 5];
int tail[MAXN + 5], ecnt;
inline void add_edge(const int u, const int v) {
e[++ecnt] = edge{v, tail[u]};
tail[u] = ecnt;
e[++ecnt] = edge{u, tail[v]};
tail[v] = ecnt;
}
int n;
inline void Init() {
n = read(1);
for (signed i = (1), i_end_ = (n - 1); i <= i_end_; ++i)
add_edge(read(1), read(1));
}
int f[MAXN + 5][3];
void Dfs(const int u, const int fa) {
for (signed i = tail[u], v = e[i].to; i; i = e[i].nxt, v = e[i].to)
if (v ^ fa) Dfs(v, u);
f[u][0] = 0;
f[u][1] = f[u][2] = 1;
int pi = 1;
for (signed i = tail[u], v = e[i].to; i; i = e[i].nxt, v = e[i].to)
if (v ^ fa) pi = 1ll * pi * (f[v][0] * 2 % MOD + f[v][2]) % MOD;
for (signed i = tail[u], v = e[i].to; i; i = e[i].nxt, v = e[i].to)
if (v ^ fa) {
f[u][0] += 1ll * (f[v][1] + f[v][2]) * pi % MOD *
Inv(f[v][0] * 2 % MOD + f[v][2]) % MOD;
if (f[u][0] >= MOD) f[u][0] -= MOD;
}
for (signed i = tail[u], v = e[i].to; i; i = e[i].nxt, v = e[i].to)
if (v ^ fa) f[u][2] = 1ll * f[u][2] * (f[v][0] + f[v][2]) % MOD;
for (signed i = tail[u], v = e[i].to; i; i = e[i].nxt, v = e[i].to)
if (v ^ fa) f[u][1] = 1ll * f[u][1] * (f[v][0] * 2 % MOD + f[v][2]) % MOD;
f[u][1] = (f[u][1] - f[u][2] + MOD) % MOD;
}
signed main() {
Init();
Dfs(1, 0);
fwrit((f[1][0] + f[1][2]) % MOD), putchar('\n');
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long int tbegin, tend, t;
int n;
long long int a[100050];
int main() {
cin >> tbegin >> tend >> t;
cin >> n;
for (int i = 0; i < n; i++) scanf("%I64d", &a[i]);
a[n++] = tend - t + 1;
sort(a, a + n);
long long Min = 1e15;
long long endtime = tbegin;
long long int Time = 0;
for (int i = 0; i < n; i++) {
if (a[i] > 0) {
long long temp = max((long long)0, endtime - a[i] + 1);
if (endtime + t <= tend) {
if (Min > temp) {
Min = temp;
Time = a[i] - 1;
}
}
}
endtime = max(endtime + t, a[i] + t);
}
cout << Time << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f, oo = inf;
inline long long read() {
register long long x = 0;
char f = 0;
register char c = getchar();
for (; !isdigit(c); c = getchar()) f |= (c == '-');
for (; isdigit(c); c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48);
return f ? -x : x;
}
inline double readdb() {
register double x = 0, p = 0.1;
register char f = 0, c = getchar();
for (; !isdigit(c); c = getchar()) f |= (c == '-');
for (; isdigit(c); c = getchar()) x = x * 10 + (c ^ 48);
if (c == '.')
for (c = getchar(); isdigit(c); c = getchar(), p /= 10)
x = x + (c ^ 48) * p;
return f ? -x : x;
}
inline void write(long long x) {
if (x < 0) x = -x, putchar('-');
if (x >= 10) write(x / 10);
putchar(x % 10 + '0');
}
inline void writeln(long long x) {
write(x);
puts("");
}
inline void writeln(long long x, char c, long long y) {
write(x);
putchar(c);
writeln(y);
}
inline void writeln(long long x, char c, long long y, char d, long long z) {
write(x);
putchar(c);
write(y);
putchar(d);
writeln(z);
}
char s[100500];
int n, f[233];
int main() {
n = read();
scanf("%s", s + 1);
for (register int i = (1); i <= (n); ++i) {
f[s[i] - 'a']++;
}
for (register int i = (0); i <= (26); ++i) {
while (f[i]--) printf("%c", i + 'a');
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
char a[1000005];
int main() {
long long n, m, ans = 0, i;
;
char c, temp;
long long x;
scanf("%lld%lld", &n, &m);
scanf("%s", a);
for (i = 0; i < n; i++) {
long long f = 0;
while (a[i] == '.') {
f++;
i++;
}
if (f >= 1) ans += (f - 1);
}
for (i = 0; i < m; i++) {
scanf("%lld%c%c", &x, &temp, &c);
long long x2 = x;
if ((x == 1) && (c != '.')) {
x--;
if (a[x + 1] == '.' && a[x] == '.') ans--;
} else if ((x > 1) && (c != '.')) {
x--;
if (a[x - 1] == '.' && a[x] == '.') ans--;
if (a[x + 1] == '.' && a[x] == '.') ans--;
} else if ((x == 1) && (c == '.')) {
x--;
if (a[x + 1] == '.' && a[x] != '.') ans++;
} else if ((x > 1) && (c == '.')) {
x--;
if (a[x - 1] == '.' && a[x] != '.') {
ans++;
}
if (a[x + 1] == '.' && a[x] != '.') {
ans++;
}
}
a[x2 - 1] = c;
printf("%lld\n", ans);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<int> gr[100005];
bool visited[100005];
bool flag;
void dfs(int x, int par) {
visited[x] = 1;
int i, j;
for (i = 0; i < gr[x].size(); i++) {
j = gr[x][i];
if (j != par) {
if (visited[j] == 1)
flag = 1;
else
dfs(j, x);
}
}
}
int main() {
int n, m, i, j, k, l, p, ans = 0;
scanf("%d%d", &n, &m);
for (i = 0; i < m; i++) {
scanf("%d%d", &k, &l);
gr[k].push_back(l);
gr[l].push_back(k);
}
for (i = 1; i <= n; i++) {
if (visited[i] == 0) {
flag = 0;
dfs(i, -1);
if (flag == 0) ans++;
}
}
printf("%d\n", ans);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long logN = 20;
const long long N = 100005;
const long long M = 1000000007;
int main() {
int t;
cin >> t;
string s;
while (t--) {
int n;
cin >> n;
cin >> s;
if (s[0] == '1' || s[n - 1] == '1') {
cout << 2 * n << "\n";
continue;
} else {
int cl = n, cr = -1, al = 0, ar = 0, k = 0, i;
for (i = 0; i < n; i++) {
if (s[i] == '1') {
cl = i;
break;
}
}
for (i = n - 1; i >= 0; i--) {
if (s[i] == '1') {
cr = i;
break;
}
}
for (long long i = 0; i < n; i++)
if (s[i] == '1') k++;
int ans = max(2 * (cr + 1), max(2 * (n - cl), n + k));
if (cl != n && cr != -1)
ans = max(ans, max(2 * (cr + 1) - cl, 2 * (n - cl) - (n - cr + 1)));
cout << ans << "\n";
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string modified(string& s, int n, int k) {
string result_prefix = s.substr(k - 1, n - k + 1);
string result_suffix = s.substr(0, k - 1);
if (n % 2 == k % 2) reverse(result_suffix.begin(), result_suffix.end());
return result_prefix + result_suffix;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
string s, best_s, temp;
int t, n, best_k;
cin >> t;
while (t--) {
cin >> n >> s;
best_s = modified(s, n, 1);
best_k = 1;
for (int k = 2; k <= n; ++k) {
temp = modified(s, n, k);
if (temp < best_s) {
best_s = temp;
best_k = k;
}
}
cout << best_s << '\n' << best_k << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long int MOD = 1e9 + 7;
long long int INF = 1e18;
long long int sub(long long int a, long long int b, long long int p = MOD) {
return ((a % p) - (b % p) + p) % p;
}
long long int mult(long long int a, long long int b, long long int p = MOD) {
return ((a % p) * (b % p)) % p;
}
long long int add(long long int a, long long int b, long long int p = MOD) {
return (a % p + b % p) % p;
}
long long int fpow(long long int n, long long int k, long long int p = MOD) {
long long int r = 1;
while (k > 0) {
if (k & 1) r = r * n % p;
n = n * n % p;
k = k >> 1;
}
return r;
}
long long int inv(long long int a, long long int p = MOD) {
return fpow(a, p - 2, p);
}
long long int fdiv(long long int a, long long int b, long long int p = MOD) {
long long int yinv = inv(b);
long long int ans = (a * yinv) % p;
return ans;
}
unsigned long long int I1018 = 1000000000000000000;
const unsigned long long int I10e5 = 100000;
const long long int I10e6 = 1e6;
template <typename T>
istream &operator>>(istream &in, vector<T> &a) {
for (auto &item : a) {
in >> item;
}
return in;
}
template <typename T, typename U>
ostream &operator<<(ostream &out, pair<T, U> &a) {
cout << a.first << " " << a.second;
return out;
}
template <typename T, typename U>
istream &operator>>(istream &out, pair<T, U> &a) {
cin >> a.first >> a.second;
return out;
}
template <typename T, typename U>
ostream &operator<<(ostream &out, map<T, U> &a) {
for (auto &item : a) {
out << item << endl;
}
return out;
}
template <typename T>
ostream &operator<<(ostream &out, vector<T> &a) {
for (auto &item : a) {
out << item << " ";
}
return out;
}
template <typename T>
ostream &operator<<(ostream &out, vector<vector<T>> &a) {
for (auto &item : a) {
out << item << "\n";
}
return out;
}
std::vector<bool> is_prime;
std::vector<long long int> primes;
void sieve(long long int n) {
is_prime.resize(n + 2, true);
primes.clear();
long long int p;
for (p = 2; p * p <= n; p++) {
if (is_prime[p]) {
long long int i;
for (i = p * p; i <= n; i += p) {
is_prime[i] = false;
}
}
}
is_prime[0] = is_prime[1] = false;
long long int i;
for (i = 2; i <= n; i++) {
if (is_prime[i]) {
primes.emplace_back(i);
}
}
}
map<long long int, long long int> prime_factors(long long int n) {
map<long long int, long long int> s;
long long int i;
long long int tc = 0;
while (n % 2 == 0) {
tc++;
n /= 2;
}
if (tc > 0) {
s[2] = tc;
}
for (i = 3; i <= sqrt(n); i += 2) {
tc = 0;
while (n % i == 0) {
tc++;
n /= i;
}
if (tc > 0) {
s[i] = tc;
}
}
if (n > 2) {
s[n] += 1;
}
return s;
}
std::vector<long long int> fact_vec;
void fact_fun(long long int n) {
fact_vec.resize(n + 10);
long long int i;
fact_vec[0] = 1;
for (i = 1; i <= n + 2; i++) {
fact_vec[i] = (fact_vec[i - 1] * i) % MOD;
}
}
long long int npr(long long int n, long long int r) {
long long int ans = fact_vec[n];
ans /= fact_vec[n - r];
return ans;
}
long long int ncr(long long int n, long long int r) {
long long int ans = fact_vec[n];
ans /= fact_vec[n - r];
ans /= fact_vec[r];
return ans;
}
int main() {
long long int i, j;
ios::sync_with_stdio(false);
cin.tie(0);
long long int n;
cin >> n;
std::vector<pair<long long int, long long int>> v(n);
map<long long int, long long int> sm;
for (auto &p : v) cin >> p.first >> p.second;
std::vector<pair<long long int, long long int>> tp = v;
sort((tp).begin(), (tp).end());
sort((v).begin(), (v).end(), greater<pair<long long int, long long int>>());
long long int ans = 0;
for (auto p : v) {
long long int s = p.first, e = p.second;
auto it = lower_bound((tp).begin(), (tp).end(), make_pair(e, INF));
if (it == tp.end()) {
sm[s] = max(ans, max(1ll, sm[s]));
} else {
sm[s] = max(ans, max(sm[s], 1 + sm[it->first]));
}
ans = max(ans, sm[s]);
}
for (auto p : sm) {
ans = max(ans, p.second);
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
set<long long> y;
set<long long> x;
set<long long>::iterator t;
set<long long>::iterator t2;
multiset<long long> height;
multiset<long long> width;
long long w, h, n;
cin >> w >> h >> n;
y.insert(0);
y.insert(h);
x.insert(0);
x.insert(w);
width.insert(w);
height.insert(h);
long long j;
long long lisa;
char ch;
for (int i = 0; i < n; i++) {
cin >> ch >> j;
if (ch == 'H') {
t = y.lower_bound(j);
lisa = *t;
t--;
height.erase(height.equal_range(lisa - *t).first);
height.insert(lisa - j);
height.insert(j - *t);
y.insert(j);
} else {
t = x.lower_bound(j);
lisa = *t;
t--;
width.erase(width.equal_range(lisa - *t).first);
width.insert(lisa - j);
width.insert(j - *t);
x.insert(j);
}
cout << (*width.rbegin()) * (*height.rbegin()) << endl;
}
return 0;
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.