solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
int main() {
int n, m, i;
scanf("%d%d", &n, &m);
if (n / m == 0) {
for (i = 0; i < m; i++) printf("%d ", n / m);
} else {
for (i = 0; i < m; i++) {
if (i < m - (n % m))
printf("%d ", n / m);
else
printf("%d ", (n / m) + 1);
}
}
}
| 0 |
#include <bits/stdc++.h>
double p[1005][1005];
double ps[1024], val[1024];
bool vis[1024];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
scanf("%lf", &p[i][j]);
p[i][j] /= 100;
}
}
for (int i = 1; i <= n; i++) {
ps[i] = 1;
val[i] = 1;
}
ps[n] = 0;
val[n] = 0;
while (1) {
double d = 1000000000000000000LL;
int wz = 0;
for (int i = 1; i <= n; i++) {
if (ps[i] > 0.99999999 || vis[i]) {
continue;
}
if (val[i] / (1 - ps[i]) < d) {
d = val[i] / (1 - ps[i]);
wz = i;
}
}
if (!wz) {
break;
}
vis[wz] = true;
for (int i = 1; i <= n; i++) {
if (vis[i]) {
continue;
}
val[i] += ps[i] * p[i][wz] * d;
ps[i] *= (1 - p[i][wz]);
}
}
printf("%.10f\n", val[1] / (1 - ps[1]));
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
class point {
public:
long long int x;
long long int y;
};
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int n, m;
cin >> n >> m;
long long int arrb[n], arrg[m];
for (long long int i = 0; i < n; i++) {
cin >> arrb[i];
}
for (long long int i = 0; i < m; i++) {
cin >> arrg[i];
}
sort(arrb, arrb + n);
sort(arrg, arrg + m);
long long int lmao = 0;
for (long long int i = 0; i < m; i++) {
if (binary_search(arrb, arrb + n, arrg[i])) {
} else {
lmao++;
}
}
if (arrb[n - 1] > arrg[0] || (lmao > (m - 1) * n)) {
cout << "-1" << endl;
return 0;
} else {
long long int ans = 0;
for (long long int i = 0; i < n; i++) {
ans += arrb[i];
}
ans *= m;
long long int count = 0;
for (long long int i = 0; i < m; i++) {
if (binary_search(arrb, arrb + n, arrg[i])) {
} else {
ans += arrg[i];
count++;
}
}
long long int sub = 0;
long long int x = 0;
long long int y = 0;
if (m - 1 != 0) {
x = count / (m - 1);
y = count % (m - 1);
}
long long int k = n - 1;
while (x--) {
sub += arrb[k];
k--;
}
sub *= (m - 1);
sub += (y)*arrb[k];
cout << ans - sub << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int T;
cin >> T;
while (T--) {
int x;
scanf("%d", &x);
int ans = 1;
while (x) {
if (x & 1) ans <<= 1;
x >>= 1;
}
printf("%d\n", ans);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> connections;
long long cycles;
vector<long long> parent;
long long find_parent(long long start) {
return parent[start] =
(parent[start] == start) ? start : find_parent(parent[start]);
}
void merge(long long a, long long b) {
long long parent_a = find_parent(a);
long long parent_b = find_parent(b);
if (parent_a == parent_b) {
cycles++;
} else {
connections[parent_a] += connections[parent_b];
connections[parent_b] = 1;
}
parent[parent_b] = parent_a;
}
int main() {
long long n, m;
cin >> n >> m;
connections.assign(n, 1);
for (long long i = 0; i < n; i++) {
parent.push_back(i);
}
for (long long i = 0; i < m; i++) {
long long x, y;
cin >> x >> y;
merge(x - 1, y - 1);
}
long long total = 0;
for (long long i = 0; i < n; i++) {
total += ((connections[i] - 1) * (connections[i] - 2)) / 2;
}
if (total == cycles) {
cout << "YES";
} else {
cout << "NO";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1000100;
int n, arr[MAX];
long long mem[MAX][3], a, b, ans = (1LL << 60);
vector<int> factorize(int num) {
vector<int> ret;
for (int i = 2; i <= num / i; i += 1 + (i & 1))
while (num % i == 0) ret.push_back(i), num /= i;
if (num > 1) ret.push_back(num);
return ret;
}
long long dp(int idx, int flag, int p) {
if (idx == n) return 0;
long long &ret = mem[idx][flag];
if (ret != -1) return ret;
if (arr[idx] % p == 0)
ret = dp(idx + 1, 2 * (flag != 0), p);
else if ((arr[idx] - 1) % p == 0 || (arr[idx] + 1) % p == 0)
ret = b + dp(idx + 1, 2 * (flag != 0), p);
else
ret = (1LL << 60);
if (flag < 2) ret = min(ret, a + dp(idx + 1, 1, p));
return ret;
}
int main() {
cin >> n >> a >> b;
for (int i = 0; i < n; i++) scanf("%d", arr + i);
int f[6] = {arr[0], arr[0] - 1, arr[0] + 1,
arr[n - 1], arr[n - 1] - 1, arr[n - 1] + 1};
set<int> s;
for (int i = 0; i < 6; i++) {
vector<int> temp = factorize(f[i]);
s.insert(temp.begin(), temp.end());
}
for (int p : s) {
memset(mem, -1, (n + 1) * sizeof mem[0]);
ans = min(ans, dp(0, 0, p));
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
const int maxn = 2e3 + 10;
const int maxm = 1e5 + 10;
const long long int mod = 998244353;
const long long int INF = 1e18 + 100;
const int inf = 0x3f3f3f3f;
const double pi = acos(-1.0);
const double eps = 1e-8;
using namespace std;
int n, m, TT;
int cas, tol;
int a[maxn] = {0};
char s[maxn];
long long int dp[maxn][maxn];
long long int fpow(long long int a, long long int b) {
long long int ans = 1;
while (b) {
if (b & 1) ans = ans * a % mod;
a = a * a % mod;
b >>= 1;
}
return ans;
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; i++) {
a[i] = a[i - 1] + (s[i] == '?');
dp[i][i] = 0;
dp[i][i + 1] = (i + 1 <= n && s[i] != ')' && s[i + 1] != '(');
}
for (int d = 3; d <= n; d++) {
for (int i = 1, j = d, c; j <= n; i++, j++) {
dp[i][j] = 0, c = -1;
if (s[i] != ')') {
if (s[j] != ')') dp[i][j] += dp[i][j - 1], c++;
if (s[j] != '(')
dp[i][j] += dp[i + 1][j - 1] + fpow(2, a[j - 1] - a[i]);
}
if (s[i] != '(') {
if (s[j] != ')') dp[i][j] += dp[i + 1][j - 1], c++;
if (s[j] != '(') dp[i][j] += dp[i + 1][j], c++;
}
dp[i][j] -= max(c, 0) * dp[i + 1][j - 1];
dp[i][j] %= mod;
}
}
printf("%lld\n", dp[1][n]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
long long ans = 0;
vector<int> t(s.length() + 1, s.length());
for (int i = s.length() - 1; i >= 0; i--) {
t[i] = t[i + 1];
for (int k = 1; i + 2 * k < t[i]; k++) {
if (s[i] == s[i + k] && s[i + k] == s[i + 2 * k]) {
t[i] = i + 2 * k;
}
}
ans += s.length() - t[i];
}
cout << ans << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 20, K = 19;
const int mod = 1e9 + 7;
int ans[N], vis[N];
vector<pair<int, pair<int, int>>> graph[N];
vector<int> gp[N];
map<pair<int, int>, int> use;
void bfs() {
int dir = 0;
queue<int> q;
q.push(0);
vis[0] = 1;
while (q.size()) {
int sz = q.size();
while (sz--) {
int u = q.front();
q.pop();
for (auto x : graph[u]) {
int v = x.first;
ans[x.second.first] = dir ^ x.second.second;
if (!use[make_pair(u, v)]) {
if (dir) {
gp[u].push_back(v);
} else {
gp[v].push_back(u);
}
use[make_pair(u, v)] = use[make_pair(v, u)] = 1;
}
if (!vis[v]) {
vis[v] = 1;
q.push(v);
}
}
}
dir ^= 1;
}
}
int d = 1;
int dfs2(int u) {
int mx = 0;
for (auto x : gp[u]) {
mx = max(mx, 1 + dfs2(x));
if (mx >= 2) {
d = 0;
return 1e9;
}
}
return mx;
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
x--, y--;
graph[x].push_back(make_pair(y, make_pair(i, 1)));
graph[y].push_back(make_pair(x, make_pair(i, 0)));
}
bfs();
for (int i = 0; i < n; i++) dfs2(i);
if (d)
puts("YES");
else
return puts("NO"), 0;
for (int i = 0; i < m; i++) printf("%d", ans[i]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int l, r;
} a[200005];
int n, m, L, R, Max, id, f[500005][20], Log[500005], n1;
int solve(int l, int r) {
int x = l, ans = 0;
for (int i = Log[R]; i >= 0; i--)
if (f[x][i] < r) x = f[x][i], ans += 1 << i;
if (f[x][0] >= r)
return ans + 1;
else
return -1;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
scanf("%d%d", &a[i].l, &a[i].r), a[i].l++, a[i].r++,
f[a[i].l][0] = max(f[a[i].l][0], a[i].r);
for (int i = 1; i <= n; i++) R = max(R, a[i].r);
Log[0] = -1;
for (int i = 1; i <= R; i++) Log[i] = Log[i >> 1] + 1;
for (int i = 1; i <= R; i++) f[i][0] = max(f[i][0], f[i - 1][0]);
for (int j = 1; j <= Log[R]; j++)
for (int i = 1; i <= R; i++) f[i][j] = f[f[i][j - 1]][j - 1];
while (m--) {
int x, y;
scanf("%d%d", &x, &y);
x++, y++;
if (y > R)
printf("-1\n");
else
printf("%d\n", solve(x, y));
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long oll = 0;
bool comp(const pair<int, int> &a, const pair<int, int> &b) {
return a.second < b.second;
}
double dt(int x1, int y1, int x2, int y2) {
return sqrt(pow(x1 - x2, 2) + pow(y1 - y2, 2));
}
void solve() {
int T;
cin >> T;
while (T--) {
long long x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
long long ans = (x2 - x1) * (y2 - y1) + 1;
cout << ans << "\n";
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n;
cin >> n;
int ans[n];
int a[n], b[n];
int i, j, k;
for (i = 0; i < n; i++) {
cin >> a[i];
ans[i] = n - a[i];
}
for (i = 0; i < n; i++) {
cin >> b[i];
ans[i] -= b[i];
}
for (i = 0; i < n; i++) {
int cn1 = 0, cn2 = 0;
for (j = 0; j < i; j++) {
if (ans[j] > ans[i]) cn1 += 1;
}
if (cn1 != a[i]) {
cout << "NO";
exit(0);
}
for (j = i + 1; j < n; j++) {
if (ans[j] > ans[i]) cn2 += 1;
}
if (cn2 != b[i]) {
cout << "NO";
exit(0);
}
}
cout << "YES" << endl;
for (i = 0; i < n; i++) cout << ans[i] << " ";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
for (int i = 0; i < N; i++) {
long long int a, b, k;
cin >> a >> b >> k;
if (k % 2 == 0)
cout << (a * (k / 2) - b * (k / 2)) << "\n";
else {
cout << (a + a * (k / 2) - b * (k / 2)) << "\n";
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
using namespace std;
signed main() {
long long int a, b, mod;
cin >> a >> b >> mod;
long long int ans = -1, p = 1;
for (long long int i = 0; i < 9; ++i) p = (p * 10) % mod;
for (long long int i = 0; i <= min(max(0ll, mod - 1), a); ++i) {
long long int now = (i * p) % mod;
long long int need = (mod - now) % mod;
if (need > b) {
ans = i;
break;
}
}
if (ans == -1)
cout << 2 << "\n";
else {
string num = to_string(ans);
while (num.size() < 9) num.insert(0, "0");
cout << 1 << " " << num << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
const int MAXN = 51;
const int MAXM = 1;
const int MAXL = 1;
using namespace std;
int n, m, a, b, A[51][51], ans = 2000000000;
int count(int x1, int y1, int x2, int y2) {
int t = 0;
for (int i = x1, _b = (x2); i <= _b; i++)
for (int j = y1, _b = (y2); j <= _b; j++) t += A[i][j];
return t;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0, _n = (n); i < _n; i++)
for (int j = 0, _n = (m); j < _n; j++) scanf("%d", &A[i][j]);
scanf("%d%d", &a, &b);
for (int i = 0, _n = (n - a + 1); i < _n; i++) {
for (int j = 0, _n = (m - b + 1); j < _n; j++) {
ans = min(ans, count(i, j, i + a - 1, j + b - 1));
}
}
for (int i = 0, _n = (n - b + 1); i < _n; i++) {
for (int j = 0, _n = (m - a + 1); j < _n; j++) {
ans = min(ans, count(i, j, i + b - 1, j + a - 1));
}
}
printf("%d\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, c = 0, ans = 0;
char cur = '#';
string s;
int main() {
getline(cin, s);
for (int i = 0; i <= s.length() - 1; i++) {
if (cur == '#' || s[i] == cur)
c++, cur = s[i];
else
c = 1, ans++, cur = s[i];
if (c == 5 && i != s.length() - 1) ans++, c = 0, cur = '#';
}
cout << ans + 1;
fclose(stdin);
fclose(stdout);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int mod = 1000000007;
long long int dp[200005][3];
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n, l, r;
cin >> n >> l >> r;
long long int a = (r / 3) - ((l - 1) / 3);
long long int b = ((r + 2) / 3) - ((l + 1) / 3);
long long int c = (r + 1) / 3 - (l) / 3;
memset(dp, 0, sizeof(dp));
if (n == 1) {
cout << a;
return 0;
}
if (n == 2) {
cout << (a * a + 2 * b * c) % mod;
return 0;
}
dp[2][0] = (a * a + 2 * b * c) % mod;
dp[2][1] = (2 * a * c + b * b) % mod;
dp[2][2] = (2 * a * b + c * c) % mod;
for (long long int i = 3; i < n + 1; i++) {
dp[i][0] =
((a * dp[i - 1][0]) + (b * dp[i - 1][1]) + (c * dp[i - 1][2])) % mod;
dp[i][1] =
((a * dp[i - 1][1]) + (b * dp[i - 1][2]) + (c * dp[i - 1][0])) % mod;
dp[i][2] =
((a * dp[i - 1][2]) + (b * dp[i - 1][0]) + (c * dp[i - 1][1])) % mod;
}
long long int ans = (dp[n][0]);
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int dp[n + 1][m + 1];
string a, b;
cin >> a >> b;
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= m; j++) {
dp[i][j] = 0;
}
}
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j] - 1);
dp[i][j + 1] = max(dp[i][j + 1], dp[i][j] - 1);
if (a[i] == b[j]) {
dp[i + 1][j + 1] = max(dp[i][j] + 2, dp[i + 1][j + 1]);
}
}
}
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= m; j++) {
ans = max(ans, dp[i][j]);
}
}
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int lim = 1e6;
int inf = 1e8;
long long mod = 1e9 + 7;
void err(istream_iterator<string> it) { cerr << endl; }
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << "\t";
err(++it, args...);
}
template <typename T1, typename T2>
ostream& operator<<(ostream& c, pair<T1, T2> v) {
c << "(" << v.first << "," << v.second << ")";
return c;
}
template <template <class...> class TT, class... T>
ostream& operator<<(ostream& out, TT<T...>& c) {
out << "{ ";
for (auto& x : c) out << x << " ";
out << "}";
return out;
}
int maxv(int i, int j, int n, int m) {
if ((i == 0 and (j == 0 or j == m - 1)) or
(i == n - 1 and (j == 0 or j == m - 1))) {
return 2;
}
if (i == 0 or i == n - 1 or j == 0 or j == m - 1) return 3;
return 4;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
bool check = 1;
int n, m;
cin >> n >> m;
int a[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> a[i][j];
if (a[i][j] > maxv(i, j, n, m)) {
check = 0;
}
}
}
if (check) {
cout << "YES" << '\n';
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cout << maxv(i, j, n, m) << " ";
}
cout << '\n';
}
} else {
cout << "NO" << '\n';
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 400010;
const long long mod = 1000000007;
const long double eps = 1e-9;
const long long inf = ((1ll << 31ll) - 1ll);
const long long INF = 2000000000000000000ll;
const long double pi = acos(-1);
long long qpow(long long b, long long e) {
if (!e) return 1;
if (e & 1) return qpow(b, e - 1) * b % mod;
long long pwur = qpow(b, e >> 1);
return pwur * pwur % mod;
}
long long modinv(long long x) { return qpow(x, mod - 2); }
long long tc, n, a[maxn];
vector<long long> ans;
bool sorted() {
for (long long i = 1; i < n; i++)
if (a[i] > a[i + 1]) return 0;
return 1;
}
void shft(long long x) {
swap(a[x + 2], a[x + 1]);
swap(a[x + 1], a[x]);
}
void tryl() {
for (long long i = 1; i <= n - 2; i++) {
pair<long long, long long> mn = {mod, -1};
for (long long j = i; j <= n; j++) {
if (mn.first > a[j]) {
mn = {a[j], j};
}
}
while (mn.second != i) {
if (mn.second - 2 >= i) {
shft(mn.second - 2);
mn.second -= 2;
ans.push_back(mn.second);
} else {
shft(mn.second - 1);
shft(mn.second - 1);
mn.second -= 1;
ans.push_back(mn.second);
ans.push_back(mn.second);
}
}
}
}
void tryr() {
for (long long i = n; i >= 3; i--) {
pair<long long, long long> mx = {-1, -1};
for (long long j = 1; j <= i; j++) {
if (mx.first <= a[j]) {
mx = {a[j], j};
}
}
while (mx.second != i) {
if (mx.second + 2 <= i) {
shft(mx.second);
ans.push_back(mx.second);
mx.second += 2;
} else {
shft(mx.second - 1);
ans.push_back(mx.second - 1);
mx.second += 1;
}
}
}
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.setf(ios::fixed);
cout.precision(0);
srand(time(NULL));
cin >> tc;
while (tc--) {
ans.clear();
cin >> n;
for (long long i = 1; i <= n; i++) cin >> a[i];
long long bu = 10;
while (bu--) {
tryl();
tryr();
}
for (long long i = 0; i <= 3; i++) {
if (i) shft(n - 2);
if (a[n - 2] <= a[n - 1] && a[n - 1] <= a[n]) {
for (long long j = 1; j <= i; j++) ans.push_back(n - 2);
break;
}
}
if (!sorted()) {
cout << -1 << '\n';
continue;
}
cout << ans.size() << '\n';
for (auto i : ans) cout << i << ' ';
cout << '\n';
}
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
#define pf printf
#define PF(a) printf("%d\n",(a))
#define PF2(a,b) printf("%d %d\n",(a), (b))
#define PF3(a,b,c) printf("%d %d %d\n",(a), (b), (c))
#define PFL(a) printf("%lld\n",(a))
#define PFL2(a,b) printf("%lld %lld\n",(a), (b))
#define PFL3(a,b,c) printf("%lld %lld %lld\n",(a), (b), (c))
#define get(a) cin>>a
#define sf scanf
#define SF(a) scanf("%d",&a)
#define SF2(a,b) scanf("%d %d",&a, &b)
#define SF3(a,b,c) scanf("%d %d %d",&a, &b, &c)
#define SFL(a) scanf("%lld",&a)
#define SFL2(a,b) scanf("%lld %lld",&a, &b)
#define SFL3(a,b,c) scanf("%lld %lld %lld",&a, &b, &c)
#define gl(a) getline(cin,(a))
#define gc() getchar()
#define pb push_back
#define m_p make_pair
#define pc() printf("Case %d: ",tt++)
#define tc() cout<<"Case "<<tt++<<": "
#define SZ(a) (int)(a).size()
#define all(a) a.begin(),a.end()
#define FF first
#define SS second
#define MAX 2134567891
#define MOD 1000000007
#define MM 100005
#define PI 2*acos(0.0)
#define cond(n,m) (xx>=0 && xx<(n) && yy>=0 && yy<(m))
#define mem(a) memset((a),0,sizeof (a))
#define SET(a) memset((a),-1,sizeof (a))
#define output freopen("output.txt","w",stdout);
#define input freopen("input.txt","r",stdin);
#define I_O ios_base::sync_with_stdio(0); cin.tie(0)
#define rep(a) for(int i=0;i<(a);i++)
#define FOR(a,b) for(int i=(a);i<(b);i++)
#define REP(a) for(int j=0;j<(a);j++)
#define rev(a) for(int i=(a);i>=0;i--)
#define fr(i,n) for(i=0;i<n;i++)
#define fr1(i,n,m) for(i=n;i<m;i++)
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
int dx8[] = {0, 0, 1, 1, 1, -1, -1, -1};
int dy8[] = {1, -1, -1, 0, 1, -1, 0, 1};
typedef long long ll;
typedef unsigned long long llu;
typedef priority_queue < int > PQ;
typedef pair < ll , ll > pi;
typedef pair < int , pi > pii;
typedef vector < int > vi;
typedef vector < ll > vl;
typedef vector < string > vs;
/*
//FUNCTION//
ll bigmod(ll a, ll b, ll c)
{
if(b==0)return 1%c;ll x=bigmod(a,b/2,c);x=x*x%c;
if(b%2==1)x=x*a%c;return x;
}
ll poww(ll a, ll b)
{
if(b==0)return 1;ll x=poww(a,b/2);x=x*x;if(b%2==1)x=x*a;return x;
}
ll mod_inverse(ll a, ll mod){return bigmod(a,mod-2,mod);}
ll LCM(ll a, ll b){ return a*b/ __gcd(a,b);}
int pr = 10000000;
vi primelist;
bool a[MM*100];
void seive( )
{
int i,j,k=sqrt(pr);
a[1]=1;
primelist.pb(2);
for(i=4;i<=pr;i+=2)a[i]=1;
for(i=3;i<=k;i+=2)if(!a[i])for(j=i*i;j<=pr;j+=2*i)a[j]=1;
for(i=3;i<=pr;i+=2)if(!a[i])primelist.pb(i);
}
ll fact_divs( ll n, ll p)
{
ll cnt=0;while(p<=n){cnt += n/p;n /= p;}return cnt;
}
struct point{double x, y;};
double area( point A, point B, point C){
return 0.5*(A.x*(B.y-C.y) - A.y*(B.x-C.x) + B.x*C.y - C.x*B.y);
}
//*/
ll dp[5005][5005];
ll a[5005], n;
ll dpcall(ll id, ll cur){
if(id > n || id < 1) return 0;
if(cur <= 0) return 1;
ll &ret = dp[id][cur];
if(~ret) return ret;
ret = dpcall(id-1, cur-1) + dpcall(id+1, cur-1);
if(ret >= MOD) ret -= MOD;
return ret;
}
ll res[5005];
int main() {
I_O;
SET(dp);
ll k, m, sum = 0;
cin>>n>>k>>m;
for(int i=1; i<=n; i++) cin>>a[i];
for(int i=1; i<=n; i++){
for(int j=k; j>=0; j--){
ll now = dpcall(i, j);
ll lf = dpcall(i-1, k-j-1);
ll rt = dpcall(i+1, k-j-1);
res[i] += (now * lf)%MOD;
res[i] %= MOD;
if(i+1<=n && i-1>=1 && j == k) continue;
res[i] += (now * rt)%MOD;
res[i] %= MOD;
}
// cout<<"DBG = "<<i<<" -> "<<res[i]<<endl;
sum += (a[i] * res[i])%MOD;
sum %= MOD;
}
rep(m){
ll p, val;
cin>>p>>val;
sum -= (a[p]*res[p])%MOD;
sum += MOD;
sum %= MOD;
a[p] = val;
sum += (a[p] * res[p])%MOD;
sum %= MOD;
cout<<sum<<"\n";
}
return 0;
}
/*
5 1 5
3 5 1 4 2
5 1 5
9 5 1 4 2
4 40 6
92 21 56 46
*/
| 7 |
#include <bits/stdc++.h>
using namespace std;
bool succ;
int dig[25];
long long sol[6];
stack<int> a, b, c;
void dfs(int x, int r) {
if (x < 0) {
if (r == 0)
succ = 1;
else
return;
memset(sol, 0, sizeof(sol));
while (!a.empty()) {
int i = 0, u;
u = a.top();
a.pop();
while (u--) {
sol[i] = sol[i] * 10 + 4;
i++;
}
u = b.top();
b.pop();
while (u--) {
sol[i] = sol[i] * 10 + 7;
i++;
}
u = c.top();
c.pop();
while (u--) {
sol[i] = sol[i] * 10;
i++;
}
}
for (int i = 0; i < 6; i++)
printf("%I64d%c", sol[i], (i == 5) ? '\n' : ' ');
return;
}
for (int i = 0; i <= 6 && !succ; i++) {
for (int j = 0; j <= 6 - i && !succ; j++) {
int tmp = r + 4 * i + 7 * j;
if (tmp % 10 == dig[x]) {
a.push(i);
b.push(j);
c.push(6 - i - j);
dfs(x - 1, tmp / 10);
if (succ) break;
a.pop();
b.pop();
c.pop();
}
}
}
}
void gao(long long x) {
int cnt = 0;
do {
dig[cnt++] = x % 10;
x /= 10;
} while (x);
reverse(dig, dig + cnt);
dfs(cnt - 1, 0);
}
int main() {
int T;
long long x;
scanf("%d", &T);
while (T--) {
scanf("%I64d", &x);
while (!a.empty()) a.pop();
while (!b.empty()) b.pop();
while (!c.empty()) c.pop();
succ = 0;
gao(x);
if (!succ) printf("-1\n");
}
return 0;
}
| 7 |
#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);
t = (t * t) % m;
if (b & 1) t = (t * a) % m;
return t;
}
long long int modInverse(long long int a, long long int m) {
return power(a, m - 2, m);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n, i, j, k, l, w;
cin >> n >> w;
long long int ar[n], sm[n + 1];
sm[0] = 0;
for (i = 0; i < n; i++) {
cin >> ar[i];
}
for (i = 0; i < n; i++) {
sm[i + 1] = sm[i] + ar[i];
}
long long int mx = 0, mn = 0;
for (i = 1; i <= n; i++) {
if (sm[i] < mn) mn = sm[i];
if (sm[i] > mx) mx = sm[i];
}
long long int a, b;
a = (w - mx);
b = abs(mn);
if ((a - b + 1) > 0) {
cout << (a - b + 1) << endl;
} else
cout << "0";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
long long int sum = 0;
long long int z = n;
while (n-- > 0) {
sum += 1ll * n * (n + 1) / 2;
}
cout << sum + z << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e5 + 10, MOD = 1e9 + 7;
int n;
long long a[MAXN], b[MAXN], dp[MAXN][2], k;
void solve() {
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> b[i];
for (int i = 0; i < n; i++) {
dp[i][0] = a[i] - b[i] * k + dp[i - 1][0];
dp[i][1] = b[i] - a[i] * k + dp[i - 1][1];
dp[i][0] = max(dp[i][0], 0ll), dp[i][1] = max(dp[i][1], 0ll);
}
for (int i = 0; i < n; i++)
for (int j : {0, 1})
if (dp[i][j] > k) {
cout << "NO\n";
return;
}
cout << "YES\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int T = 1;
while (T--) solve();
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e9;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
if (a[0] + a[1] <= a[n - 1]) {
cout << 1 << " " << 2 << " " << n << '\n';
} else {
cout << -1 << '\n';
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 100;
const long long INF = 1e9 + 1;
const long long MOD = 998244353;
const long double EPS = 1e-12;
const long double PI = acos(-1);
const unsigned long long PRIME = 31;
void bye() {
cout << "\n";
exit(0);
}
struct Coord {
int x, y;
};
struct Cube {
Coord v;
int id;
};
struct Swap {
Coord f, t;
};
vector<Swap> LP, RP;
vector<Cube> all, now, need;
vector<vector<int> > g;
bool cmp(int a, int b) { return now[a].v.x < now[b].v.x; }
int XX[] = {0, 0, 1, -1};
int YY[] = {1, -1, 0, 0};
void swapCube(Cube &kek, int dir, int f) {
Cube old = kek;
if (!f) {
LP.push_back({kek.v, {kek.v.x + XX[dir], kek.v.y + YY[dir]}});
} else if (f == 1) {
RP.push_back({{kek.v.x + XX[dir], kek.v.y + YY[dir]}, kek.v});
}
kek.v.x += XX[dir];
kek.v.y += YY[dir];
if (f <= 1) {
swap(g[old.v.x][old.v.y], g[kek.v.x][kek.v.y]);
}
}
bool check(Coord v, int dir) {
v.x += XX[dir];
v.y += YY[dir];
return !g[v.x][v.y];
}
void go(int id, Coord to, int f) {
while (now[id].v.x > to.x) {
swapCube(now[id], 3, f);
}
while (now[id].v.x < to.x) {
swapCube(now[id], 2, f);
}
while (now[id].v.y > to.y) {
swapCube(now[id], 1, f);
}
while (now[id].v.y < to.y) {
swapCube(now[id], 0, f);
}
}
bool can_go(Cube tmp, Coord to) {
while (tmp.v.x > to.x && check(tmp.v, 3)) {
swapCube(tmp, 3, 2);
}
while (tmp.v.x < to.x && check(tmp.v, 2)) {
swapCube(tmp, 2, 2);
}
while (tmp.v.y > to.y && check(tmp.v, 1)) {
swapCube(tmp, 1, 2);
}
while (tmp.v.y < to.y && check(tmp.v, 0)) {
swapCube(tmp, 0, 2);
}
if (tmp.v.x == to.x && tmp.v.y == to.y) {
return 1;
}
return 0;
}
void init() {
for (auto v : now) {
g[v.v.x][v.v.y] = v.id + 1;
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m;
cin >> n >> m;
g.resize(n, vector<int>(n));
for (int i = 0; i < m; i++) {
Cube tmp;
cin >> tmp.v.x >> tmp.v.y;
tmp.v.x--;
tmp.v.y--;
tmp.id = i;
all.push_back(tmp);
now.push_back(tmp);
}
for (int i = 0; i < m; i++) {
Cube tmp;
cin >> tmp.v.x >> tmp.v.y;
tmp.v.x--;
tmp.v.y--;
tmp.id = i;
need.push_back(tmp);
}
init();
vector<int> ord(m);
for (int i = 0; i < m; i++) {
ord[i] = i;
}
sort((ord).begin(), ord.end(), cmp);
for (int cnt = 0; cnt < n; cnt++) {
for (int i = 0; i < m; i++) {
if (can_go(now[ord[i]], {i, now[ord[i]].v.y})) {
go(now[ord[i]].id, {i, now[ord[i]].v.y}, 0);
}
}
}
for (int cnt = 0; cnt < n; cnt++) {
for (int i = 0; i < m; i++) {
if (can_go(now[i], {now[i].v.x, i})) {
go(i, {now[i].v.x, i}, 0);
}
}
}
for (int cnt = 0; cnt < n; cnt++) {
for (int i = 0; i < m; i++) {
if (can_go(now[i], {i, i})) {
go(i, {i, i}, 0);
}
}
}
for (int i = 0; i < m; i++) {
ord[i] = i;
}
for (int i = 0; i < n; i++) {
fill((g[i]).begin(), g[i].end(), 0);
}
now = need;
init();
sort((ord).begin(), ord.end(), cmp);
for (int cnt = 0; cnt < n; cnt++) {
for (int i = 0; i < m; i++) {
if (can_go(now[ord[i]], {i, now[ord[i]].v.y})) {
go(now[ord[i]].id, {i, now[ord[i]].v.y}, 1);
}
}
}
for (int cnt = 0; cnt < n; cnt++) {
for (int i = 0; i < m; i++) {
if (can_go(now[i], {now[i].v.x, i})) {
go(i, {now[i].v.x, i}, 1);
}
}
}
for (int cnt = 0; cnt < n; cnt++) {
for (int i = 0; i < m; i++) {
if (can_go(now[i], {i, i})) {
go(i, {i, i}, 1);
}
}
}
cout << (long long)(LP).size() + (long long)(RP).size() << "\n";
for (int i = 0; i < (long long)(LP).size(); i++) {
cout << LP[i].f.x + 1 << " " << LP[i].f.y + 1 << " " << LP[i].t.x + 1 << " "
<< LP[i].t.y + 1 << "\n";
}
for (int i = (long long)(RP).size() - 1; i >= 0; i--) {
cout << RP[i].f.x + 1 << " " << RP[i].f.y + 1 << " " << RP[i].t.x + 1 << " "
<< RP[i].t.y + 1 << "\n";
}
bye();
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
struct TLine {
long long a, b;
int id;
} line[maxn];
int a[maxn], b[maxn];
int n;
vector<TLine> st[maxn << 2];
bool bad(const TLine &A, const TLine &B, const TLine &C) {
return (A.b - C.b) * (C.a - B.a) < (B.b - C.b) * (C.a - A.a);
}
void build(int id, int l, int r) {
if (l == r) {
st[id].push_back(line[l]);
return;
}
int mid = (l + r) >> 1;
build(id << 1, l, mid);
build(id << 1 | 1, mid + 1, r);
vector<TLine> Save(st[id << 1].size() + st[id << 1 | 1].size());
merge(st[id << 1].begin(), st[id << 1].end(), st[id << 1 | 1].begin(),
st[id << 1 | 1].end(), Save.begin(),
[](const TLine &A, const TLine &B) {
return make_pair(A.a, A.b) > make_pair(B.a, B.b);
});
TLine pre = {-1, -1, -1};
for (auto &line : Save) {
if (line.a == pre.a) {
assert(line.b <= pre.b);
continue;
};
if (pre.b > line.b) continue;
while (st[id].size() >= 2 && bad(*(st[id].end() - 2), st[id].back(), line))
st[id].pop_back();
st[id].push_back(line);
pre = line;
}
}
long long Calc(int id, long long x) { return line[id].a * x + line[id].b; }
long long GetBest(int id, int x) {
int res = st[id].size();
int l = 1, r = st[id].size() - 1;
while (l <= r) {
int mid = (l + r) >> 1;
if (Calc(st[id][mid - 1].id, x) < Calc(st[id][mid].id, x))
l = res = mid + 1;
else
res = mid, r = mid - 1;
}
return st[id][res - 1].id;
}
int Get(int id, int l, int r, int u, int v, int x) {
if (l > v || r < u) return 0;
if (u <= l && r <= v) {
return GetBest(id, x);
}
int mid = (l + r) >> 1;
int L = Get(id << 1, l, mid, u, v, x),
R = Get(id << 1 | 1, mid + 1, r, u, v, x);
if (Calc(L, x) > Calc(R, x)) return L;
return R;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int q;
cin >> n >> q;
for (int i = 1; i <= n; ++i) {
cin >> line[i].b >> line[i].a;
line[i].id = i;
}
build(1, 1, n);
for (int i = 1; i <= q; ++i) {
int l, r, t;
cin >> l >> r >> t;
cout << Get(1, 1, n, l, r, t) << '\n';
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct suffix_array {
suffix_array(const char* S) : N(strlen(S)) {
vector<int> V;
for (int i = 0; i < N; i++) V.push_back(S[i]);
init(V);
}
suffix_array(const vector<int>& VV) : N(VV.size()) {
vector<int> V(VV);
init(V);
}
int lcp(int si, int sj) {
if (sj < si) swap(si, sj);
if (si == sj) return N - SA[si];
int len = sj - si;
int buck = 31 - __builtin_clz(len);
return min(LCP_MRQ[buck][si], LCP_MRQ[buck][sj - (1 << buck)]);
}
pair<int, int> backstep(int i, int c) {
typeof(BACK_START.begin()) it = BACK_START.find(c);
if (it == BACK_START.end()) return make_pair(0, 0);
int pi = it->second;
++it;
int pj = it == BACK_START.end() ? N : it->second;
int si = RA[i];
int p = lower_bound(BACK_LIST.begin() + pi, BACK_LIST.begin() + pj, si) -
BACK_LIST.begin();
pair<int, int> r(-1, -1);
for (int k = p - 1; k <= p; k++) {
if (k < pi || pj <= k) continue;
int sj = BACK_LIST[k];
r = max(r, make_pair(1 + lcp(si, sj), SA[sj] - 1));
}
return make_pair(r.second, r.first);
}
template <typename T>
pair<int, int> find(const T* K, int KN) {
int ind = 0, len = 0;
for (int i = KN - 1; i >= 0; i--) {
pair<int, int> res = backstep(ind, K[i]);
ind = res.first;
len = min(len + 1, res.second);
}
return make_pair(ind, len);
}
pair<int, int> range(int i, int dep) {
pair<int, int> sr(RA[i], RA[i]);
for (int j = 31 - __builtin_clz(N + 1); j >= 0; j--) {
int su = sr.first - (1 << j);
int sv = sr.second + (1 << j);
if (su >= 0 && lcp(su, sr.first) >= dep) sr.first = su;
if (sv <= N && lcp(sv, sr.second) >= dep) sr.second = sv;
}
++sr.second;
return sr;
}
int N;
vector<int> SA;
vector<int> RA;
private:
void compress(vector<int>& V, vector<int>& C) {
copy(V.begin(), V.end(), C.begin());
sort(C.begin(), C.end());
typeof(C.begin()) cend = unique(C.begin(), C.end());
for (int i = 0; i < N; i++) {
V[i] = lower_bound(C.begin(), cend, V[i]) - C.begin() + 1;
}
V.push_back(0);
C.push_back(0);
}
void compute_sa(vector<int>& V, vector<int>& C) {
vector<int> T(N + 1);
for (int i = 0; i <= N; i++) SA.push_back(i);
for (int ski = 0; V[SA[N]] < N; ski = ski ? ski << 1 : 1) {
fill(C.begin(), C.end(), 0);
for (int i = 0; i < ski; i++) T[i] = N - i;
for (int i = 0, p = ski; i <= N; i++)
if (SA[i] >= ski) T[p++] = SA[i] - ski;
for (int i = 0; i <= N; i++) C[V[i]]++;
for (int i = 1; i <= N; i++) C[i] += C[i - 1];
for (int i = N; i >= 0; i--) SA[--C[V[T[i]]]] = T[i];
T[SA[0]] = 0;
for (int j = 1; j <= N; j++) {
int a = SA[j];
int b = SA[j - 1];
T[a] = T[b] + (a + ski >= N || b + ski >= N || V[a] != V[b] ||
V[a + ski] != V[b + ski]);
}
V.swap(T);
}
}
void compute_lcp(const vector<int>& OV) {
LCP_MRQ.push_back(vector<int>(N));
int len = 0;
for (int i = 0; i < N; i++, len = max(0, len - 1)) {
int si = RA[i];
int j = SA[si - 1];
for (; i + len < N && j + len < N && OV[i + len] == OV[j + len]; len++)
;
LCP_MRQ[0][si - 1] = len;
}
for (int i = 1; 1 << i <= N; i++) {
LCP_MRQ.push_back(vector<int>());
const vector<int>& plcp = LCP_MRQ[i - 1];
for (int j = 0; j + (1 << i) <= N; j++) {
LCP_MRQ[i].push_back(min(plcp[j], plcp[j + (1 << i - 1)]));
}
}
}
void compute_backsteps(const vector<int>& OV) {
int add = 0;
for (int i = 0; i < OV.size(); i++) ++BACK_START[OV[i]];
for (typeof(BACK_START.begin()) it = BACK_START.begin();
it != BACK_START.end(); it++) {
add += it->second;
it->second = add;
}
BACK_LIST.resize(N);
for (int si = N; si >= 0; si--) {
int i = SA[si] - 1;
if (i >= 0) BACK_LIST[--BACK_START[OV[i]]] = si;
}
}
void init(vector<int>& V) {
vector<int> OV(V);
vector<int> C(N);
compress(V, C);
compute_sa(V, C);
RA.resize(N + 1);
for (int i = 0; i <= N; i++) RA[SA[i]] = i;
compute_lcp(OV);
compute_backsteps(OV);
}
vector<vector<int> > LCP_MRQ;
map<int, int> BACK_START;
vector<int> BACK_LIST;
};
int LO[20];
int HI[20];
int SLO[20];
int SHI[20];
int M;
string S;
string T[20];
vector<int> CSUM[20];
int find_m(suffix_array& sa, int p, int x, int occ) {
int lo = x;
int hi = M + 1;
while (lo < hi) {
int md = (lo + hi) / 2;
pair<int, int> rn = sa.range(x, md - x + 1);
if (CSUM[p][rn.second] - CSUM[p][rn.first] <= occ) {
hi = md;
} else {
lo = md + 1;
}
}
return lo;
}
int main() {
cin >> S;
M = S.size();
int N;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> T[i];
S += '?';
SLO[i] = S.size();
SHI[i] = SLO[i] + T[i].size();
S += T[i];
cin >> LO[i] >> HI[i];
}
suffix_array sa(S.c_str());
for (int i = 0; i < N; i++) CSUM[i].push_back(0);
for (int i = 0; i <= S.size(); i++) {
for (int j = 0; j < N; j++) {
CSUM[j].push_back(CSUM[j][i]);
if (SLO[j] <= sa.SA[i] && sa.SA[i] < SHI[j]) {
CSUM[j][i + 1]++;
}
}
}
vector<pair<int, pair<int, int> > > res;
for (int i = 0; i < M; i++) {
int mnln = i;
int mxln = M;
for (int j = 0; j < N; j++) {
mnln = max(mnln, find_m(sa, j, i, HI[j]));
if (LO[j] != 0) {
mxln = min(mxln, find_m(sa, j, i, LO[j] - 1));
}
}
if (mnln < mxln) {
res.push_back(make_pair(sa.RA[i], make_pair(mnln - i, mxln - i)));
}
}
sort(res.begin(), res.end());
long long result = 0;
for (int i = 0; i < res.size(); i++) {
int lp = i + 1 < res.size() ? sa.lcp(res[i].first, res[i + 1].first) : 0;
result += max(lp, res[i].second.second) - max(lp, res[i].second.first);
}
cout << result << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e+16;
const int SMALL_INF = 1998244353;
const int NSIZE = 2 * 1e+5 + 1000;
const int _NSIZE = 1000;
const long long MOD = 998244353;
const long double EPS = 1e-12;
const int MAX = 1e+6 + 1000;
const long double PI = atan(1) * 4;
const long long HZ = -692281337;
const long long UNUSED = SMALL_INF;
struct Dish {
int a, b, m, idx;
};
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<Dish> d(n);
vector<pair<int, int> > seg(n);
for (int i = 0; i < n; i++) {
cin >> d[i].a >> d[i].b >> d[i].m;
int r = d[i].b >= d[i].m ? d[i].a - d[i].b + d[i].m
: d[i].a - d[i].m + d[i].b;
int l = d[i].a >= d[i].m ? d[i].a - d[i].m - d[i].b
: d[i].m - d[i].b - d[i].a;
seg[i] = {l, r};
d[i].idx = i;
}
sort(d.begin(), d.end(),
[&](Dish p, Dish q) { return p.a + p.b - p.m < q.a + q.b - q.m; });
int difcnt = 0;
vector<pair<int, int> > ans(n, {-1, -1});
for (int i = 0; i < n;) {
int j = i;
vector<pair<int, int> > line;
while (true) {
line.push_back({seg[d[j].idx].first, -(j + 1)});
line.push_back({seg[d[j].idx].second, j + 1});
if (j < n - 1 &&
d[j].a + d[j].b - d[j].m == d[j + 1].a + d[j + 1].b - d[j + 1].m)
j++;
else
break;
}
sort(line.begin(), line.end());
vector<Dish> h;
for (auto k : line) {
int ind = abs(k.second) - 1;
if (k.second < 0) {
h.push_back(d[ind]);
} else if (ans[d[ind].idx] == make_pair(-1, -1)) {
difcnt++;
while (!h.empty()) {
Dish now = h.back();
h.pop_back();
ans[now.idx] = now.b >= now.m ? make_pair(0, now.m)
: make_pair(now.m - now.b, now.b);
ans[now.idx].first += (seg[now.idx].second - k.first) / 2;
ans[now.idx].second -= (seg[now.idx].second - k.first) / 2;
}
}
}
i = j + 1;
}
cout << difcnt << endl;
for (auto i : ans) cout << i.first << " " << i.second << endl;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
char a[100005], b[100005];
long long occ[2][2], ans;
int n;
int main() {
scanf("%d%s%s", &n, a, b);
for (int i = 0; i < n; i++) occ[a[i] - '0'][b[i] - '0']++;
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++)
for (int k = 0; k < 2; k++)
for (int l = 0; l < 2; l++)
if (i * 2 + j != k * 2 + l &&
((i | j) != (k | j) || (k | l) != (i | l)))
ans += occ[i][j] * occ[k][l];
printf("%lld\n", ans / 2);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
set<int> s;
vector<vector<int> > v;
bool ch[100005];
void go(int i) {
ch[i] = true;
int z = 0;
for (auto it : v[i]) {
if (ch[it] == false) {
z++;
go(it);
}
}
if (z == 0) {
s.insert(i);
}
}
void dynamic() {
int n;
cin >> n;
long double sum = 0;
cin >> sum;
v.resize(n + 1);
memset(ch, 0, sizeof(ch));
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
go(1);
int z = s.size();
if (v[1].size() == 1) {
z++;
}
sum = sum / z;
sum *= 2;
cout << setprecision(12) << sum << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
t = 1;
while (t--) {
dynamic();
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a;
cin >> a;
int r, b[4], t = 0, i;
cout << a % 2;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a[2001];
char s[20001];
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
gets(s);
for (int i = 0; i < n; i++) {
gets(s);
for (int j = 0; j < m; j++)
if (s[j] == 'U' && i % 2 == 0)
a[j]++;
else if (s[j] == 'L') {
int cc = j - i;
if (cc >= 0) a[cc]++;
} else if (s[j] == 'R') {
int cc = j + i;
if (cc < m) a[cc]++;
}
}
for (int i = 0; i < m; i++) printf("%d ", a[i]);
putchar('\n');
getchar();
getchar();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
char arr[4][4];
int a[16], s = 0, x;
int i, j;
for (i = 0; i < 4; i++) {
for (j = 0; j < 4; j++) {
cin >> arr[i][j];
if (arr[i][j] != '.') {
a[s++] = arr[i][j] - '0';
}
}
}
sort(a, a + s);
int temp = a[s - 1], flag = 0;
j = 0;
for (i = 1; i <= temp; i++) {
int count = 0;
while (a[j] == i) {
count++;
j++;
}
if (count > (2 * n)) {
flag = 1;
break;
}
}
if (flag == 1)
cout << "NO";
else
cout << "YES";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int md = 1e9 + 7;
ll pw(ll a, ll b) {
ll r = 1, base = a;
while (b != 0) {
if (b & 1) r = (r * base) % md;
base = base * base % md;
b >>= 1;
}
return r;
}
int n, m;
vector<int> a, was;
vector<vector<int> > g;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
a.resize(n);
g.resize(n);
was.resize(n);
for (int i = 0; i < n; i++) cin >> a[i], a[i]--;
for (int i = 0; i < m; i++) {
int w1, w2;
cin >> w1 >> w2;
w1--;
w2--;
g[w1].push_back(w2);
}
reverse(a.begin(), a.end());
int ans = 0;
for (int i = 0; i < n; i++) was[i] = 0;
was[a[0]] = 1;
int cnt = 1;
for (int i = 1; i < n; i++) {
int cnt2 = 0;
for (int to : g[a[i]]) {
if (was[to]) cnt2++;
}
if (cnt == cnt2) {
ans++;
} else {
was[a[i]] = 1;
cnt++;
}
}
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long int n, p = 0, sum = 0, c1 = 0, c2 = 0;
cin >> n;
int a[n];
map<int, int> m1;
map<int, int> m2;
map<int, int>::iterator it;
for (int i = 0; i < n; i++) {
cin >> a[i];
m1[a[i] % 2]++;
}
sort(a, a + n);
for (int i = 0; i < n - 1; i++) {
int x = a[i + 1] - a[i];
if (x == 1) m2[x]++;
}
for (it = m1.begin(); it != m1.end(); it++) {
c1 = c1 + (it->second) / 2;
}
if (c1 * 2 == n) {
cout << "YES" << endl;
} else {
int x = m2[1];
if ((c1 + x) * 2 >= n)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, q;
long long k, f[55] = {75};
string str =
"What are you doing at the end of the world? Are you busy? Will you save "
"us?";
string str1 = "What are you doing while sending \"",
str2 = "\"? Are you busy? Will you send \"", str3 = "\"?";
char Calc(int n, long long k) {
if (n < 53 && k > f[n]) return '.';
if (n == 0) return str[k - 1];
if (k <= 34) return str1[k - 1];
if (n >= 54 || k <= f[n - 1] + 34) return Calc(n - 1, k - 34);
if (k <= f[n - 1] + 66) return str2[k - f[n - 1] - 35];
if (k >= f[n] - 1) return str3[1 - (f[n] - k)];
return Calc(n - 1, k - f[n - 1] - 66);
}
int main() {
for (int i = 1; i < 55; i++) f[i] = f[i - 1] * 2 + 68;
for (cin >> q; q--;) {
cin >> n >> k;
putchar(Calc(n, k));
}
puts("");
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline int Get() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while ('0' <= ch && ch <= '9') {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return x * f;
}
const long long mod = 1e9 + 7;
const long long Mod = 998244353;
int n, m;
long long f[2005][15];
struct road {
int to, next;
} s[2005 << 1];
int h[2005], cnt;
void add(int i, int j) {
s[++cnt] = (road){j, h[i]};
h[i] = cnt;
}
vector<int> e[2005];
long long fac[2005], ifac[2005];
long long ksm(long long t, long long x) {
long long ans = 1;
for (; x; x >>= 1, t = t * t % mod)
if (x & 1) ans = ans * t % mod;
return ans;
}
long long Hash[2005];
long long Hash2[2005];
const long long p = 666233, p2 = 134341;
unsigned long long p3 = 233333;
int size[2005];
bool cmp(int a, int b) {
if (size[a] != size[b]) return size[a] < size[b];
if (Hash[a] != Hash[b]) return Hash[a] < Hash[b];
return Hash2[a] < Hash2[b];
}
long long t[2005];
vector<int> sn[2005];
int dep[2005], mxdep[2005];
void dfs1(int v, int fr) {
size[v] = 1;
mxdep[v] = dep[v];
for (int i = 0; i < e[v].size(); i++) {
int to = e[v][i];
if (to == fr) continue;
sn[v].push_back(to);
dep[to] = dep[v] + 1;
dfs1(to, v);
mxdep[v] = max(mxdep[v], mxdep[to]);
size[v] += size[to];
}
sort(sn[v].begin(), sn[v].end(), cmp);
t[v] = 1;
for (int i = 0; i < sn[v].size(); i++) {
int j = i;
while (j + 1 < sn[v].size() && size[sn[v][i]] == size[sn[v][j + 1]] &&
Hash[sn[v][i]] == Hash[sn[v][j + 1]] &&
Hash2[sn[v][j]] == Hash2[sn[v][j + 1]])
j++;
t[v] = t[v] * ifac[j - i + 1] % mod;
i = j;
}
Hash2[v] = Hash[v] = '(';
for (int i = 0; i < sn[v].size(); i++) {
Hash[v] = (Hash[v] * p + Hash[sn[v][i]]) % mod;
Hash2[v] = (Hash2[v] * p2 + Hash2[sn[v][i]]) % Mod;
}
Hash[v] = (Hash[v] * p + ')') % mod;
Hash2[v] = (Hash2[v] * p + ')') % Mod;
}
int st[2005], top;
int cal(int v, int u) {
if (!top) return 0;
static long long ans[1 << 13], g[1 << 13];
int num = sn[u].size();
for (int i = 0; i < 1 << num; i++) ans[i] = 0;
ans[0] = 1;
for (int i = 1; i <= top; i++) {
memcpy(g, ans, sizeof(g));
int now = st[i];
for (int j = 0; j < num; j++) {
if (!f[now][sn[u][j]]) continue;
int t = 1 << j;
for (int sta = 0; sta < 1 << num; sta++) {
if (!(sta & t))
g[sta | t] = (g[sta | t] + ans[sta] * f[now][sn[u][j]]) % mod;
}
}
memcpy(ans, g, sizeof(g));
}
return ans[(1 << num) - 1] * t[u] % mod;
}
long long ans;
int rt;
void solve(int v, int fr) {
for (int i = 1; i <= m; i++)
if (sn[i].size() == 0) f[v][i] = 1;
for (int i = h[v]; i; i = s[i].next) {
int to = s[i].to;
if (to == fr) continue;
solve(to, v);
}
top = 0;
for (int i = h[v]; i; i = s[i].next) {
if (s[i].to == fr) continue;
st[++top] = s[i].to;
}
for (int i = 1; i <= m; i++) {
if (sn[i].size()) {
f[v][i] = cal(v, i);
}
}
(ans += f[v][rt]) %= mod;
}
map<pair<int, int>, int> vis;
int work() {
for (int i = 1; i <= m; i++) sn[i].clear();
for (int i = 1; i <= m; i++) Hash[i] = Hash2[i] = 0;
dep[rt] = 1;
dfs1(rt, 0);
if (vis.find(make_pair(Hash[rt], Hash2[rt])) != vis.end()) return 0;
vis[make_pair(Hash[rt], Hash2[rt])] = 1;
memset(f, 0, sizeof(f));
ans = 0;
solve(1, 0);
return ans;
}
int main() {
n = Get();
int a, b;
for (int i = 1; i < n; i++) {
a = Get(), b = Get();
add(a, b), add(b, a);
}
m = Get();
fac[0] = 1;
for (int i = 1; i <= m; i++) fac[i] = fac[i - 1] * i % mod;
ifac[m] = ksm(fac[m], mod - 2);
for (int i = m - 1; i >= 0; i--) ifac[i] = ifac[i + 1] * (i + 1) % mod;
for (int i = 1; i < m; i++) {
a = Get(), b = Get();
e[a].push_back(b);
e[b].push_back(a);
}
long long tot = 0;
for (rt = m; rt >= 1; rt--) (tot += work()) %= mod;
cout << tot << "\n";
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
vector<int> edge[maxn];
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long son[maxn], a[maxn];
long long ans;
bool flag = 0;
long long dfs(int u, int fa) {
if (flag) return 0;
long long lcm = 1, sum = 0, mi = 1e18;
int cnt = 0;
for (int i = 0; i < (int)edge[u].size(); i++) {
int v = edge[u][i];
if (v == fa) continue;
long long t = dfs(v, u);
if (flag) return 0;
mi = min(mi, t);
sum += t;
cnt++;
lcm = lcm / gcd(son[v], lcm) * son[v];
if (mi < lcm) {
flag = 1;
return 0;
}
}
if (flag) return 0;
if (!cnt) {
son[u] = 1;
return a[u];
}
son[u] = lcm * cnt;
long long ret = mi / lcm * lcm * cnt;
ans += sum - ret;
return ret;
}
int n;
int main() {
scanf("%d", &n);
int x, y;
long long tot = 0;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), tot += a[i];
for (int i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
edge[x].push_back(y);
edge[y].push_back(x);
}
dfs(1, 0);
if (flag)
cout << tot << endl;
else
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool check(long long a, long long b, long long c) {
int f = 0;
if ((a + b) > c) f = 1;
if ((b + c) > a) f++;
if ((c + a) > b) f++;
if (f == 3)
return false;
else
return true;
}
void solve() {
int n;
cin >> n;
int i;
long long arr[n];
for (i = 0; i < n; i++) {
cin >> arr[i];
}
if (check(arr[0], arr[1], arr[n - 1])) {
cout << 1 << " " << 2 << " " << n << endl;
return;
}
cout << "-1\n";
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
string s;
cin >> s;
char mn = 'z';
for (int i = 0; i < (int)s.size(); i++) {
if (mn < s[i])
cout << "Ann" << endl;
else
cout << "Mike" << endl;
mn = min(mn, s[i]);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int n, long long int p) {
long long int i, sum = 1;
for (i = 0; i < p; i++) sum = sum * n;
return sum;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n, m;
cin >> n >> m;
map<string, string> ma;
for (long long int i = 0; i < m; i++) {
string s1, s2;
cin >> s1 >> s2;
if (s1.size() <= s2.size())
ma[s1] = s1;
else
ma[s1] = s2;
}
std::vector<string> v(n);
for (long long int i = 0; i < n; i++) {
string s;
cin >> s;
v[i] = ma[s];
}
for (long long int i = 0; i < n; i++) cout << v[i] << " ";
cout << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool cmp(int a, int b) {
if (a > b)
return true;
else
return false;
}
int main() {
int n, min, next;
int ind = 1;
bool sw = false;
cin >> n;
cin >> min;
for (int i = 2; i <= n; i++) {
cin >> next;
if (next == min) sw = true;
if (next < min) {
ind = i;
min = next;
sw = false;
}
}
if (sw)
cout << "Still Rozdil" << endl;
else
cout << ind << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct debugger {
template <typename T>
debugger& operator,(const T& v) {
cerr << v << " ";
return *this;
}
} dbg;
bool check_key(map<int64_t, int64_t> m, int64_t key) {
if (m.find(key) == m.end()) return false;
return true;
}
vector<int64_t> SieveOfEratosthenes(int64_t n) {
bool prime[n + 1];
memset(prime, true, sizeof(prime));
vector<int64_t> res;
for (int64_t p = 2; p * p <= n; p++) {
if (prime[p] == true) {
for (int64_t i = p * p; i <= n; i += p) prime[i] = false;
}
}
for (int64_t p = 2; p <= n; p++)
if (prime[p]) res.push_back(p);
return res;
}
int64_t decimalToOctal(int64_t decimalNumber) {
int64_t rem, i = 1, octalNumber = 0;
while (decimalNumber != 0) {
rem = decimalNumber % 8;
decimalNumber /= 8;
octalNumber += rem * i;
i *= 10;
}
return octalNumber;
}
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
int64_t t;
cin >> t;
map<int64_t, int64_t> x;
for (int64_t i = 0; i < t; i++) {
int64_t n1;
cin >> n1;
x[i + 1] = n1;
}
int64_t t1;
cin >> t1;
for (int64_t _ = 0; _ < t1; _++) {
int64_t n1, n2;
cin >> n1 >> n2;
if (n1 == 1) {
x[2] += x[1] - n2;
x[1] = 0;
continue;
} else if (n1 == t) {
x[t - 1] += n2 - 1;
x[t] = 0;
continue;
} else {
x[n1 - 1] += n2 - 1;
x[n1 + 1] += x[n1] - n2;
x[n1] = 0;
continue;
}
}
if (t == 1) {
cout << x[1] << ("\n");
} else {
for (auto thing : x) {
cout << thing.second << ("\n");
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
const long long N = 2e5 + 10;
const long long mod = 1e9 + 7;
int read() {
int a;
scanf("%d", &a);
return a;
}
int siz[N], n, A[N], t[N], fas[N], dep[N];
long long ans, suf[N][2], sup[N][2];
vector<int> G[N];
void dfs(int u, int fa) {
dep[u] = dep[fa] + 1;
fas[u] = fa;
siz[u] = 1;
suf[u][0] = 1;
for (int siz1 = G[u].size(), i = 0; i < siz1; i++) {
int v = G[u][i];
if (v == fa) continue;
dfs(v, u);
siz[u] += siz[v];
suf[u][0] += suf[v][1];
suf[u][1] += suf[v][0];
}
ans = (ans + mod +
1ll * (suf[u][0] - suf[u][1]) * A[u] % mod * (n - siz[u] + 1) % mod) %
mod;
ans = (ans + mod + 1ll * A[u] * (siz[u] - 1) % mod) % mod;
for (int siz1 = G[u].size(), i = 0; i < siz1; i++) {
int v = G[u][i];
if (v == fa) continue;
ans = (ans + mod +
1ll * (suf[v][1] - suf[v][0]) * A[u] % mod * (siz[u] - siz[v] - 1) %
mod) %
mod;
}
}
bool cmp(int a, int b) { return dep[a] < dep[b]; }
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
A[i] = read();
t[i] = i;
}
for (int i = 1; i < n; i++) {
int u = read(), v = read();
G[u].push_back(v);
G[v].push_back(u);
}
dfs(1, 0);
sort(t + 1, t + 1 + n, cmp);
for (int i = 2; i <= n; i++) {
int u = t[i];
sup[u][0] += sup[fas[u]][1] + suf[fas[u]][1] - suf[u][0];
sup[u][1] += sup[fas[u]][0] + suf[fas[u]][0] - suf[u][1];
ans =
(mod + ans + (sup[u][0] - sup[u][1]) * siz[u] % mod * A[u] % mod) % mod;
}
cout << ans % mod;
}
| 7 |
#include <bits/stdc++.h>
const long long oo = 0x3f3f3f3f;
const int _cnt = 1000 * 1000;
const int _p = 1000 * 1000 * 1000 + 7;
long long o(long long x) { return x % _p; }
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int lcm(int a, int b) { return a / gcd(a, b) * b; }
using namespace std;
void file_put() {
freopen("filename.in", "r", stdin);
freopen("filename.out", "w", stdout);
}
struct ttype {
long long l, r;
int no;
friend bool operator<(const ttype &t1, const ttype &t2) {
return t1.r > t2.r;
}
};
struct ptype {
long long x;
int no;
};
bool cmp0(ptype p1, ptype p2) { return p1.x < p2.x; }
int n, m;
ttype p[200005], q[200005], w[200005];
ptype point[200005];
vector<ttype> X[200005];
int ans[200005];
priority_queue<ttype> Q;
int _find(long long x, int l, int r) {
if (point[r].x < x) return r + 1;
int ans = 0, mid;
while (l <= r) {
mid = (l + r) >> 1;
if (point[mid].x >= x) {
ans = mid;
r = mid - 1;
} else
l = mid + 1;
}
return ans;
}
int _find1(long long x, int l, int r) {
if (point[l].x > x) return l - 1;
int ans = 0, mid;
while (l <= r) {
mid = (l + r) >> 1;
if (point[mid].x <= x) {
ans = mid;
l = mid + 1;
} else
r = mid - 1;
}
return ans;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%I64d%I64d", &p[i].l, &p[i].r);
for (int i = 1; i <= m; i++) {
scanf("%I64d", &point[i].x);
point[i].no = i;
}
sort(point + 1, point + m + 1, cmp0);
for (int i = 1; i <= n - 1; i++) {
q[i].l = p[i + 1].l - p[i].r;
q[i].r = p[i + 1].r - p[i].l;
}
for (int i = 1; i <= n - 1; i++) {
w[i].l = _find(q[i].l, 1, m);
w[i].r = _find1(q[i].r, 1, m);
w[i].no = i;
if (w[i].l > w[i].r) return 0 * printf("No\n");
X[w[i].l].push_back(w[i]);
}
for (int i = 1; i <= m; i++) {
for (int j = 0; j < X[i].size(); j++) Q.push(X[i][j]);
if (Q.empty()) continue;
ans[Q.top().no] = point[i].no;
Q.pop();
if (Q.empty()) continue;
if (Q.top().r == i) return 0 * printf("No\n");
}
printf("Yes\n");
for (int i = 1; i <= n - 2; i++) printf("%d ", ans[i]);
if (n >= 2) printf("%d\n", ans[n - 1]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1E5 + 1;
int n, k;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> k;
long long res = 0;
for (int i = 1; i <= min(k, n / 2); i++) {
res += n - 2 * (i - 1) - 1 + n - 2 * (i - 1) - 2;
}
cout << res << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, k, l, r, sz, i, len, q, p, mid, anspos, ans[1000001];
long long mxl, mxr;
long long pos[1000001], t[1000001], pr[100001];
struct Pair {
long long pos;
long long x;
long long d;
};
Pair a[100001], b[100001];
bool cmp(Pair p1, Pair p2) { return p1.x < p2.x; }
bool cmd(Pair p1, Pair p2) { return p1.pos < p2.pos; }
long long binl(long long L, long long R, long long height) {
long long otv = -1;
while (L <= R) {
mid = L + R;
mid /= 2;
if (b[mid].x > height)
R = mid - 1;
else
otv = mid, L = mid + 1;
}
return otv;
}
long long binr(long long L, long long R, long long height) {
long long otv = -1;
while (L <= R) {
mid = L + R;
mid /= 2;
if (b[mid].x < height)
L = mid + 1;
else
otv = mid, R = mid - 1;
}
return otv;
}
long long tree(long long L, long long R) {
long long nn = 0;
while (L <= R) {
if (L % 2 == 1) nn = max(nn, t[L]);
if (R % 2 == 0) nn = max(nn, t[R]);
L = (L + 1) / 2;
R = (R - 1) / 2;
}
return nn;
}
void update(long long x) {
x /= 2;
while (x) {
t[x] = max(t[x * 2], t[x * 2 + 1]);
x /= 2;
}
}
int main() {
cin >> n >> k;
sz = 1;
while (sz < n) sz *= 2;
for (i = 1; i <= n; i++) {
cin >> a[i].x;
a[i].pos = i;
b[i] = a[i];
}
sort(b + 1, b + n + 1, cmp);
for (int i = 1; i <= n; i++) pos[b[i].pos] = i, pr[i] = b[i].pos;
for (int i = 1; i <= n; i++) {
int l = binl(1, pos[i] - 1, a[i].x - k);
int r = binr(pos[i] + 1, n, a[i].x + k);
int mxl = 0, mxr = 0;
if (l > 0) mxl = tree(sz, l + sz - 1);
if (r > 0) mxr = tree(r + sz - 1, n + sz - 1);
t[pos[i] + sz - 1] = max(mxl, mxr) + 1;
update(pos[i] + sz - 1);
a[pr[pos[i]]].d = t[pos[i] + sz - 1];
}
sort(b + 1, b + n + 1, cmd);
cout << t[1] << endl;
for (int i = 1; i <= n; i++) {
if (a[i].d == t[1]) {
p = i;
break;
}
}
ans[++q] = p;
for (int j = p; j >= 1; j--) {
if (a[j].d == a[p].d - 1 && abs(a[j].x - a[p].x) >= k) {
ans[++q] = j;
p = j;
}
}
for (int i = q; i >= 1; i--) cout << ans[i] << " ";
return 0;
}
| 6 |
#include <bits/stdc++.h>
const int M = 1e5 + 5;
int len;
long long lsh[M * 3];
int n, m, k, p, t[M], v[M], nxt[M], pre[M];
long long CB[M * 3];
long long now, val[M], ans[M];
struct Query {
int L, R, p, id;
inline bool operator<(const Query& it) const {
return p == it.p ? p & 1 ? R < it.R : R > it.R : L < it.L;
}
} q[M];
inline void Add(const int& id, const int& to) {
now += CB[to];
++CB[v[id]];
}
inline void Del(const int& id, const int& to) {
--CB[v[id]];
now -= CB[to];
}
signed main() {
register int i, L = 1, R = 0;
scanf("%d%d", &n, &k);
lsh[++len] = 0;
lsh[++len] = k;
lsh[++len] = -k;
for (i = 1; i <= n; ++i) scanf("%d", t + i);
for (i = 1; i <= n; ++i) {
scanf("%lld", val + i);
if (t[i] == 1)
val[i] = val[i - 1] + val[i];
else
val[i] = val[i - 1] - val[i];
lsh[++len] = val[i];
lsh[++len] = val[i] - k;
lsh[++len] = val[i] + k;
}
std::sort(lsh + 1, lsh + len + 1);
len = std::unique(lsh + 1, lsh + len + 1) - lsh - 1;
for (i = 0; i <= n; ++i) {
v[i] = std::lower_bound(lsh + 1, lsh + len + 1, val[i]) - lsh;
pre[i] = std::lower_bound(lsh + 1, lsh + len + 1, val[i] - k) - lsh;
nxt[i] = std::lower_bound(lsh + 1, lsh + len + 1, val[i] + k) - lsh;
}
scanf("%d", &m);
p = ceil(n / sqrt(m * 2.0 / 3));
for (i = 1; i <= m; ++i) {
scanf("%d%d", &q[i].L, &q[i].R);
--q[i].L;
q[i].id = i;
q[i].p = q[i].L / p;
}
std::sort(q + 1, q + m + 1);
for (i = 1; i <= m; ++i) {
const int &QL = q[i].L, &QR = q[i].R;
while (R < QR) ++R, Add(R, pre[R]);
while (L > QL) --L, Add(L, nxt[L]);
while (L < QL) Del(L, nxt[L]), ++L;
while (R > QR) Del(R, pre[R]), --R;
ans[q[i].id] = now;
}
for (i = 1; i <= m; ++i) printf("%lld\n", ans[i]);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
vector<vector<int>> a(n);
int mx = 0;
for (int i = 0; i < n; ++i) {
int m;
cin >> m;
a[i].resize(m);
for (int j = 0; j < m; ++j) {
cin >> a[i][j];
mx = max(mx, a[i][j]);
}
}
vector<int> maxs(n);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < a[i].size(); ++j) {
maxs[i] = max(maxs[i], a[i][j]);
}
}
long long ans = 0;
for (int i = 0; i < n; ++i) {
int d = mx - maxs[i];
ans += (d * 1LL * (int)a[i].size());
}
cout << ans;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int const N = 1e5 + 10;
int const M = 1e9 + 7;
int unlucky;
vector<int> lucky, x;
int f[2][N];
int *cur = f[0], *nxt = f[1];
int fac[N], rev_fac[N];
bool is_lucky(int x) {
while (x) {
int y = x % 10;
if (y != 4 && y != 7) return false;
x /= 10;
}
return true;
}
void init() {
fac[0] = 1;
for (int i = 1; i < N; ++i) fac[i] = (ll)i * fac[i - 1] % M;
rev_fac[N - 1] = 549915853;
for (int i = N - 2; i >= 0; --i)
rev_fac[i] = (ll)rev_fac[i + 1] * (i + 1) % M;
}
int C(int n, int m) {
if (n < m) return 0;
return (ll)fac[n] * rev_fac[m] % M * (ll)rev_fac[n - m] % M;
}
int main() {
init();
int n, k;
scanf("%d%d", &n, &k);
for (int i = 0, x; i < n; ++i) {
scanf("%d", &x);
if (is_lucky(x))
lucky.push_back(x);
else
++unlucky;
}
sort(lucky.begin(), lucky.end());
int sz = (int)lucky.size();
for (int i = 1, cnt = 1; i <= sz; ++i) {
if (i == sz || lucky[i] != lucky[i - 1]) {
x.push_back(cnt);
cnt = 1;
} else {
++cnt;
}
}
sz = (int)x.size();
cur[0] = nxt[0] = 1;
for (int i = 0; i < sz; ++i) {
for (int j = 1; j <= k && j <= i + 1; ++j) {
nxt[j] = (cur[j] + (ll)cur[j - 1] * x[i]) % M;
}
swap(cur, nxt);
}
int tot = 0;
for (int j = 0; j <= k; ++j) {
tot = (tot + (ll)cur[j] * C(unlucky, k - j)) % M;
}
printf("%d\n", tot);
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
const long long INF = 0x3f3f3f3f3f3f3f3f;
const long long llinf = (1LL << 61);
const int inf = (1 << 30);
const int nmax = 3e5 + 50;
const int mod = 1e9 + 7;
using namespace std;
long long n, a[2][nmax], b[nmax], c[nmax], d[nmax], e[nmax], s[5][nmax], sum, i,
j, t, tmp, ans, nr = 1;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cerr.tie(0);
cout.tie(0);
cin >> n;
for (i = 0; i < 2; i++)
for (j = 1; j <= n; j++) cin >> a[i][j];
for (i = 2; i <= n; i++) {
sum += a[0][i];
s[0][i] = sum;
b[i] = b[i - 1] + sum;
}
for (i = n; i >= 1; i--) {
sum += a[1][i];
s[1][i] = sum;
c[i] = c[i + 1] + sum;
if (i == n) c[i] += b[n];
}
sum = 0;
for (i = 1; i <= n; i++) {
sum += a[1][i];
s[2][i] = sum;
d[i] = d[i - 1] + sum;
}
for (i = n; i >= 2; i--) {
sum += a[0][i];
s[3][i] = sum;
e[i] = e[i + 1] + sum;
if (i == n) e[i] += d[n];
}
sum = 0, i = 0, j = 1;
for (t = 1;; t++) {
if (i & 1) {
tmp = c[j + 1] - b[j - 1] - s[0][j - 1] * (n - j + 1 + n - j) +
(s[1][j + 1] - s[0][j - 1]) * (nr - 1);
ans = max(ans, tmp + sum);
} else {
tmp = e[j + 1] - d[j - 1] - s[2][j - 1] * (n - j + 1 + n - j) +
(s[3][j + 1] - s[2][j - 1]) * (nr - 1);
ans = max(ans, tmp + sum);
}
i ^= 1;
sum += nr * a[i][j] + (nr + 1) * a[i][j + 1];
ans = max(ans, sum);
nr += 2, j++;
if (j > n) break;
}
cout << ans << endl;
return 0;
}
| 5 |
#include <iostream>
#include <vector>
#include <math.h>
#include <string>
#include <algorithm>
#include <set>
#include <iomanip>
#define ll long long
#define dd long double
#define ii int
#define mod 1000000007
#define mod1 998244353
#define co pow(2,64)-1
#define f(i,n) for(i=0;i<=n;v++)
using namespace std;
typedef vector<int> vi;
typedef pair<int,int> pi;
//freopen("input.txt", "r", stdin);
//freopen("output.txt", "w", stdout);
//bit-manipulation
#define count_zeroes_atbeg(n) __builtin_clz(n)
#define count_zeroes_atend(n) __builtin_ctz(n)
#define count_ones(n) __builtin_popcount(n)
#define parity(n) __builtin_parity(n)
/*struct cmp {
bool operator() (const pair<int, int> &a, const pair<int, int> &b) const {
int lena = a.second - a.first + 1;
int lenb = b.second - b.first + 1;
if (lena == lenb) return a.first < b.first;
return lena > lenb;
}
};*/
int main()
{
ios_base::sync_with_stdio(0);
cin.tie(0);
ll t;
cin>>t;
while(t--)
{
ll a,b,c;
cin>>a>>b>>c;
ll prime[9];
prime[0] = 7;
prime[1] = 11;
prime[2] = 101;
prime[3] = 1009;
prime[4] = 10007;
prime[5] = 111323;
prime[6] = 1000003;
prime[7] = 10000019;
prime[8] = 100000007;
ll num1 = prime[c-1];
ll num2 = num1;
if(a==1 && b==1 && c==1)
cout<<1<<" "<<1<<endl;
else{
if(a>c){
while(true) {
num1*=2;
if(num1>=pow(10, a-1) && num1<pow(10, a))
break;
}
}
if(b>c){
while(true) {
num2*=3;
if(num2>=pow(10, b-1) && num2<pow(10, b))
break;
}
}
cout<<num1<<" "<<num2<<endl;
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
double n, r;
int main() {
scanf("%lf%lf", &n, &r);
double s = 2.0 * acos(-1) / n;
double a = sin(s / 2.0);
double ans = a * r / (1 - a);
printf("%.7f", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, q, cnt = 0, rt = 1;
long long a[300005];
long long dat[2400005];
long long tag[2400005];
long long par[300005][20];
long long dep[300005];
long long L[300005];
long long R[300005];
vector<long long> edge[300005];
void read() {
scanf("%lld%lld", &n, &q);
for (long long i = 1; i <= n; i++) scanf("%lld", &a[i]);
long long x, y;
for (long long i = 1; i < n; i++) {
scanf("%lld%lld", &x, &y);
edge[x].push_back(y);
edge[y].push_back(x);
}
}
void push_down(long long k, long long len) {
if (tag[k]) {
dat[k * 2 + 1] += tag[k] * (len - (len >> 1));
dat[k * 2 + 2] += tag[k] * (len >> 1);
tag[k * 2 + 1] += tag[k];
tag[k * 2 + 2] += tag[k];
tag[k] = 0;
}
}
void push_up(long long k) { dat[k] = dat[k * 2 + 1] + dat[k * 2 + 2]; }
void update(long long a, long long b, long long k, long long l, long long r,
long long x) {
if (a <= l && r <= b) {
dat[k] += (r - l + 1) * x, tag[k] += x;
return;
}
push_down(k, r - l + 1);
long long mid = (l + r) >> 1;
if (a <= mid) update(a, b, k * 2 + 1, l, mid, x);
if (b > mid) update(a, b, k * 2 + 2, mid + 1, r, x);
push_up(k);
}
long long query(long long a, long long b, long long k, long long l,
long long r) {
if (a <= l && r <= b) return dat[k];
push_down(k, r - l + 1);
long long mid = (l + r) >> 1, ans = 0;
if (a <= mid) ans += query(a, b, k * 2 + 1, l, mid);
if (b > mid) ans += query(a, b, k * 2 + 2, mid + 1, r);
return ans;
}
void dfs1(long long x, long long d, long long p) {
par[x][0] = p, dep[x] = d, L[x] = ++cnt;
for (long long k = 0; k + 1 < 20; k++) {
if (par[x][k]) par[x][k + 1] = par[par[x][k]][k];
}
for (long long i = 0; i < edge[x].size(); i++) {
long long t = edge[x][i];
if (t != p) dfs1(t, d + 1, x);
}
R[x] = cnt;
}
long long lca(long long a, long long b) {
if (dep[a] < dep[b]) swap(a, b);
for (long long k = 0; k < 20 && dep[a] != dep[b]; k++) {
if (((dep[a] - dep[b]) >> k) & 1) a = par[a][k];
}
if (a == b) return a;
for (long long k = 20 - 1; k >= 0; k--) {
if (par[a][k] != par[b][k]) {
a = par[a][k], b = par[b][k];
}
}
return par[a][0];
}
long long get_son(long long x) {
long long a = rt;
for (long long k = 0; k < 20 && dep[x] + 1 != dep[a]; k++) {
if (((dep[rt] - dep[x] - 1) >> k) & 1) a = par[a][k];
}
return a;
}
inline bool in_tree(long long s, long long p) {
return L[p] <= L[s] && L[s] <= R[p];
}
inline bool in_path(long long s) { return lca(s, rt) == s; }
long long get_lca(long long a, long long b) {
bool fa = in_tree(a, rt), fb = in_tree(b, rt);
if (fa & fb) return lca(a, b);
if (fa ^ fb) return rt;
long long p = lca(a, b);
if (!in_path(p)) return p;
long long la = lca(rt, a), lb = lca(rt, b);
return dep[la] > dep[lb] ? la : lb;
}
void add(long long x, long long v) { update(L[x], R[x], 0, 1, n, v); }
void add_tree(long long x, long long v) {
if (x == rt)
add(1, v);
else if (!in_tree(rt, x))
add(x, v);
else
add(1, v), add(get_son(x), -v);
}
void add_sub(long long x, long long y, long long z) {
long long p = get_lca(x, y);
add_tree(p, z);
}
long long get_sum(long long x) { return query(L[x], R[x], 0, 1, n); }
long long query_sub(long long x) {
long long ans = 0;
if (rt == x)
ans += get_sum(1);
else if (!in_tree(rt, x))
ans += get_sum(x);
else
ans += get_sum(1), ans -= get_sum(get_son(x));
return ans;
}
void init() {
dfs1(1, 0, 0);
for (long long i = 1; i <= n; i++) update(L[i], L[i], 0, 1, n, a[i]);
}
void work() {
init();
long long opt, x, y, z;
while (q--) {
scanf("%lld%lld", &opt, &x);
if (opt == 1) rt = x;
if (opt == 2) scanf("%lld%lld", &y, &z), add_sub(x, y, z);
if (opt == 3) printf("%lld\n", query_sub(x));
}
}
signed main() {
read();
work();
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int arr[50010];
int steps[50010];
int main() {
int N, T;
cin >> N >> T;
for (int i = 1; i < N; i++) cin >> steps[i];
memset(arr, 0, sizeof arr);
int i = 1;
while (i <= N) {
arr[i] = 1;
if (i == N) break;
i += steps[i];
}
if (arr[T])
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, t, j = 1;
cin >> n >> t;
int a[n - 1];
for (int i = 0; i < n - 1; i++) cin >> a[i];
int i = 0;
while (j <= n - 1) {
j = j + a[j - 1];
if (j == t) {
cout << "YES" << endl;
return 0;
}
}
cout << "NO" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2001000;
string s[maxn];
int pos[maxn], id[maxn];
int n;
signed main() {
int mx = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
cin >> s[i];
int cnt, sz = s[i].length();
scanf("%d", &cnt);
for (int j = 1; j <= cnt; j++) {
int p;
scanf("%d", &p);
if (sz > pos[p]) {
pos[p] = sz;
id[p] = i;
}
mx = max(mx, p + sz - 1);
}
}
int cnt = 0, tot = 0, now;
string ret;
for (int i = 1; i <= mx; i++) {
if (pos[i] > cnt) {
cnt = pos[i];
now = id[i];
tot = 0;
}
if (cnt == 0) {
ret += 'a';
continue;
}
ret += s[now][tot++];
cnt--;
}
cout << ret << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 262151;
const int SIZE = 300030;
int a[SIZE];
long long sum[SIZE], sumPos[SIZE];
vector<int> v[2 * MOD];
void init() {
memset(sum, 0, sizeof(sum)), memset(sumPos, 0, sizeof(sumPos));
for (int i = 0; i < 2 * MOD; i++) v[i].clear();
}
long long gao(int Left, int Right) {
if (a[Left] >= 0) return sumPos[Right] - sumPos[Left - 1];
return sumPos[Right] - sumPos[Left - 1] + 2 * a[Left];
}
int main() {
int n;
init();
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
v[a[i] % MOD + MOD].push_back(i);
sum[i] = sum[i - 1] + a[i];
sumPos[i] = sumPos[i - 1] + (a[i] >= 0 ? a[i] : 0);
}
long long Max = -(1 << 31);
int mark1, mark2;
for (int i = 0; i < 2 * MOD; i++) {
int tmp = v[i].size();
if (!tmp || tmp == 1) continue;
tmp = v[i][0];
for (int j = 1; j < v[i].size(); j++) {
if (a[v[i][j]] != a[tmp]) {
long long t = gao(tmp, v[i][j - 1]);
if (Max < t) {
Max = t;
mark1 = tmp, mark2 = v[i][j - 1];
}
tmp = v[i][j];
continue;
}
}
long long t = gao(tmp, v[i][v[i].size() - 1]);
if (Max < t) {
Max = t;
mark1 = tmp, mark2 = v[i][v[i].size() - 1];
}
}
int ans = mark1 - 1 + n - mark2;
for (int i = mark1 + 1; i < mark2; i++)
if (a[i] < 0) ans++;
printf("%I64d %d\n", Max, ans);
for (int i = 1; i < mark1; i++) printf("%d ", i);
for (int i = mark1 + 1; i < mark2; i++)
if (a[i] < 0) printf("%d ", i);
for (int i = mark2 + 1; i <= n; i++) printf("%d ", i);
puts("");
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v[200005], v2[200005];
int visit[200005];
void dfs(int node) {
visit[node] = 1;
for (int i = 0; i < v2[node].size(); i++) {
if (!visit[v2[node][i]]) dfs(v2[node][i]);
}
}
int main() {
int i, j, k;
int n, m;
scanf("%d", &n);
scanf("%d", &m);
for (i = 1; i <= n; i++) {
scanf("%d", &j);
while (j--) {
scanf("%d", &k);
v[i].push_back(k);
}
}
for (i = 1; i < n; i++) {
for (j = 0; j < min(v[i].size(), v[i + 1].size()); j++) {
if (v[i][j] != v[i + 1][j]) break;
}
if (j == min(v[i].size(), v[i + 1].size())) {
if (j == v[i + 1].size() && j != v[i].size()) {
printf("No\n");
return 0;
}
} else {
if (v[i][j] > v[i + 1][j]) {
v2[v[i][j] + m].push_back(v[i + 1][j]);
visit[v[i][j] + m] = 1;
} else {
v2[v[i][j]].push_back(v[i + 1][j]);
v2[v[i + 1][j] + m].push_back(v[i][j] + m);
}
}
}
for (i = m + 1; i <= 2 * m; i++) {
if (visit[i] == 1) {
dfs(i);
}
}
for (i = 1; i <= m; i++) {
if (visit[i] && visit[i + m]) {
printf("No\n");
return 0;
}
}
printf("Yes\n");
vector<int> ans;
for (i = 1; i <= m; i++) {
if (visit[i + m]) ans.push_back(i);
}
cout << ans.size() << endl;
for (i = 0; i < ans.size(); i++) printf("%d ", ans[i]);
printf("\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
int c[1000000];
int main() {
int n, a[100005], b[100005], i, m, k = 1, j, x = 0, l = 0;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
for (j = 0; j < a[i]; j++) c[l++] = k;
k++;
}
scanf("%d", &m);
for (i = 0; i < m; i++) scanf("%d", &b[i]);
for (i = 0; i < m; i++) printf("%d\n", c[b[i] - 1]);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m, ans;
int main() {
cin >> n >> m;
ans = (n + m) / 3;
if (ans > m || ans > n) {
cout << min(n, m);
} else {
cout << ans;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 55;
int n, dp[maxn][maxn][maxn][maxn], cnt = 0, head[maxn], s, m, pos[maxn],
degree[maxn], ans = 0x3f3f3f3f,
c[maxn][maxn];
struct edge {
int u, v, c, next;
} e[110];
void dfs(int xx, int yy) {
for (int i = head[xx]; i; i = e[i].next)
if (e[i].v != yy) {
dfs(e[i].v, xx);
pos[xx] += pos[e[i].v];
}
}
void add(int u, int v, int w) {
cnt++;
e[cnt].u = u;
e[cnt].v = v;
e[cnt].c = w;
e[cnt].next = head[u];
head[u] = cnt;
}
int solve(int u, int v, int s1, int s2) {
if (!s1 && !s2) return 0;
if (!s1) return 0x3f3f3f3f;
int &ANS = dp[u][v][s1][s2];
if (ANS != 0x3f3f3f3f) return ANS;
if (degree[v] == 1) {
ANS = solve(v, u, s2, 0) + c[u][v];
return ANS;
}
for (int i = head[v]; i; i = e[i].next)
if (e[i].v != u)
for (int k = 0; k <= s1; k++) solve(v, e[i].v, k, s1 + s2 - k);
int g[maxn][maxn];
memset(g, 0, sizeof(g));
g[1][0] = 0x3f3f3f3f;
bool t = 0;
for (int i = head[v]; i; i = e[i].next)
if (e[i].v != u) {
for (int j = 0; j <= s1; j++)
for (int k = 0; k <= s1 - j; k++)
g[t][k + j] = max(g[t][k + j],
min(g[t ^ 1][j], solve(v, e[i].v, k, s1 + s2 - k)));
t ^= 1;
}
ANS = g[t ^ 1][s1] + c[u][v];
return ANS;
}
int main() {
scanf("%d", &n);
memset(dp, 0x3f, sizeof(dp));
cnt = 0;
memset(head, 0, sizeof(head));
for (int i = 1; i <= n - 1; i++) {
int x, y, z;
scanf("%d %d %d", &x, &y, &z);
add(x, y, z);
add(y, x, z);
degree[x]++;
degree[y]++;
c[x][y] = c[y][x] = z;
}
scanf("%d", &s);
scanf("%d", &m);
memset(pos, 0, sizeof(pos));
for (int i = 1; i <= m; i++) {
int x;
scanf("%d", &x);
pos[x]++;
}
dfs(s, 0);
for (int i = head[s]; i; i = e[i].next)
ans = min(ans, solve(s, e[i].v, pos[e[i].v], m - pos[e[i].v]));
cout << ans;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 223;
const int mod = 1e9 + 7;
const long long inf = 1e18 + 9;
inline void boost() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
}
int n;
long long a[N], b[N];
vector<long long> ans;
int sz = 1;
struct trie {
int nxt[3], end;
trie() {
memset(nxt, 0, sizeof nxt);
end = 0;
}
} t[N * 30];
inline void add(int x) {
int v = 1;
for (int i = 29; i >= 0; i--) {
int to = ((x >> i) & 1);
if (!t[v].nxt[to]) t[v].nxt[to] = ++sz;
v = t[v].nxt[to];
t[v].end++;
}
}
inline long long get(int x) {
int v = 1;
long long val = 0;
for (int i = 29; i >= 0; i--) {
int to = ((x >> i) & 1);
if (!t[v].nxt[to]) {
if (to == 0) val += (1 << i);
v = t[v].nxt[to ^ 1];
} else {
if (t[t[v].nxt[to]].end > 0) {
if (to == 1) val += (1 << i);
v = t[v].nxt[to];
} else {
if (to == 0) val += (1 << i);
v = t[v].nxt[to ^ 1];
}
}
}
return val;
}
inline void del(int x) {
int v = 1;
for (int i = 29; i >= 0; i--) {
int to = ((x >> i) & 1);
if (!t[v].nxt[to]) t[v].nxt[to] = ++sz;
v = t[v].nxt[to];
t[v].end--;
}
}
int main() {
boost();
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) cin >> b[i];
for (int i = 1; i <= n; i++) add(b[i]);
for (int i = 1; i <= n; i++) {
long long val = get(a[i]);
del(val);
val ^= a[i];
ans.push_back(val);
}
for (int it : ans) cout << it << ' ';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int pos[26][26];
long long int ct[26];
int main() {
string a;
cin >> a;
for (int i = 0; i < a.length(); i++) {
int c = a[i] - 'a';
for (int j = 0; j < 26; j++) {
pos[j][c] += ct[j];
}
ct[c]++;
}
long long int ans = 0;
if (a.length() == 1) {
printf("1");
return 0;
} else {
for (int i = 0; i < 26; i++) ans = max(ans, ct[i]);
for (int i = 0; i < 26; i++)
for (int j = 0; j < 26; j++) ans = max(ans, pos[i][j]);
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long sgn(long long n) { return (n >= 0 ? 1 : -1); }
int32_t main() {
long long n, x, y;
cin >> n >> x >> y;
if (n > y) {
cout << -1;
return 0;
}
long long ans = n - 1 + (y - n + 1) * (y - n + 1);
if (ans < x) {
cout << -1;
return 0;
}
for (long long i = 0; i < n - 1; ++i) cout << "1 ";
cout << (y - n + 1);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
multiset<pair<int, int> > p, q, r;
multiset<pair<int, int> >::iterator it;
int b[2007], a[2007];
int main() {
int n, m, c = 0, f = 0, k = 0, o = 0, l = 0, e = 0, h, u;
cin >> n >> m;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
if (a[i] <= m) b[a[i]]++;
}
u = n / m;
for (int i = 1; i <= m; i++) {
for (int j = 0; j < n; j++) {
if (a[j] <= m) {
if (b[i] < u && (b[a[j]] > u)) {
b[i]++;
b[a[j]]--;
a[j] = i;
c++;
}
} else {
if (b[i] < u) {
a[j] = i;
b[i]++;
c++;
}
}
if (b[i] >= u) break;
}
}
cout << n / m << " " << c << "\n";
for (int i = 0; i < n; i++) printf("%d ", a[i]);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f, mod = 1000000007;
const long long INF = 0x3f3f3f3f3f3f3f3fLL;
const double pi = acosl(-1.), eps = 1e-9;
inline int power(int a, int b, int m = mod, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
const int NN = 202020;
long long a[NN], w[NN];
int aw[NN];
int sw[NN];
long long W[NN];
void upaw(int u, int d) {
if (d < 0) d += mod;
for (; u < NN; u += u & -u) {
aw[u] += d;
if (aw[u] >= mod) aw[u] -= mod;
}
}
void upsw(int u, int d) {
if (d < 0) d += mod;
for (; u < NN; u += u & -u) {
sw[u] += d;
if (sw[u] >= mod) sw[u] -= mod;
}
}
void upW(int u, long long d) {
for (; u < NN; u += u & -u) W[u] += d;
}
int caaw(int u, int ans = 0) {
for (; u; u -= u & -u) {
ans += aw[u];
if (ans >= mod) ans -= mod;
}
return ans;
}
int casw(int u, int ans = 0) {
for (; u; u -= u & -u) {
ans += sw[u];
if (ans >= mod) ans -= mod;
}
return ans;
}
long long caW(int u, long long ans = 0) {
for (; u; u -= u & -u) ans += W[u];
return ans;
}
int nam(int L, int R, int id) {
long long lft = caW(id - 1) - caW(L - 1);
long long rgt = caW(R) - caW(id);
if (lft == rgt) return 0;
if (lft < rgt) return -1;
if (lft > rgt) return 1;
}
inline void sum(int &a, int b) {
a += b;
if (a >= mod) a -= mod;
}
inline void sub(int &a, int b) {
a += b;
if (a < 0) a += mod;
}
int calc(int L, int R, int id) {
long long ans = 0;
ans += caaw(R) - caaw(id - 1);
ans += (id - a[id]) * ((caW(R) - caW(id - 1)) % mod) % mod;
ans -= casw(R) - casw(id - 1);
ans += (a[id] - id) * ((caW(id) - caW(L - 1)) % mod) % mod;
ans -= caaw(id) - caaw(L - 1);
ans += casw(id) - casw(L - 1);
ans %= mod;
if (ans < 0) ans += mod;
return ans;
}
int main() {
int n, T;
cin >> n >> T;
for (int i = 1; i <= n; i++) scanf("%d", a + i);
for (int i = 1; i <= n; i++) {
scanf("%d", w + i);
upaw(i, (int)((long long)a[i] * w[i] % mod));
upsw(i, (int)((long long)i * w[i] % mod));
upW(i, w[i]);
}
int L, R;
while (T--) {
scanf("%d%d", &L, &R);
if (L < 0) {
L = -L;
upaw(L, (int)(((long long)a[L] * R - (long long)a[L] * w[L]) % mod));
upsw(L, ((long long)L * R - (long long)L * w[L]) % mod);
upW(L, R - w[L]);
w[L] = R;
continue;
}
int st = L, ed = R + 1, md1, md2;
int d, d0;
while (st + 2 < ed) {
md1 = ((st << 1) + ed) / 3;
md2 = (st + (ed << 1)) / 3;
d = nam(L, R, md1);
if (d < 0) {
st = md1;
continue;
}
if (d > 0) {
ed = md2;
continue;
}
d = nam(L, R, md2);
if (d < 0) {
st = md1;
continue;
}
if (d > 0) {
ed = md2;
continue;
}
ed = md2;
}
long long lft = caW(st - 1) - caW(L - 1);
long long rgt = caW(R) - caW(st);
if (lft + w[st] - rgt < 0) st++;
printf("%d\n", calc(L, R, st));
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T& x) {
char c;
bool fu = 0;
for (c = getchar(); c <= 32; c = getchar())
;
if (c == '-') fu = 1, c = getchar();
for (x = 0; c > 32; c = getchar()) x = x * 10 + c - '0';
if (fu) x *= -1;
}
template <class T>
inline void read(T& x, T& y) {
read(x);
read(y);
}
template <class T>
inline void read(T& x, T& y, T& z) {
read(x, y);
read(z);
}
const int nmax = 3456789, mod = 1e9 + 7;
deque<pair<int, int> > Q;
int n, m, t, f[nmax], d[nmax], rem[nmax];
int main() {
cin >> n >> m >> t;
for (int i = 0; i < n; ++i) {
string s;
cin >> s;
f[i] = ((s[0] - '0') * 10 + (s[1] - '0')) * 3600 +
((s[3] - '0') * 10 + (s[4] - '0')) * 60 + (s[6] - '0') * 10 +
(s[7] - '0');
}
int cnt = 0, fla = 0;
for (int i = 0; i < n; ++i) {
if (i > 0)
while (!Q.empty() && Q.front().second <= f[i]) Q.pop_front();
if (Q.size() < m) {
Q.push_back(make_pair(i, f[i] + t));
rem[i] = ++cnt;
} else {
pair<int, int> bc = Q.back();
Q.pop_back();
rem[i] = rem[bc.first];
Q.push_back(make_pair(bc.first, f[i] + t));
}
if (Q.size() == m) fla = 1;
}
if (fla == 0) {
cout << "No solution";
return 0;
}
cout << cnt << "\n";
for (int i = 0; i < n; ++i) {
cout << rem[i] << "\n";
}
cin.get();
cin.get();
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:60777216")
using namespace std;
int a[22][22];
int n, m;
set<pair<int, int> > t;
bool good(int* a) {
vector<int> p;
for (int i = (0); i < (m); i++)
if (a[i] != i) p.push_back(i);
if (p.size() == 2) {
t.insert(pair<int, int>(p[0], p[1]));
t.insert(pair<int, int>(p[1], p[0]));
}
return p.size() <= 2;
}
int main() {
cin >> n >> m;
for (int i = (0); i < (n); i++)
for (int j = (0); j < (m); j++) cin >> a[i][j], a[i][j]--;
map<pair<int, int>, int> w;
for (int i = (0); i < (n); i++) {
t.clear();
if (good(a[i])) t.insert(pair<int, int>(-1, -1));
for (int k1 = (0); k1 < (m); k1++)
for (int k2 = (0); k2 < (m); k2++) {
swap(a[i][k1], a[i][k2]);
if (good(a[i])) t.insert(pair<int, int>(k1, k2));
swap(a[i][k1], a[i][k2]);
}
for (set<pair<int, int> >::iterator it = t.begin(); it != t.end(); it++)
w[*it]++;
}
for (map<pair<int, int>, int>::iterator it = w.begin(); it != w.end(); it++) {
if (it->second == n) {
puts("YES");
return 0;
}
}
puts("NO");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int cal(string s) {
int res = 0;
while (true) {
int cnt = 0;
for (int i = 1; i < s.length(); ++i)
cnt += (s[i - 1] == 'M' && s[i] == 'F');
if (cnt == 0) break;
for (int i = 1; i < s.length(); ++i)
if (s[i - 1] == 'M' && s[i] == 'F') {
swap(s[i - 1], s[i]);
++i;
}
res++;
}
return res;
}
int dp[1100000], st[1100000];
int main() {
string s;
cin >> s;
s = "F" + s;
for (int i = 1, cnt = 1, pre = 0; i < s.length(); ++i) {
if (s[i] == 'M')
dp[i] = dp[i - 1];
else {
cnt++;
if (cnt == i + 1)
dp[i] = 0, st[i] = 0;
else {
st[i] = max(0, st[pre] - (i - pre - 1) + 1);
dp[i] = st[i] + (i - cnt + 1);
}
pre = i;
}
}
cout << dp[s.length() - 1] << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, s;
cin >> n >> s;
vector<int> arr(n, 0);
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
if (n == 1) {
cout << abs(arr[0] - s);
return 0;
}
sort(arr.begin(), arr.begin() + n);
int med = n / 2;
long long minOp = abs(s - arr[med]);
for (int i = med - 1; i >= 0; i--) {
if (arr[i] > s) {
minOp += abs(s - arr[i]);
} else {
break;
}
}
for (int i = med + 1; i < n; i++) {
if (arr[i] < s) {
minOp += abs(s - arr[i]);
} else {
break;
}
}
cout << minOp << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000000 + 5;
const int inf = 0x3f3f3f3f;
int n, k, dfs_clock, A[MAXN], dfn[MAXN], sz[MAXN];
vector<int> G[MAXN];
stack<pair<int, int> > s;
inline void add(int u, int v) { G[u].push_back(v); }
void dfs(int u) {
sz[u] = 1, dfn[u] = ++dfs_clock;
for (int i = 0; i < (int)G[u].size(); ++i) dfs(G[u][i]), sz[u] += sz[G[u][i]];
}
int maxv[MAXN << 2], addv[MAXN << 2];
inline void up(int o) { maxv[o] = max(maxv[(o << 1)], maxv[((o << 1) | 1)]); }
inline void Add(int o, int k) { maxv[o] += k, addv[o] += k; }
inline void down(int o) {
if (addv[o]) {
Add((o << 1), addv[o]);
Add(((o << 1) | 1), addv[o]);
addv[o] = 0;
}
}
inline void modify(int o, int l, int r, int ql, int qr, int k) {
if (qr < l || ql > r) return;
if (ql <= l && r <= qr) return Add(o, k);
down(o);
modify((o << 1), l, ((l + r) >> 1), ql, qr, k);
modify(((o << 1) | 1), ((l + r) >> 1) + 1, r, ql, qr, k);
up(o);
}
int main() {
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; ++i) scanf("%d", A + i);
A[++n] = inf;
for (int i = 1; i <= n; ++i) {
while (!s.empty() && s.top().first < A[i]) add(i, s.top().second), s.pop();
s.push(make_pair(A[i], i));
}
dfs(n);
for (int i = 1; i <= k; ++i) modify(1, 1, n, dfn[i], dfn[i] + sz[i] - 1, 1);
printf("%d ", maxv[1]);
for (int i = k + 1; i < n; ++i) {
modify(1, 1, n, dfn[i], dfn[i] + sz[i] - 1, 1);
modify(1, 1, n, dfn[i - k], dfn[i - k] + sz[i - k] - 1, -1);
printf("%d ", maxv[1]);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, c;
cin >> n >> c;
vector<int> s(n - 1), e(n - 1);
for (int i = 0; i < n - 1; ++i) {
cin >> s[i];
}
for (int i = 0; i < n - 1; ++i) {
cin >> e[i];
}
int prevStairs = 0, prevElevator = c;
cout << 0 << " ";
for (int i = 1; i < n; ++i) {
int stairs = s[i - 1];
int elevator = e[i - 1];
int nxtStairs = min(prevStairs + stairs, prevElevator + stairs);
int nxtElevator = min(prevStairs + elevator + c, prevElevator + elevator);
cout << min(nxtStairs, nxtElevator) << " ";
prevStairs = nxtStairs;
prevElevator = nxtElevator;
}
cout << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, l, c, d, p, nl, np, x, y, z, t;
cin >> n >> k >> l >> c >> d >> p >> nl >> np;
x = (k * l) / nl;
y = c * d;
p = p / np;
if (x >= y && x >= p) t = min(y, p);
if (y >= x && y >= p) t = min(x, p);
if (p >= y && p >= x) t = min(y, x);
cout << t / n;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, val;
char str[3];
int main() {
int x = 1023, y = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%s%d", str, &val);
if (str[0] == '|') {
x |= val;
y |= val;
} else if (str[0] == '&') {
x &= val;
y &= val;
} else {
x ^= val;
y ^= val;
}
}
int do_or = 0, do_and = 0, do_xor = 0;
for (int i = 0; i < 10; i++) {
if ((x & (1 << i)) && (y & (1 << i)))
do_or |= (1 << i);
else if ((x & (1 << i)) && !(y & (1 << i)))
;
else if (!(x & (1 << i)) && (y & (1 << i)))
do_xor |= (1 << i);
else
do_and |= (1 << i);
}
do_and ^= 1023;
puts("3");
printf("| %d\n", do_or);
printf("& %d\n", do_and);
printf("^ %d\n", do_xor);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int a = 0, ab = 0, aba = 0;
int length = s.length();
for (int i = 0; i < length; i++) {
if (s[i] == 'a') {
a++;
aba++;
}
if (s[i] == 'b') ab++;
aba = max(aba, ab);
ab = max(ab, a);
}
cout << aba << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, p = 0;
cin >> n >> m;
if (n == 1 && m != 0) {
cout << m << " " << m << endl;
return 0;
} else if (m == 1 && n != 0) {
cout << n << " " << n << endl;
return 0;
} else if (n == 0 && m == 0) {
cout << p << " " << p << endl;
return 0;
} else if (n == 0) {
cout << "Impossible\n";
return 0;
} else if (m == 0) {
cout << n << " " << n << endl;
return 0;
} else if (n == m) {
cout << m << " " << n + m - 1 << endl;
return 0;
} else if (n > m) {
if (n % m == 0)
cout << m + (n / m) << " " << n + m - 1 << endl;
else
cout << m + (n - m) << " " << n + m - 1 << endl;
} else if (m > n) {
if (m % n == 0)
cout << n + (m / n) << " " << n + m - 1 << endl;
else
cout << n + (m - n) << " " << n + m - 1 << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n, k;
int a;
cin >> n >> k;
vector<long long> first(n + 1, k + 10);
vector<long long> last(n + 1, -1);
for (long long i = 1; i <= k; ++i) {
cin >> a;
first[a] = min(first[a], i);
last[a] = i;
}
long long ans = 2 * (n - 1) + n;
for (int i = 1; i <= n; ++i) {
if (first[i] != k + 10) ans--;
if (i > 1 && first[i - 1] < last[i]) ans--;
if (i > 1 && first[i] < last[i - 1]) ans--;
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10, M = 1e6;
struct T {
T() {}
T(long long typee, long long xx, long long LL, long long cc) {
type = typee, x = xx, l = LL, c = cc;
}
long long type, x, l, c;
} a[N];
long long n, m, cnt;
vector<long long> d(N), mem(M);
bool was[M];
long long solve(long long at) {
if (at < M && was[at]) return mem[at];
int l = 1, r = cnt, mid = (l + r) / 2;
while (r - l > 1) {
if (d[mid] < at)
l = mid;
else
r = mid;
mid = (l + r) / 2;
}
if (d[l] < at) mid = r;
if (at == d[mid]) {
if (a[mid].type == 1) {
if (at < M) was[at] = mem[at] = a[mid].x;
return a[mid].x;
}
long long ret = solve(a[mid].l);
if (at < M) was[at] = mem[at] = ret;
return ret;
}
at -= d[mid - 1];
at = at % a[mid].l;
if (at == 0) at = a[mid].l;
long long ret = solve(at);
if (at < M) was[at] = mem[at] = ret;
return ret;
}
int main() {
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
int type, x = 0, l = 0, c = 0;
scanf("%d", &type);
if (type == 1) {
scanf("%d", &x);
a[++cnt] = T(type, x, l, c);
d[cnt] = d[cnt - 1] + 1;
} else {
scanf("%d %d", &l, &c);
a[++cnt] = T(type, x, l, c);
d[cnt] = d[cnt - 1] + l * c;
}
}
scanf("%d", &n);
while (n--) {
long long at;
scanf("%I64d", &at);
printf("%I64d ", solve(at));
}
puts("");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string s[1013];
int raz(string s1, string s2) {
int ans = 0;
for (int i = 0; i < s1.size(); i++) {
if (s1[i] != s2[i]) {
ans++;
}
}
return ans;
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> s[i];
}
int mn = 100;
for (int i = 1; i < n; i++) {
for (int j = i + 1; j <= n; j++) {
int per = raz(s[i], s[j]);
if (per < mn) {
mn = per;
}
}
}
if (n == 1) {
cout << 6;
return 0;
}
cout << mn / 2 - (mn + 1) % 2;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> a(5005);
long long res;
long long help(long long l, long long r) {
if (r < l) return 0;
long long cur = INT_MAX;
for (long long i = l; i <= r; i++) cur = min(cur, a[i]);
for (long long i = l; i <= r; i++) a[i] -= cur;
long long i = l, second = l;
for (; i <= r; i++) {
if (!a[i]) {
cur += help(second, i - 1);
second = i + 1;
}
}
if (second != r + 1) cur += help(second, r);
return min(cur, r - l + 1);
}
void solve() {
long long n;
cin >> n;
for (long long i = 0; i < n; i++) cin >> a[i];
long long cur = 0, i = 0;
res = 0;
for (; i < n; i++) {
if (!a[i]) {
res += help(cur, i - 1);
cur = i + 1;
}
}
if (cur != n) res += help(cur, n);
cout << min(res, n);
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) {
solve();
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long arr[310][310];
int main() {
long long i, j, m, n, k, x = 1, y = 1, z = 1;
scanf("%lld", &n);
z = n;
for (i = 1; i <= n; i++) {
if (i % 2 == 1) {
for (j = i; j <= n; j++) arr[i][j] = x++;
for (j = 1; j < i; j++) arr[i][j] = x++;
} else {
for (j = i; j > 0; j--) arr[i][j] = x++;
for (j = n; j > i; j--) arr[i][j] = x++;
}
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) printf("%lld ", arr[j][i]);
printf("\n");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char s[10100];
string q1, q2, q3, my, ans;
int main() {
scanf("%s", s);
my = s;
printf("? ");
for (int i = 0; i < my.size(); i++) {
printf("%c", 'a' + (i % 26));
}
printf("\n");
fflush(stdout);
scanf("%s", s);
q1 = s;
printf("? ");
for (int i = 0; i < my.size(); i++) {
printf("%c", 'a' + (i / 26 % 26));
}
printf("\n");
fflush(stdout);
scanf("%s", s);
q2 = s;
printf("? ");
for (int i = 0; i < my.size(); i++) {
printf("%c", 'a' + (i / (26 * 26) % 26));
}
printf("\n");
fflush(stdout);
scanf("%s", s);
q3 = s;
ans = my;
for (int i = 0; i < my.size(); i++) {
int idx = (q3[i] - 'a') * (26 * 26);
idx += (q2[i] - 'a') * 26;
idx += (q1[i] - 'a');
ans[idx] = my[i];
}
printf("! %s\n", ans.c_str());
fflush(stdout);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T re() {
T N = 0;
char c = getchar();
for (; c < '0' || c > '9'; c = getchar())
;
for (; c >= '0' && c <= '9'; c = getchar()) N = (N << 3) + (N << 1) + c - '0';
return N;
}
const int mxsz = 1e5 + 3;
bool good[26];
char s[mxsz], buf[mxsz];
int n;
int haswc = -1;
void query() {
int m = strlen(buf);
bool can = 1;
if (haswc == -1) {
can &= (n == m);
for (int i = 0; can && i < n; i++) {
if (s[i] != '?')
can &= (s[i] == buf[i]);
else
can &= (good[buf[i] - 'a']);
}
} else {
if (m < n - 1)
can = 0;
else {
int l = 0, r = m - 1;
for (int i = 0; can && i < haswc; i++) {
if (s[i] != '?')
can &= s[i] == buf[l++];
else
can &= good[buf[l++] - 'a'];
}
for (int i = n - 1; can && i > haswc; --i) {
if (s[i] != '?')
can &= s[i] == buf[r--];
else
can &= good[buf[r--] - 'a'];
}
for (int i = l; can && i <= r; i++) can &= !good[buf[i] - 'a'];
}
}
puts(can ? "YES" : "NO");
}
int main() {
scanf("%s", buf);
for (int i = 0, t = strlen(buf); i < t; i++) good[buf[i] - 'a'] = 1;
scanf("%s", s);
n = strlen(s);
for (int i = 0; i < n; i++)
if (s[i] == '*') haswc = i;
for (int i = 0, q = re<int>(); i < q; i++) {
scanf("%s", buf);
query();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long SET(long long N, long long pos) {
return N = N | ((long long)1 << pos);
}
long long RESET(long long N, long long pos) {
return N = N & ~((long long)1 << pos);
}
bool CHECK(long long N, long long pos) {
return (bool)(N & ((long long)1 << pos));
}
template <typename T>
inline T __lcm(T a, T b) {
return (a * b) / __gcd(a, b);
}
struct node {
long long i, x, y;
};
long long dx[] = {0, 1, 0, -1, -1, 1, -1, 1};
long long dy[] = {1, 0, -1, 0, 1, 1, -1, -1};
void solve() {
long long n;
cin >> n;
long long ans = 1;
for (long long i = 1; i <= n; i++) {
ans *= i;
ans %= 1000000007;
}
long long ans2 = 1;
for (long long i = 0; i < n - 1; i++) {
ans2 *= 2;
ans2 %= 1000000007;
}
ans = ans - ans2;
ans += 1000000007;
ans %= 1000000007;
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 205;
const int INF = (int)1e9;
int main() {
int n, K;
int num[N];
cin >> n >> K;
for (int i = 0; i < n; i++) cin >> num[i];
int ans = -INF;
vector<int> in, out;
for (int i = 0; i < n; i++)
for (int j = i; j < n; j++) {
int sum = 0;
in.clear();
out.clear();
for (int k = 0; k < n; k++) {
if (k >= i && k <= j) {
in.push_back(num[k]);
sum += num[k];
} else
out.push_back(num[k]);
}
sort(in.begin(), in.end());
sort(out.begin(), out.end());
int in_sz = in.size();
int out_sz = out.size();
int x = min(in_sz, out_sz);
for (int k = 1; k <= min(x, K); k++)
if (in[k - 1] < out[out_sz - k]) sum += out[out_sz - k] - in[k - 1];
ans = max(ans, sum);
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
v[i]--;
}
multiset<int> leften;
int rlen = 0;
long long left_sum = 0;
long long right_sum = 0;
for (int i = 0; i < n; i++) {
if (i < v[i]) {
leften.insert(abs(v[i] - i));
left_sum += abs(v[i] - i);
} else {
rlen += 1;
right_sum += abs(v[i] - i);
}
}
int best = 0;
long long best_sum = left_sum + right_sum;
reverse(v.begin(), v.end());
for (int i = 0; i < n; i++) {
if (best_sum > left_sum + right_sum) {
best_sum = left_sum + right_sum;
best = i;
}
left_sum -= leften.size();
right_sum += rlen - 1;
int ones = 0;
while (!leften.empty() && (*leften.begin() - i) == 1) {
leften.erase(leften.begin());
rlen += 1;
ones++;
}
int last = v[i];
int last_prod = abs(last - (n - 1)) - i;
rlen -= 1;
if (last == 0) {
rlen += 1;
} else {
leften.insert(abs(v[i]) + i + 1);
}
right_sum -= abs(last - (n - 1));
left_sum += last;
}
cout << best_sum << " " << best;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 60;
int N;
struct node {
string name;
int ball, win, score;
} a[MAXN];
map<string, int> ball, win, score;
bool cmp(node a, node b) {
if (a.score != b.score) {
return a.score > b.score;
}
if (a.win != b.win) {
return a.win > b.win;
}
if (a.ball != b.ball) {
return a.ball > b.ball;
}
}
void solve() {
cin >> N;
for (int i = 0; i < N; i++) {
cin >> a[i].name;
win[a[i].name] = 0;
ball[a[i].name] = 0;
score[a[i].name] = 0;
}
for (int i = 0; i < N * (N - 1) / 2; i++) {
int x, y;
string s;
cin >> s;
int pos = s.find('-');
string t1 = s.substr(0, pos);
s.erase(0, pos + 1);
string t2 = s;
scanf("%d:%d", &x, &y);
ball[t1] += x;
ball[t2] += y;
win[t1] = win[t1] + x - y;
win[t2] = win[t2] + y - x;
if (x < y) {
score[t2] += 3;
} else if (x == y) {
score[t1]++;
score[t2]++;
} else {
score[t1] += 3;
}
}
for (int i = 0; i < N; i++) {
a[i].ball = ball[a[i].name];
a[i].win = win[a[i].name];
a[i].score = score[a[i].name];
}
sort(a, a + N, cmp);
vector<string> v;
for (int i = 0; i < N / 2; i++) {
v.push_back(a[i].name);
}
sort(v.begin(), v.end());
for (int i = 0; i < v.size(); i++) {
cout << v[i] << endl;
}
}
void Times(int T) {
while (T--) {
solve();
}
}
int main() {
int T;
T = 1;
Times(T);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
vector<pair<int, int> > res;
vector<int> x(3), y(3);
map<int, int> m;
for (int i = 0; i < 3; i++) {
cin >> x[i] >> y[i];
m[x[i]] = y[i];
}
sort(x.begin(), x.end());
sort(y.begin(), y.end());
for (int i = x[0]; i < x[1]; i++) res.push_back({i, m[x[0]]});
for (int i = x[2]; i > x[1]; i--) res.push_back({i, m[x[2]]});
for (int i = y[0]; i <= y[2]; i++) res.push_back({x[1], i});
cout << res.size() << "\n";
for (auto &i : res) cout << i.first << " " << i.second << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5, M = 1e6 + 6, OO = 0x3f3f3f3f;
int n, m, a[N], b[N];
int main() {
long long i, j, k;
long long n, x, m;
cin >> n >> k;
m = pow(2, n - 1);
while (m != k) {
if (k > m) {
j = k - m;
k = m - j;
}
n--;
m = pow(2, n - 1);
}
cout << n;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int N, a[5000], Q, dp[5001][5001];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> N;
for (int n = 0; n < N; n++) cin >> a[n];
for (int i = 0; i < N; i++) dp[i][i] = a[i];
for (int l = 2; l <= N; l++) {
for (int b = 0, e = l - 1; e < N; b++, e++) {
dp[b][e] = dp[b + 1][e] ^ dp[b][e - 1];
}
}
for (int l = 2; l <= N; l++) {
for (int b = 0, e = l - 1; e < N; b++, e++) {
dp[b][e] = max({dp[b][e], dp[b + 1][e], dp[b][e - 1]});
}
}
cin >> Q;
for (int q = 0; q < Q; q++) {
int l, r;
cin >> l >> r;
cout << dp[l - 1][r - 1] << '\n';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long dp[778][8];
long long C(int n, int m) {
if (m > n / 2) m = n - m;
if (m == 0)
return 1;
else if (m == 1)
return n;
if (dp[n - 1][m] == -1) dp[n - 1][m] = C(n - 1, m);
if (dp[n - 1][m - 1] == -1) dp[n - 1][m - 1] = C(n - 1, m - 1);
return dp[n - 1][m] + dp[n - 1][m - 1];
}
int main() {
for (int i = 0; i < 778; i++)
for (int j = 0; j < 8; j++) dp[i][j] = -1;
int N;
scanf("%d", &N);
printf("%I64d\n", C(N, 5) + C(N, 6) + C(N, 7));
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int CONST = 998244353;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, k;
cin >> n >> k;
vector<int> A(n);
for (int i = 0; i < n; i++) {
cin >> A[i];
}
int ans = 0;
sort(A.begin(), A.end());
vector<vector<int> > dpcnt(n, vector<int>(k + 1));
vector<vector<int> > prefcnt(n, vector<int>(k + 1));
for (int x = 1; x * (k - 1) <= A[n - 1]; x++) {
for (int i = 0; i < n; i++) {
for (int j = 0; j <= k; j++) {
prefcnt[i][j] = dpcnt[i][j] = 0;
}
}
for (int i = 0; i < n; i++) {
dpcnt[i][1] = 1;
if (i != 0) {
prefcnt[i][1] = prefcnt[i - 1][1];
}
prefcnt[i][1] += dpcnt[i][1];
}
int j = 0;
for (int i = 0; i < n; i++) {
while (j < i && A[i] - A[j] >= x) {
j++;
}
j--;
if (j != -1) {
for (int d = 1; d < k; d++) {
dpcnt[i][d + 1] += prefcnt[j][d];
prefcnt[i][d + 1] = prefcnt[i - 1][d + 1] + dpcnt[i][d + 1];
if (prefcnt[i][d + 1] >= CONST) {
prefcnt[i][d + 1] -= CONST;
}
if (dpcnt[i][d + 1] >= CONST) {
dpcnt[i][d + 1] -= CONST;
}
}
} else {
j++;
}
}
for (int i = 0; i < n; i++) {
ans += dpcnt[i][k];
if (ans >= CONST) {
ans -= CONST;
}
}
}
cout << ans;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, m;
cin >> n >> m;
vector<pair<long long, long long>> a;
for (int i = 1; i <= m; i++) {
long long x, y;
cin >> x >> y;
a.push_back({x, y});
}
vector<long long> pre(m);
sort(a.rbegin(), a.rend());
pre[0] = a[0].first;
for (int i = 1; i < m; i++) pre[i] = pre[i - 1] + a[i].first;
long long sol = 0;
if (n <= m) {
sol = max(sol, pre[n - 1]);
}
for (int i = 0; i < m; i += 1) {
long long l = 0, r = m - 1, ans = -1;
while (l <= r) {
long long mid = (l + r) / 2;
if (a[mid].first >= a[i].second) {
l = mid + 1;
ans = mid;
} else {
r = mid - 1;
}
}
if (ans + 1 >= n) {
ans = max(ans, pre[n - 1]);
} else {
if (ans == -1) {
sol = max(sol, a[i].first + (n - 1) * a[i].second);
} else {
if (ans >= i) {
sol = max(sol, pre[ans] + (n - (ans + 1)) * a[i].second);
} else {
sol = max(sol, pre[ans] + a[i].first + (n - (ans + 2)) * a[i].second);
}
}
}
}
cout << sol << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
template <typename T>
int size(T& a) {
return (int)a.size();
}
template <typename T>
T sqr(T a) {
return a * a;
}
const int MAXN = 501;
int s[MAXN][MAXN];
char str[MAXN];
int calc[MAXN][26][26];
int cntOdd[MAXN][26];
int cntEven[MAXN][26];
int dm[MAXN][26][26];
int pl[MAXN][26][26];
int pr[MAXN][26][26];
const int INF = (int)1e9;
int getMinimumChange(int firstColor, int secondColor, int row, int m) {
return m - cntEven[row][firstColor] - cntOdd[row][secondColor];
}
bool good(int a, int b, int z, int u) { return a != z && b != u; }
char path[MAXN][2];
void solve() {
int n, m;
scanf("%d%d\n", &n, &m);
for (int i = 0; i < n; ++i) {
gets(str);
for (int j = 0; j < m; ++j) {
s[i][j] = str[j] - 'a';
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; j += 2) cntEven[i][s[i][j]]++;
for (int j = 1; j < m; j += 2) cntOdd[i][s[i][j]]++;
}
for (int i = 0; i < n; ++i)
for (int a = 0; a < 26; ++a)
for (int b = 0; b < 26; ++b) calc[i][a][b] = getMinimumChange(a, b, i, m);
for (int i = 0; i < 26; ++i)
for (int j = 0; j < 26; ++j)
if (i != j) dm[0][i][j] = calc[0][i][j];
for (int i = 0; i < n - 1; ++i) {
for (int u = 0; u < 26; ++u)
for (int v = 0; v < 26; ++v) dm[i + 1][u][v] = INF;
for (int a = 0; a < 26; ++a)
for (int b = 0; b < 26; ++b) {
if (a == b) continue;
if (dm[i][a][b] == INF) continue;
for (int z = 0; z < 26; ++z)
for (int u = 0; u < 26; ++u) {
if (z != u && good(a, b, z, u)) {
int cur = dm[i][a][b] + calc[i + 1][z][u];
if (cur < dm[i + 1][z][u]) {
dm[i + 1][z][u] = cur;
pl[i + 1][z][u] = a;
pr[i + 1][z][u] = b;
}
}
}
}
}
int va = -1, vb = -1, res = INF;
for (int i = 0; i < 26; ++i)
for (int j = 0; j < 26; ++j) {
if (i == j) continue;
if (dm[n - 1][i][j] < res) {
res = dm[n - 1][i][j];
va = i;
vb = j;
}
}
printf("%d\n", res);
int cnt = n - 1;
while (cnt >= 0) {
path[cnt][0] = va + 'a';
path[cnt][1] = vb + 'a';
int ta = pl[cnt][va][vb];
int tb = pr[cnt][va][vb];
--cnt;
va = ta;
vb = tb;
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
printf("%c", path[i][j % 2]);
}
printf("\n");
}
}
int main() { solve(); }
| 6 |
#include <bits/stdc++.h>
using namespace std;
double a, b, c, d, p1, np1, p2, np2, ans;
double prob_n(int n) { return powl(np1, n - 1) * powl(np2, n - 1) * p1; }
int main() {
cin >> a >> b >> c >> d;
p1 = a / b;
p2 = c / d;
np1 = 1.0 - p1;
np2 = 1.0 - p2;
a = prob_n(1);
b = prob_n(2);
ans += a + b;
int j = 3;
while (abs(a - b) > 0.0000000000001) {
a = prob_n(j);
ans += a;
j++;
swap(a, b);
}
cout << fixed << setprecision(12) << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int i, j, k, n, m, an;
int f[100][100][2], g[100];
long long h[100];
inline void M(int j, int k, int A) {
f[i + 1][j][k] = (f[i + 1][j][k] + A) % 1000000007;
}
int main() {
scanf("%d", &n);
for (; n; n >>= 1) g[++m] = n & 1;
reverse(g + 1, g + m + 1);
h[0] = 1;
for (i = 1; i <= m; i++) h[i] = h[i - 1] * 2 % 1000000007;
f[0][0][1] = 1;
for (i = 0; i <= m - 1; i++)
for (j = 0; j <= i; j++) {
M(j, 0, h[j] * f[i][j][0] % 1000000007);
M(j + 1, 0, f[i][j][0] % 1000000007);
M(j, 1, (!j ? 0 : h[j - 1]) * f[i][j][1] % 1000000007);
if (g[i + 1]) {
M(j + 1, 1, f[i][j][1]);
M(j, 0, (!j ? 1 : h[j - 1]) * f[i][j][1] % 1000000007);
}
}
for (i = 0; i <= m; i++)
for (j = 0; j <= 1; j++) an = (an + f[m][i][j]) % 1000000007;
printf("%d\n", an);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, zero = 0, one = 0;
int arr[200000];
cin >> t;
for (int i = 0; i < t; i++) {
cin >> arr[i];
if (arr[i] == 0)
zero++;
else
one++;
}
int zcount = 0, onecount = 0;
for (int i = 0; i < t; i++) {
if (arr[i] == 0)
zcount++;
else
onecount++;
if (zcount == zero) {
cout << i + 1;
break;
} else if (onecount == one) {
cout << i + 1;
break;
}
}
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.