solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
string s;
cin >> s;
int sub_len = 0;
map<char, vector<int>> sub_lens;
for (int i = 0; i < s.size(); i++) {
if (i and s[i] == s[i - 1]) {
sub_len++;
} else {
if (i) {
if (not sub_lens.count(s[i - 1])) sub_lens[s[i - 1]] = vector<int>();
sub_lens[s[i - 1]].push_back(sub_len);
}
sub_len = 1;
}
}
sub_lens[s.back()].push_back(sub_len);
int ans = 0;
for (auto [c, lens] : sub_lens) {
int x = 0;
for (int len : lens) {
x += len / k;
}
ans = max(ans, x);
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T sqr(const T& x) {
return x * x;
}
template <class T>
inline string tostr(const T& a) {
ostringstream os("");
os << a;
return os.str();
}
const int inf = 1999999999;
const double pi = acos(-1.0);
const double eps = 1e-9;
int main() {
clock_t _ = clock();
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
int n;
cin >> n;
if (n == 1 || n == 2) {
cout << -1 << ('\n');
return 0;
}
cout << 100 << ' ' << 99 << ' ';
for (int i = 0; i < n - 2; i++) cout << "1" << ' ';
cout << ('\n');
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int M = 2000 + 5;
long long int mod = 1000000000 + 7;
long long int dp[M][M];
int flag[M];
int a[M];
int main() {
time_t t_start, t_end;
t_start = clock();
int n;
cin >> n;
int fre = 0;
int fix = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] != -1) {
flag[a[i]] = 1;
}
}
for (int i = 1; i <= n; i++) {
if (a[i] == -1) {
if (flag[i] == 0) {
fix++;
} else {
fre++;
}
}
}
int sz = M - 1;
dp[0][0] = 1;
for (int i = 1; i <= sz; i++) {
dp[i][0] = (dp[i - 1][0] * i) % mod;
}
for (int col = 1; col <= sz; col++) {
for (int row = 0; row + col <= sz; row++) {
long long int v1 = 0;
if (col - 1 >= 0) {
v1 = dp[row][col - 1] * row;
v1 = v1 % mod;
}
long long int v2 = 0;
if (row + 1 <= sz && col - 2 >= 0) {
v2 = dp[row + 1][col - 2] * (col - 1);
v2 = v2 % mod;
}
dp[row][col] = (v1 + v2) % mod;
}
}
cout << dp[fre][fix] << endl;
t_end = clock();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long c[120], a[120], i, j, n, m, k, dproc[120], izb[120], ans;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
for (i = 0; i < n; ++i) cin >> a[i];
for (i = 0; i < n; ++i) {
cin >> dproc[i];
if (a[i] > izb[dproc[i]]) {
izb[dproc[i]] = a[i];
}
}
for (i = 0; i < k; ++i) {
cin >> c[i];
c[i]--;
if (a[c[i]] != izb[dproc[c[i]]]) ans++;
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
const int MOD = 1e9 + 7;
const int MAXN = 1e5 + 100;
const double eps = 1e-9;
double sqr(double a) { return a * a; }
bool IsEqual(double a, double b) { return abs(a - b) < eps; }
int d, l, v1, v2;
int main() {
cin >> d >> l >> v1 >> v2;
double ans = double(l - d) / (v1 + v2);
printf("%0.15f", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c = 0, h = 0;
cin >> n;
int arr[10000];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
while (true) {
for (int i = 0; i < n; i++) {
if (arr[i] == 0) c++;
}
if (c == n) {
return 0;
}
c = 0;
for (int y = 0; y < n; y++) {
if (y == 0 && h == 1) {
cout << 'R';
continue;
}
if (arr[y] > 0 && n - y > 1) {
cout << "PR";
arr[y]--;
} else if (arr[y] > 0) {
cout << 'P';
arr[y]--;
} else if (n - y > 1)
cout << 'R';
}
h = 1;
for (int j = n - 1; j >= 0; j--) {
if (j == n - 1) {
cout << "L";
continue;
}
if (arr[j] > 0 && j > 0) {
cout << "PL";
arr[j]--;
} else if (arr[j] > 0) {
cout << 'P';
arr[j]--;
} else if (j > 0)
cout << 'L';
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int A[19000] = {0};
int main() {
int a;
cin >> a;
A[0] = 1;
for (int i = 1; i < a; i++) A[i] = A[i - 1] + 6 + 6 * (2 * i - 1);
cout << A[a - 1] << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int MAX = 1e9 + 5;
int i, j, k, n, mn, a[5], b[5];
double ort(int a, int b, int c, int d) { return (a + b + c + d * 1.0) / 4; }
bool ctr(int a[]) {
for (int i = 1; i <= 4; i++) b[i] = a[i];
sort(b + 1, b + 5);
return (((b[4] - b[1] * 1.0) == ort(b[1], b[2], b[3], b[4])) &&
((b[4] - b[1]) == ((b[2] + b[3]) / 2.0)));
}
bool dfs(int wh) {
if (wh == 5) {
return ctr(a);
}
for (int i = max(mn / 3, 1); i <= mn * 3; i++) {
a[wh] = i;
if (dfs(wh + 1)) return true;
}
return false;
}
int main() {
ios::sync_with_stdio(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
if (n == 0)
mn = 1;
else
mn = *max_element(a + 1, a + n + 1);
if (dfs(n + 1)) {
cout << "YES" << '\n';
for (int i = n + 1; i <= 4; i++) cout << a[i] << '\n';
} else
cout << "NO" << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[10000];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
int num = 0;
int ans = 0;
for (int i = 1; i < n; i++) {
if (a[i] == a[i - 1]) {
num++;
ans = max(ans, num);
} else {
num = 0;
}
}
cout << ans + 1 << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
ifstream fin("Sisend.txt");
long long n;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cerr.tie(0);
cin >> n;
long long l = 1, r = n;
while (l < r) {
long long m = (l + r) / 2;
long long k = n, v = 0, p = 0;
while (k) {
long long j = min(m, k);
k -= j;
v += j;
p += k / 10;
k -= k / 10;
}
if (p > v)
l = m + 1;
else
r = m;
}
cout << l;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T sq(const T& x) {
return x * x;
}
const int INF = 2147483647;
struct Node {
vector<int> a;
long long s[5];
Node() { update(); }
int size() const { return a.size(); }
void insert(int x) {
a.insert(upper_bound(a.begin(), a.end(), x), x);
update();
}
void erase(int x) {
a.erase(lower_bound(a.begin(), a.end(), x));
update();
}
void update() {
memset(s, 0, sizeof s);
for (size_t i = 0; i < a.size(); ++i) s[i % 5] += a[i];
}
};
struct Kiwi {
list<Node> li;
int size;
Kiwi() : size(0) {}
void insert(int x) {
++size;
auto it = li.begin();
for (; it != li.end(); ++it) {
auto nx = it;
++nx;
int right_bound = (nx == li.end()) ? INF : nx->a[0];
if (x <= right_bound) break;
}
if (it == li.end()) it = li.insert(it, Node());
it->insert(x);
if (sq(it->size()) >= size * 4) {
int gap = sqrt(size + 0.5);
Node node;
node.a.assign(it->a.begin() + gap, it->a.end());
node.update();
it->a.erase(it->a.begin() + gap, it->a.end());
it->update();
li.insert(++it, node);
}
}
void erase(int x) {
--size;
auto it = li.begin();
while (x > it->a.back()) ++it;
it->erase(x);
if (it->size() == 0) {
li.erase(it);
} else if (it != li.begin()) {
auto pv = it;
--pv;
if (sq(pv->size() + it->size()) <= size * 1.4) {
copy(it->a.begin(), it->a.end(), back_inserter(pv->a));
pv->update();
li.erase(it);
}
}
}
long long sum() const {
long long ret = 0;
int p = 2;
for (auto it = li.begin(); it != li.end(); ++it) {
ret += it->s[p];
p = ((p - (int)it->a.size()) % 5 + 5) % 5;
}
return ret;
}
};
void york() {
int m;
Kiwi b;
char s[32];
scanf("%d", &m);
while (m--) {
scanf("%s", s);
if (s[0] == 's') {
printf("%I64d\n", b.sum());
} else if (s[0] == 'a') {
int t;
scanf("%d", &t);
b.insert(t);
} else {
int t;
scanf("%d", &t);
b.erase(t);
}
}
}
int main() {
york();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int size;
int curmax;
cin >> size;
curmax = size;
vector<int> arr;
arr.reserve(size);
vector<int> temp_arr(size, 0);
for (int i = 0; i < size; i++) {
cin >> arr[i];
}
for (int i = 0; i < size; i++) {
temp_arr[arr[i] - 1] = arr[i];
string print_str = "";
while (temp_arr[curmax - 1] != 0) {
string cur_string = to_string(curmax);
print_str.append(cur_string);
print_str.append(" ");
curmax--;
if (curmax == 0) {
cout << print_str;
return 0;
}
}
print_str.append("\n");
cout << print_str;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-ffloat-store")
#pragma GCC optimize("-fno-defer-pop")
long long int power(long long int a, long long int b, long long int m) {
if (b == 0) return 1;
if (b == 1) return a % m;
long long int t = power(a, b / 2, m) % m;
t = (t * t) % m;
if (b & 1) t = ((t % m) * (a % m)) % m;
return t;
}
long long int modInverse(long long int a, long long int m) {
return power(a, m - 2, m);
}
long long int n, c[100001];
string ar[100001][2];
long long int dp[100001][2];
long long int minval(long long int i, long long int rev) {
if (i == n + 1) {
return 0;
}
if (dp[i][rev] != -1) {
return dp[i][rev];
}
long long int a = 1e16;
if (ar[i][0] >= ar[i - 1][rev]) a = min(a, minval(i + 1, 0));
if (ar[i][1] >= ar[i - 1][rev]) a = min(a, c[i] + minval(i + 1, 1));
return dp[i][rev] = a;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
memset(dp, -1, sizeof(dp));
long long int i, j, k, l;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> c[i];
}
for (i = 1; i <= n; i++) {
cin >> ar[i][0];
ar[i][1] = ar[i][0];
reverse(ar[i][1].begin(), ar[i][1].end());
}
k = min(minval(2, 0), c[1] + minval(2, 1));
if (k > 1e15) {
cout << "-1";
} else
cout << k;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
char str[N];
char ans[N];
int main() {
int n;
scanf("%d", &n);
int cur = 0;
scanf("%s", str);
for (int i = 0; i < n;) {
int ind = i + 1;
while (ind < n && str[i] == str[ind]) {
ind++;
}
if (ind == n) break;
ans[cur++] = str[i];
ans[cur++] = str[ind];
i = ind + 1;
}
ans[cur] = '\0';
printf("%d\n", n - cur);
if (cur) printf("%s\n", ans);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1010;
int n, m;
int g[N][N];
int ans = 0;
inline void Solve(int l, int r, int K, int dep) {
if (l >= r) return;
ans = ((ans) < (dep) ? (dep) : (ans));
int siz = (r - l + 1) / K;
if (!siz) ++siz;
int last = l, cnt = 0;
vector<pair<int, int> > S;
while (last <= r && cnt < K)
++cnt, Solve(last, cnt == K ? r : min(last + siz - 1, r), K, dep + 1),
S.push_back(make_pair(last, cnt == K ? r : min(last + siz - 1, r))),
last += siz;
cerr << "Solve(" << l << "," << r << "," << K << "," << dep << ")\n";
cerr << "S: ";
for (auto x : S) cerr << "[" << x.first << "," << x.second << "] ";
cerr << endl;
for (register int i = 0; i < (int)S.size(); ++i)
for (register int j = i + 1; j < (int)S.size(); ++j)
for (register int k = S[i].first; k <= S[i].second; ++k)
for (register int l = S[j].first; l <= S[j].second; ++l) g[k][l] = dep;
}
int main() {
scanf("%d%d", &n, &m);
for (register int len = 1; len < n; len *= m) {
++ans;
for (register int i = 0; i < n; i += len)
for (register int j = 0; j < n; j += len)
if (i != j)
for (register int x = 0; x < len && i + x < n; ++x)
for (register int y = 0; y < len && j + y < n; ++y)
g[i + x + 1][j + y + 1] = ans;
}
printf("%d\n", ans);
for (register int i = 1; i <= n; ++i)
for (register int j = i + 1; j <= n; ++j) printf("%d ", g[i][j]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int tree[10000][2];
int lights;
void mark(int node, int l) {
int p = node / 2;
if (p == 0) return;
tree[p][node % 2] = min(tree[p][node % 2], lights - l);
mark(p, l);
}
int cont[10000];
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
memset(tree, -1, sizeof(tree));
int n, a, p;
cin >> n;
int lim = (1 << (n + 1)) - 1;
for (int i = 2; i <= lim; ++i) {
cin >> a;
p = i / 2;
tree[p][i % 2] = a;
}
lights = 0;
queue<int> Q;
Q.push(1);
Q.push(0);
while (!Q.empty()) {
int u = Q.front();
Q.pop();
int l = Q.front();
Q.pop();
if (tree[u][0] == -1) {
lights = max(lights, l);
cont[u] = l;
continue;
}
Q.push(2 * u);
Q.push(tree[u][0] + l);
Q.push(2 * u + 1);
Q.push(tree[u][1] + l);
tree[u][0] = tree[u][1] = 0x3fffffff;
}
for (int i = 1 << n; i <= lim; ++i) mark(i, cont[i]);
int ans = 0;
Q.push(1);
Q.push(0);
while (!Q.empty()) {
int u = Q.front();
Q.pop();
int l = Q.front();
Q.pop();
if (tree[u][0] == -1) continue;
ans += tree[u][0] + tree[u][1] - 2 * l;
Q.push(2 * u);
Q.push(tree[u][0]);
Q.push(2 * u + 1);
Q.push(tree[u][1]);
}
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int INF = (1LL << 31) - 1;
const long long LINF = LLONG_MAX;
const int maxn = 1e5 + 1;
vector<pair<int, int> > g[maxn];
vector<int> h[maxn];
bool visited[maxn];
long long n, m, color[maxn], ans[maxn], P[maxn], cnt;
void avc(int v, int p) {
visited[v] = 1;
P[v] = p;
for (auto x : g[v]) {
if (p == P[x.first] && !x.second) {
cout << 0 << endl;
exit(0);
}
if (!visited[x.first] && x.second) avc(x.first, p);
if (P[x.first] && P[x.first] != p) {
h[p].push_back(P[x.first]);
h[P[x.first]].push_back(p);
}
}
}
void dfs(int v, bool c) {
visited[v] = 1;
color[v] = c;
for (int u : h[v])
if (!visited[u]) dfs(u, !c);
}
bool check(int x) {
for (int i = 1; i <= x; i++)
for (int j : h[i])
if (color[i] == color[j]) return 0;
return 1;
}
void count(int v) {
visited[v] = 1;
for (int u : h[v])
if (!visited[u]) count(u);
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
ans[0] = 1;
for (int i = 1; i < maxn; i++) ans[i] = 2 * ans[i - 1] % mod, ans[i] %= mod;
cin >> n >> m;
for (int i = 0, v, u, c; i < m; i++) {
cin >> v >> u >> c;
g[v].push_back({u, c});
g[u].push_back({v, c});
}
int part = 1;
for (int i = 1; i <= n; i++)
if (!visited[i]) {
avc(i, part);
part++;
}
part--;
fill(visited, visited + part + 1, 0);
for (int i = 1; i <= part; i++)
if (!visited[i]) dfs(i, 0);
fill(visited, visited + part + 1, 0);
for (int i = 1; i <= part; i++)
if (!visited[i]) count(i), cnt++;
if (check(part))
cout << ans[cnt - 1] << endl;
else
cout << 0 << endl;
}
| 7 |
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
class myP
{
public:
void operator()(string s)
{
cout << s << endl;
}
};
bool isTarget(int n)
{
int x = n / 2020;
int y = n % 2020;
if (x >= y)
return 1;
else
return 0;
}
int main()
{
vector<string> v;//��Ž��
int n;//���Ĵ���
cin >> n;
int num;//���������
while (n--)
{
cin >> num;
if (isTarget(num))
v.push_back("YES");
else
v.push_back("NO");
}
for_each(v.begin(), v.end(), myP());
return 0;
}
| 0 |
#include <bits/stdc++.h>
int T;
int n;
int m, sz[2005], dp[2005];
int main() {
scanf("%d", &T);
while (T--) {
scanf("%d", &n);
m = 0;
for (int i = 1, mx = 0, tmp = 0; i <= (n << 1) + 1; i++, tmp++) {
int a;
if (i <= (n << 1))
scanf("%d", &a);
else
a = i;
if (a > mx) {
mx = a;
sz[m++] = tmp;
tmp = 0;
}
}
m--;
dp[0] = 1;
for (int i = 1; i <= n; i++) dp[i] = 0;
for (int i = 1; i <= m; i++)
for (int j = n; j >= sz[i]; j--)
if (dp[j - sz[i]]) dp[j] = 1;
if (dp[n])
puts("YES");
else
puts("NO");
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
using pib = pair<int, bool>;
using ll = long long;
using ld = long double;
const int MN = 1e5 + 5, MK = 6e4 + 5, MOD = 1e9 + 7, BASE = 31,
MASK = (1 << 10) - 1;
char s[205];
int dp[205][205][205];
int precalc[205];
void uadd(int &a, int b) {
a += b;
if (a >= MOD) a -= MOD;
}
int main() {
int n;
scanf("%d\n%s", &n, s + 1);
n <<= 1;
int m = strlen(s + 1);
for (int i = 1; i <= m; i++) {
for (int j = i - 1; j >= 1; j--)
if (s[i] != s[j]) {
for (int k = 1; k < j; k++)
if (s[k] != s[i - j + k]) goto fail;
precalc[i] = j;
break;
fail:;
}
}
dp[0][0][0] = 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j <= i; j++) {
for (int k = 0; k < m; k++) {
if (j) {
if (s[k + 1] == ')')
uadd(dp[i + 1][j - 1][k + 1], dp[i][j][k]);
else
uadd(dp[i + 1][j - 1][precalc[k + 1]], dp[i][j][k]);
}
{
if (s[k + 1] == '(')
uadd(dp[i + 1][j + 1][k + 1], dp[i][j][k]);
else
uadd(dp[i + 1][j + 1][precalc[k + 1]], dp[i][j][k]);
}
}
if (j) uadd(dp[i + 1][j - 1][m], dp[i][j][m]);
uadd(dp[i + 1][j + 1][m], dp[i][j][m]);
}
}
printf("%d\n", dp[n][0][m]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long degree(long long a, long long k, long long p) {
long long res = 1;
long long cur = a;
while (k) {
if (k % 2) {
res = (res * cur) % p;
}
k /= 2;
cur = (cur * cur) % p;
}
return res;
}
long long get_degree(long long n, long long p) {
long long int degree_num = 0;
long long u = p;
long long temp = n;
while (u <= temp) {
degree_num += temp / u;
u *= p;
}
return degree_num;
}
long long combinations(long long int n, long long int k, long long p) {
long long int num_degree = get_degree(n, p) - get_degree(n - k, p);
long long int den_degree = get_degree(k, p);
if (num_degree > den_degree) {
return 0;
}
long long res = 1;
for (long long i = n; i > n - k; --i) {
long long ti = i;
while (ti % p == 0) {
ti /= p;
}
res = (res * ti) % p;
}
for (long long i = 1; i <= k; ++i) {
long long ti = i;
while (ti % p == 0) {
ti /= p;
}
res = (res * degree(ti, p - 2, p)) % p;
}
return res;
}
long long int dp[1001] = {0};
long long int c[1001] = {0};
long long int c1[1001] = {0};
int main(void) {
ios_base::sync_with_stdio(false);
long long int k;
cin >> k;
for (long long int i = 0; i < k; i++) cin >> c[i];
dp[0] = 1;
c1[0] = c[0];
for (long long int i = 1; i < k; i++) c1[i] = c[i] + c1[i - 1];
for (long long int i = 1; i < k; i++) {
dp[i] = dp[i - 1];
long long int obj = c[i] - 1;
long long int pla = c1[i - 1] + 1;
long long int comb;
if (pla > 1)
comb = combinations(obj + pla - 1, pla - 1, 1000000007ll);
else
comb = 1;
dp[i] = (dp[i - 1] * comb) % 1000000007ll;
}
cout << dp[k - 1];
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200100;
int i, j, n, m, k, a[N], b[N], ans, x, y;
bool check(int m) {
int j = 2 * (n - k) - 1;
for (int i = 0; i < 2 * (n - k); i++) {
if (i > j) break;
if (i == j) {
if (a[i] > m) return false;
break;
}
if (a[i] + a[j] > m) return false;
j--;
}
for (int i = 0; i < n; i++)
if (a[i] > m) return false;
return true;
}
int main() {
cin >> n >> k;
for (i = 0; i < n; i++) cin >> a[i];
k = min(n, k);
int l = 0, r = 2000010;
while (l + 1 < r) {
m = (l + r) / 2;
if (check(m))
r = m;
else
l = m;
}
cout << r;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a, b, arr[1000009], srr[1000009], n, h = 1000000007;
int main() {
scanf("%d%d", &a, &b);
for (int i = 1; i <= a; i++) {
scanf("%d", &arr[i]);
if (arr[i] > n) n = arr[i];
if (h > arr[i]) h = arr[i];
if (b >= arr[i])
srr[1]++, srr[arr[i] + 1]--;
else
srr[arr[i] - b]++, srr[arr[i] + 1]--;
}
for (int i = 1; i <= 1000009; i++) srr[i] += srr[i - 1];
while (h > 0) {
int k = 0;
int u = 0;
k = h;
while (k <= n) {
u += srr[k];
k += h;
}
if (u >= a) {
cout << h << " ";
return 0;
}
h--;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<int> vec;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
cout << n - 1 << endl;
for (int i = 2; i <= n; i++) {
cout << i << " ";
}
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using vi = std::vector<int>;
using pii = std::pair<int, int>;
using ll = long long;
using vll = std::vector<ll>;
int solve() {
int n;
unsigned a, b, c, d;
scanf("%d", &n);
scanf("%u%u%u%u", &a, &b, &c, &d);
int n6 = (n - n / 2 - n / 3 + n / 6) + 1024;
unsigned* bit = new unsigned[n6 / 32]();
auto index = [](int i) { return i - i / 2 - i / 3 + i / 6 + 2; };
auto calc = [](int p, int n) -> unsigned {
unsigned r = 0;
while (n /= p) r += n;
return r;
};
auto set_bit = [&](int i) { bit[i >> 5] |= (1u << (i & 31)); };
auto get_bit = [&](int i) { return (bit[i >> 5] >> (i & 31)) & 1; };
auto f = [=](unsigned p) {
return (unsigned)(((a * p + b) * p + c) * p + d);
};
unsigned ans = 0;
ans += calc(2, n) * f(2);
ans += calc(3, n) * f(3);
int n_sqrt = sqrt(n);
for (int i = 5, k = 2; i <= n; i += k, k ^= 6) {
if (!get_bit(index(i))) {
ans += calc(i, n) * f(i);
if (i <= n_sqrt) {
for (int j = i * i; j <= n; j += i) {
if (j % 2 == 0 || j % 3 == 0) continue;
set_bit(index(j));
}
}
}
}
printf("%u\n", ans);
delete[] bit;
return 0;
}
int main() {
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
int main(void) {
long long n;
while (cin >> n) {
long long m, k;
if (n & 1) {
m = (n + 1) / 2;
k = n - m;
long long ans1 = 2 * m * k, ans2 = m * m + k * k;
if (!ans1 || !ans2) {
cout << -1 << endl;
} else {
cout << 2 * m * k << " " << m * m + k * k << endl;
}
} else {
n /= 2;
long long ans1 = n * n - 1, ans2 = n * n + 1;
if (!ans1 || !ans2) {
cout << -1 << endl;
} else {
cout << n * n - 1 << " " << n * n + 1 << endl;
}
}
}
return EXIT_SUCCESS;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
vector<vector<int>> table(n, vector<int>(m));
for (int i = 0; i < n; i++) {
string str;
cin >> str;
for (int j = 0; j < m; j++) {
if (str[j] == 'A') {
table[i][j] = 0;
} else if (str[j] == 'G') {
table[i][j] = 1;
} else if (str[j] == 'C') {
table[i][j] = 2;
} else {
table[i][j] = 3;
}
}
}
vector<int> gu(2), ki(2);
long long ecost = 1LL << 60, fcost = 1LL << 60;
vector<int> gug(2), kik(2), ccc(n), cccc(n);
vector<int> gugg(2), kikk(2), ddd(m), dddd(m);
for (int i = 0; i < 4; i++) {
for (int j = i + 1; j < 4; j++) {
if (i == j) continue;
gu[0] = i, gu[1] = j;
int k = 0, l = 0;
for (; k == i || k == j; k++) {
}
for (; l == i || l == j || l == k; l++) {
}
ki[0] = k, ki[1] = l;
long long dcost = 0;
for (int a = 0; a < n; a++) {
long long mincost = 1LL << 60;
for (int c = 0; c < 2; c++) {
long long ccost = 0;
for (int b = 0; b < m; b++)
if (a % 2 == 0) {
if (table[a][b] != gu[(b + c) % 2]) {
ccost++;
}
} else {
if (table[a][b] != ki[(b + c) % 2]) {
ccost++;
}
}
if (mincost > ccost) {
ccc[a] = c;
}
mincost = min(mincost, ccost);
}
dcost += mincost;
}
if (ecost > dcost) {
gug = gu;
kik = ki;
ecost = dcost;
cccc = ccc;
}
long long gcost = 0;
for (int a = 0; a < m; a++) {
long long mincost = 1LL << 60;
for (int c = 0; c < 2; c++) {
long long ccost = 0;
for (int b = 0; b < n; b++)
if (a % 2 == 0) {
if (table[b][a] != gu[(b + c) % 2]) {
ccost++;
}
} else {
if (table[b][a] != ki[(b + c) % 2]) {
ccost++;
}
}
if (mincost > ccost) {
ddd[a] = c;
}
mincost = min(mincost, ccost);
}
gcost += mincost;
}
if (fcost > gcost) {
gugg = gu;
kikk = ki;
fcost = gcost;
dddd = ddd;
}
}
}
vector<char> tai(4);
tai[0] = 'A';
tai[1] = 'G';
tai[2] = 'C';
tai[3] = 'T';
if (ecost < fcost) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (i % 2 == 0) {
cout << tai[gug[(j + cccc[i]) % 2]];
} else {
cout << tai[kik[(j + cccc[i]) % 2]];
}
}
cout << "\n";
}
} else {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (j % 2 == 0) {
cout << tai[gugg[(i + dddd[j]) % 2]];
} else {
cout << tai[kikk[(i + dddd[j]) % 2]];
}
}
cout << "\n";
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T read() {
T value;
cin >> value;
return value;
}
int read_int() { return read<int>(); }
size_t read_size() { return read<size_t>(); }
long long read_ll() { return read<long long>(); }
string read_string() { return read<string>(); }
template <class T>
void read_vector(vector<T> &a, size_t size) {
a.resize(size);
for (T &value : a) cin >> value;
}
void read_pairs(vector<pair<int, int> > &a, size_t size) {
a.resize(size);
for (pair<int, int> &value : a) cin >> value.first >> value.second;
}
void read_iii(vector<pair<pair<int, int>, int> > &a, size_t size) {
a.resize(size);
for (pair<pair<int, int>, int> &value : a)
cin >> value.first.first >> value.first.second >> value.second;
}
const char SPACE = ' ', ENDL = '\n';
template <class T>
void print(vector<T> &a, char sep = SPACE) {
for (T &value : a) cout << value << sep;
cout << '\n';
}
template <class T>
vector<int> compress(vector<T> &values) {
vector<T> sorted = values;
sort(sorted.begin(), sorted.end());
sorted.resize(unique(sorted.begin(), sorted.end()) - sorted.begin());
vector<int> result(values.size());
for (int i = 0; i < values.size(); ++i) {
result[i] =
lower_bound(sorted.begin(), sorted.end(), values[i]) - sorted.begin();
}
return result;
}
int get_bit(long long mask, int bit) { return (int)((mask >> bit) & 1); }
string reverse(string s) {
reverse(s.begin(), s.end());
return s;
}
vector<int> reverse(vector<int> a) {
reverse(a.begin(), a.end());
return a;
}
vector<int> concat_separated(vector<int> &a, vector<int> &b, int sep = -1) {
size_t n = a.size(), m = b.size();
vector<int> s(n + 1 + m);
for (int i = 0; i < n; ++i) s[i] = a[i];
s[n] = sep;
for (int j = 0; j < m; ++j) s[n + 1 + j] = b[j];
return s;
}
const int BASE = 1000 * 1000 * 1000 + 7;
const int MODULO = 1000 * 1000 * 1000 + 31;
template <int modulo>
inline int add(int a, int b) {
return (a + b) % modulo;
}
template <int modulo>
inline int subtract(int a, int b) {
return add<modulo>(a, modulo - b);
}
template <int modulo>
inline int multiply(long long a, long long b) {
return (int)((a * b) % modulo);
}
struct DSU {
vector<int> parents;
vector<int> sizes;
vector<int> ranks;
DSU(size_t n = 1) { resize(n); }
void resize(size_t n) {
parents.resize(n);
for (int v = 0; v < n; ++v) {
parents[v] = v;
}
ranks.resize(n, 1);
sizes.resize(n, 0);
}
int get(int v) {
int parent = parents[v];
if (parent == v) return v;
return parents[v] = get(parent);
}
bool merge(int f, int t, int weight = 1, bool multiple_edges = false) {
int a = get(f);
int b = get(t);
if (multiple_edges) {
sizes[a] += weight;
}
if (a == b) return false;
if (ranks[a] < ranks[b]) {
swap(a, b);
}
parents[b] = a;
if (ranks[a] == ranks[b]) ++ranks[a];
sizes[a] += sizes[b];
if (!multiple_edges) sizes[a] += weight;
return true;
}
bool connected(int f, int t) { return get(f) == get(t); }
int get_size(int v) { return sizes[get(v)]; }
};
class SegmentTree {
public:
int size;
vector<long long> t;
SegmentTree(int n) : size(n), t(size << 2, 0) {}
void update_vertex(int v, int vL, int vR) { t[v] = t[vL] + t[vR]; }
int index;
long long value;
void update_value(int _index, long long _value) {
index = _index;
value = _value;
update_tree_index(1, 0, size);
}
void update_tree_index(int v, int left, int right) {
if (left + 1 == right) {
t[v] = value;
} else {
int mid = (left + right) >> 1;
int vL = (v << 1), vR = (vL + 1);
if (index < mid)
update_tree_index(vL, left, mid);
else
update_tree_index(vR, mid, right);
update_vertex(v, vL, vR);
}
}
int get_prefix(long long _value) {
value = _value;
return get_tree_prefix(1, 0, size);
}
int get_tree_prefix(int v, int left, int right) {
if (left + 1 == right) {
return left;
} else {
int mid = (left + right) >> 1;
int vL = (v << 1), vR = (vL + 1);
long long left_value = t[vL];
if (left_value < value) {
value -= left_value;
return get_tree_prefix(vR, mid, right);
} else {
return get_tree_prefix(vL, left, mid);
}
}
}
};
class FenwickTree {
int size;
vector<long long> t;
vector<long long> values;
public:
FenwickTree(int n) : size(n + 1), t(size, 0LL), values(size, 0LL) {}
void update_tree_index(int index, long long delta) {
for (; index < size; index += index & -index) {
t[index] += delta;
}
}
void update_value(int index, long long value) {
++index;
long long delta = value - values[index];
values[index] = value;
update_tree_index(index, delta);
}
long long _sum;
int get_prefix(long long value) {
int result = 0;
_sum = 0;
for (int bit = 20; bit >= 0; --bit) {
int next = result | (1 << bit);
if (next < size && _sum + t[next] < value) {
result = next;
_sum += t[next];
}
}
return result;
}
};
template <int block_size>
class SqrtDecomposition {
int size;
vector<long long> blocks;
vector<long long> values;
public:
SqrtDecomposition(int n) : size(n), blocks(size, 0LL), values(size, 0LL) {}
void update_index(int index, long long delta) {
int block = index / block_size;
blocks[block] += delta;
}
void update_value(int index, long long value) {
long long delta = value - values[index];
values[index] = value;
update_index(index, delta);
}
long long sum;
int get_prefix(long long value) {
int result = 0;
sum = 0;
for (int block = 0; block * block_size < size; ++block) {
long long next_sum = sum + blocks[block];
if (next_sum < value) {
sum = next_sum;
} else {
result = block * block_size;
break;
}
}
while (result < size && sum + values[result] < value) {
sum += values[result];
++result;
}
return result;
}
};
const int MAX_K = 1e6 + 1;
int counts[MAX_K];
int get_answer(int n, vector<int> &a, int k, int d) {
int answer = k;
int unique = 0;
for (int i = 0; i < n; ++i) {
counts[a[i]]++;
if (counts[a[i]] == 1) ++unique;
if (i >= d) {
counts[a[i - d]]--;
if (counts[a[i - d]] == 0) --unique;
}
if (i >= d - 1) answer = min(answer, unique);
}
for (int i = 0; i < n; ++i) {
counts[a[i]] = 0;
}
return answer;
}
vector<int> get_brute_answer(int n, int m,
vector<pair<int, int> > &friend_queries, int k,
vector<pair<int, int> > &edges, int q,
vector<vector<int> > &queries) {
DSU dsu(n);
map<int, vector<int> > friends;
for (pair<int, int> &friend_query : friend_queries) {
int f = friend_query.first - 1, t = friend_query.second - 1;
friends[f].push_back(t);
friends[t].push_back(f);
}
for (pair<int, int> &edge_query : edges) {
int f = edge_query.first - 1, t = edge_query.second - 1;
dsu.merge(f, t);
}
vector<int> answer;
return answer;
}
FILE *print_file;
int print_test(int n, int m, vector<pair<int, int> > &friends, int k,
vector<pair<int, int> > &edges, int q,
vector<vector<int> > &queries, vector<int> &expected,
vector<int> &actual, int bad_index) {
fprintf(print_file, "%d %d %d\n", n, m, k);
for (pair<int, int> &fq : friends) {
fprintf(print_file, "%d %d\n", fq.first, fq.second);
}
for (pair<int, int> &eq : edges) {
fprintf(print_file, "%d %d\n", eq.first, eq.second);
}
fprintf(print_file, "%d\n", q);
fprintf(print_file, "===\n");
for (int value : expected) {
fprintf(print_file, "%d ", value);
}
fprintf(print_file, "\n");
for (int value : actual) {
fprintf(print_file, "%d ", value);
}
fprintf(print_file, "\n");
fprintf(print_file, "%d\n", bad_index);
fprintf(print_file, "===\n\n");
return 1 + m + k + 1 + q + 1 + 1 + 1 + 1 + 1 + 1;
}
void set_print_file(const char *file_name) {
print_file = fopen(file_name, "a");
}
void stress(int first_new_line = 1) {
std::mt19937 rnd(time(0));
std::uniform_int_distribution<> nGen(1, 20);
std::uniform_int_distribution<> mGen(0, 10);
std::uniform_int_distribution<> kGen(0, 10);
int first_line = first_new_line;
for (int it = 0; it < 10; ++it) {
int n = nGen(rnd);
int m = mGen(rnd);
m = min(m, n * (n - 1) / 2);
int k = kGen(rnd);
k = min(k, n * (n - 1) / 2);
std::uniform_int_distribution<> vGen(1, n);
set<pair<int, int> > fp;
vector<pair<int, int> > friends;
for (int i = 0; i < m; ++i) {
while (true) {
int f = vGen(rnd);
int t = vGen(rnd);
if (f > t) swap(f, t);
if (f != t && !fp.count({f, t})) {
fp.insert({f, t});
friends.push_back({f, t});
break;
}
}
}
set<pair<int, int> > ep;
vector<pair<int, int> > edges;
for (int i = 0; i < k; ++i) {
while (true) {
int f = vGen(rnd);
int t = vGen(rnd);
if (f > t) swap(f, t);
if (f != t && !ep.count({f, t})) {
ep.insert({f, t});
edges.push_back({f, t});
break;
}
}
}
int q = 20;
vector<vector<int> > queries(q);
vector<int> expected =
get_brute_answer(n, m, friends, k, edges, q, queries);
vector<int> actual;
int bad_index = -1;
for (int i = 0; i < expected.size(); ++i) {
if (expected[i] != actual[i]) {
bad_index = i;
break;
}
}
if (bad_index >= 0) {
std::cout << "Gotcha!" << SPACE << first_line << ENDL;
first_line += print_test(n, m, friends, k, edges, q, queries, expected,
actual, bad_index);
}
}
fclose(print_file);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int tests = read_size();
for (int t = 0; t < tests; ++t) {
int n = read_size();
int k = read_size();
int d = read_size();
vector<int> a;
read_vector(a, n);
int answer = get_answer(n, a, k, d);
cout << answer << ENDL;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int f[10];
vector<int> sol;
int dp[10][1000001];
bool vis[10][1000001];
int calc(int i, int v) {
if (v < 0) return -(1 << 29);
if (!i) return 0;
if (vis[i][v] == false) {
vis[i][v] = true;
dp[i][v] = max(calc(i - 1, v), 1 + calc(i, v - f[i]));
}
return dp[i][v];
}
void print(int i, int v) {
if (v < 0) return;
if (!i) return;
if (dp[i][v] == 1 + calc(i, v - f[i])) {
printf("%d", i);
print(i, v - f[i]);
} else
print(i - 1, v);
}
int main() {
int v;
cin >> v;
for (int i = 1; i <= 9; ++i) cin >> f[i];
int x = calc(9, v);
if (x > 0)
print(9, v);
else
printf("-1");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
const int mod = 1000000007;
const int inf = 50000000;
const int maxn = 300010;
int n, t, k, A[maxn], L[maxn], isLeaf[maxn];
vector<int> level[maxn], adj[maxn];
int main() {
scanf("%d %d %d", &n, &t, &k);
int mxlvs = 0;
level[0].push_back(1);
isLeaf[1] = 1;
A[0] = 1;
L[0] = 0;
int x = 1;
for (int i = 1; i <= t; i++) {
scanf("%d", &A[i]);
mxlvs += A[i];
L[i] = A[i] - 1 + (i == t);
for (int j = 1; j <= A[i]; j++) {
isLeaf[x + j] = 1;
level[i].push_back(x + j);
}
x += A[i];
}
mxlvs -= (t - 1);
if (mxlvs < k || k < A[t]) {
printf("-1\n");
return 0;
}
int red = mxlvs - k;
for (int i = 2; i <= t; i++) {
if (red >= min(L[i - 1], L[i])) {
red -= min(L[i - 1], L[i]);
L[i - 1] -= min(L[i - 1], L[i]);
} else {
L[i - 1] -= red;
red = 0;
break;
}
}
if (red != 0) {
printf("-1\n");
return 0;
}
for (int i = 1; i <= t; i++) {
int p1 = 0, p2 = 0;
for (int j = 0; j < A[i - 1] - L[i - 1]; j++) {
adj[level[i - 1][p1]].push_back(level[i][p2]);
p1 += 1;
p2 += 1;
}
while (p2 < level[i].size()) {
adj[level[i - 1][0]].push_back(level[i][p2]);
p2 += 1;
}
}
printf("%d\n", n);
for (int i = 1; i <= n; i++) {
for (int it : adj[i]) {
printf("%d %d\n", i, it);
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e3 + 5;
template <typename T>
void chkmax(T &x, T y) {
x = max(x, y);
}
template <typename T>
void chkmin(T &x, T y) {
x = min(x, y);
}
template <typename T>
void read(T &x) {
x = 0;
int f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -f;
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
x *= f;
}
template <typename T>
void write(T x) {
if (x < 0) x = -x, putchar('-');
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
template <typename T>
void writeln(T x) {
write(x);
puts("");
}
int n, Min, ans;
vector<int> a[MAXN];
bool vis[MAXN], mp[MAXN][MAXN];
char s[MAXN][MAXN];
int tot, belong[MAXN], size[MAXN];
int timer, dfn[MAXN], low[MAXN];
int top, Stack[MAXN];
bool instack[MAXN];
void tarjan(int pos) {
dfn[pos] = low[pos] = ++timer;
instack[pos] = true;
Stack[++top] = pos;
for (unsigned i = 0; i < a[pos].size(); i++)
if (dfn[a[pos][i]] == 0) {
tarjan(a[pos][i]);
low[pos] = min(low[pos], low[a[pos][i]]);
} else if (instack[a[pos][i]])
low[pos] = min(low[pos], dfn[a[pos][i]]);
if (low[pos] == dfn[pos]) {
int tmp = Stack[top--];
instack[tmp] = false;
belong[tmp] = ++tot, size[tot]++;
while (tmp != pos) {
tmp = Stack[top--];
instack[tmp] = false;
belong[tmp] = tot, size[tot]++;
}
}
}
int fac(int x) {
if (x == 0) return 1;
int ans = x;
while (--x) ans *= x;
return ans;
}
void work(int pos, int cnt) {
if (pos > n) {
for (int i = 1; i <= n; i++) a[i].clear();
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (i != j && (mp[i][j] ^ vis[i] ^ vis[j])) a[i].push_back(j);
memset(dfn, 0, sizeof(dfn)), tot = 0;
tarjan(1);
bool flg = true;
for (int i = 1; i <= n; i++)
if (!dfn[i] || belong[i] != belong[1]) {
flg = false;
break;
}
if (flg) {
if (cnt < Min) {
Min = cnt;
ans = fac(cnt);
} else if (cnt == Min)
ans += fac(cnt);
}
} else {
vis[pos] = true;
work(pos + 1, cnt + 1);
vis[pos] = false;
work(pos + 1, cnt);
}
}
int main() {
read(n);
for (int i = 1; i <= n; i++) {
scanf("\n%s", s[i] + 1);
for (int j = 1; j <= n; j++) {
mp[i][j] = s[i][j] == '1';
if (mp[i][j]) a[i].push_back(j);
}
}
if (n <= 6) {
Min = 1e9, work(1, 0);
if (Min > 2)
puts("-1");
else
cout << Min << ' ' << ans << endl;
return 0;
}
static int d[MAXN], res[MAXN];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) d[i] += mp[i][j];
memcpy(res, d, sizeof(d));
sort(res + 1, res + n + 1, [&](int x, int y) { return x > y; });
bool flg = false;
int pre = 0;
for (int j = 1; j <= n - 1; j++) {
pre += res[j];
flg |= pre == j * (j - 1) / 2 + j * (n - j);
}
if (!flg) {
cout << 0 << ' ' << 1 << endl;
return 0;
}
int ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++)
if (i != j) {
d[i] -= mp[i][j], d[i] += mp[j][i];
d[j] += mp[i][j], d[j] -= mp[j][i];
}
memcpy(res, d, sizeof(d));
sort(res + 1, res + n + 1, [&](int x, int y) { return x > y; });
bool flg = false;
int pre = 0;
for (int j = 1; j <= n - 1; j++) {
pre += res[j];
flg |= pre == j * (j - 1) / 2 + j * (n - j);
}
ans += !flg;
for (int j = 1; j <= n; j++)
if (i != j) {
d[j] -= mp[i][j], d[j] += mp[j][i];
d[i] += mp[i][j], d[i] -= mp[j][i];
}
}
cout << 1 << ' ' << ans << endl;
return 0;
}
| 12 |
#include <bits/stdc++.h>
const int MAX_L = 2005;
const int INF_INT = 0x3f3f3f3f;
const long long INF_LL = 0x7fffffff;
const int MOD = 1e9 + 7;
const double eps = 1e-9;
const double pi = acos(-1);
using namespace std;
const int N = 5000;
char s[5000];
char t[5000];
int p[5000];
int a[5000];
int b[5000];
void manacher() {
t[0] = '@';
t[1] = '#';
int n = 2;
int tt = strlen(s + 1);
for (int i = 1; i <= tt; i++) t[n++] = s[i], t[n++] = '#';
s[n] = '\0';
int mx = 0, id = 0;
for (int i = 1; i <= n - 1; i++) {
if (mx > i)
p[i] = min(mx - i, p[2 * id - i]);
else
p[i] = 1;
while (t[i - p[i]] == t[i + p[i]]) p[i]++;
if (mx < i + p[i]) mx = i + p[i], id = i;
}
}
int main(int argc, char const *argv[]) {
while (scanf("%s", s + 1) == 1) {
manacher();
int len = strlen(t);
memset(a, 0, sizeof(a));
memset(b, 0, sizeof(b));
for (int i = 1; i < len; i++) {
for (int j = 0; j < p[i]; j++) a[i + j]++;
}
for (int i = 1; i < len; i++) {
for (int j = 0; j < p[i]; j++) b[i - j]++;
}
vector<int> pre, suf;
for (int i = 2; i < len; i += 2) pre.push_back(a[i]), suf.push_back(b[i]);
for (int i = suf.size() - 2; i >= 0; i--) suf[i] += suf[i + 1];
long long ans = 0;
len = strlen(s + 1);
suf.push_back(0);
for (int i = 1; i <= len; i++) ans += pre[i - 1] * suf[i];
cout << ans << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mn = 100005;
int n, a[mn];
int ans = 0, ans2 = 0;
vector<vector<int> > comp;
bool seen[mn];
vector<vector<int> > mod[5];
void print(vector<int>& cur, int l, int r) {
ans2++;
printf("%d\n", r - l);
for (int i = l; i < r; i++) printf("%d ", cur[i] + 1);
printf("\n");
for (int i = l + 1; i < r; i++) printf("%d ", cur[i] + 1);
printf("%d ", cur[l] + 1);
printf("\n");
}
void print(const vector<int>& cur, int l1, int r1, int l2, int r2) {
ans2++;
printf("%d\n", r2 - l1);
for (int i = l1; i < r2; i++) printf("%d ", cur[i] + 1);
printf("\n");
for (int i = l1 + 1; i < r1; i++) printf("%d ", cur[i] + 1);
printf("%d ", cur[l1] + 1);
for (int i = l2 + 1; i < r2; i++) printf("%d ", cur[i] + 1);
printf("%d ", cur[l2] + 1);
printf("\n");
}
int main() {
n = ({
int t;
scanf("%d", &t);
t;
});
for (int i = 0; i < n; i++)
a[i] = ({
int t;
scanf("%d", &t);
t;
}) -
1;
for (int i = 0; i < n; i++)
if (!seen[i]) {
vector<int> v;
int j = i;
do {
seen[j] = 1;
v.push_back(j);
j = a[j];
} while (j != i);
comp.push_back(v);
}
for (int i = 0; i < comp.size(); i++) {
int v = comp[i].size();
while (v >= 6) v -= 4, ans++;
if (v == 5) v = 0, ans++;
mod[v].push_back(comp[i]);
}
ans += mod[4].size();
if (mod[2].size() > mod[3].size()) {
ans += mod[3].size();
int rem = mod[2].size() - mod[3].size();
ans += (rem + 1) / 2;
} else {
int rem = mod[3].size() - mod[2].size();
ans += mod[2].size();
ans += rem / 3 * 2;
ans += rem % 3;
}
printf("%d\n", ans);
for (int t = 0; t < 5; t++)
for (int i = 0; i < mod[t].size(); i++) {
vector<int> cur = mod[t][i];
int v = cur.size();
while (v >= 6) {
print(cur, v - 5, v);
v -= 4;
}
if (v == 5) {
print(cur, v - 5, v);
v = 0;
}
mod[t][i] = cur;
}
for (int i = 0; i < mod[4].size(); i++) {
vector<int> cur = mod[4][i];
print(cur, 0, 4);
}
if (mod[2].size() > mod[3].size()) {
for (int i = 0; i < mod[3].size(); i++) {
vector<int> cur = mod[3][i];
vector<int> cur1 = mod[2][i];
vector<int> r;
r.push_back(cur[0]);
r.push_back(cur[1]);
r.push_back(cur[2]);
r.push_back(cur1[0]);
r.push_back(cur1[1]);
print(r, 0, 3, 3, 5);
}
for (int i = mod[3].size(); i < mod[2].size(); i++) {
if (i + 1 == mod[2].size())
print(mod[2][i], 0, 2);
else {
vector<int> r;
r.push_back(mod[2][i][0]);
r.push_back(mod[2][i][1]);
r.push_back(mod[2][i + 1][0]);
r.push_back(mod[2][i + 1][1]);
print(r, 0, 2, 2, 4);
i++;
}
}
} else {
for (int i = 0; i < mod[2].size(); i++) {
vector<int> cur = mod[3][i];
vector<int> cur1 = mod[2][i];
vector<int> r;
r.push_back(cur[0]);
r.push_back(cur[1]);
r.push_back(cur[2]);
r.push_back(cur1[0]);
r.push_back(cur1[1]);
print(r, 0, 3, 3, 5);
}
for (int i = mod[2].size(); i < mod[3].size(); i++) {
if (i + 2 >= mod[3].size())
print(mod[3][i], 0, 3);
else {
vector<int> r;
r.push_back(mod[3][i][0]);
r.push_back(mod[3][i][1]);
r.push_back(mod[3][i][2]);
r.push_back(mod[3][i + 1][0]);
r.push_back(mod[3][i + 1][1]);
i++;
print(r, 0, 3, 3, 5);
r.clear();
r.push_back(mod[3][i + 1][0]);
r.push_back(mod[3][i + 1][1]);
r.push_back(mod[3][i + 1][2]);
r.push_back(mod[3][i][0]);
r.push_back(mod[3][i][2]);
print(r, 0, 3, 3, 5);
i++;
}
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-7;
const int N = 1024;
struct point {
double x, y;
inline point operator+(const point& rhs) const {
return (point){x + rhs.x, y + rhs.y};
}
inline point operator-(const point& rhs) const {
return (point){x - rhs.x, y - rhs.y};
}
inline double length() { return sqrt(x * x + y * y); }
inline point operator*(const double& t) const {
return (point){x * t, y * t};
}
inline point operator/(const double& t) const {
return (point){x / t, y / t};
}
} A[N];
inline double cross(const point& a, const point& b) {
return a.x * b.y - a.y * b.x;
}
struct Line {
point X, Y;
double tht;
inline bool operator<(const Line& rhs) const {
if (fabs(tht - rhs.tht) > eps) return tht < rhs.tht;
return cross(rhs.Y - X, Y - X) > 0;
}
inline void flip() { swap(X, Y); }
inline void move(double r) {
point a = Y - X;
point b = (point){-a.y, a.x};
b = b / b.length() * r;
X = X + b, Y = Y + b;
}
inline void getdeg() { tht = atan2(Y.y - X.y, Y.x - X.x); }
} B[N], sta[N];
int n, m, hd, tl;
point get_dot(Line a, Line b) {
double t = cross(b.Y - b.X, a.X - b.X) / cross(a.Y - a.X, b.Y - b.X);
return a.X + (a.Y - a.X) * t;
}
bool test(Line a, point t) { return cross(t - a.X, a.Y - a.X) >= 0; }
bool check1(Line a, Line b) {
return fabs(cross(a.Y - a.X, b.Y - b.X)) < eps &&
cross(a.Y - a.X, b.Y - a.X) <= 0;
}
bool check0(int _L, int _R, double r) {
m = n;
for (int i = 1; i <= n; ++i) B[i] = (Line){A[i], A[i % n + 1], 0};
for (int i = _L;; i = i % n + 1) {
B[++m] = B[i];
B[m].move(r);
B[m].flip();
if (i == _R) break;
}
for (int i = 1; i <= m; ++i) B[i].getdeg();
sort(B + 1, B + m + 1);
hd = 1, tl = 1;
sta[1] = B[1];
for (int i = 2; i <= m; ++i)
if (fabs(B[i].tht - B[i - 1].tht) > eps) {
while (hd < tl && test(B[i], get_dot(sta[tl], sta[tl - 1]))) --tl;
while (hd < tl && test(B[i], get_dot(sta[hd], sta[hd + 1]))) ++hd;
if (hd <= tl && check1(B[i], sta[tl])) return 0;
sta[++tl] = B[i];
}
while (hd + 1 < tl && test(sta[hd], get_dot(sta[tl], sta[tl - 1]))) --tl;
while (hd + 1 < tl && test(sta[tl], get_dot(sta[hd], sta[hd + 1]))) ++hd;
return tl - hd + 1 > 2;
}
bool check(double r, bool flag = 0) {
for (int i = 1, _r = 1; i <= n; ++i) {
while (_r < n && check0(i, _r + 1, r)) ++_r;
if ((i == 1 && _r == n) || check0(_r % n + 1, (i == 1) ? n : i - 1, r)) {
if (flag) {
point x = get_dot(sta[hd], sta[hd + 1]);
cout << x.x << ' ' << x.y << '\n';
check0(i, _r, r);
x = get_dot(sta[hd], sta[hd + 1]);
cout << x.x << ' ' << x.y << '\n';
return 1;
} else
return 1;
}
}
return 0;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i) cin >> A[i].x >> A[i].y;
if (n <= 4) {
cout << "0\n"
<< A[1].x << ' ' << A[1].y << '\n'
<< A[3].x << ' ' << A[3].y << '\n';
return 0;
}
double l = eps, r = 10000;
for (int T = 0; T <= 50; ++T) {
const double mid = (l + r) / 2;
if (check(mid))
r = mid;
else
l = mid;
}
cout << fixed << setprecision(13) << r << '\n';
check(r, 1);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, vis[200005], size[200005], ans, x, y;
vector<long long> v[200005];
void dfs(long long x, long long fa) {
size[x] = vis[x] == 1;
for (long long i = 0; i < v[x].size(); i++) {
long long h = v[x][i];
if (h == fa) continue;
dfs(h, x);
size[x] += size[h];
}
}
void dfs2(long long x, long long fa) {
for (long long i = 0; i < v[x].size(); i++) {
long long h = v[x][i];
if (h == fa) continue;
ans += min(m * 2 - size[h], size[h]);
dfs2(h, x);
}
}
signed main() {
ios::sync_with_stdio(0);
cin >> n >> m;
for (long long i = 1; i <= m << 1; i++) cin >> x, vis[x] = 1;
for (long long i = 1; i < n; i++) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
dfs(1, 0);
dfs2(1, 0);
printf("%lld", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1E5 + 5;
struct Point {
long long x, y, w;
double l, r;
} a[N];
long long n, Ans = 0, num[N], cnt[N];
double w;
bool cmp1(Point a, Point b) { return a.l < b.l; }
bool cmp2(Point a, Point b) { return a.r < b.r; }
long long find(long long x) {
long long ret = 0;
while (x) {
ret += cnt[x];
x -= (x & (-x));
}
return ret;
}
long long Get(long long l, long long r) { return find(r) - find(l - 1); }
void change(long long x, long long v) {
while (x <= n) {
cnt[x] += v;
x += (x & (-x));
}
}
int main() {
scanf("%I64d%lf", &n, &w);
w += 0.000005;
for (long long i = 1; i <= n; i++) {
scanf("%I64d", &a[i].x);
scanf("%I64d", &a[i].y);
a[i].w = i;
a[i].l = double(a[i].x) / double(a[i].y - w);
a[i].r = double(a[i].x) / double(a[i].y + w);
}
sort(a + 1, a + n + 1, cmp1);
for (long long i = 1; i <= n; i++) {
num[a[i].w] = i;
}
sort(a + 1, a + n + 1, cmp2);
for (long long i = 1; i <= n; i++) {
Ans += Get(num[a[i].w] + 1, n);
change(num[a[i].w], 1);
}
printf("%I64d\n", Ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
struct Node {
int x, y, step;
};
int s[1005][1005];
char mp[1005][1005];
bool vis[1005][1005];
int dir[4][2] = {0, 1, 0, -1, -1, 0, 1, 0};
int n, m, sx, sy, ex, ey, ans, shortest;
bool ISok(int x, int y) {
if (x >= 0 && x < n && y >= 0 && y < m && !vis[x][y] && mp[x][y] != 'T')
return true;
return false;
}
void bfs() {
int flag = 0;
queue<Node> Q;
memset(vis, false, sizeof(vis));
Node st, now;
while (!Q.empty()) Q.pop();
st.x = sx, st.y = sy, st.step = 0;
vis[sx][sy] = true;
Q.push(st);
while (!Q.empty()) {
st = Q.front();
Q.pop();
if (st.x == ex && st.y == ey) {
shortest = st.step;
return;
}
for (int i = 0; i < 4; i++) {
int dx = st.x + dir[i][0];
int dy = st.y + dir[i][1];
if (ISok(dx, dy)) {
if (isdigit(mp[dx][dy]) && mp[dx][dy] != '0') s[dx][dy] = st.step + 1;
now.x = dx;
now.y = dy;
now.step = st.step + 1;
vis[dx][dy] = true;
Q.push(now);
}
}
}
return;
}
int main() {
while (~scanf("%d%d", &n, &m)) {
ans = 0;
memset(s, 0, sizeof(s));
for (int i = 0; i < n; i++) {
scanf("%s", mp[i]);
for (int j = 0; j < m; j++) {
if (mp[i][j] == 'E') sx = i, sy = j;
if (mp[i][j] == 'S') ex = i, ey = j;
}
}
bfs();
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (s[i][j] && s[i][j] <= shortest) ans += (mp[i][j] - '0');
printf("%d\n", ans);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void fs(long long int &number) {
bool negative = false;
register long long int c;
number = 0;
c = getchar();
if (c == '-') {
negative = true;
c = getchar();
}
for (; (c > 47 && c < 58); c = getchar()) number = number * 10 + c - 48;
if (negative) number *= -1;
}
long long int power(long long int a, long long int x) {
a %= 100000000000007;
long long int res = 1;
while (x > 0) {
if (x & 1) res = res * a % 100000000000007;
a = a * a % 100000000000007;
x >>= 1;
}
return res;
}
long long int max(long long int a, long long int b) {
if (a > b) {
return a;
} else {
return b;
}
}
long long int madd(long long int a, long long int b) {
long long int ans;
ans = (a % 100000000000007 + b % 100000000000007) % 100000000000007;
return ans;
}
long long int mmult(long long int a, long long int b) {
long long int ans = 1;
ans = ((a % 100000000000007) * (b % 100000000000007)) % 100000000000007;
return ans % 100000000000007;
}
long long int modinverse(long long int a) {
return power(a, 100000000000007 - 2);
}
long long int fact[30];
long long int ncn2(long long int n) {
return fact[n] / (fact[n / 2] * fact[n / 2]);
}
long long int fnum(long long int x) {
vector<long long int> v;
while (x != 0) {
v.push_back(x % 10);
x = x / 10;
}
long long int count = 0;
vector<long long int> temp;
for (long long int i = v.size() - 1; i >= 0; i--) {
temp.push_back(v[i]);
}
for (long long int i = 0; i < v.size(); i++) {
temp.push_back(v[i]);
}
long long int sum = 0;
for (long long int i = 0; i < temp.size(); i++) {
sum += (temp[i]) * power(10, i);
}
return sum;
}
void its_her_choice() {
long long int n, s, t;
cin >> n >> s >> t;
cout << max(n - s + 1, n - t + 1);
cout << "\n";
}
signed main() {
long long int t;
cin >> t;
for (long long int casn = 1; casn < t + 1; casn++) {
its_her_choice();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int s[3005][3005], r[3005][3005], c[3005][3005];
struct note {
int x1, y1, x2, y2;
} a[300005];
int n;
int ans[300005];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x1, y1, x2, y2;
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
x1++;
y1++;
a[i].x1 = x1;
a[i].x2 = x2;
a[i].y1 = y1;
a[i].y2 = y2;
for (int j = x1; j <= x2; j++)
for (int k = y1; k <= y2; k++) s[j][k] = 1;
for (int j = x1; j <= x2; j++) r[j][y1] = 1, r[j][y2 + 1] = 1;
for (int j = y1; j <= y2; j++) c[x1][j] = 1, c[x2 + 1][j] = 1;
}
for (int i = 1; i <= 3001; i++)
for (int j = 1; j <= 3001; j++) {
s[i][j] += s[i - 1][j] + s[i][j - 1] - s[i - 1][j - 1];
r[i][j] += r[i - 1][j];
c[i][j] += c[i][j - 1];
}
for (int i = 1; i <= n; i++) {
int x1 = a[i].x1, y1 = a[i].y1, len = min(3000 - x1 + 1, 3000 - y1 + 1);
for (int j = 1; j <= len; j++) {
int x2 = x1 + j - 1, y2 = y1 + j - 1;
if (s[x2][y2] - s[x1 - 1][y2] - s[x2][y1 - 1] + s[x1 - 1][y1 - 1] !=
j * j)
break;
if (r[x2][y1] - r[x1 - 1][y1] != j) break;
if (r[x2][y2 + 1] - r[x1 - 1][y2 + 1] != j) continue;
if (c[x1][y2] - c[x1][y1 - 1] != j) break;
if (c[x2 + 1][y2] - c[x2 + 1][y1 - 1] != j) continue;
for (int k = 1; k <= n; k++) {
if (a[k].x1 >= x1 && a[k].x2 <= x2 && a[k].y1 >= y1 && a[k].y2 <= y2) {
ans[++ans[0]] = k;
}
}
printf("YES %d\n", ans[0]);
for (int k = 1; k <= ans[0]; k++) printf("%d ", ans[k]);
return 0;
}
}
puts("NO");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
const int N = 210, M = 40100;
int n, m, g[N][N], u[M], v[M], w[M];
double ans;
pair<int, int> p[N];
bool cmp(const pair<int, int> &a, const pair<int, int> &b) {
return a.first > b.first || (a.first == b.first && a.second > b.second);
}
double ff(int u, int v, int w) {
for (int i = 1; i < n + 1; i++) p[i] = make_pair(g[i][u], g[i][v]);
sort(p + 1, p + n + 1, cmp);
pair<int, int> c = p[1];
double ret = c.first;
for (int i = 2; i < n + 1; i++)
if (p[i].first < c.first && p[i].second > c.second)
ret = min(ret, 0.5 * (p[i].first + c.second + w)), c = p[i];
ret = min(ret, 1. * c.second);
return ret;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i < n + 1; i++)
for (int j = 1; j < n + 1; j++) g[i][j] = (i == j ? 0 : 0x20202020);
for (int i = 0; i < m; i++) {
scanf("%d%d%d", u + i, v + i, w + i);
g[u[i]][v[i]] = g[v[i]][u[i]] = w[i];
}
for (int k = 1; k < n + 1; k++)
for (int i = 1; i < n + 1; i++)
for (int j = 1; j < n + 1; j++)
if (i != j && i != k && j != k)
g[i][j] = min(g[i][j], g[i][k] + g[k][j]);
ans = 1e20;
for (int i = 0; i < m; i++) ans = min(ans, ff(u[i], v[i], w[i]));
printf("%.10f\n", ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct point {
int x, y;
point() {}
point(int a, int b) { x = a, y = b; }
};
template <class T>
T sqr(T a) {
return a * a;
}
template <class T>
T power(T n, T p) {
T res = 1;
for (int i = 0; i < p; i++) res *= n;
return res;
}
template <class T>
double getdist(T a, T b) {
return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}
template <class T>
T extract(string s, T ret) {
stringstream ss(s);
ss >> ret;
return ret;
}
template <class T>
string tostring(T n) {
stringstream ss;
ss << n;
return ss.str();
}
long long mod = 1000000009;
long long arr[300010], F[300010];
namespace fibonacci {
void gen(int n) {
F[1] = F[2] = 1;
for (int i = 3; i <= n; i++) F[i] = (F[i - 1] + F[i - 2]) % mod;
}
long long kth_fibo(long long f1, long long f2, long long k) {
if (k == 1) return f1;
if (k == 2) return f2;
long long ret = (F[k - 1] * f2) % mod;
ret += (F[k - 2] * f1) % mod;
ret %= mod;
return ret;
}
long long sum(long long f1, long long f2, long long k) {
long long ret = (kth_fibo(f1, f2, k + 2) - f2) % mod;
ret += mod;
return ret % mod;
}
} // namespace fibonacci
struct node {
long long f1, f2, sum;
node(long long sum = 0, long long f1 = 0, long long f2 = 0)
: sum(sum), f1(f1), f2(f2){};
void add(long long _f1, long long _f2, long long k) {
f1 += _f1;
f2 += _f2;
f1 %= mod;
f2 %= mod;
sum += fibonacci::sum(_f1, _f2, k);
sum %= mod;
}
};
node segtree[300010 * 4];
void build(int l, int r, int cur) {
if (l == r) {
segtree[cur] = node(arr[l] % mod);
return;
}
int lchild = cur << 1, rchild = lchild | 1, m = (l + r) >> 1;
build(l, m, lchild);
build(m + 1, r, rchild);
segtree[cur].sum = segtree[lchild].sum + segtree[rchild].sum;
segtree[cur].sum %= mod;
}
void push_down(int l, int r, int cur) {
if (segtree[cur].f1 == 0 && segtree[cur].f2 == 0) return;
if (l == r) return;
int lchild = cur << 1, rchild = lchild | 1, m = (l + r) >> 1;
long long f1, f2, nf1, nf2;
f1 = segtree[cur].f1;
f2 = segtree[cur].f2;
segtree[lchild].add(f1, f2, m - l + 1);
nf1 = fibonacci::kth_fibo(f1, f2, max(1, m - l + 2));
nf2 = fibonacci::kth_fibo(f1, f2, max(2, m - l + 3));
segtree[rchild].add(nf1, nf2, r - m);
segtree[cur].sum = segtree[lchild].sum + segtree[rchild].sum;
segtree[cur].sum %= mod;
segtree[cur].f1 = segtree[cur].f2 = 0;
}
void update(int L, int R, int l, int r, int cur) {
push_down(l, r, cur);
if (l > R || r < L) return;
if (l >= L && r <= R) {
long long f1 = F[l - L + 1];
long long f2 = F[l - L + 2];
segtree[cur].add(f1, f2, r - l + 1);
return;
}
int lchild = cur << 1, rchild = lchild | 1, m = (l + r) >> 1;
update(L, R, l, m, lchild);
update(L, R, m + 1, r, rchild);
segtree[cur].sum = segtree[lchild].sum + segtree[rchild].sum;
segtree[cur].sum %= mod;
}
long long query(int L, int R, int l, int r, int cur) {
push_down(l, r, cur);
if (l > R || r < L) return 0;
if (l >= L && r <= R) return segtree[cur].sum;
int lchild = cur << 1, rchild = lchild | 1, m = (l + r) >> 1;
return (query(L, R, l, m, lchild) + query(L, R, m + 1, r, rchild)) % mod;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m, i, q, l, r;
cin >> n >> m;
for (i = 1; i <= n; i++) cin >> arr[i];
fibonacci::gen(n);
build(1, n, 1);
while (m--) {
cin >> q >> l >> r;
if (q == 1)
update(l, r, 1, n, 1);
else
cout << query(l, r, 1, n, 1) << "\n";
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int P[21] = {1, 2, 3, 5, 7, 11, 13, 17, 19, 23, 29,
31, 37, 41, 43, 47, 53, 59, 61, 67, 71};
const long long int Inf = 1000000000000000000;
int n, np, S[30];
long long int r, ra, rp;
long long int Pot(int a, int b) {
long long int rt = 1, ra = a;
;
for (int i = 1; i <= b; i++) rt = rt * ra;
return rt;
}
void Calcula(int m) {
int i, j, k;
if (m == 1) {
ra = 1;
for (j = 1; j <= np; j++) {
rp = Pot(P[j], S[j] - 1);
if (Inf / rp > ra)
ra = ra * rp;
else
ra = Inf;
}
if (ra < r) r = ra;
} else {
for (i = 60; i >= 2; i--)
if (m % i == 0) {
S[++np] = i;
Calcula(m / i);
np--;
}
}
}
int main() {
cin >> n;
r = Inf;
np = 0;
S[0] = 2000;
Calcula(n);
cout << r;
cin.get();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5010;
int n, b;
int get(int x) {
if (x > b)
return b + 1;
else
return x;
}
int c[N], d[N], sz[N];
int dp[N][N][2];
vector<vector<int> > g(N);
void dfs(int v) {
vector<int> p[2];
for (int to : g[v]) {
dfs(to);
p[0].resize(sz[v] + sz[to] + 1, b + 1);
p[1].resize(sz[v] + sz[to] + 1, b + 1);
for (int i = 0; i <= sz[v]; ++i) {
for (int j = 0; j <= sz[to]; ++j) {
p[0][i + j] = min(p[0][i + j], dp[v][i][0] + dp[to][j][0]);
p[0][i + j] = get(p[0][i + j]);
p[1][i + j] = min(
p[1][i + j], min(p[0][i + j], min(dp[v][i][0], dp[v][i][1]) +
min(dp[to][j][0], dp[to][j][1])));
p[1][i + j] = get(p[1][i + j]);
}
}
for (int i = 0; i < p[0].size(); ++i) {
dp[v][i][0] = p[0][i];
dp[v][i][1] = p[1][i];
}
sz[v] += sz[to];
}
sz[v]++;
dp[v][sz[v]][0] = dp[v][sz[v]][1] = b + 1;
for (int i = sz[v]; i > 0; --i) {
dp[v][i][0] = min(dp[v][i][0], dp[v][i - 1][0] + c[v]);
dp[v][i][0] = get(dp[v][i][0]);
dp[v][i][1] = dp[v][i - 1][1] + d[v];
dp[v][i][1] = get(dp[v][i][1]);
}
dp[v][0][1] = b + 1;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(nullptr);
cin >> n >> b;
for (int i = 1; i <= n; ++i) {
int ci, di;
cin >> ci >> di;
c[i] = ci;
d[i] = c[i] - di;
if (i > 1) {
int p;
cin >> p;
g[p].push_back(i);
}
}
dfs(1);
for (int i = sz[1]; i >= 0; --i) {
if (dp[1][i][0] <= b || dp[1][i][1] <= b) {
cout << i;
return 0;
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> pi;
//bool vis[1000];
int x[]={1,-1,0,0};
int y[]={0,0,1,-1};
//int f=0;
//int t[2000000];
vector<int> v1,v2;
//"'';
/*bool hs(int mask,int i){
return mask & (1 << i);
}*/
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin>>t;
while(t--){
int n;
cin>>n;
vector<int> ans(n,0);
for(int i=0;i<n;i++){
int a;
cin>>a;
ans[i]+=1;
int z=i-a;
if(z>=0){
ans[z]-=1;
}
}
for(int i=n-2;i>=0;i--){
ans[i]+=ans[i+1];
}
for(int i=0;i<n;i++){
if(ans[i]>0){
cout<<1<<" ";
}
else{
cout<<0<<" ";
}
}
cout<<endl;
}
}
| 0 |
#include<bits/stdc++.h>
#define ll long long
#define F first
#define S second
#define PB push_back
#define ALL(a) begin(a),end(a)
#define mem(a,n) memset(a,n,sizeof(a))
#define IOS ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define bug(in) cout<<#in<<" = "<<(in)<<endl;
#define rep(i,a,b) for(int i=(a);i<=(b);i++)
#define PrQ priority_queue <int, vector<int>, greater<int> >
#define mapit map<int,int>::iterator
using namespace std;
const ll LINF=1e18+5,INF=0x3f3f3f3f,eps=1319,mod=1e9+7;
template<typename T>inline void read(T &a){char c=getchar();T x=0,f=1;while(!isdigit(c)){if(c=='-')f=-1;c=getchar();}while(isdigit(c)){x=(x<<1)+(x<<3)+c-'0';c=getchar();}a=f*x;}
inline ll Qpow(ll a,ll b){ll s=1;while(b){if(b&1){s=(s*a)%mod;}a=a*a%mod;b>>=1;}return s;}
inline ll Qinv(ll a){return Qpow(a,mod-2);}
const int maxn= 2e5+5;
//int dir[][2]={{1,0},{0,1},{-1,0},{0,-1},{1,1},{1,-1},{-1,1},{-1,-1},{0,0}};
//ll n,m,k,q,a[maxn],b[maxn];
int n,a[maxn];
char b[maxn];
//-----
const int MOD=998244353;
ll inv[1000100],jc[1000100],x,y;
void gcd(int a,int b)//拓展欧几里得
{
if(b==0) {x=1,y=0;return;}
gcd(b,a%b);
int k=x;x=y;y=k-a/b*y;
return ;
}
void pre(){
jc[1]=1;
for(int i=2;i<=1000000;i++) jc[i]=(jc[i-1]*i)%MOD;
gcd(jc[1000000],MOD); inv[1000000]=(x+MOD)%MOD;
for(int i=999999;i>=0;i--) inv[i]=(inv[i+1]*(i+1))%MOD;
return ;
}
int C(int n,int m){
return (((1LL*jc[n]*inv[m])%MOD)*inv[n-m])%MOD;//组合数
}
//-----
void solve()
{
cin>>n>>b+1;
rep(i,1,n) a[i] = (b[i]=='0' ? 0:1);
ll x=0,y=0,s=0;
rep(i,1,n)
{
if(a[i]==0) x++,y+=s/2,s=0;
if(a[i]==1) s++;
}
y+=s/2;
cout<<max(1,C(x+y,y))<<endl;
}
int main()
{
pre();
IOS;
int t;cin>>t;while(t--)
solve();return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long ans = 0;
string s;
cin >> s;
vector<string> comp;
int l = 0;
for (int i = 0; i < s.size(); i++) {
if (!isalpha(s[i])) {
if (l < i) comp.push_back(s.substr(l, i - l));
string xd = "";
xd += s[i];
comp.push_back(xd);
l = i + 1;
}
}
int n = comp.size();
map<string, long long> coun;
stack<string> cur;
for (int i = 0; i < n; i++) {
if (comp[i] == ".") {
coun[cur.top()]--;
cur.pop();
} else if (comp[i] == ",") {
} else if (comp[i] == ":") {
} else {
ans += coun[comp[i]];
if (comp[i + 1] == ":") {
cur.push(comp[i]);
coun[comp[i]]++;
}
i++;
}
}
cout << ans << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long N;
cin >> N;
for (int i = 0; i < N; i++) {
long long j;
cin >> j;
long long lis[j];
long long sor[j];
for (int l = 0; l < j; l++) {
cin >> lis[l];
}
sor[j - 1] = lis[j - 1];
for (int l = j - 2; l >= 0; l--) {
sor[l] = min(sor[l + 1], lis[l]);
}
long long count = 0;
for (int l = 0; l < j; l++) {
if (lis[l] > sor[l]) {
count++;
}
}
cout << count << endl;
;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 3e5 + 3;
long long n, m, a, pos[maxn], lo[maxn], hi[maxn];
long long st[maxn * 2 * 2], z;
void build_st() {
z = n + m;
for (long long i = (m); i < (z); i++) st[i + z] = 1;
for (long long i = z - 1; i; i--) st[i] = st[i * 2] + st[i * 2 + 1];
}
void update_st(long long p, long long v) {
for (st[p += z] = v; p > 1; p /= 2) st[p / 2] = st[p] + st[p ^ 1];
}
long long query_st(long long l, long long r) {
long long ans = 0;
for (l += z, r += z; l < r; l /= 2, r /= 2) {
if (l & 1) ans += st[l++];
if (r & 1) ans += st[--r];
}
return ans;
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
cin >> n >> m;
for (long long i = (1); i < (n + 1); i++)
lo[i] = hi[i] = i, pos[i] = i + m - 1;
build_st();
while (m--) {
cin >> a;
hi[a] = max(hi[a], query_st(0, pos[a] + 1));
update_st(pos[a], 0);
pos[a] = m;
update_st(pos[a], 1);
lo[a] = 1;
}
for (long long i = (1); i < (n + 1); i++)
hi[i] = max(hi[i], query_st(0, pos[i] + 1));
for (long long i = (1); i < (n + 1); i++)
cout << lo[i] << " " << hi[i] << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long tpp = 9e18;
int tp = 1e9;
long long n, t;
long double fe(long double a, long long b) {
long double r = 1.000000011;
while (b) {
if (b & 1) r = (r * a);
a = (a * a);
b = b >> 1;
}
return r;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> t;
;
long double res = fe(1.000000011, t);
res = res * n;
cout << setprecision(15) << res << endl;
return 0;
;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename V>
ostream &operator<<(ostream &os, const pair<T, V> pai) {
return os << '(' << pai.first << ' ' << pai.second << ')';
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> v) {
cout << '[';
for (int i = 0, _i = (((int)(v).size())); i < _i; i++) cout << v[i] << ",";
cout << "]";
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const set<T> v) {
cout << "{";
for (auto p : v) cout << p << ",";
cout << "}";
return os;
}
template <typename T, typename V>
ostream &operator<<(ostream &os, const map<T, V> v) {
cout << "{";
for (auto p : v) cout << p << ",";
cout << "}";
return os;
}
template <typename T>
void get_max(T &a, T b) {
a = max(a, b);
}
template <typename T>
void get_min(T &a, T b) {
a = min(a, b);
}
int a, b, p, q;
int solve() {
cin >> a >> b >> p >> q;
int interval;
for (interval = 0; interval * interval < b - a + 1; interval++)
;
vector<pair<int, int> > cand;
for (int i = 0, _i = (interval); i < _i; i++)
cand.push_back({2LL * p * i % (2 * q), i});
sort((cand).begin(), (cand).end());
unique((cand).begin(), (cand).end(),
[](pair<int, int> a, pair<int, int> b) { return a.first == b.first; });
0;
int bun;
pair<int, int> res = {(1 << 30), 0};
for (bun = 0; (bun + 1) * interval <= b - a + 1; bun++) {
0;
int tf =
(q + 1LL * (2 * q - 2) * p % (2 * q) * (a + bun * interval)) % (2 * q);
auto p =
lower_bound((cand).begin(), (cand).end(), make_pair(tf, (1 << 30)));
if (p == cand.end()) p = cand.begin();
for (int j = 0, _j = (2); j < _j; j++) {
0;
get_min(res, {min(abs(tf - p->first + (long long)20 * q) % (2 * q),
abs(p->first - tf + (long long)20 * q) % (2 * q)),
a + bun * interval + p->second});
if (p == cand.begin())
p = prev(cand.end());
else
p = prev(p);
}
}
0;
for (int i = (bun * interval + a), _i = (b + 1); i < _i; i++) {
get_min(res, {min((q + (long long)(q * 2 - 2) * p % (2 * q) * i) % (2 * q),
(q + 2LL * p % (2 * q) * i) % (2 * q)),
i});
0;
}
0;
0;
return res.second;
}
int main(void) {
iostream::sync_with_stdio(false);
cin.tie(nullptr), cout.tie(nullptr);
int T;
cin >> T;
for (int i = 0, _i = (T); i < _i; i++) cout << solve() << '\n';
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
while (scanf("%d", &n) == 1) {
if (n % 2 == 0)
printf("-1\n");
else {
for (int i = n - 1; i >= 0; i--) {
printf("%d", i);
if (i != 0)
printf(" ");
else
printf("\n");
}
for (int i = 0; i < n; i++) {
printf("%d", (i * 2) % n);
if (i != n - 1)
printf(" ");
else
printf("\n");
}
for (int i = 0; i <= n - 1; i++) {
printf("%d", (i + n - 1) % n);
if (i != n - 1)
printf(" ");
else
printf("\n");
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100004;
vector<pair<int, int> > g[N];
vector<int> nw;
vector<double> tp;
int n, m, a[N], ok = 0;
double b[N], w = 0;
bool vis[N];
bool dfs(int u, int fa, int na, int nb) {
int v, z;
vis[u] = 1;
nw.push_back(u);
a[u] = na;
b[u] = nb;
for (pair<int, int>& pa : g[u]) {
tie(v, z) = pa;
if (v == fa) continue;
int ma = -na, mb = z - nb;
if (vis[v]) {
if (ma == a[v]) {
if (mb != b[v]) return 0;
} else {
double nw = 1.0 * (mb - b[v]) / (a[v] - ma);
if (ok && w != nw) return 0;
ok = 1;
w = nw;
}
} else if (!dfs(v, u, ma, mb))
return 0;
}
return 1;
}
bool solve() {
for (int i = 1; i <= n; i++) {
sort(g[i].begin(), g[i].end());
for (int j = 0; j + 1 < g[i].size(); j++) {
if (g[i][j].first == g[i][j + 1].first &&
g[i][j].second != g[i][j + 1].second)
return 0;
}
}
for (int i = 1; i <= n; i++)
if (!vis[i]) {
nw.clear();
tp.clear();
ok = 0;
if (!dfs(i, 0, 1, 0)) return 0;
if (!ok) {
tp.clear();
for (int u : nw) {
if (a[u] < 0)
tp.push_back(b[u]);
else
tp.push_back(-b[u]);
}
sort(tp.begin(), tp.end());
w = tp[tp.size() / 2];
}
for (int u : nw) b[u] = w * a[u] + b[u];
}
return 1;
}
int main() {
int x, y, z;
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d %d %d", &x, &y, &z);
g[x].push_back(pair<int, int>(y, z));
g[y].push_back(pair<int, int>(x, z));
}
if (solve()) {
puts("YES");
for (int i = 1; i <= n; i++) printf("%.1f ", b[i]);
} else
puts("NO");
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long double PI = acosl(-1);
bool myfunc(int a, int b) { return (a > b); }
long long int fact(long long int n) {
if (n == 0 || n == 1)
return 1;
else
return n * fact(n - 1);
}
int main() {
long long int t, x, n;
cin >> t;
while (t--) {
cin >> n >> x;
cout << 2 * x << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7, n, m, ans, y, cnt;
string s;
short j;
int inn() {
int x;
cin >> x;
return x;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int _tc;
cin >> _tc;
while (_tc--) {
n = inn();
m = inn();
ans = 0;
j = 0;
s = bitset<64>(m).to_string();
reverse(s.begin(), s.end());
long long h = 1;
for (int i = 0; i < s.size(); i++) {
h *= n;
h %= mod;
if (j == 0) h = 1;
if (s[i] == '1') {
ans += h % mod;
ans %= mod;
}
j++;
}
cout << ans << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
map<string, int> m;
int n;
string s;
cin >> n >> s;
for (size_t i = 0; i < s.size() - 1; ++i) m[s.substr(i, 2)]++;
int maior = 0;
for (const auto& c : m)
if (c.second > maior) {
maior = c.second;
s = c.first;
}
cout << s << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
int main() {
int r, c;
scanf("%d %d", &r, &c);
long long int a[r + 1][c + 1];
if (r == 1 && c == 1)
printf("0\n");
else if (c == 1) {
long long int count = 2;
for (int i = 0; i < r; ++i) {
printf("%lld\n", count);
count++;
}
} else {
int count = 1;
for (int i = 1; i <= r; ++i) {
a[i][0] = count;
count++;
}
for (int i = 1; i <= c; ++i) {
a[0][i] = count;
count++;
}
for (int i = 1; i <= r; ++i) {
for (int j = 1; j <= c; ++j) {
a[i][j] = a[i][0] * a[0][j];
printf("%lld ", a[i][j]);
}
printf("\n");
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
int main() {
long long int x, y, result = 0;
scanf("%I64d", &x);
if (x == 0)
printf("1");
else {
while (x) {
y = x % 16;
if (y == 0 || y == 4 || y == 6 || y == 9 || y == 10 || y == 13) {
result++;
}
if (y == 8 || y == 11) {
result += 2;
}
x /= 16;
}
printf("%d", result);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct SegmentTreeNode {
int maxNum, secondMaxNum;
void assignLeaf(int value) {
maxNum = value;
secondMaxNum = -1;
}
void merge(SegmentTreeNode& left, SegmentTreeNode& right) {
maxNum = max(left.maxNum, right.maxNum);
secondMaxNum = min(max(left.maxNum, right.secondMaxNum),
max(left.secondMaxNum, right.maxNum));
}
int getValue() { return maxNum + secondMaxNum; }
};
template <class T, class V>
class SegmentTree {
SegmentTreeNode* nodes;
int N;
public:
SegmentTree(T arr[], int N) {
this->N = N;
nodes = new SegmentTreeNode[getSegmentTreeSize(N)];
buildTree(arr, 1, 0, N - 1);
}
~SegmentTree() { delete[] nodes; }
V getValue(int lo, int hi) {
SegmentTreeNode result = getValue(1, 0, N - 1, lo, hi);
return result.getValue();
}
void update(int index, T value) { update(1, 0, N - 1, index, value); }
private:
void buildTree(T arr[], int stIndex, int lo, int hi) {
if (lo == hi) {
nodes[stIndex].assignLeaf(arr[lo]);
return;
}
int left = 2 * stIndex, right = left + 1, mid = (lo + hi) / 2;
buildTree(arr, left, lo, mid);
buildTree(arr, right, mid + 1, hi);
nodes[stIndex].merge(nodes[left], nodes[right]);
}
SegmentTreeNode getValue(int stIndex, int left, int right, int lo, int hi) {
if (left == lo && right == hi) return nodes[stIndex];
int mid = (left + right) / 2;
if (lo > mid) return getValue(2 * stIndex + 1, mid + 1, right, lo, hi);
if (hi <= mid) return getValue(2 * stIndex, left, mid, lo, hi);
SegmentTreeNode leftResult = getValue(2 * stIndex, left, mid, lo, mid);
SegmentTreeNode rightResult =
getValue(2 * stIndex + 1, mid + 1, right, mid + 1, hi);
SegmentTreeNode result;
result.merge(leftResult, rightResult);
return result;
}
int getSegmentTreeSize(int N) {
int size = 1;
for (; size < N; size <<= 1)
;
return size << 1;
}
void update(int stIndex, int lo, int hi, int index, T value) {
if (lo == hi) {
nodes[stIndex].assignLeaf(value);
return;
}
int left = 2 * stIndex, right = left + 1, mid = (lo + hi) / 2;
if (index <= mid)
update(left, lo, mid, index, value);
else
update(right, mid + 1, hi, index, value);
nodes[stIndex].merge(nodes[left], nodes[right]);
}
};
long long int power(long long int x, long long int y, long long int p) {
long long int res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long int modInverse(long long int n, long long int p) {
return power(n, p - 2, p) % p;
}
const long long int N = 3 * 1e5;
const long long int modo = 998244353;
long long int power10[N + 1];
void solve() {
long long int n;
cin >> n;
long long int a[n + 1];
for (int i = 1; i <= n - 1; i++) {
a[i] = (10 * 9 * 2 * power10[n - i - 1]) % modo;
a[i] += (10 * 9 * 9 * power10[max(n - i - 2, 0ll)] * (n - i - 1)) % modo;
cout << (a[i] % modo) << " ";
}
cout << 10;
}
int main() {
power10[0] = 1;
for (int i = 1; i <= N; i++) {
power10[i] = (power10[i - 1] * 10) % modo;
}
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct pt {
double x, y;
};
bool check(double a, double b) {
if (a < 0.00001) {
a = 0.;
}
if (b < 0.00001) {
return false;
}
return true;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
pt a, b, pos, vel;
double minx, miny, maxx, maxy;
cin >> a.x >> a.y >> b.x >> b.y;
cout << fixed << setprecision(10);
vector<pair<double, int> > times;
for (int i = 0; i < n; i++) {
cin >> pos.x >> pos.y >> vel.x >> vel.y;
minx = (a.x - pos.x) / vel.x;
miny = (a.y - pos.y) / vel.y;
maxx = (b.x - pos.x) / vel.x;
maxy = (b.y - pos.y) / vel.y;
if (minx > maxx) swap(minx, maxx);
if (miny > maxy) swap(miny, maxy);
if (check(minx, maxx)) {
times.push_back({minx, 1});
times.push_back({maxx, -1});
}
if (check(miny, maxy)) {
times.push_back({miny, 1});
times.push_back({maxy, -1});
}
}
sort(times.begin(), times.end());
int depth = 0;
for (int i = 0; i < times.size(); i++) {
if (times[i].second == 1)
depth++;
else
depth--;
if (depth == 2 * n) {
cout << max(times[i].first, 0.00000);
return 0;
}
}
cout << -1;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 2e5 + 100;
long long ABI[MAXN];
void update(long long x) {
while (x) {
ABI[x]++;
x -= x & -x;
}
}
long long query(long long x) {
long long res = 0;
while (x < MAXN) {
res += ABI[x];
x += x & -x;
}
return res;
}
vector<long long> arr[300];
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long N;
cin >> N;
string cad;
cin >> cad;
for (long long i = 0; i < N; i++) {
arr[cad[i]].push_back(i);
}
vector<long long> vect(N);
for (long long i = 0; i < 300; i++) {
vector<long long> temp;
for (auto x : arr[i]) {
temp.push_back(N - x - 1);
}
sort(temp.begin(), temp.end());
for (long long j = 0; j < temp.size(); j++) {
vect[arr[i][j]] = temp[j];
}
}
long long res = 0;
for (long long i = 0; i < N; i++) {
res += query(vect[i] + 1);
update(vect[i] + 1);
}
cout << res << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T &x) {
x = 0;
char c = getchar();
int f = 1;
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
x = x * 10 + c - '0';
c = getchar();
}
x *= f;
}
template <class T>
inline void umin(T &x, T y) {
x = x < y ? x : y;
}
template <class T>
inline void umax(T &x, T y) {
x = x > y ? x : y;
}
inline unsigned int R() {
static unsigned int seed = 416;
return seed ^= seed >> 5, seed ^= seed << 17, seed ^= seed >> 13;
}
const int N = 555555;
struct node {
int x, y, z;
} ans[N];
int sz;
int n, m, fa[N], dep[N];
vector<int> e[N], a[N], ch[N];
bool used[N];
void dfs(int u, int Fa, int Dep) {
fa[u] = Fa;
dep[u] = Dep;
for (register int i = (0); i <= (((int)e[u].size()) - 1); i++)
if (e[u][i] != Fa)
if (!dep[e[u][i]])
dfs(e[u][i], u, Dep + 1), ch[u].push_back(e[u][i]);
else if (dep[u] > dep[e[u][i]])
a[u].push_back(e[u][i]);
}
void dfs1(int u) {
for (register int i = (0); i <= (((int)ch[u].size()) - 1); i++)
dfs1(ch[u][i]);
static int s[N];
int len = 0;
for (register int i = (0); i <= (((int)ch[u].size()) - 1); i++)
if (!used[ch[u][i]]) s[++len] = ch[u][i];
for (register int i = (0); i <= (((int)a[u].size()) - 1); i++)
s[++len] = a[u][i];
while (len >= 2) ans[++sz] = (node){s[len], u, s[len - 1]}, len -= 2;
if (dep[u] > 1 && len) {
ans[++sz] = (node){s[len], u, fa[u]};
used[u] = 1;
}
}
int main() {
read(n);
read(m);
for (register int i = (1); i <= (m); i++) {
int u, v;
read(u);
read(v);
e[u].push_back(v);
e[v].push_back(u);
}
for (register int i = (1); i <= (n); i++)
if (!dep[i]) dfs(i, 0, 1), dfs1(i);
printf("%d\n", sz);
for (register int i = (1); i <= (sz); i++)
printf("%d %d %d\n", ans[i].x, ans[i].y, ans[i].z);
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
const int N = 200001;
unsigned char a[N];
int main() {
int n, q;
scanf("%d", &n);
for (int i = 1; i < n + 1; i++) scanf("%hhu", &a[i]);
scanf("%d", &q);
while (q--) {
int l, r;
unsigned char x, y;
scanf("%d%d%hhu%hhu", &l, &r, &x, &y);
for (int i = l; i < r + 1; i++)
if (a[i] == x) a[i] = y;
}
for (int i = 1; i < n + 1; i++) printf("%hhu ", a[i]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int ara[300005];
map<int, int> m;
set<int> st;
set<int>::iterator it;
int main() {
int i, j, k;
int n, ans = 0, cnt = 0, temp, x;
scanf("%d", &(n));
for (i = 0; i < n; i++) {
scanf("%d", &(ara[i]));
m[ara[i]]++;
st.insert(ara[i]);
}
for (it = st.begin(); it != st.end(); it++) {
cnt = 0;
x = *it;
cnt = m[x];
for (i = 1; i <= 5; i++) {
cnt += m[x + i];
}
ans = max(ans, cnt);
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long int N = (long long int)2e5 + 10;
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cout << fixed << setprecision(16);
long long int n, m, k, sum = 0, cnt = 0, tcnt = 0;
cin >> n >> m >> k;
multiset<long long int> s;
vector<long long int> a(n), b;
for (auto& i : a) cin >> i;
b = a;
sort(a.begin(), a.end(), greater<long long int>());
for (long long int i = 0; i < m * k; i++) s.insert(a[i]);
for (auto i = s.rbegin(); i != s.rend(); i++) {
sum += *i;
cnt++;
if (cnt == m * k) break;
}
cnt = 0;
cout << sum << "\n";
for (long long int i = 0; i < n; i++) {
if (s.find(b[i]) != s.end()) {
s.erase(s.find(b[i]));
cnt++;
if (cnt == m and tcnt < k - 1) cout << i + 1 << " ", cnt = 0, tcnt++;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
int c = 0, t = 0, q = 0, max = 0, prev = 0, last = 0, final = 0;
while (n--) {
cin >> t >> c;
if (t < last) {
q += c - (t - prev);
last += c;
} else {
q = c;
last = t + c;
}
if (q > max) max = q;
if (last > final) final = last;
prev = t;
}
cout << final << " " << max << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
int n;
long long ans, a[maxn];
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
if (a[i] > a[i - 1]) {
ans += (a[i] - a[i - 1]) * (n - a[i] + 1);
} else if (a[i] < a[i - 1]) {
ans += a[i] * (a[i - 1] - a[i]);
}
}
cout << ans << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
if (k == 0 || k >= n) {
cout << "0 0\n";
} else {
cout << 1 << " ";
if (n >= k * 3) {
cout << k * 2 << endl;
} else
cout << n - k << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1003;
int n, A[N], dp[N][N];
int Solve(int id, int pr) {
if (dp[id][pr]) return (dp[id][pr]);
if (id >= n) return (dp[id][pr] = max(A[id], A[pr]));
dp[id][pr] = min({max(A[id], A[pr]) + Solve(id + 2, id + 1),
max(A[id], A[id + 1]) + Solve(id + 2, pr),
max(A[pr], A[id + 1]) + Solve(id + 2, id)});
return (dp[id][pr]);
}
void Prnt(int id, int pr) {
if (id == n) {
printf("%d %d\n", pr, id);
return;
}
if (id > n) {
printf("%d\n", pr);
return;
}
if (dp[id][pr] == max(A[id], A[pr]) + dp[id + 2][id + 1]) {
printf("%d %d\n", pr, id);
Prnt(id + 2, id + 1);
return;
}
if (dp[id][pr] == max(A[id], A[id + 1]) + dp[id + 2][pr]) {
printf("%d %d\n", id, id + 1);
Prnt(id + 2, pr);
return;
}
printf("%d %d\n", pr, id + 1);
Prnt(id + 2, id);
return;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &A[i]);
memset(dp, 0, sizeof(dp));
printf("%d\n", Solve(2, 1));
Prnt(2, 1);
return (0);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double r, x, y, x1, y1;
cin >> r >> x >> y >> x1 >> y1;
double p = (x - x1) * (x - x1);
double q = (y - y1) * (y - y1);
double dis = sqrt(p + q);
cout << (int)ceil(dis / (2 * r)) << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long double PI = 3.1415926535897923846;
const long long int MOD = 1000000007;
const long long int N = 998244353;
long long int power(long long int x, long long int n) {
long long int res = 1;
while (n > 0) {
if (n & 1) res = res * x % MOD;
x = x * x % MOD;
n >>= 1;
}
return res;
}
long long int modinverse(long long int a) { return power(a, MOD - 2); }
void solve() {
long long int n;
cin >> n;
vector<long long int> a(n);
for (long long int i = 0; i < n; i++) {
cin >> a[i];
}
if (n % 2 == 0) {
long long int xo = 0;
for (long long int i = 0; i < n - 1; i++) xo = (xo ^ a[i]);
if (a.back() - xo) {
cout << "NO\n";
return;
}
}
n -= (1 - n % 2);
cout << "YES\n";
cout << n - 1 << endl;
for (long long int i = 0; i + 2 < n; i += 2) {
cout << i + 1 << ' ' << i + 2 << ' ' << i + 3 << endl;
}
for (long long int i = n - 3; i >= 0; i -= 2) {
cout << i + 1 << ' ' << i + 2 << ' ' << i + 3 << endl;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int test = 1;
while (test--) {
solve();
}
cerr << "Time : " << 1000 * ((double)clock()) / (double)CLOCKS_PER_SEC
<< "ms\n";
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 10001;
int st, en;
const int limit = -5000000;
const int maxlongint = 1 << 20;
struct edges {
int v, flow, rev;
int cost;
} make;
vector<edges> g[maxn];
int dist[maxn];
bool vis[maxn];
int tot;
bool ans[maxn];
int i, j, m, n, l, o, p, x, y, z;
int k;
struct pairs {
int x, y;
} pre[maxn];
struct tris {
int s, t, fee;
} sp[maxn];
inline bool spfa() {
for (int i = 0; i <= st; i++) dist[i] = maxlongint;
dist[st] = 0;
queue<int> q;
q.push(st);
while (!q.empty()) {
int x = q.front();
vis[x] = false;
q.pop();
for (int i = 0; i < g[x].size(); i++)
if (g[x][i].flow && dist[g[x][i].v] > dist[x] + g[x][i].cost) {
dist[g[x][i].v] = dist[x] + g[x][i].cost;
pre[g[x][i].v].x = x;
pre[g[x][i].v].y = i;
if (!vis[g[x][i].v]) {
q.push(g[x][i].v);
vis[g[x][i].v] = true;
}
}
}
return dist[en] < maxlongint;
}
inline void addedge(int x, int y, int flow, int cost) {
int v1 = g[x].size();
int v2 = g[y].size();
make.v = y;
make.flow = flow;
make.cost = cost;
make.rev = v2;
g[x].push_back(make);
make.v = x;
make.flow = 0;
make.rev = v1;
make.cost = -cost;
g[y].push_back(make);
}
int mincut(int x, int fw) {
if (x == st) return fw;
int f = mincut(pre[x].x, min(fw, g[pre[x].x][pre[x].y].flow));
g[pre[x].x][pre[x].y].flow -= f;
g[x][g[pre[x].x][pre[x].y].rev].flow += f;
return f;
}
int main() {
scanf("%d%d", &n, &k);
en = 2 * n + 1;
st = en + 1;
addedge(st, 0, k, 0);
for (int i = 1; i <= n; i++) {
scanf("%d%d%d", &sp[i].s, &sp[i].t, &sp[i].fee);
addedge(0, i * 2 - 1, 1, 0);
addedge(i * 2 - 1, i * 2, 1, -sp[i].fee);
addedge(i * 2, en, 1, 0);
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (sp[i].s + sp[i].t <= sp[j].s) addedge(i * 2, j * 2 - 1, 1, 0);
while (spfa()) mincut(en, maxlongint);
for (int i = 1; i <= n; i++)
for (j = 0; j < g[i * 2 - 1].size(); j++)
if (g[i * 2 - 1][j].v == i * 2 && g[i * 2 - 1][j].flow == 0)
ans[i] = true;
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
cout << endl;
fclose(stdin);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long int exgcd(long long int a, long long int b, long long int &x,
long long int &y) {
if (!b) {
x = 1;
y = 0;
return a;
}
long long int ret, tmp;
ret = exgcd(b, a % b, x, y);
tmp = x;
x = y;
y = tmp - a / b * y;
return ret;
}
int main() {
long long int a, b, c, d, x, y;
scanf("%lld%lld%lld", &a, &b, &c);
c = -c;
d = exgcd(a, b, x, y);
if (c % d)
printf("-1");
else
printf("%lld %lld\n", x * c / d, y * c / d);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
string s[105];
int main() {
int n, i, j, k, p, q, l;
int b[26];
while (scanf("%d", &n) != EOF) {
for (i = 0; i < n; i++) {
cin >> s[i];
}
int maxx = 0;
for (i = 0; i < 26; i++) {
for (j = i; j < 26; j++) {
int vv = 0;
for (k = 0; k < n; k++) {
int zz = 0;
l = s[k].size();
for (p = 0; p < l; p++) {
if (s[k][p] - 'a' == i || s[k][p] - 'a' == j) {
zz++;
} else {
break;
}
}
if (p == l) {
vv += l;
}
}
if (vv > maxx) {
maxx = vv;
}
}
}
cout << maxx << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int x, long long int y, long long int p) {
long long int r = 1;
x = x % p;
while (y) {
if (y & 1) r = r * x % p;
y = y >> 1;
x = x * x % p;
}
return r;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int csrand(int l = 0, int r = 1e9) {
uniform_int_distribution<int> uid(l, r);
return uid(rng);
}
const int N = 2e5 + 99;
long long int dp[N];
long long int n;
long long int yes1(long long int v) { return v * (n - v + 1) * 1LL; }
long long int val(long long int a, long long int b) {
long long int ans = 0;
if (a == b) ans = 0;
if (a > b)
ans = b * (a - b);
else
ans = (b - a) * (n - b + 1);
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
long long int ans = 0;
for (int i = 0; i < n; i++) {
if (i == 0)
ans += yes1(a[i]);
else
ans += val(a[i - 1], a[i]);
}
cout << ans << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, d, e;
cin >> n >> d >> e;
e *= 5;
int ans = n;
for (int i = 0; i <= n; i += e) {
ans = min(ans, (n - i) % d);
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
const int mod = 1000000007;
int c[103][103] = {0};
int dp[10][103];
int num[10];
int main() {
int i, j, n, k, ans = 0, min = 0;
for (i = 0; i < 103; i++) c[i][0] = c[i][i] = 1;
for (i = 2; i < 103; i++)
for (j = 1; j < i; j++) c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % mod;
scanf("%d", &n);
for (i = 0; i < 10; i++) {
scanf("%d", num + i);
min += num[i];
}
for (i = num[9]; i <= n; i++) dp[9][i] = 1;
for (i = 8; i >= 0; i--) {
for (j = num[i]; j <= n; j++)
for (k = 0; k + j <= n; k++)
dp[i][k + j] =
(dp[i][k + j] +
(1ll * dp[i + 1][k] * c[k + j - (i ? 0 : 1)][j]) % mod) %
mod;
}
if (min == 0) {
min = 1;
}
for (i = min; i <= n; i++) ans = (ans + dp[0][i]) % mod;
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
string s;
int board[3][3] = {0}, cnt1 = 0, cnt2 = 0;
bool wincheck(int color) {
for (int i = 0; i < 3; i++)
if (board[i][0] == color && board[i][1] == color && board[i][2] == color)
return 1;
for (int i = 0; i < 3; i++)
if (board[0][i] == color && board[1][i] == color && board[2][i] == color)
return 1;
if (board[0][0] == color && board[1][1] == color && board[2][2] == color)
return 1;
if (board[0][2] == color && board[1][1] == color && board[2][0] == color)
return 1;
return 0;
}
int main() {
for (int i = 0; i < 3; i++) {
cin >> s;
for (int j = 0; j < 3; j++)
if (s[j] == 'X') {
board[i][j] = 1;
cnt1++;
} else if (s[j] == '0') {
board[i][j] = 2;
cnt2++;
}
}
if (cnt2 > cnt1 || cnt1 - cnt2 > 1) {
cout << "illegal" << endl;
return 0;
}
if (wincheck(1) && cnt2 == cnt1) {
cout << "illegal" << endl;
return 0;
}
if (wincheck(2) && cnt1 > cnt2) {
cout << "illegal" << endl;
return 0;
}
if (wincheck(1) && wincheck(2)) {
cout << "illegal" << endl;
return 0;
}
if (wincheck(2)) {
cout << "the second player won" << endl;
return 0;
}
if (wincheck(1)) {
cout << "the first player won" << endl;
return 0;
}
if (cnt1 + cnt2 == 9) {
cout << "draw" << endl;
return 0;
}
if (cnt1 == cnt2) {
cout << "first" << endl;
return 0;
}
cout << "second" << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const int MAXN = 200050;
const int MOD = 1e9 + 7;
const int MOD1 = 1e9 + 35011;
const int MOD2 = 1e9 + 18169;
const int INF = (1 << 30);
const long long INFl = 1e18;
int t;
int n, k;
char mas[3][105];
bool CheckLine(int& posX, const int& posY) {
for (int i = posX; i < n; ++i) {
if (mas[posY][i] != '.' && mas[posY][i] != 's') {
break;
} else if (i == n - 1) {
posX = n - 1;
return true;
}
}
for (int i = posX + 3; i < n; i += 3) {
if (mas[posY][i] != '.' || mas[posY][i - 1] != '.' ||
mas[posY][i - 2] != '.' ||
(mas[posY][i - 3] != '.' && mas[posY][i - 3] != 's')) {
return false;
}
for (int j = i; j < min(n, i + 4); ++j) {
if (mas[1][j] != '.') {
break;
} else if (j == min(n, i + 4) - 1) {
posX = i;
return true;
}
}
}
return false;
}
void solve() {
scanf("%d %d\n", &n, &k);
int posY = 0, posX = 0;
for (size_t i = 0; i < 3; ++i) {
for (size_t j = 0; j < n; ++j) {
scanf("%c", &mas[i][j]);
if (mas[i][j] == 's') {
posY = i;
posX = j;
}
}
int ctmp;
scanf("%c", &ctmp);
}
if (posY != 1) {
++posX;
if (!CheckLine(posX, posY)) {
for (int i = posX; i < min(posX + 4, n); ++i) {
if (mas[1][i] != '.') {
puts("NO");
return;
}
}
if (mas[posY][posX] != '.') {
puts("NO");
return;
}
posX += 2;
posY = 1;
} else {
posX += 2;
}
if (posX == n - 1) {
puts("YES");
return;
}
}
while (posX < n - 1) {
++posX;
if (mas[1][posX] != '.') {
puts("NO");
return;
}
for (int i = posX + 1; i < min(n, posX + 4); ++i) {
if (mas[1][i] != '.') {
if (!CheckLine(posX, 0)) {
if (!CheckLine(posX, 2)) {
puts("NO");
return;
}
}
if (posX == n - 1) {
puts("YES");
return;
}
break;
}
}
posX += 2;
}
puts("YES");
}
int main() {
scanf("%d", &t);
while (t--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, i, j, l, u, r;
char s[103];
cin >> t;
for (i = 0; i < t; i++) {
u = 0;
cin >> l;
cin >> s;
if (l < 11)
cout << "NO\n";
else if (s[0] == '8' && l >= 11)
cout << "YES\n";
else {
for (j = 0; s[j] != '\0'; j++) {
if (s[j] == '8') {
u++;
r = j;
break;
}
}
if (u > 0 && r <= l - 11 && l >= 11)
cout << "YES\n";
else
cout << "NO\n";
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string str;
long long b, s, c, nb, ns, nc, pb, ps, pc;
long long R;
long long l = 0, r = 1e14, mid;
void input();
bool check(long long x);
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
input();
while (l <= r) {
mid = (l + r) / 2;
if (check(mid))
l = mid + 1;
else
r = mid - 1;
}
cout << l - 1 << endl;
return 0;
}
void input() {
cin >> str;
for (int i = 0; i < str.size(); i++) {
if (str[i] == 'B')
b++;
else if (str[i] == 'S')
s++;
else
c++;
}
cin >> nb >> ns >> nc;
cin >> pb >> ps >> pc;
cin >> R;
}
bool check(long long x) {
long long bnd = b * x;
long long snd = s * x;
long long cnd = c * x;
long long m = R;
if (bnd > nb) m -= (bnd - nb) * pb;
if (snd > ns) m -= (snd - ns) * ps;
if (cnd > nc) m -= (cnd - nc) * pc;
return m >= 0LL;
}
| 4 |
#define _CRT_SECURE_NO_WARNINGS
#include <bits/stdc++.h>
#include <random>
#include <chrono>
using namespace std;
typedef long double C;
typedef complex<C> P;
#define X real()
#define Y imag()
#define endl '\n'
#define int long long
#define all(X) (X).begin(), (X).end()
#define rall(X) (X).rbegin(), (X).rend()
#define bitset _bitset
mt19937_64 rnd(chrono::system_clock::now().time_since_epoch().count());
const int mod = 1e9 + 7, MAXN = 210, MAXORDER = 3 * MAXN, MAXLOG = 30;
struct node {
bool used = 0;
int d;
vector<int> edges;
};
vector<node> g;
vector<int> order;
int ind[MAXN];
int sparse[MAXLOG][MAXORDER];
int dp[MAXN][MAXN];
int lca(int a, int b) {
int l = ind[a], r = ind[b];
if (l > r) swap(l, r);
int j = log2(r - l + 1);
a = sparse[j][l], b = sparse[j][r - (1 << j) + 1];
if (g[a].d > g[b].d)
swap(a, b);
return a;
}
void build_sparse() {
int _log = log2(order.size()) + 1;
for (int i = 0; i < order.size(); i++)
sparse[0][i] = order[i];
for (int i = 1; i < _log; i++) {
for (int j = 0; j < order.size() - (1 << i) + 1; j++) {
int a = sparse[i - 1][j], b = sparse[i - 1][j + (1 << (i - 1))];
if (g[a].d > g[b].d)
swap(a, b);
sparse[i][j] = a;
}
}
for (int i = 0; i < order.size(); i++)
ind[order[i]] = min(ind[order[i]], i);
}
int dist(int a, int b) {
int c = lca(a, b);
return g[a].d - g[c].d + g[b].d - g[c].d;
}
void dfs(int start, int d) {
g[start].d = d;
g[start].used = 1;
order.push_back(start);
for (auto &i : g[start].edges) {
if (!g[i].used) {
dfs(i, d + 1);
order.push_back(start);
}
}
order.push_back(start);
}
int gcd(int a, int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
void extgcd(int a, int b, int &x, int &y) {
if (b == 0) {
x = 1; y = 0;
return;
}
else {
extgcd(b, a % b, x, y);
int temp = y;
y = x - (a / b) * y;
x = temp;
}
}
int inv(int a, int mod) {
int x, y;
extgcd(a, mod, x, y);
x = (x % mod + mod) % mod;
return x;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
#endif
int n; cin >> n;
g.resize(n);
for (int i = 0; i < n - 1; i++) {
int a, b; cin >> a >> b; a--; b--;
g[a].edges.push_back(b);
g[b].edges.push_back(a);
}
for (int i = 1; i < MAXN; i++)
dp[0][i] = 1;
for (int i = 1; i < MAXN; i++)
for (int j = 1; j < MAXN; j++)
dp[i][j] = (((dp[i - 1][j] + dp[i][j - 1]) % mod) * inv(2, mod)) % mod;
int ans = 0;
for (int k = 0; k < n; k++) {
fill(&ind[0], &ind[0] + MAXN, LLONG_MAX);
for (auto &i : g) i.used = 0;
order.clear();
dfs(k, 0);
build_sparse();
for (int i = 0; i < n; i++) {
for (int j = 0; j < i; j++) {
int v = lca(i, j);
ans = (ans + dp[dist(i, v)][dist(j, v)]) % mod;
}
}
}
ans = (ans * inv(n, mod)) % mod;
cout << ans;
return 0;
}
| 7 |
#include <bits/stdc++.h>
int main(void) {
int t;
scanf("%d", &t);
while (t--) {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
printf("%d ", 4 * n - i * 2);
}
printf("\n");
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a[1500];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
a[0] = 0;
a[n + 1] = 1001;
int ans = 0;
for (int i = 0; i <= n; i++) {
for (int j = i + 2; j <= n + 1; j++) {
if (a[j] - a[i] == j - i) {
ans = max(ans, j - i - 1);
}
}
}
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int largest(long long int n) {
long long int maxx = INT_MIN;
while (n != 0) {
maxx = max(maxx, n % 10);
n /= 10;
}
return maxx;
}
int32_t main() {
long long int n;
cin >> n;
if (n == 0)
cout << 0 << endl;
else {
long long int ans = 0;
while (n > 0) {
n -= largest(n);
ans++;
}
cout << ans << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int n, k;
long long int arr[100100];
long long int kal[100100];
long long int h = 0;
void cal() {
long long int sum = 0;
for (long long int i = 1; i <= n; i++) {
sum = sum + arr[i];
kal[i] = sum;
}
}
long long int binS(long long int l, long long int r, long long int x) {
long long int ans = -1;
while (r >= l) {
long long int m = (l + r) / 2;
long long int u = kal[m] - kal[x - 1];
long long int v = (m - x) + 1;
v = v * arr[m];
if (v == u + k) {
ans = m;
l = m + 1;
} else if (u + k > v) {
ans = m;
l = m + 1;
} else {
r = m - 1;
}
}
return ans;
}
int main() {
cin >> n >> k;
for (long long int i = 1; i <= n; i++) {
cin >> arr[i];
}
sort(arr + 1, arr + n + 1);
cal();
long long int ans = -1;
for (long long int i = 1; i <= n; i++) {
long long int u = binS(i, n, i);
if (u == -1) continue;
long long int v = (u - i) + 1;
if (ans == -1) {
h = arr[u];
ans = v;
} else if (ans < v) {
h = arr[u];
ans = v;
}
}
cout << ans << " " << h << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 30;
const int MAXN = 100010;
const int SIZE = 350;
const int CNT = 310;
deque<int> seq[CNT];
int cnt[CNT][MAXN];
int N;
int query(int a, int b, int k) {
int ans = 0;
int start = a / SIZE;
int end = b / SIZE;
deque<int>::iterator it1 = seq[start].begin() + a % SIZE;
for (int i = a; i < (start + 1) * SIZE && i <= b; i++) {
if (*it1 == k) ans++;
++it1;
}
if (start != end) {
deque<int>::iterator it2 = seq[end].begin();
for (int i = end * SIZE; i <= b; i++) {
if (*it2 == k) ans++;
++it2;
}
}
for (int i = start + 1; i < end; i++) ans += cnt[i][k];
return ans;
}
void update(int a, int b) {
int start = a / SIZE;
int end = b / SIZE;
int last = seq[end].at(b % SIZE);
seq[end].erase(seq[end].begin() + b % SIZE);
cnt[end][last]--;
seq[start].insert(seq[start].begin() + a % SIZE, last);
cnt[start][last]++;
for (int i = start; i < end; i++) {
int v = seq[i].back();
seq[i].pop_back();
cnt[i][v]--;
seq[i + 1].push_front(v);
cnt[i + 1][v]++;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> N;
for (int i = 0; i < N; i++) {
int x;
cin >> x;
seq[i / SIZE].push_back(x);
cnt[i / SIZE][x]++;
}
int q;
cin >> q;
int prev = 0;
while (q--) {
int op;
cin >> op;
int l, r;
cin >> l >> r;
l = (l + prev - 1) % N;
r = (r + prev - 1) % N;
if (l > r) swap(l, r);
if (op == 1) {
update(l, r);
} else {
int k;
cin >> k;
k = (k + prev - 1) % N + 1;
cout << (prev = query(l, r, k)) << endl;
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n, m, x, pos = 0;
vector<int> v;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x;
v.push_back(pos + x);
pos += x;
}
cin >> m;
for (int j = 0; j < m; j++) {
cin >> x;
vector<int>::iterator low;
low = lower_bound(v.begin(), v.end(), x);
cout << low - v.begin() + 1 << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int ans[100010];
map<pair<int, int>, bool> mark;
bool fcmp(pair<int, int> a, pair<int, int> b) {
bool c = a.second < b.second;
return c;
}
int main() {
int n, m;
cin >> n >> m;
pair<int, int> s[100010];
for (int i = 0; i < n; i++) cin >> s[i].first >> s[i].second;
int t = 0;
if (m > n) m = n;
int last = 0;
for (int i = m - 1; i < n; i += m) {
if (s[i].first > t) t += (s[i].first - t);
int mx = 0;
for (int j = i - (m - 1); j <= i; j++) s[j].first = j;
sort(s + last, s + i + 1, fcmp);
for (int j = last; j <= i; j++) {
mx = max(mx, s[j].second);
int k = j, K = 0;
while (s[j].second == s[k].second && k <= i) {
ans[s[k].first] = t + s[k].second;
if (s[j].second == s[k].second)
K++;
else
break;
k++;
}
k = k - j;
k--;
j += k;
K = (1 + (K / 2));
t += K;
}
last = i + 1;
t += mx * 2;
if (i + m >= n && i < n - 1) {
i = n - 1;
i -= m;
}
}
for (int i = 0; i < n; i++) cout << ans[i] << " ";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
map<long long, int> mp;
int main() {
int n;
int a[] = {1234567, 123456, 1234};
cin >> n;
for (int i = 0; i <= n / a[0]; i++) {
for (int j = 0; j <= (n - a[0] * i) / a[1]; j++) {
mp[a[0] * i + a[1] * j] = 1;
}
}
for (int i = 0; i < 1e6; i++) {
if (mp.find(n - a[2] * i) != mp.end()) {
cout << "YES";
return 0;
}
}
cout << "NO";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
const int MOD = 998244353;
const int MAXN = 1e6 + 3;
long long gcd(long long a, long long b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
long long power(long long x, long long y) {
long long res = 1;
while (y > 0) {
if (y & 1) res = res * x;
y = y >> 1;
x = x * x;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n;
cin >> n;
vector<long long> a(n + 1);
map<long long, long long> last;
for (long long i = 1; i <= (n); ++i) {
cin >> a[i];
last[a[i]] = i;
}
long long ans = 1;
for (long long i = 1; i <= (n); ++i) {
if (i > 1) {
ans = 2 * ans;
ans %= MOD;
}
long long cur = last[a[i]];
long long idx = i + 1;
while (idx <= cur) {
cur = max(cur, last[a[idx]]);
idx++;
}
i = cur;
}
cout << ans << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, sum, cost = 0;
cin >> n >> sum;
long long int i, a[n];
map<long long int, long long int> mymap;
for (long long int i = 0; i < n; i++) {
cin >> a[i];
mymap[a[i]]++;
}
long long int max_limit = sum;
set<long long int> s;
for (long long int i = 1; i < max_limit + 1; i++) {
if (mymap[i] == 0) {
s.insert(i);
cost += i;
if (cost > sum) {
int def = cost - sum;
if (s.count(def)) {
s.erase(def);
} else {
long long int deg = *s.upper_bound(def);
s.erase(deg);
}
break;
} else if (cost == sum) {
break;
}
}
}
cout << s.size() << endl;
for (auto it : s) {
cout << (it) << " ";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int Nmax = 1e6 + 5;
long long dp[Nmax][2], up[Nmax];
vector<pair<int, int> > v[Nmax];
int n, K;
long long take(vector<long long> &v, int k) {
int i;
long long sum = 0;
for (i = 0; i < k && v[i] > 0; ++i) sum += v[i];
return sum;
}
void dfs(int node, int dad = 0) {
for (auto it : v[node])
if (it.first != dad) {
up[it.first] = it.second;
dfs(it.first, node);
}
vector<int> sons;
for (auto it : v[node])
if (it.first != dad) sons.push_back(it.first);
vector<long long> pr;
long long sum = 0;
for (auto it : sons) {
sum += dp[it][1];
pr.push_back(up[it] - dp[it][1] + dp[it][0]);
}
sort(pr.begin(), pr.end());
reverse(pr.begin(), pr.end());
dp[node][0] = sum + take(pr, min(K - 1, (int)sons.size()));
dp[node][1] = sum + take(pr, min(K, (int)sons.size()));
dp[node][1] = max(dp[node][0], dp[node][1]);
}
void solve() {
cin >> n >> K;
int i;
for (i = 1; i < n; ++i) {
int x, y, cost;
cin >> x >> y >> cost;
v[x].push_back({y, cost});
v[y].push_back({x, cost});
}
dfs(1);
cout << dp[1][1] << '\n';
}
void clr() {
int i;
for (i = 1; i <= n; ++i) {
v[i].clear();
dp[i][0] = dp[i][1] = 0;
up[i] = 0;
}
}
int main() {
cin.sync_with_stdio(false);
cin.tie(0);
int tests;
cin >> tests;
while (tests--) {
solve();
clr();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, arr[20], count, i, m;
scanf("%d", &n);
while (count != 4) {
count = 0;
for (i = 0; i < 20; i++) arr[i] = 0;
m = ++n;
while (m != 0) {
a = m % 10;
m = m / 10;
if (arr[a] == 0) {
count++;
arr[a] = 1;
}
}
}
printf("%d", n);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000 * 1000 * 1000 + 7;
const long long INF = 1ll * 1000 * 1000 * 1000 * 1000 * 1000 * 1000 + 7;
const long long MOD2 = 998244353;
const long long N = 5000 + 10;
const long long N2 = 1000 * 1000;
const long double PI = 3.14159265;
long long gcd(long long a, long long b) {
if (!b) return a;
return gcd(b, a % b);
}
long long power(long long x, long long y, long long p = INF) {
long long res = 1;
x %= p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int r, c;
cin >> r >> c;
int total = r * c;
int ans = 4;
int count = 0;
char a[r][c];
for (int i = 0; i < r; ++i) {
for (int j = 0; j < c; ++j) {
cin >> a[i][j];
if (a[i][j] == 'A') count++;
}
}
if (!count) {
cout << "MORTAL"
<< "\n";
continue;
}
if (count == total) {
cout << 0 << "\n";
continue;
}
count = 0;
for (int i = 0; i < r; ++i) {
if (a[i][0] == 'A') count++;
}
if (count == r) ans = min(ans, 1);
if (count) ans = min(ans, 3);
count = 0;
for (int i = 0; i < r; ++i) {
if (a[i][c - 1] == 'A') count++;
}
if (count == r) ans = min(ans, 1);
if (count) ans = min(ans, 3);
count = 0;
for (int i = 0; i < c; ++i) {
if (a[r - 1][i] == 'A') count++;
}
if (count == c) ans = min(ans, 1);
if (count) ans = min(ans, 3);
count = 0;
for (int i = 0; i < c; ++i) {
if (a[0][i] == 'A') count++;
}
if (count == c) ans = min(ans, 1);
if (count) ans = min(ans, 3);
if (a[0][0] == 'A' || a[r - 1][c - 1] == 'A' || a[r - 1][0] == 'A' ||
a[0][c - 1] == 'A')
ans = min(ans, 2);
for (int i = 1; i < r - 1; i++) {
count = 0;
for (int j = 0; j < c; ++j) {
if (a[i][j] == 'A') {
count++;
}
}
if (count == c) {
ans = min(ans, 2);
}
}
for (int i = 1; i < c - 1; i++) {
count = 0;
for (int j = 0; j < r; ++j) {
if (a[j][i] == 'A') {
count++;
}
}
if (count == r) {
ans = min(ans, 2);
}
}
cout << ans << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000100;
const int mod = 998244353;
long long jc[N], inv[N], n;
long long ksm(long long x, long long y) {
long long res = 1;
while (y) {
if (y & 1) res = (res * x) % mod;
x = (x * x) % mod;
y >>= 1;
}
return res;
}
long long C(int n, int m) {
return ((jc[n] * inv[m]) % mod * inv[n - m]) % mod;
}
int main() {
long long i, j, k;
long long ans, sign, tmp, res;
scanf("%d", &n);
jc[0] = 1;
for (i = 1; i <= n; i++) jc[i] = (jc[i - 1] * i) % mod;
inv[n] = ksm(jc[n], mod - 2);
for (i = n - 1; i >= 0; i--) inv[i] = (inv[i + 1] * (i + 1)) % mod;
ans = 0;
sign = 1;
for (i = 1; i <= n; i++, sign = mod - sign)
ans = (ans + (sign * C(n, i)) % mod * ksm(3, (n - i) * n + i)) % mod;
ans = (ans * 2ll) % mod;
sign = mod - 1;
for (i = 1; i <= n; i++, sign = mod - sign) {
tmp = ksm(3, n - i);
res = (ksm(tmp, n) - ksm((tmp + mod - 1) % mod, n) + mod) % mod;
ans = (ans + (3ll * res * C(n, i)) % mod * sign) % mod;
}
printf("%I64d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
char s[500 + 5];
bool graph[500 + 1][500 + 1];
int main() {
int n, m;
int finish_size = 0;
int first = 1;
cin.sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int tmp1, tmp2;
cin >> tmp1 >> tmp2;
graph[tmp1][tmp2] = true;
graph[tmp2][tmp1] = true;
}
for (int i = 1; i <= n; ++i) {
int cnt = 0;
for (int j = 1; j <= n; ++j)
if (graph[i][j]) cnt++;
if (cnt == n - 1) {
s[i] = 'b';
finish_size++;
}
}
for (int i = 1; i <= n; ++i) {
if (s[i] != 'b') continue;
for (int j = 1; j <= n; ++j) {
graph[i][j] = false;
graph[j][i] = false;
}
}
while (s[first] != '\0') first++;
if (finish_size != n) {
int first_a;
vector<int> a;
first_a = first;
a.push_back(first_a);
s[first_a] = 'a';
finish_size++;
if (finish_size != n) {
for (int i = 1; i <= n; ++i) {
if (graph[first_a][i]) {
graph[first_a][i] = false;
a.push_back(i);
s[i] = 'a';
}
}
for (int i = 1; i < a.size(); ++i) {
int vector_now = 0;
for (int j = 1; j <= n; ++j) {
if (graph[a[i]][j] && j == a[vector_now]) {
graph[a[i]][j] = false;
vector_now++;
} else if ((graph[a[i]][j] && j != a[vector_now]) ||
(!graph[a[i]][j] && j == a[vector_now])) {
if (a[i] == j) {
vector_now++;
continue;
}
cout << "NO" << endl;
return 0;
}
}
}
}
}
while (s[first] != '\0') first++;
if (finish_size != n) {
int first_c;
vector<int> c;
first_c = first;
c.push_back(first_c);
s[first_c] = 'c';
finish_size++;
if (finish_size != n) {
for (int i = 1; i <= n; ++i) {
if (graph[first_c][i]) {
if (s[i] == '\0') {
graph[first_c][i] = false;
c.push_back(i);
s[i] = 'c';
} else {
cout << "NO" << endl;
return 0;
}
}
}
for (int i = 1; i < c.size(); ++i) {
int vector_now = 0;
for (int j = 1; j <= n; ++j) {
if (graph[c[i]][j] && j == c[vector_now]) {
graph[c[i]][j] = false;
vector_now++;
} else if ((graph[c[i]][j] && j != c[vector_now]) ||
(!graph[c[i]][j] && j == c[vector_now])) {
if (c[i] == j) {
vector_now++;
continue;
}
cout << "NO" << endl;
return 0;
}
}
}
}
}
for (int i = 1; i <= n; ++i) {
if (s[i] == '\0') {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
for (int i = 1; i <= n; ++i) cout << s[i];
cout << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int const N = 555;
int n, a[N], dp[N][N];
int f(int i, int j) {
if (i > j) return 0;
if (j == i) return 1;
int &ret = dp[i][j];
if (ret != -1) return ret;
ret = 1e9;
ret = 1 + f(i + 1, j);
if (a[i] == a[i + 1]) {
ret = min(ret, 1 + f(i + 2, j));
}
for (int id = i + 2; id <= j; id++) {
if (a[i] == a[id]) {
ret = min(ret, f(i + 1, id - 1) + f(id + 1, j));
}
}
return ret;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
memset(dp, -1, sizeof dp);
cout << f(0, n - 1);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x;
cin >> n >> x;
vector<vector<pair<int, int> > > v(2);
for (int c = 0; c < n; c++) {
int t, h, m;
cin >> t >> h >> m;
v[t].push_back(make_pair(h, m));
}
int res = 0;
for (int c = 0; c < 2; c++) {
int t = c;
int bond = x;
int n = 0;
vector<vector<bool> > visites(
2, vector<bool>(max(v[0].size(), v[1].size()), false));
while (1) {
int best = -1;
for (int c = 0; c < v[t].size(); c++)
if (v[t][c].first <= bond &&
(best == -1 || v[t][c].second > v[t][best].second) &&
!visites[t][c])
best = c;
if (best != -1) {
visites[t][best] = true;
bond += v[t][best].second;
n++;
t++;
t %= 2;
} else {
break;
}
}
res = max(res, n);
}
cout << res;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <class T>
inline T LCM(T a, T b) {
if (a < 0) return LCM(-a, b);
if (b < 0) return LCM(a, -b);
return a * (b / gcd(a, b));
}
const int MAXN = 2e5 + 32;
long long int ans[MAXN];
vector<int> num;
int main() {
memset(ans, 0, sizeof(ans));
long long int n, sum, total = 0;
int temp;
long long needed;
cin >> n >> sum;
for (int i = 0; i < n; i++) {
scanf("%d", &temp);
num.push_back(temp);
total = total + 1ll * temp;
ans[i] = ans[i] + max(0ll, temp - (sum - (n - 1)));
}
for (int i = 0; i < n; i++) {
needed = sum - (total - num[i]);
if (needed > 0) {
ans[i] = ans[i] + needed - 1;
}
printf("%lld ", ans[i]);
}
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007, dp[2][22001] = {0};
int main() {
int n, a[1001];
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
int cnt = 1, ans = 0;
for (int f = 0; cnt <= n; f = !f, cnt++) {
for (int j = 1000; j <= 21000; j++) {
dp[f][j] = dp[!f][j - a[cnt]] + dp[!f][j + a[cnt]];
dp[f][j] %= mod;
}
dp[f][11000 - a[cnt]]++;
dp[f][11000 + a[cnt]]++;
ans = (ans + dp[f][11000]) % mod;
}
cout << ans;
return 0;
}
| 7 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.