solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
const long long int inf = 1e18;
void solve() {
long long int n, m, k, s;
cin >> n >> m >> k >> s;
vector<long long int> a(n);
for (auto &x : a) cin >> x, x--;
vector<long long int> g[n];
for (long long int i = 0; i < m; i++) {
long long int u, v;
cin >> u >> v;
u--, v--;
g[u].push_back(v);
g[v].push_back(u);
}
vector<vector<long long int> > dist(k, vector<long long int>(n, -1));
for (long long int i = 0; i < k; i++) {
vector<long long int> q;
for (long long int j = 0; j < n; j++) {
if (a[j] == i) {
dist[i][j] = 0;
q.push_back(j);
}
}
for (long long int j = 0; j < q.size(); j++) {
long long int u = q[j];
for (auto v : g[u]) {
if (dist[i][v] == -1) {
dist[i][v] = dist[i][u] + 1;
q.push_back(v);
}
}
}
}
for (long long int i = 0; i < n; i++) {
vector<long long int> dd;
for (long long int j = 0; j < k; j++) dd.push_back(dist[j][i]);
sort(dd.begin(), dd.end());
long long int ans = 0;
for (long long int i = 0; i < s; i++) ans += dd[i];
cout << ans << " ";
}
}
void debug(long long int tt) {}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int t = 1;
while (t--) {
solve();
}
}
| 4 |
#include <bits/stdc++.h>
const int maxn = (1 << 22) + 1;
int n, m;
int points[maxn];
bool marked[maxn] = {false}, visited[maxn] = {false};
void dfs(int p) {
visited[p] = true;
if (marked[p]) {
int q = (1 << n) - 1 - p;
if (!visited[q]) dfs(q);
}
for (int i = 0; i < n; i++) {
int q = p & ~(1 << i);
if (!visited[q]) dfs(q);
}
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
int p;
scanf("%d", &p);
points[i] = p;
marked[p] = true;
}
int count = 0;
for (int i = 0; i < m; i++) {
int p = points[i];
if (!visited[p]) {
count++;
visited[p] = true;
int q = (1 << n) - 1 - p;
dfs(q);
}
}
printf("%d\n", count);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void print(vector<T> a) {
std::copy(a.begin(), a.end(), std::ostream_iterator<T>(std::cout, " "));
}
string a;
int mp[27];
vector<char> res;
void solve() {
res.clear();
for (int i = 0; i <= 26; ++i) mp[i] = 0;
cin >> a;
for (int i = a.size() - 1; i >= 0; --i) {
if (mp[a[i] - 'a'] == 0) {
res.push_back(a[i]);
}
mp[a[i] - 'a']++;
}
int len = 0;
reverse(res.begin(), res.end());
for (int i = 0; i < res.size(); ++i) {
if (mp[res[i] - 'a'] % (i + 1) != 0) {
cout << -1 << endl;
return;
}
len += mp[res[i] - 'a'] / (i + 1);
}
string source = a.substr(0, len);
string p = "";
map<char, int> mp;
for (int i = 0; i < res.size(); ++i) {
mp[res[i]] = i;
}
for (int i = 0; i < res.size(); ++i) {
for (int j = 0; j < len; ++j) {
if (mp[a[j]] >= i) {
p += a[j];
}
}
}
if (a != p) {
cout << -1 << endl;
return;
}
cout << source << " ";
for (int i = 0; i < res.size(); ++i) cout << res[i];
cout << endl;
}
signed main() {
std::ios::sync_with_stdio(false);
signed T = 1;
cin >> T;
for (int i = 1; i <= T; ++i) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
set<int> set;
int n;
cin >> n;
cout << n / 2 + 1;
}
| 0 |
#include <bits/stdc++.h>
int main() {
long long int n, i, k, p, q, mid, x, y;
scanf("%lld%lld", &n, &k);
p = 1;
q = n;
while (p <= q) {
mid = (p + q) / 2;
x = mid;
y = 0;
while (x > 0) {
y = y + (x % 10);
x = x / 10;
}
if ((mid - y) >= k) {
q = mid - 1;
} else {
p = mid + 1;
}
}
x = mid;
y = 0;
while (x > 0) {
y = y + (x % 10);
x = x / 10;
}
if ((mid - y) >= k) {
x = n - mid;
printf("%lld\n", x + 1);
} else {
x = n - mid - 1;
printf("%lld\n", x + 1);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long double pi = 3.14159265358979;
const int mod = 1e9 + 7;
const int N = 1e6 + 7;
void solve() {
int n;
cin >> n;
int a[n + 1];
int ok = 1;
map<int, int> mp;
for (int i = 1; i < n + 1; i++) {
cin >> a[i];
if (a[i] > i) ok = 0;
mp[a[i]] = 1;
}
if (!ok) {
cout << -1;
return;
}
int cur = 0;
int ans[n + 1];
for (int i = 1; i < n + 1; i++) {
while (mp[cur]) cur++;
if (i == 1) {
ans[i] = cur++;
} else {
if (a[i] == a[i - 1]) {
ans[i] = cur++;
} else {
ans[i] = a[i - 1];
}
}
cout << ans[i] << " ";
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int tc = 1;
while (tc--) {
solve();
cout << '\n';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long ar[200], arr[200];
int main() {
ios::sync_with_stdio(false);
long long i, j, x, a = 0, b = 0;
string s, t;
cin >> s >> t;
for (i = 0; i < s.size(); i++) ar[s[i]]++;
for (i = 0; i < t.size(); i++) arr[t[i]]++;
for (i = 0; i < 200; i++) {
x = min(ar[i], arr[i]);
a += x;
ar[i] -= x;
arr[i] -= x;
}
for (i = 0; i < 200; i++) {
if (i >= 'A' && i <= 'Z') {
b += min(ar[i], arr[i + 32]);
arr[i + 32] -= min(ar[i], arr[i + 32]);
}
if (i >= 'a' && i <= 'z') {
b += min(ar[i], arr[i - 32]);
arr[i - 32] -= min(ar[i], arr[i - 32]);
}
}
cout << a << " " << b << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long max(long long x, long long y) { return x > y ? x : y; }
long long min(long long x, long long y) { return x < y ? x : y; }
long long gcd(long long p, long long q) {
if (q == 0) return p;
return gcd(q, p % q);
}
bool check(long long b, long long p) {
long long m;
while (gcd(p, b) != 1) {
m = gcd(p, b);
while (p % m == 0) p = p / m;
b = m;
}
if (p == 1)
return true;
else
return false;
}
int main() {
long long p, q, b;
int n;
scanf("%d", &n);
while (n--) {
scanf("%I64d%I64d%I64d", &p, &q, &b);
if (p == 0) {
printf("Finite\n");
continue;
}
long long mmax = max(p, q);
long long mmin = min(p, q);
long long GCD = gcd(mmax, mmin);
p = q / GCD;
if (check(b, p))
printf("Finite\n");
else
printf("Infinite\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int m = 0;
int n = 0;
cin >> m;
cin >> n;
vector<vector<char> > vec(m, vector<char>(n, 0));
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
cin >> vec[i][j];
}
}
int count_s = 0;
for (int i = 0; i < m; i++) {
count_s = 0;
for (int j = 0; j < n; j++) {
if (vec[i][j] == 'S') {
count_s++;
}
}
for (int j = 0; j < n; j++) {
if (count_s == 0) {
vec[i][j] = 'e';
}
}
}
for (int i = 0; i < n; i++) {
count_s = 0;
for (int j = 0; j < m; j++) {
if (vec[j][i] == 'S') {
count_s++;
}
}
for (int j = 0; j < m; j++) {
if (count_s == 0) {
vec[j][i] = 'e';
}
}
}
int num_eaten = 0;
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (vec[i][j] == 'e') {
num_eaten++;
}
}
}
cout << num_eaten;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline int rd() {
int x = 0, ch = getchar(), f = 1;
while (!isdigit(ch) && (ch != '-') && (ch != EOF)) ch = getchar();
if (ch == '-') {
f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return x * f;
}
inline void rt(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10)
rt(x / 10), putchar(x % 10 + '0');
else
putchar(x + '0');
}
const int maxn = 1005;
int n, m, q;
pair<int, int> d[maxn][maxn], r[maxn][maxn];
int v[maxn][maxn];
pair<int, int> tmp, tmp1, tmp2, mat11, mat12, mat21, mat22;
inline pair<int, int> find(int nx, int ny, int x, int y) {
for (int i = 1; i <= int(x); i++)
tmp = d[nx][ny], nx = tmp.first, ny = tmp.second;
for (int i = 1; i <= int(y); i++)
tmp = r[nx][ny], nx = tmp.first, ny = tmp.second;
return make_pair(nx, ny);
}
int main() {
n = rd(), m = rd(), q = rd();
for (int i = 0; i <= int(n); i++)
for (int j = 0; j <= int(m); j++)
d[i][j] = make_pair(i + 1, j), r[i][j] = make_pair(i, j + 1);
for (int i = 1; i <= int(n); i++)
for (int j = 1; j <= int(m); j++) v[i][j] = rd();
for (; q--;) {
int x1 = rd(), orz_szj = rd(), x2 = rd(), orz_rxd = rd(), h = rd(),
w = rd();
mat11 = find(0, 0, x1 - 1, orz_szj - 1),
mat21 = find(0, 0, x2 - 1, orz_rxd - 1);
mat12 = r[mat11.first][mat11.second], mat22 = r[mat21.first][mat21.second];
mat11 = d[mat11.first][mat11.second], mat21 = d[mat21.first][mat21.second];
tmp1 = find(mat11.first, mat11.second, h - 1, 0),
tmp2 = find(mat21.first, mat21.second, h - 1, 0);
for (int i = 1; i <= int(w); i++) {
tmp1 = r[tmp1.first][tmp1.second], tmp2 = r[tmp2.first][tmp2.second];
swap(d[tmp1.first][tmp1.second], d[tmp2.first][tmp2.second]);
}
tmp1 = find(mat12.first, mat12.second, 0, w - 1),
tmp2 = find(mat22.first, mat22.second, 0, w - 1);
for (int i = 1; i <= int(h); i++) {
tmp1 = d[tmp1.first][tmp1.second], tmp2 = d[tmp2.first][tmp2.second];
swap(r[tmp1.first][tmp1.second], r[tmp2.first][tmp2.second]);
}
tmp1 = mat12, tmp2 = mat22;
for (int i = 1; i <= int(w); i++) {
swap(d[tmp1.first][tmp1.second], d[tmp2.first][tmp2.second]);
tmp1 = r[tmp1.first][tmp1.second], tmp2 = r[tmp2.first][tmp2.second];
}
tmp1 = mat11, tmp2 = mat21;
for (int i = 1; i <= int(h); i++) {
swap(r[tmp1.first][tmp1.second], r[tmp2.first][tmp2.second]);
tmp1 = d[tmp1.first][tmp1.second], tmp2 = d[tmp2.first][tmp2.second];
}
}
pair<int, int> hs = make_pair(0, 0);
for (int i = 1; i <= int(n); i++) {
hs = d[hs.first][hs.second];
tmp = hs;
for (int j = 1; j <= int(m); j++)
tmp = r[tmp.first][tmp.second], rt(v[tmp.first][tmp.second]),
putchar(' ');
putchar('\n');
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c* x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
template <class c>
debug& operator<<(const c&) {
return *this;
}
};
int main() {
vector<string> dic = {"C", "C#", "D", "D#", "E", "F",
"F#", "G", "G#", "A", "B", "H"};
vector<int> temp(3);
for (int i = 0; i < 3; i++) {
string s;
cin >> s;
for (auto it = 0; it < 12; it++) {
if (dic[it] == s) {
temp[i] = it + 1;
break;
}
}
}
sort(temp.begin(), temp.end());
do {
vector<int> ans;
for (int i = 1; i < 3; i++) {
if (temp[i] > temp[i - 1]) {
ans.push_back(temp[i] - temp[i - 1]);
} else {
int res = 0;
int from = temp[i - 1];
while (from != temp[i]) {
from++;
from %= 12;
res++;
}
ans.push_back(res);
}
}
if (ans[0] == 4 && ans[1] == 3) {
cout << "major\n";
return 0;
} else if (ans[0] == 3 && ans[1] == 4) {
cout << "minor\n";
return 0;
}
} while (next_permutation(temp.begin(), temp.end()));
cout << "strange\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300000;
int n, bit[N];
inline int lowbit(int i) { return i & (-i); }
int get(int idx) {
int ret = 0;
for (; idx >= 1; idx -= lowbit(idx)) ret += bit[idx];
return ret;
}
void update(int idx, int val) {
for (; idx <= n; idx += lowbit(idx)) bit[idx] += val;
}
vector<int> p, q;
vector<int> cp, cq, c;
int main(void) {
scanf("%d", &n);
p.assign(n, 0), q.assign(n, 0), cp.assign(n, 0), cq.assign(n, 0),
c.assign(n, 0);
for (int i = 0; i < n; i++) {
scanf("%d", &p[i]);
p[i]++;
}
for (int i = 0; i < n; i++) {
scanf("%d", &q[i]);
q[i]++;
}
for (int i = 1; i <= n; i++) bit[i] = 0;
for (int i = 1; i <= n; i++) update(i, 1);
for (int i = 0; i < n; i++) {
cp[i] = get(p[i] - 1);
update(p[i], -1);
}
for (int i = 1; i <= n; i++) bit[i] = 0;
for (int i = 1; i <= n; i++) update(i, 1);
for (int i = 0; i < n; i++) {
cq[i] = get(q[i] - 1);
update(q[i], -1);
}
int carry = 0;
for (int i = n - 1, f = 0; i >= 0; i--, f++) {
int new_carry = (cp[i] + cq[i] + carry) / (f + 1);
c[i] = (cp[i] + cq[i] + carry) % (f + 1);
carry = new_carry;
}
for (int i = 1; i <= n; i++) bit[i] = 0;
for (int i = 1; i <= n; i++) update(i, 1);
for (int i = 0; i < n; i++) {
int lo = 1, hi = n, mid = -1, ans = -1;
while (lo <= hi) {
mid = (lo + hi) / 2;
if (get(mid) >= c[i] + 1) {
ans = mid;
hi = mid - 1;
} else
lo = mid + 1;
}
printf("%d ", ans - 1);
update(ans, -1);
}
printf("\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
long long dp[100005];
long long say = pow(10, 9) + 7;
for (long long i = 0; i < k; i++) dp[i] = 1;
dp[k] = 2;
for (long long i = k + 1; i < 100005; i++) {
dp[i] = dp[i - 1] % say + dp[i - k] % say;
dp[i] = dp[i] % say;
}
long long sum[100005];
sum[0] = 0;
for (long long i = 0; i < 100005; i++) {
sum[i] = dp[i] + sum[i - 1];
}
while (n--) {
int a, b;
cin >> a >> b;
long long ans = sum[b] - sum[a - 1];
cout << ans % say << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long n) {
long long res = 1;
long long x = 2;
while (n > 0) {
if (n % 2) res *= x;
x *= x;
n >>= 1;
}
return res;
}
long long n, l, r, p[61];
int main() {
cin >> n;
for (long i = 0; i <= 60; i++) {
p[i] = power(i);
}
for (long i = 0; i <= n - 1; i++) {
cin >> l >> r;
if (l == r)
cout << l << endl;
else {
long long k = 0;
while (p[k + 1] - 1 <= r) k++;
long long res = p[k];
if (res - 1 >= l)
cout << res - 1 << endl;
else {
long long tmp;
while (true) {
k--;
if (res + p[k] - 1 <= r) res += p[k];
if (res - 1 >= l) {
cout << res - 1 << endl;
break;
}
}
}
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long i, j, x, y, z, count = 0, sum = 0, n, m;
cin >> n >> x >> y;
if (y % n == 0)
cout << -1 << endl;
else if (y < n) {
if (x == 0 && y == 0)
cout << -1 << endl;
else if (x == 0)
cout << 1 << endl;
else if (abs(x) < double(n * 1.0 / 2))
cout << 1 << endl;
else
cout << -1 << endl;
} else {
if (((y / n) - 1) & 1) {
z = (y / n) - 1;
if (x == 0)
cout << -1 << endl;
else if (abs(x) < n && x < 0) {
cout << (z / 2) + z + 2 << endl;
} else if (abs(x) < n && x > 0) {
cout << (z / 2) + z + 3 << endl;
} else
cout << -1 << endl;
} else {
z = (y / n) - 1;
if (abs(x) < double(n * 1.0 / 2)) {
cout << (z / 2) + ((z / 2) * 2) + 2 << endl;
} else
cout << -1 << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const auto start_time = std::chrono::high_resolution_clock::now();
void timecalculater() {}
void __print(int x) { cout << x; }
void __print(long x) { cout << x; }
void __print(long long x) { cout << x; }
void __print(unsigned x) { cout << x; }
void __print(unsigned long x) { cout << x; }
void __print(unsigned long long x) { cout << x; }
void __print(float x) { cout << x; }
void __print(double x) { cout << x; }
void __print(long double x) { cout << x; }
void __print(char x) { cout << '\'' << x << '\''; }
void __print(const char *x) { cout << '\"' << x << '\"'; }
void __print(const string &x) { cout << '\"' << x << '\"'; }
void __print(bool x) { cout << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cout << '{';
__print(x.first);
cout << ',';
__print(x.second);
cout << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cout << '{';
for (auto &i : x) cout << (f++ ? "," : ""), __print(i);
cout << "}";
}
void _print() { cout << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cout << ", ";
_print(v...);
}
long long p = 998244353;
const int N = 2e5 + 5;
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cin.exceptions(cin.failbit);
int T = 1;
cin >> T;
while (T--) {
int n;
cin >> n;
vector<int> v[n - 1];
int a[n - 1][n];
memset(a, 0, sizeof(a));
for (long long i = 0; i < (n - 1); ++i) {
int x;
cin >> x;
for (long long j = 0; j < (x); ++j) {
int y;
cin >> y;
v[i].push_back(y - 1);
y--;
a[i][y] = 1;
}
}
int ans[n];
for (int i = 0; i < n - 1; i++) {
if (v[i].size() == 2) {
int b[n - 1][n];
memset(b, 0, sizeof(b));
int temp[n];
int rem[n - 1];
for (long long j = 0; j < (n - 1); ++j) rem[j] = v[j].size();
int x = v[i][0], y = v[i][1];
temp[0] = x;
temp[1] = y;
for (int j = 0; j < n - 1; j++) {
if (a[j][x] == 1) {
b[j][x] = 1;
rem[j]--;
}
if (a[j][y] == 1) {
b[j][y] = 1;
rem[j]--;
}
}
int xx = 1;
for (int r = 2; r < n; r++) {
int cnt = 0;
int ind;
for (int j = 0; j < n - 1; j++) {
if ((int)(v[j]).size() <= (r + 1)) {
if (rem[j] == 1) {
cnt++;
ind = j;
}
}
}
if (cnt == 1) {
int u = (int)(v[ind]).size();
u--;
for (int j = r - 1; j >= 0 && u > 0; j--) {
if (a[ind][temp[j]] != 1) {
xx = 0;
break;
}
u--;
}
for (int j = 0; j < n; j++) {
if (b[ind][j] != a[ind][j]) {
temp[r] = j;
for (int k = 0; k < n - 1; k++) {
if (a[k][j] == 1 && b[k][j] == 0) {
b[k][j] = 1;
rem[k]--;
}
}
break;
}
}
for (long long j = 0; j < (n - 1); ++j) {
}
for (long long j = 0; j < (n); ++j) {
}
if (!xx) break;
} else {
xx = 0;
break;
}
}
if (xx) {
for (long long j = 0; j < (n); ++j) ans[j] = temp[j];
break;
}
}
if (v[i].size() == 2) {
int b[n - 1][n];
memset(b, 0, sizeof(b));
int temp[n];
int rem[n - 1];
for (long long j = 0; j < (n - 1); ++j) rem[j] = v[j].size();
int x = v[i][0], y = v[i][1];
temp[0] = y;
temp[1] = x;
for (int j = 0; j < n - 1; j++) {
if (a[j][x] == 1) {
b[j][x] = 1;
rem[j]--;
}
if (a[j][y] == 1) {
b[j][y] = 1;
rem[j]--;
}
}
int xx = 1;
for (int r = 2; r < n; r++) {
int cnt = 0;
int ind;
for (int j = 0; j < n - 1; j++) {
if ((int)(v[j]).size() <= (r + 1)) {
if (rem[j] == 1) {
cnt++;
ind = j;
}
}
}
if (cnt == 1) {
int u = (int)(v[ind]).size();
u--;
for (int j = r - 1; j >= 0 && u > 0; j--) {
if (a[ind][temp[j]] != 1) {
xx = 0;
break;
}
u--;
}
for (int j = 0; j < n; j++) {
if (b[ind][j] != a[ind][j]) {
temp[r] = j;
for (int k = 0; k < n - 1; k++) {
if (a[k][j] == 1 && b[k][j] == 0) {
b[k][j] = 1;
rem[k]--;
}
}
break;
}
}
for (long long j = 0; j < (n - 1); ++j) {
}
for (long long j = 0; j < (n); ++j) {
}
if (!xx) break;
} else {
xx = 0;
break;
}
}
if (xx) {
for (long long j = 0; j < (n); ++j) ans[j] = temp[j];
break;
}
}
}
for (long long i = 0; i < (n); ++i) cout << ans[i] + 1 << " ";
cout << '\n';
}
timecalculater();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 1000005;
const long long SQRTN = 1003;
const long long LOGN = 22;
const double PI = acos(-1);
const long long INF = 1e16;
const long long MOD = 1000000007;
const long long FMOD = 998244353;
const double eps = 1e-9;
bool primes[100001];
long long spf[100001];
void sieve() {
primes[0] = primes[1] = false;
for (long long i = 1; i <= 100000; i++) {
spf[i] = i;
primes[i] = true;
}
spf[2] = 2;
for (long long i = 4; i <= 100000; i += 2) {
spf[i] = 2;
primes[i] = false;
}
for (long long i = 3; i * i <= 100000; i += 2) {
if (spf[i] == i) {
for (long long j = i * i; j <= 100000; j += i) {
if (spf[j] == j) spf[j] = i;
primes[j] = false;
}
}
}
return;
}
long long power(long long n, long long m, long long p) {
long long res = 1;
n = n % MOD;
while (m > 0) {
if (m & 1) {
res = ((res) % p * (n) % p) % p;
m--;
}
n = ((n) % p * (n) % p) % p;
m >>= 1;
}
return res;
}
long long N = 10000;
long long factorialNumInverse[100001];
long long naturalNumInverse[100001];
long long fact[100001];
void InverseofNumber(long long p) {
naturalNumInverse[0] = naturalNumInverse[1] = 1;
for (long long i = 2; i <= N; i++)
naturalNumInverse[i] = naturalNumInverse[p % i] * (p - p / i) % p;
}
void InverseofFactorial(long long p) {
factorialNumInverse[0] = factorialNumInverse[1] = 1;
for (long long i = 2; i <= N; i++)
factorialNumInverse[i] =
(naturalNumInverse[i] * factorialNumInverse[i - 1]) % p;
}
void factorial(long long p) {
fact[0] = 1;
for (long long i = 1; i <= N; i++) {
fact[i] = (fact[i - 1] * i) % p;
}
}
long long Binomial(long long N, long long R, long long p) {
long long ans =
((fact[N] * factorialNumInverse[R]) % p * factorialNumInverse[N - R]) % p;
return ans;
}
long long modInverse(long long n, long long p) { return power(n, p - 2, p); }
long long nCrModPFermat(long long n, long long r, long long p) {
if (n < r) return 0;
if (r == 0) return 1;
long long fac[n + 1];
fac[0] = 1;
for (long long i = 1; i <= n; i++) fac[i] = (fac[i - 1] * i) % p;
return (fac[n] * modInverse(fac[r], p) % p * modInverse(fac[n - r], p) % p) %
p;
}
void solvethetestcase();
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t = 1;
for (long long testcase = 1; testcase < t + 1; testcase++) {
solvethetestcase();
}
}
long long n, m, a, b, c, d, e, f, g, h, i, j, k, l, o, r, s, u, v, w, x, y, one,
zero, p, t1, t2, t, q, cnt, val, res;
long long dp[10000001];
void solvethetestcase() {
cin >> n >> x >> y;
for (long long i = 1; i <= n; i++) {
if (i & 1)
dp[i] = min(x + dp[i - 1], y + x + dp[(i + 1) / 2]);
else
dp[i] = min(x + dp[i - 1], y + dp[i / 2]);
}
cout << dp[n];
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
map<pair<pair<long long int, long long int>,
pair<long long int, long long int> >,
long long int>
pqr;
map<pair<long long int, long long int>, long long int> xyz;
vector<pair<int, pair<int, int> > > a;
vector<pair<pair<int, int>, pair<int, int> > > b;
vector<pair<int, int> > c;
bool compare(string &x, string &y) { return x.size() < y.size(); }
int main() {
int n, i;
cin >> n;
vector<string> arr(n);
for (i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr.begin(), arr.end(), compare);
for (i = 0; i < n - 1; i++) {
if (arr[i + 1].find(arr[i]) == string::npos) {
cout << "NO";
return 0;
}
}
cout << "YES" << endl;
for (auto it : arr) {
cout << it << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n;
long double T;
struct Test {
long double p, t;
long double first, last;
long double value;
} a[150001];
inline bool cmp(Test a, Test b) { return a.value > b.value; }
inline bool cmp_(Test a, Test b) { return a.p > b.p; }
inline bool check(long double c) {
long double mins = 1e18;
long double mins_ = 1e18;
for (int i = 1; i <= n; i++) {
if (a[i].p * (1 - c * (a[i].first + a[i].t) / T) > mins) {
return 0;
}
mins_ = min(mins_, a[i].p * (1 - c * a[i].last / T));
if (a[i].p != a[i + 1].p) {
mins = mins_;
}
}
return 1;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i].p;
}
for (int i = 1; i <= n; i++) {
cin >> a[i].t;
T += a[i].t;
a[i].value = a[i].p / a[i].t;
}
sort(a + 1, a + n + 1, cmp);
long double now = 0;
long double sum1 = 0, sum2 = 0;
for (int i = 1; i <= n; i++) {
if (now != a[i].value) {
sum1 = sum2;
now = a[i].value;
int k = i - 1;
while (a[++k].value == now) {
sum2 += a[k].t;
}
}
a[i].first = sum1;
a[i].last = sum2;
}
sort(a + 1, a + n + 1, cmp_);
double l = 0, r = 1;
while (r - l >= 1e-12) {
long double mid = (l + r) / 2;
if (check(mid)) {
l = mid;
} else {
r = mid;
}
}
printf("%.11lf", (l + r) / 2);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
inline int nxt() {
int x;
scanf("%d", &x);
return x;
}
int main() {
long long n, m;
cin >> n >> m;
string s;
cin >> s;
if (n == m) {
cout << s;
} else {
set<long long> t;
long long pr = (n - m) / 2;
long long lef = (n - m) / 2;
long long pr1 = 0;
long long lef1 = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '(') {
if (pr != pr1) {
t.insert(i);
pr1++;
}
} else if (s[i] == ')') {
if (lef1 != lef) {
t.insert(i);
lef1++;
}
}
}
for (int i = 0; i < n; i++) {
if (t.find(i) == t.end()) {
cout << s[i];
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
const int MAXN = 1005;
int n;
int a[MAXN];
std::vector<std::pair<int, int> > ans;
void init() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
}
void move(int x, int y) {
a[y] -= a[x];
a[x] *= 2;
ans.push_back(std::make_pair(x, y));
}
void work(int &x, int &y, int &z) {
if (a[x] > a[y]) std::swap(x, y);
if (a[x] > a[z]) std::swap(x, z);
if (a[y] > a[z]) std::swap(y, z);
if (a[x] == 0) return;
int t = a[y] / a[x];
while (t) {
if (t & 1)
move(x, y);
else
move(x, z);
t >>= 1;
}
work(x, y, z);
}
void solve() {
int cnt = 0;
for (int i = 0; i < n; ++i)
if (a[i] > 0) ++cnt;
if (cnt <= 1) {
printf("-1\n");
return;
}
int x = -1, y = -1;
for (int i = 0; i < n; ++i)
if (a[i] > 0) {
if (x == -1)
x = i;
else if (y == -1) {
y = i;
break;
}
}
for (int i = y + 1; i < n; ++i)
if (a[i] > 0) {
int t = i;
work(t, x, y);
}
printf("%d\n", ans.size());
for (int i = 0; i < (int)ans.size(); ++i)
printf("%d %d\n", ans[i].first + 1, ans[i].second + 1);
}
int main() {
init();
solve();
return 0;
}
| 11 |
#include <bits/stdc++.h>
int n;
int ans[4000005] = {
0, 1, 9, 245, 126565, 54326037, 321837880,
323252721, 754868154, 328083248, 838314395, 220816781, 893672292, 166441208,
251255697, 114256285, 118775501, 482714697, 11784725, 460862131, 550384565,
106742050, 425241115, 626692854, 674266678, 320014275, 345949512, 527320049,
897822749, 137190263, 491039182, 810384961, 482023334, 658099864, 886790989,
845381174, 371433224, 278969124, 420088324, 696766322, 388302635, 141033366,
46387851, 932125021, 278342766, 371131134, 922501918, 110778457, 506223573,
806353719, 391845991, 923507761, 780307355, 109951115, 830090230, 605558495,
344686604, 988110893, 944684429, 715019947, 799898820, 384672708, 907325090,
758952329, 550672104, 368337206, 394915145, 401744167, 923781939, 831857516,
407845661, 329267374, 927004007, 891609656, 897919613, 481297880, 737337940,
651873737, 287246681, 973133651, 679864988, 784719328, 820504764, 875613823,
806512665, 164851642, 500228957, 951814419, 447763649, 273141670, 979349615,
964027956, 809510400, 276634497, 116631976, 426739449, 175282420, 885948162,
62270880, 974395255, 675165056, 759589968, 837957573, 931897605, 152352780,
585420109, 1772087, 333401718, 898833639, 745874265, 786209423, 691982338,
498790927, 473374639, 274302623, 971280670, 241671319, 13070005, 302088807,
550276351, 436592588, 631667314, 548656698, 730626984, 146295220, 674398632,
400383348, 454138904, 786220712, 118620797, 233440672, 217349271, 274853536,
310607544, 105221205, 769566615, 853585061, 800665807, 695377419, 924327065,
388199705, 551624811, 721435546, 501720515, 308465454, 825369234, 396065729,
451899519, 295058424, 142088952, 473485086, 378771634, 734511215, 462404399,
959198328, 337668263, 794122911, 38911400, 951992982, 472696081, 373904752,
105884826, 630251717, 28980684, 845136347, 353665773, 691661192, 19922354,
231463797, 757917231, 242739918, 979036950, 713722080, 234689388, 2243164,
209872853, 240808787, 539523346, 425797848, 913772061, 224613100, 421742777,
222232478, 92712941, 215137570, 949901408, 274827432, 15162482, 593145989,
274574232, 239282092, 762720192, 804146934, 500629424, 565985054, 81127381,
671811155, 655565571, 890331075, 237994348, 743647404, 667160634, 713914299,
668506729, 741341289, 277636808, 762781382, 14272789, 902864131, 567443405,
149113383, 648844381, 825489976, 933016723, 192288078, 734493315, 240985733,
861817693, 762711459, 525904609, 532463481, 377133989, 620711079, 772561562,
980733194, 227599811, 162774370, 209512798, 787116594, 3509258, 748795368,
378035466, 612938915, 802091952, 857679599, 481748937, 493370392, 358420805,
48301629, 412001241, 463126722, 509578422, 967799131, 994766554, 687287243,
863623583, 771554899, 690911527, 855314994, 923686429, 246862514, 192479791,
133487041, 703444043, 295281758, 801816257, 920762934, 749306433, 973004841,
848644684, 560026478, 952127278, 616654635, 839390326, 975154012, 409583672,
635350249, 343228425, 335331602, 223826406, 952341037, 589677800, 249747234,
555694261, 137143500, 628190328, 461598392, 431912756, 29349807, 759199489,
783281228, 781971312, 915823407, 388508707, 718062705, 27424111, 309999451,
963383322, 831185229, 132910888, 347028136, 850484840, 223055285, 142335980,
144754000, 772005560, 81796039, 167696020, 79454283, 172772542, 201056991,
484957644, 716630285, 763194701, 211505841, 903448791, 926964672, 257752668,
482951716, 411539070, 620249847, 592476107, 170473128, 814662613, 898000271,
57354872, 361106091, 488697643, 889007954, 138725767, 684860983, 36248116,
304610143, 137633385, 413715776, 99010024, 779653665, 100387568, 286328069,
564731826, 621740468, 943513219, 506666491, 249987886, 553719884, 769853086,
337485319, 702455584, 809637762, 755400257, 892290368, 502180086, 364275817,
118162370, 873374339, 261271695, 970132574, 744105500, 434447173, 117975095,
383088393, 625447969, 180281249, 545367713, 133236931, 360175662, 148087453,
806871297, 498529036, 886076476, 65645000, 465138299, 967109895, 331362616,
472283705, 796894900, 199697765, 503759892, 472807906, 187586706, 941198065,
782234442, 57693411, 18678611, 82626204, 395317191, 570588915, 152519440,
449852456, 63696518, 763741345, 878748386, 494317541, 444782633, 93316211,
929164666, 529288371, 165769871, 730546850, 955877127, 994202767, 492009567,
275683011, 415902127, 95725776, 718047399, 786963365, 73091278, 986172399,
174591541, 913259286};
signed main() {
scanf("%d", &n);
printf("%d", ans[n]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long mod = 1e9 + 7;
const long long inf = 2e9 + 10;
long long powmod(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return res;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
const int l = 1e5 + 5;
int le1, le2;
string in;
char ou[l];
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> le1 >> le2;
cin >> in;
int Set[28];
for (int(i) = 0; (i) < (int)(28); ++(i)) Set[i] = 0;
for (int(i) = 0; (i) < (int)(le1); ++(i)) Set[in[i] - 'a'] = 1;
bool fcuk = false;
int id;
char chotu;
for (int(i) = 0; (i) < (int)(26); ++(i))
if (Set[i]) {
chotu = i + 'a';
break;
}
if (le2 <= le1) {
for (int(i) = (int)(le2 - 1); (i) >= (int)(0); --(i)) {
for (int(j) = (int)(in[i] - 'a' + 1); (j) <= (int)(25); ++(j)) {
if (Set[j] == 1) {
ou[i] = j + 'a';
fcuk = true;
break;
}
}
if (fcuk) {
id = i;
break;
}
}
if (fcuk) {
for (int(i) = 0; (i) < (int)(id); ++(i)) ou[i] = in[i];
for (int(i) = (int)(id + 1); (i) <= (int)(le2 - 1); ++(i)) ou[i] = chotu;
} else {
for (int(i) = 0; (i) < (int)(le1); ++(i)) ou[i] = in[i];
for (int(i) = (int)(le1); (i) <= (int)(le2 - 1); ++(i)) ou[i] = chotu;
}
} else {
for (int(i) = 0; (i) < (int)(le1); ++(i)) ou[i] = in[i];
for (int(i) = (int)(le1); (i) <= (int)(le2 - 1); ++(i)) ou[i] = chotu;
}
for (int(i) = 0; (i) < (int)(le2); ++(i)) cout << ou[i];
cout << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
int g[n];
for (int i = 0; i < n; i++) {
cin >> g[i];
--g[i];
}
for (int i = 0; i < n; i++) {
int a = i;
int b = g[a];
int c = g[b];
if (g[c] == a) {
cout << "YES" << endl;
return 0;
}
}
cout << "NO" << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 403600;
int n, s, first, a[N];
int pt[N], q[N];
pair<int, int> ans[N];
int hd[N] = {0}, ne[N], v[N];
int main() {
scanf("%d%d", &n, &s);
for (int i = (0); i < (int)(n); i++) {
scanf("%d", &first);
v[i + 1] = i;
ne[i + 1] = hd[first];
hd[first] = i + 1;
}
memset(pt, -1, sizeof(pt));
int m = 0;
for (int i = N - 1; i >= 0; i--) {
for (int j = hd[i]; j; j = ne[j]) {
a[m] = i;
q[m++] = v[j];
}
pt[i] = m - 1;
}
int cur = N - 1, na = 0;
for (int i = (0); i < (int)(n); i++) {
cur = a[i];
int bdd = i, last = pt[cur];
while (a[i]--) {
bool up = 0;
if (pt[cur] <= bdd) bdd = last;
while (cur > 0 && pt[cur] <= bdd) --cur, up = 1;
if (up) {
bdd = last;
last = pt[cur];
}
if (cur == 0) {
break;
}
ans[na++] = pair<int, int>(q[i] + 1, q[pt[cur]] + 1);
a[pt[cur]]--;
pt[cur]--;
}
}
if (na * 2 == s) {
cout << "Yes" << endl;
printf("%d\n", na);
for (int i = (0); i < (int)(na); i++)
printf("%d %d\n", ans[i].first, ans[i].second);
} else {
cout << "No" << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, ans = 0;
cin >> n >> m;
while (n != m) {
if (n > m) {
m++, ans++;
} else {
if (m % 2 == 0) {
m /= 2, ++ans;
} else {
m++, ans++;
}
}
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200;
const int K = 1000;
const int md = 1000000007;
int a[N + 5];
int dp[2][N + 5][K + 5], ans;
void add(int &a, long long b) {
long long f = b;
f += a;
if (f >= md) f %= md;
a = f;
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
dp[0][0][0] = 1;
dp[0][1][0] = 1;
for (int i = 1; i < n; i++) {
for (int g = 0; g <= i + 1; g++) {
for (int p = 0; p <= k; p++) {
int newp = p + g * (a[i] - a[i - 1]);
if (newp > k) break;
add(dp[i % 2][g + 1][newp], dp[(i + 1) % 2][g][p]);
if (g) add(dp[i % 2][g - 1][newp], 1ll * g * dp[(i + 1) % 2][g][p]);
add(dp[i % 2][g][newp], 1ll * (g + 1) * dp[(i + 1) % 2][g][p]);
}
}
memset(dp[(i + 1) % 2], 0, sizeof(dp[(i + 1) % 2]));
}
for (int p = 0; p <= k; p++) {
add(ans, dp[(n - 1) % 2][0][p]);
}
cout << ans;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void file(string s) {
freopen((s + ".in").c_str(), "r", stdin);
freopen((s + ".out").c_str(), "w", stdout);
}
template <typename Tp>
void read(Tp &x) {
long long fh = 1;
char c = getchar();
x = 0;
while (c > '9' || c < '0') {
if (c == '-') {
fh = -1;
}
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 1) + (x << 3) + (c & 15);
c = getchar();
}
x *= fh;
}
struct Edge {
long long f, t, w, nxt;
} edge[2000005];
long long head[1000005], etot = 1;
void add_edge(long long f, long long t, long long w = 0) {
edge[++etot] = (Edge){f, t, w, head[f]};
head[f] = etot;
}
long long n, m;
long long a[1000005], ta[1000005], tat;
void lsh() {
for (long long i = 1; i <= n; i++) ta[++tat] = a[i];
sort(ta + 1, ta + tat + 1);
tat = unique(ta + 1, ta + tat + 1) - ta - 1;
for (long long i = 1; i <= n; i++)
a[i] = lower_bound(ta + 1, ta + tat + 1, a[i]) - ta - 1;
}
long long f[1 << 21];
long long LG[1 << 21];
long long cnt[21][21];
void preprocess() {
vector<long long> v1, v2;
for (long long i = 0; i < m; i++) {
for (long long j = 0; j < m; j++) {
if (i == j) continue;
v1.clear();
v2.clear();
for (long long t = 1; t <= n; t++) {
if (a[t] == i) v1.push_back(t);
if (a[t] == j) v2.push_back(t);
}
for (long long p = 0, q = 0; p < v1.size() && q < v2.size(); q++) {
while (p < v1.size() && v1[p] <= v2[q]) p++;
cnt[i][j] += v1.size() - p;
}
}
}
}
long long calc(long long S, long long cur) {
long long ret = 0;
for (long long u = S; u; u -= (u & (-u))) {
long long ut = LG[u & (-u)];
ret += cnt[ut][cur];
}
return ret;
}
signed main() {
read(n);
for (long long i = 1; i <= n; i++) read(a[i]);
lsh();
m = tat;
preprocess();
for (long long i = 0; i < m; i++) LG[1 << i] = i;
memset(f, 0x3f, sizeof(f));
f[0] = 0;
for (long long i = 1; i < (1 << m); i++) {
for (long long j = i, t; j; j -= (j & (-j))) {
t = LG[j & (-j)];
f[i] = min(f[i], f[i ^ (1 << t)] + calc((i ^ (1 << t)), t));
}
}
cout << f[(1 << m) - 1] << endl;
fclose(stdin);
fclose(stdout);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 200;
string arr[MAXN];
pair<long long, long long> dp[MAXN];
bool seen[MAXN];
vector<int> cur[20];
const int mod = 1000000007;
long long pot[MAXN];
int n;
pair<long long, long long> solve(int pos) {
if (seen[pos]) return dp[pos];
seen[pos] = true;
pair<long long, long long> ans = make_pair(0, 1);
for (int i = arr[pos].size() - 1; i >= 0; i--) {
int digito = arr[pos][i] - '0';
int p = upper_bound(cur[digito].begin(), cur[digito].end(), pos) -
cur[digito].begin();
if (p == cur[digito].size()) {
ans.first += (ans.second * digito) % mod;
ans.first %= mod;
ans.second *= 10;
ans.second %= mod;
continue;
}
pair<long long, long long> to = solve(cur[digito][p]);
ans.first += (ans.second * to.first) % mod;
ans.first %= mod;
ans.second = ans.second * to.second;
ans.second %= mod;
}
return dp[pos] = ans;
}
int main() {
string w;
cin >> w;
cin >> n;
pot[0] = 1;
for (int i = 1; i < MAXN; i++) pot[i] = (pot[i - 1] * 10) % mod;
int tot = 0;
for (int i = 0; i < n; i++) {
string a;
cin >> a;
int dig = a[0] - '0';
string b = "";
for (int j = 3; j < a.size(); j++) b.push_back(a[j]);
arr[i] = b;
cur[dig].push_back(i);
tot += b.size();
}
long long prev = 1;
long long ans = 0;
for (int i = w.size() - 1; i >= 0; i--) {
int dig = w[i] - '0';
if (cur[dig].empty()) {
ans += prev * dig;
ans %= mod;
prev *= 10;
prev %= mod;
} else {
int p = cur[dig][0];
pair<long long, long long> f = solve(p);
ans += (prev * f.first) % mod;
ans %= mod;
prev = prev * f.second;
prev %= mod;
}
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long getsum(long long nums) {
string str = to_string(nums);
long long res = 0;
for (int i = 0; i < str.size(); i++) {
res += str[i] - '0';
}
return res;
}
int main() {
long long n, s;
cin >> n >> s;
long long cur = s;
while (cur < n && cur - getsum(cur) < s) {
cur++;
}
cout << max((long long)0,
n - cur + (cur <= n && cur - getsum(cur) >= s ? 1 : 0));
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, id;
string person, phone;
int main() {
map<string, map<string, bool> > people;
map<string, map<string, bool> > output;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> person >> id;
for (int j = 1; j <= id; j++) {
cin >> phone;
output[person][phone] = true;
people[person][phone] = true;
}
}
map<string, bool>::iterator it;
for (auto& personIT : people) {
string person = personIT.first;
for (auto& phoneIT : personIT.second) {
string suf, phone = phoneIT.first;
for (int j = 1; j < phone.size(); j++) {
suf = phone.substr(j, phone.size());
if (output[person].count(suf) > 0) {
it = output[person].find(suf);
output[person].erase(it);
}
}
}
}
cout << output.size() << "\n";
for (auto& personIT : output) {
string person = personIT.first;
cout << person << " ";
cout << personIT.second.size() << " ";
for (auto& phoneIT : personIT.second) {
cout << phoneIT.first << " ";
}
cout << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
string str, ch;
int isPalindrome(int l, string c) {
int i;
for (i = 0; i < l / 2; i++)
if (c[i] != c[l - i - 1]) return 0;
return 1;
}
void String_Concatanate(char a, int pos, int l) {
int i;
for (i = 0; i < pos; i++) ch.push_back(str[i]);
ch.push_back(a);
for (i = pos; i < l; i++) ch.push_back(str[i]);
}
int main() {
cin >> str;
int i, j, l;
l = str.size();
if (isPalindrome(l, str)) {
for (i = 0; i < l / 2; i++) cout << str[i];
cout << str[i];
for (i = l / 2; i < l; i++) cout << str[i];
return 0;
} else {
for (i = 97; i <= 122; i++)
for (j = 0; j <= l; j += 1) {
String_Concatanate(i, j, l);
if (isPalindrome(l + 1, ch)) {
cout << ch << endl;
return 0;
}
ch.erase();
}
}
cout << "NA" << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int base, power;
cin >> base >> power;
int n = power;
int* arr = new int[power];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
if (power == 1) {
if (arr[0] % 2 == 0)
cout << "even" << endl;
else {
cout << "odd" << endl;
}
return 0;
}
if (base % 2 == 0) {
if (arr[n - 1] % 2 == 0)
cout << "even" << endl;
else
cout << "odd" << endl;
} else {
string prev;
if (arr[0] % 2 == 0) {
prev = "even";
} else {
prev = "odd";
}
for (int i = 1; i < n; i++) {
if (arr[i] % 2 == 0) {
if (prev == "even")
continue;
else
prev = "odd";
} else {
if (prev == "odd")
prev = "even";
else
prev = "odd";
}
}
cout << prev << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool comp(int a, int b) { return a > b; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
int a[t];
for (int i = 0; i < t; i++) {
cin >> a[i];
}
int diff = a[1] - a[0];
bool flag = 1;
for (int i = 1; i < t - 1; i++) {
if ((a[i + 1] - a[i]) != diff) {
cout << a[t - 1];
goto end;
flag = 0;
}
}
if (flag) {
cout << a[t - 1] + diff;
}
end:
cout << "";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int mx[8] = {-1, 1, -1, 1, -2, 2, -2, 2};
const int my[8] = {-2, -2, 2, 2, -1, -1, 1, 1};
const int MAXN = 1100;
const int MAXM = 1100;
int N, M;
const int MAXV = MAXN * MAXM;
int V;
int source[2];
int target[2];
int dist[2][MAXV];
int nxt[2][MAXV];
int st_dist[2][2];
bool parity(int v) { return ((v / M) + (v % M)) & 1; }
bool one_move(int a, int b) {
int dx = abs(a / M - b / M);
int dy = abs(a % M - b % M);
return (dx == 1 && dy == 2) || (dx == 2 && dy == 1);
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> N >> M;
V = N * M;
{
int X0, Y0, X1, Y1;
cin >> X0 >> Y0 >> X1 >> Y1;
X0--, Y0--, X1--, Y1--;
source[0] = X0 * M + Y0;
source[1] = X1 * M + Y1;
}
target[0] = (N / 2 - 1) * M + (M / 2 - 1);
target[1] = (N / 2 + 1 - 1) * M + (M / 2 - 1);
for (int z = 0; z < 2; z++) {
for (int i = 0; i < V; i++) dist[z][i] = -1;
queue<int> q;
dist[z][target[z]] = 0;
q.push(target[z]);
while (!q.empty()) {
int cur = q.front();
q.pop();
int x = cur / M, y = cur % M;
for (int d = 0; d < 8; d++) {
int nx = x + mx[d], ny = y + my[d];
if (0 <= nx && nx < N && 0 <= ny && ny < M) {
int n = nx * M + ny;
if (dist[z][n] == -1) {
dist[z][n] = dist[z][cur] + 1;
nxt[z][n] = cur;
q.push(n);
}
}
}
}
for (int x = 0; x < 2; x++) {
st_dist[x][z] = dist[z][source[x]];
}
}
int adv;
if (parity(source[0]) != parity(source[1])) {
adv = 0;
} else {
adv = 1;
}
int dis_dist = st_dist[!adv][!adv];
int adv_turns = (adv == 0) ? dis_dist : dis_dist - 1;
int me, goal;
if (st_dist[adv][adv] <= adv_turns) {
me = adv;
goal = adv;
} else if (st_dist[adv][!adv] - 1 <= adv_turns) {
me = adv;
goal = !adv;
} else {
me = !adv;
goal = !adv;
}
nxt[0][target[0]] = target[0] + 2 * M + 1;
nxt[1][target[1]] = target[1] - 2 * M + 1;
cout << (me == 0 ? "WHITE" : "BLACK") << '\n' << flush;
int cur[2] = {source[0], source[1]};
for (int t = 0; true; t++) {
if (t % 2 == me) {
auto print_pos = [&]() {
cout << (cur[me] / M + 1) << ' ' << (cur[me] % M + 1) << '\n' << flush;
};
if (one_move(cur[me], cur[!me])) {
cur[me] = cur[!me];
print_pos();
exit(0);
}
if (cur[me] == target[goal]) goal = me;
cur[me] = nxt[goal][cur[me]];
print_pos();
if (cur[me] == target[me]) {
exit(0);
}
} else {
int x, y;
cin >> x >> y;
if (x == -1 && y == -1) {
exit(0);
}
x--, y--;
cur[!me] = x * M + y;
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5;
struct ones {
int a, b;
} f[N];
int cmp(const ones &a, const ones &b) { return a.a < b.a; }
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) scanf("%d%d", &f[i].a, &f[i].b);
sort(f + 1, f + n + 1, cmp);
int zz = 1;
long long ans = 0, now = 0;
for (int i = 1; i <= n; i++) {
while (f[i].a - f[zz].a >= m) {
now = now - (long long)f[zz].b;
zz++;
}
now += (long long)f[i].b;
if (now > ans) ans = now;
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<pair<long long, long long> > city;
long long ans = 0;
for(int i = 0; i < n; i++) {
long long a, c;
cin >> a >> c;
city.push_back({a, c});
ans += c;
}
sort(city.begin(), city.end());
priority_queue<pair<long long, int>> Q;
vector<bool> vis(n, false);
Q.push({0, 0});
while(!Q.empty())
{
long long d; int i;
tie(d, i) = Q.top();//返回指向绑定的输出流的指针。
Q.pop();
if(vis[i]) continue;
vis[i] = true;
if(i == n - 1) {
ans -= d;
break;
}
if(i > 0) {
Q.push({d, i - 1});
}
int j = lower_bound(city.begin(), city.end(), make_pair(city[i].first + city[i].second, LLONG_MAX)) - city.begin() - 1;
//LLONG_MAX均存在与头文件limits.h,表示long long int
Q.push({d, j});
if(j + 1 < n) {
Q.push({d - city[j + 1].first + city[i].first + city[i].second, j + 1});
}
}
cout << ans << '\n';
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long int a[5001][5001];
int main() {
long long int n, m;
cin >> n >> m;
long long int i, j, k;
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
cin >> a[i][j];
}
}
long long int ans = 0;
for (i = n; i >= 1; i--) {
for (j = m; j >= 1; j--) {
if (a[i][j] == 0) {
a[i][j] = min(a[i + 1][j], a[i][j + 1]) - 1;
}
if (a[i][j] <= a[i - 1][j] || a[i][j] <= a[i][j - 1]) {
cout << -1 << endl;
return 0;
}
ans += a[i][j];
}
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int NC = (1 << 18) + 23;
const int N = 18 + 3;
int dsh[N];
int rls[N][N];
long long dp[NC][N];
int main() {
ios_base::sync_with_stdio(false);
int n, m, k;
cin >> n >> m >> k;
for (int i = 0; i < n; ++i) cin >> dsh[i];
for (int i = 0; i < k; ++i) {
int x, y, c;
cin >> x >> y >> c;
--x, --y;
rls[x][y] = c;
}
for (int i = 0; i < n; ++i) dp[(1 << i)][i] = dsh[i];
for (int i = 0; i < (1 << n); ++i) {
if (__builtin_popcount(i) >= m) continue;
for (int j = 0; j < n; ++j) {
if (((1 << j) & i) == 0) continue;
for (int p = 0; p < n; ++p) {
if (p == j) continue;
if (((1 << p) & i) != 0) continue;
auto st = (i | (1 << p));
dp[st][p] = max(dp[st][p], dp[i][j] + rls[j][p] + dsh[p]);
}
}
}
long long ans = 0;
for (int i = 0; i < (1 << n); ++i)
ans = max(ans, *max_element(dp[i], dp[i] + n));
cout << ans << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
int dp[2005][2005], dp2[2005][2005];
inline void add(int &x, int y) {
x += y;
if (x >= mod) x -= mod;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
string s;
cin >> s;
int n = s.length();
if (s[0] == '(' || s[0] == '?') dp[0][1] = 1;
if (s[0] == ')' || s[0] == '?') dp[0][0] = 1;
for (int i = 0; i + 1 < n; ++i)
for (int d = 0; d <= i + 1; ++d) {
if (s[i + 1] == '(' || s[i + 1] == '?') add(dp[i + 1][d + 1], dp[i][d]);
if (s[i + 1] == ')' || s[i + 1] == '?') add(dp[i + 1][d], dp[i][d]);
}
if (s.back() == '(' || s.back() == '?') dp2[n - 1][0] = 1;
if (s.back() == ')' || s.back() == '?') dp2[n - 1][1] = 1;
for (int i = n - 1; i - 1 >= 0; --i)
for (int d = 0; d <= n - i; ++d) {
if (s[i - 1] == '(' || s[i - 1] == '?') add(dp2[i - 1][d], dp2[i][d]);
if (s[i - 1] == ')' || s[i - 1] == '?') add(dp2[i - 1][d + 1], dp2[i][d]);
}
int ans = 0;
for (int i = 0; i + 1 < n; ++i)
for (int d = 1; d <= n; ++d)
add(ans, (long long)dp[i][d] * dp2[i + 1][d] % mod * d % mod);
cout << ans << "\n";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
set<pair<int, int> > s;
std::vector<int> vv;
std::vector<std::vector<int> > gr;
std::vector<int> vis;
int k;
pair<int, int> dfs(int u, int l) {
vis[u] = l;
vv.emplace_back(u);
for (int v : gr[u]) {
if ((vis[v]) && (vis[u] - vis[v]) >= k) {
return {vis[v], vis[u]};
} else if (!vis[v]) {
return dfs(v, l + 1);
}
}
return {-1, -1};
}
int32_t main() {
int n;
cin >> n;
int m;
cin >> m;
cin >> k;
gr.resize(n);
for (int i = 0; i < m; ++i) {
int u;
cin >> u;
u--;
int v;
cin >> v;
v--;
gr[u].emplace_back(v);
gr[v].emplace_back(u);
}
vis.resize(n, 0);
auto pp = dfs(0, 1);
cout << pp.second - pp.first + 1 << "\n";
for (int i = pp.first - 1; i < pp.second; ++i) {
cout << vv[i] + 1 << " ";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> arr;
long long n, k, a, b;
long long reccc(long long l, long long r) {
long long c = lower_bound(arr.begin(), arr.end(), r) -
lower_bound(arr.begin(), arr.end(), l);
if (c == 0) {
return a;
}
if (r == l + 1) {
return b * c;
}
long long mid = (l + r) / 2;
long long t1 = reccc(l, mid);
long long t2 = reccc(mid, r);
return min(b * (r - l) * c, t1 + t2);
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> k >> a >> b;
arr.resize(k);
for (long long i = 0; i < k; i++) {
cin >> arr[i];
arr[i]--;
}
sort(arr.begin(), arr.end());
cout << reccc(0, 1 << n) << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
int n, k, t;
int f[500005], mx[500005], sum[500005];
struct query {
int first, second, c;
} q[500001];
inline int add(int first, int second) {
first += second;
if (first >= mod) first -= mod;
if (first < 0) first += mod;
return first;
}
inline long long compute(int b) {
memset(f, 0, sizeof(f));
memset(mx, -1, sizeof(mx));
for (int i = 1; i <= t; ++i) {
int l = q[i].first, r = q[i].second;
if (q[i].c & (1 << b)) {
++f[l];
--f[r + 1];
} else
mx[r] = max(mx[r], l);
}
int j = -1;
for (int i = 1; i <= n; ++i) {
int aux = 0;
if (!f[i]) {
aux = sum[i];
if (j == -1)
aux = add(aux, 1);
else
aux = add(aux, -sum[j]);
}
sum[i + 1] = add(sum[i], aux);
f[i + 1] += f[i];
j = max(j, mx[i]);
}
return add(sum[n + 1], (j != -1 ? -sum[j] : 1));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cin >> n >> k >> t;
for (int first, j = 1; j <= t; ++j)
cin >> q[j].first >> q[j].second >> q[j].c;
long long rez = 1;
for (int i = 0; i < k; ++i) rez = (1LL * rez * compute(i)) % mod;
return cout << rez, 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &x) {
x = 0;
char c = getchar();
bool flag = false;
while (!isdigit(c)) {
if (c == '-') flag = true;
c = getchar();
}
while (isdigit(c)) {
x = (x << 1) + (x << 3) + (c ^ 48);
c = getchar();
}
if (flag) x = -x;
}
long long n, m, sum, k, now, len;
long long l[200010], p[200010], d[200010];
int main() {
read(n), read(m), now = sum = 0;
for (int i = 1; i <= m; ++i) read(l[i]), sum += l[i];
if (sum < n) {
puts("-1");
return 0;
}
k = sum - n, p[1] = 1;
for (int i = 2; i <= m; ++i) {
if (k) {
if (k >= l[i - 1] - 1)
k -= l[i - 1] - 1, p[i] = p[i - 1] + 1;
else
p[i] = p[i - 1] + l[i - 1] - k, k = 0;
} else
p[i] = p[i - 1] + l[i - 1];
}
if (k) {
puts("-1");
return 0;
}
for (int i = 1; i <= m; ++i) {
if (p[i] > n - l[i] + 1 || p[i] < 1) {
puts("-1");
return 0;
}
}
for (int i = 1; i <= m; ++i) printf("%lld ", p[i]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int func(long long int a, long long int b, long long int c,
long long int d) {
vector<long long int> v(4);
v[0] = a;
v[1] = b;
v[2] = c;
v[3] = d;
sort(v.begin(), v.end());
return ((v[1] + v[2]) / 2);
}
void solve() {
long long int n, m;
cin >> n >> m;
long long int grid[n + 1][m + 1];
for (long long int i(1); i <= n; ++i) {
for (long long int j(1); j <= m; ++j) {
cin >> grid[i][j];
}
}
long long int ans[n + 1][m + 1];
for (long long int i(1); i <= n; ++i) {
for (long long int j(1); j <= m; ++j) {
ans[i][j] = 0;
}
}
for (long long int i(1); i <= n; ++i) {
for (long long int j(1); j <= m; ++j) {
long long int u = func(grid[i][j], grid[n + 1 - i][j], grid[i][m + 1 - j],
grid[n + 1 - i][m + 1 - j]);
ans[i][j] = u;
}
}
long long int fin = 0;
for (long long int i(1); i <= n; ++i) {
for (long long int j(1); j <= m; ++j) {
fin += abs(grid[i][j] - ans[i][j]);
}
}
cout << fin << "\n";
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long int t;
cin >> t;
while (t--) {
solve();
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long dp[105][85];
int n, k;
vector<int> e[105];
long long mod = 1e9 + 7;
void dfs(int u, int fa) {
int len = e[u].size();
if (len == 1 && fa == e[u][0]) {
dp[u][k + 1] = 1;
dp[u][0] = 1;
} else {
for (int i = 0; i < len; i++) {
int v = e[u][i];
if (v != fa) {
dfs(v, u);
}
}
for (int i = 0; i <= k; i++) {
if (i == 0) {
dp[u][0] = 1;
for (int j = 0; j < len; j++) {
int v = e[u][j];
if (v == fa) continue;
long long sum = 0;
for (int l = 0; l <= 2 * k; l++) {
sum = (sum + dp[v][l]) % mod;
}
dp[u][0] = (dp[u][0] * sum) % mod;
}
} else {
long long m1 = 1, m2 = 1;
for (int j = 0; j < len; j++) {
int v = e[u][j];
if (v == fa) continue;
long long sum = 0;
for (int l = i - 1; l <= (2 * k - 1 - (i - 1)); l++) {
sum = (sum + dp[v][l]) % mod;
}
m1 = m1 * sum % mod;
m2 = m2 * (sum - dp[v][i - 1]) % mod;
}
dp[u][i] = (m1 - m2) % mod;
}
}
for (int i = k + 1; i <= (2 * k); i++) {
long long m1 = 1, m2 = 1;
for (int j = 0; j < len; j++) {
int v = e[u][j];
if (v == fa) continue;
long long sum = 0;
for (int l = (2 * k - (i - 1)); l <= i - 1; l++) {
sum = (sum + dp[v][l]) % mod;
}
m1 = m1 * sum % mod;
m2 = m2 * (sum - dp[v][i - 1]) % mod;
}
dp[u][i] = (m1 - m2) % mod;
}
}
}
int main() {
while (~scanf("%d%d", &n, &k)) {
for (int i = 0; i < n - 1; i++) {
int u, v;
scanf("%d%d", &u, &v);
e[u].push_back(v);
e[v].push_back(u);
}
dfs(1, -1);
long long ans = 0;
for (int i = 0; i <= k; i++) {
ans = (ans + dp[1][i]) % mod;
}
ans = (ans + mod) % mod;
printf("%lld\n", ans);
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int a[100010];
bool check(int lim, int n, int s1, int s2) {
set<int> s;
s.insert(s1);
s.insert(s2);
for (int i = 1; i <= n; i++) {
while (!s.empty()) {
int t = *s.begin();
if (abs(t - a[i]) > lim)
s.erase(s.begin());
else
break;
}
while (!s.empty()) {
int t = *(--s.end());
if (abs(t - a[i]) > lim)
s.erase(s.find(t));
else
break;
}
if (s.empty()) return 0;
s.insert(a[i]);
}
return 1;
}
int main() {
int n, s1, s2;
cin >> n >> s1 >> s2;
for (int i = 1; i <= n; i++) cin >> a[i];
int cur = 1000000007;
for (int i = 30; i >= 0; i--) {
int tmp = cur - (1 << i);
if (tmp < abs(s1 - s2)) continue;
if (check(tmp, n, s1, s2)) cur = tmp;
}
cout << cur << endl;
}
| 9 |
#include <bits/stdc++.h>
int main() {
int n, a[1000], b[1000], i, j, s = 0;
scanf("%d", &n);
for (j = 0; j < n; j++) {
scanf("%d%d", &a[j], &b[j]);
}
for (j = 0; j < n; j++) {
for (i = 0; i < n; i++) {
if (i == j) continue;
if (b[j] == a[i]) {
s = s + 1;
a[i] = 0;
}
}
}
printf("%d", n - s);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n][3];
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
cin >> arr[i][j];
}
}
int x = 0, y = 0, z = 0;
for (int i = 0; i < n; i++) {
x += arr[i][0];
y += arr[i][1];
z += arr[i][2];
}
if ((x == 0) && (y == 0) && (z == 0))
cout << "YES";
else
cout << "NO";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5;
int a[N], n, block_size, cnt[N], ans[N];
bool d[N];
struct Query {
int l, r, id;
Query() {}
Query(int _l, int _r, int _id) : l(_l), r(_r), id(_id) {}
bool operator<(const Query other) const {
if (l / block_size != other.l / block_size) {
return l < other.l;
} else {
int a = l / block_size;
if (a % 2 == 0) {
return r > other.r;
} else
return r < other.r;
}
}
} Q[N];
int main(int argc, char const *argv[]) {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i];
block_size = 800;
int q;
cin >> q;
for (int i = 1; i <= q; ++i) {
int l, r;
cin >> l >> r;
Q[i] = Query(l, r, i);
}
sort(Q + 1, Q + 1 + q);
int L = 0, R = 0;
stack<int> candidate;
while (!candidate.empty()) candidate.pop();
for (int i = 1; i <= q; ++i) {
int l = Q[i].l, r = Q[i].r;
while (L < l) {
cnt[a[L]]--;
if (cnt[a[L]] == 1 && !d[a[L]]) {
d[a[L]] = 1;
candidate.push(L);
}
L++;
}
while (L > l) {
L--;
cnt[a[L]]++;
if (cnt[a[L]] == 1 && !d[a[L]]) {
d[a[L]] = 1;
candidate.push(L);
}
}
while (R < r) {
R++;
cnt[a[R]]++;
if (cnt[a[R]] == 1 && !d[a[R]]) {
d[a[R]] = 1;
candidate.push(R);
}
}
while (R > r) {
cnt[a[R]]--;
if (cnt[a[R]] == 1 && !d[a[R]]) {
d[a[R]] = 1;
candidate.push(R);
}
R--;
}
while (!candidate.empty() && cnt[a[candidate.top()]] != 1) {
d[a[candidate.top()]] = 0;
candidate.pop();
}
if (!candidate.empty()) ans[Q[i].id] = a[candidate.top()];
}
for (int i = 1; i <= q; ++i) cout << ans[i] << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long double eps = 0.000001;
int main() {
long double x, y, r;
cin >> x >> y >> r;
long double X, Y, R;
cin >> X >> Y >> R;
long double V = sqrt((X - x) * (X - x) + (Y - y) * (Y - y));
cout << setprecision(20) << fixed;
if (V - R - r > eps)
cout << (V - R - r) / 2 << endl;
else if (abs(R - r) - V > eps)
cout << (abs(R - r) - V) / 2 << endl;
else
cout << 0 << endl;
fclose(stdin);
fclose(stdout);
return 0;
}
| 5 |
#include <bits/stdc++.h>
long long l, r, a[111], cnt[111], f[111];
bool chk[111];
long long bin(int l, int r) {
long long rtn = 0;
for (int i = l; i > r; i--) rtn = rtn * 2 + a[i];
return rtn;
}
long long gets(long long n) {
if (n == 0) return 0;
long long x = n, ans = 0, l = 0;
while (x) {
a[++l] = x & 1;
x /= 2;
}
for (int i = l; i >= 1; i--)
if (l % i == 0) {
chk[i] = true;
for (int j = l - i; j > 0; j -= i) {
if (bin(j, j - i) < bin(l, l - i)) {
chk[i] = false;
break;
} else if (bin(j, j - i) > bin(l, l - i)) {
chk[i] = true;
break;
}
}
}
for (int i = 1; i <= 60; i++) {
for (int j = 2; j * i < l; j++) {
ans += f[i];
}
if (l % i != 0 or l == i) continue;
long long ans1 = (bin(l, l - i) - ((1ll << (i - 1)) - 1));
if (chk[i] == false) ans1--;
for (int k = i - 1; k >= 1; k--) {
cnt[k] = 0;
}
for (int k = i - 1; k >= 1; k--)
if (i % k == 0) {
ans1 = ans1 + (-1 - cnt[k]) * (bin(l, l - k) - ((1ll << (k - 1)) - 1));
if (chk[k] == false) ans1 -= -1 - cnt[k];
for (int l = k - 1; l >= 1; l--)
if (k % l == 0) cnt[l] += -1 - cnt[k];
}
ans += ans1;
}
return ans;
}
int main() {
for (int i = 1; i <= 60; i++) {
f[i] = 1;
for (int j = 1; j < i; j++) f[i] *= 2;
for (int j = 1; j < i; j++)
if (i % j == 0) f[i] -= f[j];
}
scanf("%I64d%I64d", &l, &r);
printf("%I64d\n", gets(r) - gets(l - 1));
fclose(stdin);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool isMult = false;
void solve() {
string s, t, a, b;
cin >> s;
s += ',';
bool isNum = true;
for (char i : s) {
if (i == ',' || i == ';') {
if (isNum && t.size() && (t.size() == 1 || t[0] != '0')) {
a += t + ",";
} else {
b += t + ",";
}
isNum = true;
t.clear();
} else {
if (i < '0' || i > '9') {
isNum = false;
}
t += i;
}
}
if (a.size()) {
cout << "\"" << a.substr(0, a.size() - 1) << "\"" << '\n';
} else {
cout << '-' << '\n';
}
if (b.size()) {
cout << "\"" << b.substr(0, b.size() - 1) << "\"" << '\n';
} else {
cout << '-' << '\n';
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int tt = 1;
if (isMult) {
cin >> tt;
}
while (tt--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int i, j, k, m, n, l;
char s[100 + 10], t[100 + 10];
int x, y;
int main() {
while (cin >> n >> m) {
scanf("%s", t);
while (m--) {
strcpy(s, t);
scanf("%d%d", &x, &y);
x--, y--;
vector<int> ans(10, 0);
int cp = x, dp = 1;
while (cp >= x && cp <= y) {
if (isdigit(s[cp])) {
ans[s[cp] - '0']++;
s[cp]--;
cp += dp;
} else if (s[cp] == '<' || s[cp] == '>') {
if (s[cp] == '<')
dp = -1;
else
dp = 1;
k = cp, cp += dp;
while (s[cp] == '0' - 1) cp += dp;
if (cp < x || cp > y) break;
if (!isdigit(s[cp])) s[k] = '0' - 1;
} else
cp += dp;
}
for (int i = 0; i < (((int)(ans).size())); ++i) {
if (i) putchar(' ');
printf("%d", ans[i]);
}
putchar('\n');
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
int main() {
int kids = 0, i = 0, j = 0, result = 2;
scanf("%d", &kids);
int spot[kids];
for (i = 0; i < kids; i++) {
spot[i] = i + 1;
}
printf("%d ", result);
for (j = 2; j < kids; j++) {
result += j;
if (result % kids == 0)
printf("%d ", (result % kids) + kids);
else
printf("%d ", result % kids);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
a /= 2;
if (b == a) {
if (c == a || c == a + 1) {
printf("NO\n");
return 0;
}
} else if (b == a + 1) {
if (c == a || c == a + 1) {
printf("NO\n");
return 0;
}
}
printf("YES\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[110];
void solve() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + n + 1);
int cnt = 0, sum = 0;
for (int i = n; i >= 1; i--) {
cnt++;
sum += a[i];
if (sum >= m) {
printf("%d", cnt);
break;
}
}
}
int main() {
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 7e1 + 5;
const long long INF = 1e18;
const long long MOD = 1e9 + 7;
int S[3], A[maxN][maxN];
int dis[maxN][maxN][maxN];
pair<int, int> eren[maxN][maxN][maxN];
queue<pair<int, pair<int, int> > > Q;
int main() {
time_t START = clock();
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
memset(dis, 63, sizeof dis);
int n;
scanf("%d", &n);
for (int i = 0; i < 3; i++) scanf("%d", S + i);
sort(S, S + 3);
getchar();
for (int i = 1; i <= n; i++, getchar())
for (int j = 1; j <= n; j++) {
char ch = getchar();
A[i][j] = (ch == '*' ? -1 : ch - 'a') + 1;
}
dis[1][2][3] = 0;
Q.push({1, {2, 3}});
while (!Q.empty()) {
auto ppp = Q.front();
Q.pop();
int a, b, c;
pair<int, int> pp;
tie(a, pp) = ppp;
tie(b, c) = pp;
int v[3] = {a, b, c};
sort(v, v + 3);
for (int x = 0; x < 3; x++) {
for (int i = 1; i <= n; i++) {
if (i == a || i == b || i == c || A[i][a] != A[b][c]) continue;
int u[3] = {i, b, c};
sort(u, u + 3);
if (dis[u[0]][u[1]][u[2]] > dis[v[0]][v[1]][v[2]] + 1) {
dis[u[0]][u[1]][u[2]] = dis[v[0]][v[1]][v[2]] + 1;
eren[u[0]][u[1]][u[2]] = {a, i};
Q.push({u[0], {u[1], u[2]}});
}
}
swap(a, b);
swap(b, c);
}
}
int d = dis[S[0]][S[1]][S[2]];
if (d > MOD) d = -1;
printf("%d\n", d);
if (d > -1) {
while (d--) {
int x = eren[S[0]][S[1]][S[2]].first;
int y = eren[S[0]][S[1]][S[2]].second;
printf("%d %d\n", y, x);
for (int i = 0; i < 3; i++)
if (y == S[i]) S[i] = x;
sort(S, S + 3);
}
}
time_t FINISH = clock();
cerr << "Execution time: "
<< (long double)(FINISH - START) / CLOCKS_PER_SEC * 1000.0
<< " milliseconds.\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int r[1002], s[1002], m[1002][1002], n, rj[10000][4], k = 0;
void zamjenis(int a, int b) {
swap(s[a], s[b]);
for (int i = 0; i < n; i++) swap(m[i][a], m[i][b]);
rj[k][0] = 2;
rj[k][1] = a + 1;
rj[k][2] = b + 1;
k++;
}
void zamjenir(int a, int b) {
swap(r[a], r[b]);
for (int i = 0; i < n; i++) swap(m[a][i], m[b][i]);
for (int i = 0; i < n; i++)
if (m[b][i] == 1) s[i]--;
rj[k][0] = 1;
rj[k][1] = a + 1;
rj[k][2] = b + 1;
k++;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n - 1; i++) {
int x, y;
scanf("%d %d", &x, &y);
m[x - 1][y - 1] = 1;
r[x - 1]++;
s[y - 1]++;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n - i - 1; j++)
if (s[j] == 0) {
zamjenis(j, n - i - 1);
break;
}
for (int j = 0; j < n - 1 - i; j++)
if (r[j] > 0) {
zamjenir(j, n - i - 1);
break;
}
}
printf("%d\n", k);
for (int i = 0; i < k; i++)
printf("%d %d %d\n", rj[i][0], rj[i][1], rj[i][2]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, flag, x, one, two, three, four, six, i;
while (cin >> n) {
flag = 0;
one = two = three = four = six = 0;
for (i = 0; i < n; i++) {
cin >> x;
if (x == 5 || x == 7)
flag = 1;
else if (x == 1)
one++;
else if (x == 2)
two++;
else if (x == 3)
three++;
else if (x == 4)
four++;
else if (x == 6)
six++;
}
if (flag == 1) {
cout << "-1" << endl;
flag = 0;
} else {
if (four + six != one)
flag = 1;
else if (two < four)
flag = 1;
else if ((two - four) + three < six)
flag = 1;
else {
x = four;
while (x--) {
printf("1 2 4\n");
}
x = two - four;
while (x--) {
printf("1 2 6\n");
}
x = three;
while (x--) {
printf("1 3 6\n");
}
}
}
if (flag == 1) cout << "-1" << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
vector<long long> av, bv;
for (long long i = 0; i < n; i++) {
long long a, b;
cin >> a >> b;
av.push_back(a);
bv.push_back(b);
}
long long ans = 0, mn = 1e18;
for (long long i = 0; i < n; i++) {
long long ind = (i + 1) % n;
long long a = av[ind];
long long b = min(a, bv[i]);
mn = min(mn, b);
ans += (a - b);
}
ans += mn;
cout << ans << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
int cc = 0;
for (int i = 0; i < n; i++) {
int a, b, c, d;
cin >> a >> b >> c >> d;
if (b == c) {
cc = 1;
}
}
if (cc && m % 2 == 0)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int i = 0; i < t; i++) {
int n;
set<long long> s, d;
long long c, p;
cin >> n;
for (int j = 0; j < n; j++) {
cin >> c;
s.insert(c);
}
p = *s.begin() * *s.rbegin();
for (long long r = 2; r <= sqrt(p); r++) {
if (p % r == 0) {
d.insert(r);
d.insert(p / r);
}
}
if (s == d) {
cout << p << endl;
} else {
cout << -1 << endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a, b, m, mx, ans[100010], id[1010][1010];
int linkx[1010][1010], linky[1010][1010];
void dfs(int x, int u, int v, int t) {
int tmp;
if (!t) {
tmp = linkx[x][u];
if (tmp != -1) {
dfs(tmp, v, u, t ^ 1);
linky[tmp][v] = x;
}
linkx[x][v] = tmp;
linkx[x][u] = -1;
} else {
tmp = linky[x][u];
if (tmp != -1) {
dfs(tmp, v, u, t ^ 1);
linkx[tmp][v] = x;
}
linky[x][v] = tmp;
linky[x][u] = -1;
}
}
int main() {
scanf("%d%d%d", &a, &b, &m);
memset(linkx, -1, sizeof(linkx));
memset(linky, -1, sizeof(linky));
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
id[x][y] = i;
int u = 1, v = 1;
while (linkx[x][u] != -1) {
u++;
}
while (linky[y][v] != -1) {
v++;
}
if (u == v) {
linkx[x][u] = y;
linky[y][u] = x;
} else {
linkx[x][u] = y;
if (linky[y][u] != -1) {
dfs(y, u, v, 1);
}
linky[y][u] = x;
}
}
for (int i = 1; i <= a; i++) {
for (int j = 1; j <= a || j <= b; j++) {
if (linkx[i][j] != -1) {
ans[id[i][linkx[i][j]]] = j;
mx = max(mx, j);
}
}
}
printf("%d\n", mx);
for (int i = 1; i <= m; i++) {
printf("%d ", ans[i]);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("-O2")
template <typename tp>
void in(tp &dig) {
char ch = getchar();
dig = 0;
long long flag = 0;
while (!isdigit(ch)) {
if (ch == '-') flag = 1;
ch = getchar();
}
while (isdigit(ch)) dig = dig * 10 + ch - '0', ch = getchar();
if (flag) dig = -dig;
}
template <typename T>
void chkmax(T &x, T y) {
x = max(x, y);
}
template <typename T>
void chkmin(T &x, T y) {
x = min(x, y);
}
const int LIM = 2e5 + 5, MOD = 1e9 + 7;
long long n, m, t;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
long long x[n], y[n];
long long maxx, minx, maxy, miny;
for (int i = 0; i < n; i++) {
cin >> x[i] >> y[i];
if (i == 0) {
maxx = minx = x[0];
miny = maxy = y[0];
} else {
maxx = max(maxx, x[i]);
maxy = max(maxy, y[i]);
miny = min(miny, y[i]);
minx = min(minx, x[i]);
}
}
if (n == 3) {
cout << 2 * (maxy - miny) + 2 * (maxx - minx);
} else {
long long ans = 0, xi, yi;
for (int i = 0; i < n; i++) {
xi = max(maxx - x[i], x[i] - minx);
yi = max(maxy - y[i], y[i] - miny);
ans = max(ans, 2 * (xi + yi));
}
cout << ans << " ";
for (int i = 4; i < n + 1; i++) {
cout << 2 * (maxy - miny) + 2 * (maxx - minx) << " ";
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, x, y;
cin >> n >> x >> y;
if (n - 1 + (y - n + 1) * (y - n + 1) >= x && n <= y) {
cout << y - n + 1 << endl;
for (int i = 1; i < n; i++) cout << 1 << endl;
} else
cout << -1;
return 0;
}
| 3 |
/**
* author: Dragon_hao
* created Tue Feb 16 23:14:09 2021
**/
#include<bits/stdc++.h>
#define N 201
using namespace std;
int n, a[N], v[N], d[N];
int tree[4 * N];
void pushup(int i){
tree[i] = max(tree[i << 1], tree[i << 1 | 1]);
}
void build(int i,int l,int r)
{
if(l == r) {
tree[i] = a[l];
return;
}
int mid= (l +r)/2;
build(i << 1, l, mid);
build(i << 1 | 1, mid + 1, r);
pushup(i);
}
int query(int i,int l,int r,int x,int y)
{
if(x <= l && r <= y) return tree[i];
int maxm = 0;
int mid = (l + r) / 2;
if(x <= mid) maxm = max(maxm ,query(i << 1 ,l, mid ,x ,y));
if(y > mid) maxm = max(maxm ,query(i << 1 | 1, mid + 1, r, x, y));
return maxm;
}
void find(int x, int y, int deep) {
if(x > y) return;
int tmp = query(1, 1, n, x, y);
d[v[tmp]] = deep;
find(x, v[tmp] - 1, deep + 1);
find(v[tmp] + 1, y, deep + 1);
}
int main()
{
int T;
cin >> T;
while(T--){
scanf("%d", &n);
for(int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
v[a[i]] = i;
}
build(1, 1, n);
find(1, n, 0);
for(int i = 1; i <= n; i++) printf("%d ", d[i]);
printf("\n");
}
return 0;
} | 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3000 + 50;
vector<int> edge[maxn];
int sub[maxn][maxn], fa[maxn][maxn];
long long n, ans, dp[maxn][maxn];
void dfs(int root, int k, int dad) {
sub[root][k]++;
fa[root][k] = dad;
for (auto t : edge[k]) {
if (t != dad) {
dfs(root, t, k);
sub[root][k] += sub[root][t];
}
}
}
long long DP(int a, int b) {
if (a == b) return 0;
if (dp[a][b] != -1) return dp[a][b];
return dp[a][b] =
sub[a][b] * sub[b][a] + max(DP(fa[a][b], a), DP(fa[b][a], b));
}
int main() {
cin >> n;
memset(dp, -1, sizeof(dp));
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
edge[u].push_back(v);
edge[v].push_back(u);
}
for (int i = 1; i <= n; i++) dfs(i, i, -1);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (i != j) ans = max(ans, DP(i, j));
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 510;
const int mod = 1000000007;
const int to = 5;
int inv[] = {0, 1, 3, 2, 4};
int n, m, ar[N][N], where[N], hold[N];
char ch[N];
long long ans;
int add(int x, int y) {
x += y;
if (x >= to) x -= to;
return x;
}
int sub(int x, int y) {
x -= y;
if (x < 0) x += to;
return x;
}
int mul(int x, int y) {
x = (x * y) % to;
return x;
}
void gauss() {
int base = 0;
for (int i = 0; i < m; i++) {
int next = -1;
for (int j = base; j < n; j++) {
if (ar[j][i]) {
next = j;
break;
}
}
if (next != -1) {
swap(ar[base], ar[next]);
where[i] = base;
int x = inv[ar[base][i]];
for (int j = 0; j < m; j++) {
ar[base][j] = mul(ar[base][j], x);
}
for (int j = next + 1; j < n; j++) {
for (int z = m - 1; z >= i; z--) {
ar[j][z] = sub(ar[j][z], mul(ar[base][z], ar[j][i]));
}
}
base++;
}
}
for (int i = base; i < n; i++) {
ans = (ans * 5LL) % mod;
}
}
int main() {
ans = 1;
scanf("%d%d", &n, &m);
memset(where, -1, sizeof(where));
for (int i = 0; i < n; i++) {
scanf("%s", ch);
for (int j = 0; j < m; j++) {
ar[i][j] = ch[j] - 'a';
}
}
gauss();
int q;
scanf("%d", &q);
while (q--) {
scanf("%s", ch);
for (int i = 0; i < m; i++) {
hold[i] = ch[i] - 'a';
}
bool flag = 0;
for (int i = 0; i < m; i++) {
if (!hold[i]) continue;
if (where[i] == -1) {
flag = 1;
break;
}
for (int j = m - 1; j >= i; j--) {
hold[j] = sub(hold[j], mul(ar[where[i]][j], hold[i]));
}
}
if (flag)
printf("0\n");
else
printf("%lld\n", ans);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
char mas[102][102];
char next(char ch) {
if (ch >= '0' && ch < '9')
return ch + 1;
else if (ch == '9')
return 'a';
else if (ch >= 'a' && ch < 'z')
return ch + 1;
else if (ch == 'z')
return 'A';
else
return ch + 1;
}
int main() {
int t;
cin >> t;
for (int i = 0; i < t; i++) {
int a, b, chik, r = 0;
cin >> a >> b >> chik;
for (int j = 1; j <= a; j++)
for (int k = 1; k <= b; k++) {
cin >> mas[j][k];
if (mas[j][k] == 'R') r++;
}
int t1 = 0, t2 = 0, c1 = 0, c2 = 0;
if (r % chik == 0) {
t1 = r / chik;
c1 = chik;
} else {
t1 = (r / chik) + 1;
t2 = r / chik;
c2 = chik - (r % chik);
c1 = r % chik;
}
char now = '0';
int col = t1;
for (int j = 1; j <= a; j++) {
if (j % 2 == 1) {
for (int k = 1; k <= b; k++) {
if (mas[j][k] == '.') {
mas[j][k] = now;
} else {
if (col > 0) {
mas[j][k] = now;
col--;
} else if (c1 > 1) {
col = t1 - 1;
now = next(now);
mas[j][k] = now;
c1--;
} else {
col = t2 - 1;
now = next(now);
mas[j][k] = now;
}
}
}
} else {
for (int k = b; k > 0; k--) {
if (mas[j][k] == '.') {
mas[j][k] = now;
} else {
if (col > 0) {
mas[j][k] = now;
col--;
} else if (c1 > 1) {
col = t1 - 1;
now = next(now);
mas[j][k] = now;
c1--;
} else {
col = t2 - 1;
now = next(now);
mas[j][k] = now;
}
}
}
}
}
for (int j = 1; j <= a; j++) {
for (int k = 1; k <= b; k++) cout << mas[j][k];
cout << '\n';
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int v[1005][1005], h[1005][1005];
int a[1005][1005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie();
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
h[i][0] = 0;
}
for (int i = 0; i < m; i++) {
v[i][0] = 0;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> a[i][j];
h[i + 1][j + 1] += h[i + 1][j] + (a[i][j] == 1);
v[j + 1][i + 1] += v[j + 1][i] + (a[i][j] == 1);
}
}
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int ans1 = ans;
if (a[i][j] == 0) {
if (h[i + 1][j] > 0) ans++;
if (v[j + 1][i] > 0) ans++;
if (h[i + 1][m] - h[i + 1][j + 1] > 0) ans++;
if (v[j + 1][n] - v[j + 1][i + 1] > 0) ans++;
}
}
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long> > vii;
long long tab[100002], n;
long long dx[8] = {0, 1, 0, -1, 1, -1, 1, -1};
long long dy[8] = {1, 0, -1, 0, 1, -1, -1, 1};
bool ch(long long i, long long j, long long n, long long m) {
return (i >= 0 && i < n && j >= 0 && j < m);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, x, y, z, k, sum = 0, bank = 0, A, B, C, D, T, occuped = 0,
out = 0, add;
vector<string> as;
vector<long long> a, b;
set<long long> see;
map<long long, long long> m1, m2;
string s, s1, s2;
double in, x1, y1;
a.clear();
cin >> n >> k;
for (long long i = 0; i < n; i++) {
cin >> x;
a.push_back(x);
}
b = a;
reverse(b.begin(), b.end());
for (long long i = 0; i < n; i++) {
if (a[i] <= k)
sum++;
else {
break;
}
}
for (long long i = 0; i < n; i++) {
if (b[i] <= k)
bank++;
else {
break;
}
}
cout << endl;
if (sum + bank > n)
cout << n << endl;
else
cout << sum + bank << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> G[30];
int n;
char s[110][110];
int ans[110];
int len[110];
queue<int> st;
int idx(char ch) { return ch - 'a'; }
char getch(int id) { return 'a' + id; }
bool vis[30][30];
int ind[110];
void addEdge(int u, int v) {
if (vis[u][v]) return;
G[u].push_back(v);
ind[v]++;
vis[u][v] = 1;
}
bool ok = 1;
void init() {
int l1, l2, l;
for (int i = 0; i < n; i++) len[i] = strlen(s[i]);
for (int i = 0; i < n; i++) {
l1 = len[i];
for (int j = i + 1; j < n; j++) {
l2 = len[j];
l = min(l1, l2);
bool dif = 0;
for (int k = 0; k < l; k++) {
if (s[i][k] != s[j][k]) {
dif = 1;
addEdge(idx(s[i][k]), idx(s[j][k]));
break;
}
}
if (!dif && len[i] > len[j]) {
ok = 0;
return;
}
}
}
}
void solve() {
int p;
for (int i = 0; i < 26; i++) {
if (ind[i] == 0) st.push(i);
}
int cnt = 0;
while (!st.empty()) {
int u = st.front();
st.pop();
ans[cnt++] = u;
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
ind[v]--;
if (ind[v] == 0) st.push(v);
}
}
if (cnt != 26) {
printf("Impossible\n");
return;
} else {
for (int i = 0; i < cnt; i++) putchar(getch(ans[i]));
printf("\n");
}
return;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%s", s[i]);
}
init();
if (!ok) {
printf("Impossible\n");
} else
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long dp[150005], tmp[150005], a[305], b[305], t[305];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, m, d;
cin >> n >> m >> d;
for (int i = 1; i <= m; i++) cin >> a[i] >> b[i] >> t[i];
for (int i = 1; i <= n; i++) dp[i] = b[1] - abs(a[1] - i);
for (int i = 2; i <= m; i++) {
deque<pair<long long, long long> > window;
while (!window.empty()) window.pop_back();
for (int j = 1; j <= n; j++) {
long long r = (t[i] - t[i - 1]) * d;
r = max(1ll, j - r);
while (!window.empty() and window.back().first < dp[j]) window.pop_back();
window.push_back({dp[j], j});
while (window.front().second < r) window.pop_front();
long long mx = dp[j];
mx = max(mx, window.front().first);
tmp[j] = mx;
}
while (!window.empty()) window.pop_back();
for (int j = n; j > 0; j--) {
long long r = (t[i] - t[i - 1]) * d;
r = min(n, j + r);
while (!window.empty() and window.back().first < dp[j]) window.pop_back();
window.push_back({dp[j], j});
while (window.front().second > r) window.pop_front();
long long mx = dp[j];
mx = max(mx, window.front().first);
tmp[j] = max(tmp[j], mx);
dp[j] = tmp[j] + b[i] - abs(a[i] - j);
}
}
long long ans = -1e18;
for (int i = 1; i <= n; i++) ans = max(ans, dp[i]);
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct chip {
char dir;
chip *u, *r, *d, *l;
chip(char _dir) {
dir = _dir;
u = r = d = l = NULL;
}
};
int main(int argc, char* argv[]) {
int n, m;
cin >> n >> m;
chip*** t;
t = (chip***)malloc(n * sizeof(chip**));
for (int i = 0; i < n; i++) t[i] = (chip**)malloc(m * sizeof(chip*));
char d;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> d;
if (d != '.') {
t[i][j] = new chip(d);
if (i > 0) {
int k = i - 1;
while ((k >= 0) && (t[k][j] == NULL)) k--;
if (k >= 0) {
t[k][j]->d = t[i][j];
t[i][j]->u = t[k][j];
}
}
if (j > 0) {
int k = j - 1;
while ((k >= 0) && (t[i][k] == NULL)) k--;
if (k >= 0) {
t[i][k]->r = t[i][j];
t[i][j]->l = t[i][k];
}
}
} else
t[i][j] = NULL;
}
}
int max = 0;
int count = 0;
vector<chip*> v;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
v.clear();
chip* c = t[i][j];
while (c != NULL) {
v.push_back(c);
chip* e;
if (c->dir == 'U') e = c->u;
if (c->dir == 'R') e = c->r;
if (c->dir == 'D') e = c->d;
if (c->dir == 'L') e = c->l;
if (c->u != NULL) c->u->d = c->d;
if (c->r != NULL) c->r->l = c->l;
if (c->d != NULL) c->d->u = c->u;
if (c->l != NULL) c->l->r = c->r;
c = e;
}
if (v.size() > max) {
max = v.size();
count = 0;
}
if (v.size() == max) count++;
for (vector<chip*>::reverse_iterator r = v.rbegin(); r < v.rend(); r++) {
chip* e = *r;
if (e->u != NULL) e->u->d = e;
if (e->r != NULL) e->r->l = e;
if (e->d != NULL) e->d->u = e;
if (e->l != NULL) e->l->r = e;
}
}
}
cout << max << " " << count << endl;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) free(t[i][j]);
for (int i = 0; i < n; i++) free(t[i]);
free(t);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
bool is_palin(string s, int i, int j, int size) {
for (int k = i, l = j; k <= l; k++, l--) {
if (s[k] != s[l]) return false;
}
return true;
}
int main() {
string s;
cin >> s;
int k;
cin >> k;
int size = s.size();
if (size % k != 0) {
cout << "NO" << endl;
} else {
int ini = 0;
int fin = (size / k) - 1;
bool c = true;
for (int i = 0; i < k; i++) {
if (!is_palin(s, ini, fin, size)) {
cout << "NO" << endl;
c = false;
break;
}
int temp = fin;
ini = fin + 1;
fin = temp + (size) / k;
}
if (c) {
cout << "YES" << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast", "unroll-loops", "omit-frame-pointer", "inline")
#pragma GCC option("arch=native", "tune=native", "no-zero-upper")
#pragma GCC target("avx2")
using namespace std;
const long long INF = 1e16;
const int maxn = 2e6 + 7;
const int mod = 1e9 + 7;
inline bool read(long long &num) {
char in;
bool IsN = false;
in = getchar();
if (in == EOF) return false;
while (in != '-' && (in < '0' || in > '9')) in = getchar();
if (in == '-') {
IsN = true;
num = 0;
} else
num = in - '0';
while (in = getchar(), in >= '0' && in <= '9') {
num *= 10, num += in - '0';
}
if (IsN) num = -num;
return true;
}
long long n, m, c;
long long C[maxn], t[maxn];
string s[105];
int N, L;
double p[maxn], dp[maxn];
long long bitcount(long long x) {
int cot = 0;
while (x) {
cot++;
x -= x & -x;
}
return cot;
}
void work() {
L = s[1].size();
N = 1 << L;
for (int i = 1; i <= n; i++) {
for (int k = i + 1; k <= n; k++) {
long long staus = 0;
for (int j = 0; j < L; j++) staus |= (s[i][j] == s[k][j]) << j;
t[staus] |= (1ll << i | 1ll << k);
}
}
for (int i = N - 1; i >= 0; i--) {
for (int k = 0; k < L; k++) {
if (i >> k & 1ll) t[i ^ (1ll << k)] |= t[i];
}
C[i] = bitcount(t[i]);
}
}
int main() {
read(n);
if (n == 1) {
printf("0.000000000\n");
return 0;
}
for (int i = 1; i <= n; i++) cin >> s[i];
work();
dp[0] = 1;
for (int i = 0; i < N; i++) {
int bit = bitcount(i), cot = L - bit;
if (!C[i]) continue;
for (int k = 0; k < L; k++) {
if (i >> k & 1ll) continue;
dp[i | (1ll << k)] += 1.0 * dp[i] / cot * C[i | (1ll << k)] / C[i];
p[bit + 1] += 1.0 * dp[i] / cot * (C[i] - C[i | (1ll << k)]) / C[i];
}
}
double ans = 0;
for (int i = 1; i <= L; i++) {
ans += p[i] * i;
}
printf("%.9lf\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
string s;
cin >> s;
char d = s[n - 1];
for (int i = 0; i < n; ++i) cout << d;
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
const double eps = 1e-9;
const double pi = acos(-1.0);
const int maxn = (int)1e5 + 10;
const int mod = 314000000;
vector<pair<int, int> > g[2 * maxn], gr[2 * maxn];
int deg[2 * maxn], mi[2 * maxn], sum[2 * maxn], ma[2 * maxn];
int used[2 * maxn], n;
int dfs(int v) {
used[v] = 1;
if (v < n) {
for (int i = 0; i < (int)(gr[v]).size(); i++) {
int to = gr[v][i].first;
int cnt = gr[v][i].second;
if (mi[to] == -1) continue;
if (used[to] == 1) {
ma[v] = -2;
return -2;
} else if (used[to] == 2) {
ma[v] = max(ma[v], min(mod, ma[to] + cnt));
} else {
int ret = dfs(to);
if (ret == -2) {
ma[v] = -2;
return -2;
}
ma[v] = max(ma[v], min(mod, ma[to] + cnt));
}
}
} else {
int sum = 0;
for (int i = 0; i < (int)(gr[v]).size(); i++) {
int to = gr[v][i].first;
int cnt = gr[v][i].second;
if (used[to] == 1) {
ma[v] = -2;
return -2;
} else if (used[to] == 2) {
sum += ma[to];
sum = min(sum, mod);
} else {
int ret = dfs(to);
if (ret == -2) {
ma[v] = -2;
return -2;
}
sum += ret + cnt;
sum = min(sum, mod);
}
}
ma[v] = sum;
}
used[v] = 2;
return ma[v];
}
int main() {
int m;
cin >> m >> n;
for (int i = 0; i < n; i++) {
deg[i] = 1;
mi[i] = -1;
ma[i] = -1;
}
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
--x;
int cnt = 0;
for (int j = 0; j < y; j++) {
int z;
scanf("%d", &z);
if (z == -1) {
cnt++;
} else {
--z;
g[z].push_back(make_pair(n + i, 0));
gr[n + i].push_back(make_pair(z, 0));
}
}
deg[n + i] = y - cnt;
g[n + i].push_back(make_pair(x, cnt));
gr[x].push_back(make_pair(n + i, cnt));
}
priority_queue<pair<int, int> > q;
for (int i = 0; i < n + m; i++) {
if (deg[i] == 0) {
mi[i] = 0;
q.push(make_pair(-mi[i], i));
} else {
mi[i] = -1;
}
}
while (!q.empty()) {
int MI = -q.top().first;
int v = q.top().second;
q.pop();
if (mi[v] < MI) continue;
if (v < n) {
for (int i = 0; i < (int)(g[v]).size(); i++) {
int to = g[v][i].first;
int cnt = g[v][i].second;
sum[to] += cnt + mi[v];
sum[to] = min(sum[to], mod);
deg[to]--;
if (deg[to] == 0) {
mi[to] = sum[to];
q.push(make_pair(-mi[to], to));
}
}
} else {
for (int i = 0; i < (int)(g[v]).size(); i++) {
int to = g[v][i].first;
int cnt = g[v][i].second;
if (mi[to] == -1) {
mi[to] = cnt + mi[v];
mi[to] = min(mi[to], mod);
q.push(make_pair(-mi[to], to));
} else if (mi[to] > cnt + mi[v]) {
mi[to] = cnt + mi[v];
q.push(make_pair(-mi[to], to));
}
}
}
}
for (int i = 0; i < n; i++)
if (mi[i] != -1 && used[i] == 0) {
dfs(i);
}
for (int i = 0; i < n; i++) {
printf("%d %d\n", mi[i], ma[i]);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename S>
ostream& operator<<(ostream& os, pair<T, S> input) {
os << "(" << input.first << ", " << input.second << ")";
return os;
}
template <typename T>
ostream& operator<<(ostream& os, vector<T> input) {
for (auto t : input) os << t << "\n";
return os;
}
template <typename T>
ostream& operator<<(ostream& os, set<T> input) {
for (auto t : input) os << t << "\n";
return os;
}
long long x[300002], y[300002], d[300002], ord[300002];
long long pref[300002], suff[300002], ans[300002];
bool cmp(int i, int j) { return d[i] < d[j]; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> x[i] >> y[i];
d[i] = x[i] - y[i];
ord[i] = i;
}
sort(ord + 1, ord + 1 + n, cmp);
for (int i = 1; i <= n; i++) {
}
for (int i = 1; i <= n; i++) {
int in = ord[i];
pref[i] = pref[i - 1] + x[in];
}
for (int i = n; i >= 1; i--) {
int in = ord[i];
suff[i] = suff[i + 1] + y[in];
}
for (int i = 1; i <= n; i++) {
ans[ord[i]] =
pref[i - 1] + suff[i + 1] + (i - 1) * y[ord[i]] + (n - i) * x[ord[i]];
}
for (int i = 1; i <= m; i++) {
int l, r;
cin >> l >> r;
int ians = min(x[l] + y[r], x[r] + y[l]);
ans[l] -= ians;
ans[r] -= ians;
}
for (int i = 1; i <= n; i++) {
cout << ans[i] << " ";
}
cout << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
const int MAXN = 200000;
using namespace std;
inline int read() {
int x = 0, w = 1;
char c = ' ';
while (!isdigit(c)) {
c = getchar();
if (c == '-') w = -1;
}
while (isdigit(c)) {
x = (x << 1) + (x << 3) + (c ^ 48);
c = getchar();
}
return x * w;
}
string s, t;
int n, m, id[28][MAXN + 5], cnt[28], sum[28];
void init() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> s;
for (int i = 0; i < s.length(); ++i) {
id[s[i] - 'a'][++cnt[s[i] - 'a']] = i + 1;
}
}
int main() {
init();
cin >> m;
while (m--) {
memset(sum, 0, sizeof(sum));
cin >> t;
int ans = 0;
for (int i = 0; i < t.length(); ++i) {
++sum[t[i] - 'a'];
ans = max(ans, id[t[i] - 'a'][sum[t[i] - 'a']]);
}
cout << ans << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char c;
int n, left = 0, right = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> c;
if (c == 'L')
left--;
else if (c == 'R')
right++;
}
cout << right - left + 1 << endl;
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
#define int long long
const int mod=1e9+7;
const int mxN=1e5+10;
void solve(){
int n;cin>>n;
vector<int>a(2*n);
for(int i=0;i<2*n;i++){
cin>>a[i];
}
sort(a.rbegin(),a.rend());
for(int i=1;i<2*n;i++){
vector<pair<int,int>>v;
multiset<int>s;
int sz=2*n-2;
for(int j=1;j<2*n;j++){
if(j==i) continue;
else s.insert(a[j]);
}
v.push_back({a[0],a[i]});
int initx=a[0]+a[i];
int x=a[0];
while(sz>0){
auto itr=s.end();
itr--;
int m1=(*itr);
s.erase(itr);
int reqd=x-m1;
auto itr1=s.find(reqd);
if(itr1==s.end()) break;
else s.erase(itr1);
x=m1;
sz-=2;
v.push_back({m1,reqd});
}
if(sz==0){
cout<<"YES\n";
cout<<initx<<'\n';
for(auto x:v) cout<<x.first<<" "<<x.second<<'\n';
return;
}
}
cout<<"NO\n";
}
int32_t main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);cout.tie(NULL);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
int T=1;
cin>>T;
while(T--){
solve();
}
return 0;
} | 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
int x[N], y[N], c[N];
int mk[N];
int fa[N], rk[N];
int get(int x) {
if (fa[x] == x) return x;
return get(fa[x]);
}
void merge(int x, int y) {
int fx = get(x);
int fy = get(y);
if (rk[fx] > rk[fy]) swap(fx, fy);
fa[fx] = fy;
rk[fy] = max(rk[fy], rk[fx] + 1);
}
struct rev {
int fx, fy;
int rkx, rky;
};
rev stk[N];
int tp;
void revocation(rev node) {
fa[node.fx] = node.fx;
fa[node.fy] = node.fy;
rk[node.fx] = node.rkx;
rk[node.fy] = node.rky;
}
map<pair<int, int>, vector<pair<int, int>>> mp;
int main() {
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) scanf("%d", c + i);
for (int i = 1; i <= m; i++) scanf("%d%d", x + i, y + i);
for (int i = 1; i <= 2 * n; i++) {
fa[i] = i;
rk[i] = 1;
}
memset(mk, 0, sizeof(mk));
for (int i = 1; i <= m; i++) {
if (c[x[i]] != c[y[i]]) continue;
int fx = get(x[i]);
int fy = get(y[i]);
if (fx == fy)
mk[c[x[i]]] = 1;
else {
merge(x[i], y[i] + n);
merge(x[i] + n, y[i]);
}
}
long long cnt = k;
for (int i = 1; i <= k; i++) {
if (mk[i]) cnt--;
}
long long ans = max(0LL, cnt * (cnt - 1) / 2);
for (int i = 1; i <= m; i++) {
if (c[x[i]] == c[y[i]]) continue;
if (mk[c[x[i]]] || mk[c[y[i]]]) continue;
if (c[x[i]] > c[y[i]]) swap(x[i], y[i]);
mp[pair<int, int>{c[x[i]], c[y[i]]}].push_back(pair<int, int>{x[i], y[i]});
}
for (auto &node : mp) {
for (auto &pr : node.second) {
int fx = get(pr.first);
int fy = get(pr.second);
if (fx == fy) {
ans--;
break;
} else {
int fx1 = get(pr.first);
int fx2 = get(pr.first + n);
int fy1 = get(pr.second);
int fy2 = get(pr.second + n);
stk[++tp] = rev{fx1, fy2, rk[fx1], rk[fy2]};
stk[++tp] = rev{fx2, fy1, rk[fx2], rk[fy1]};
merge(fx1, fy2);
merge(fx2, fy1);
}
}
while (tp) {
revocation(stk[tp--]);
}
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000005;
int n, sum, a[N], b[N];
long long S[N];
pair<int, int> calc(int x) {
int pos = 0, tmp = 0;
for (; a[pos + 1] > x; b[++tmp] = a[++pos])
;
b[++tmp] = x;
for (; pos < n;) b[++tmp] = a[++pos];
for (int i = (int)(1); i <= (int)(n + 1); i++) S[i] = S[i - 1] + b[i];
pos = n + 2;
long long sum = 0;
for (int i = (int)(1); i <= (int)(n + 1); i++) {
sum += b[i] - 2 * i + 2;
for (; b[pos - 1] <= i && pos > i + 1; pos--)
;
pos = max(pos, i + 1);
long long sum2 = S[n + 1] - S[pos - 1] + 1ll * (pos - i - 1) * i;
if (sum2 < sum) return pair<int, int>(b[i] <= x ? -1 : 1, 0);
}
return pair<int, int>(0, 0);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), sum ^= a[i];
sort(a + 1, a + n + 1, greater<int>());
int l = 0, r = n, ans = -1;
if ((l + sum) & 1) l++;
if ((r + sum) & 1) r--;
while (l <= r) {
int mid = (l + r) / 2;
if ((mid + sum) & 1) mid++;
if (mid > r || mid < l) break;
pair<int, int> tmp = calc(mid);
if (tmp.first == 0) {
ans = mid;
break;
}
if (tmp.first < 0)
r = mid - 1;
else
l = mid + 1;
}
if (ans == -1) return puts("-1"), 0;
l = 0;
r = ans - 1;
int lans = ans;
while (l <= r) {
int mid = (l + r) / 2;
if ((mid + sum) & 1) mid++;
if (mid > r || mid < l) break;
pair<int, int> tmp = calc(mid);
if (tmp.first == 0)
lans = mid, r = mid - 1;
else
l = mid + 1;
}
l = ans + 1;
r = n;
int rans = ans;
while (l <= r) {
int mid = (l + r) / 2;
if ((mid + sum) & 1) mid++;
if (mid > r || mid < l) break;
pair<int, int> tmp = calc(mid);
if (tmp.first == 0)
rans = mid, l = mid + 1;
else
r = mid - 1;
}
for (; lans <= rans; lans += 2) printf("%d ", lans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 9;
long long a[maxn * 3];
int End[maxn * 3];
int main() {
int n, q;
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) {
scanf("%lld", a + i);
a[i + n] = a[i];
a[i + 2 * n] = a[i];
}
for (int i = 1; i <= 3 * n; i++) a[i] += a[i - 1];
while (q--) {
long long b;
scanf("%lld", &b);
int j = 2;
int st, mi = 1e9;
for (int i = 1; i <= 2 * n; i++) {
while (j < i + n && a[j] - a[i - 1] <= b) j++;
End[i] = j;
if (j - i < mi) {
mi = j - i;
st = i;
}
}
int ans = 1e9;
for (int i = st; i <= End[st]; i++) {
int p = i;
if (p > n) p -= n;
int now = p;
int step = 0;
while (1) {
step++;
now = End[now];
if (now - p >= n) break;
}
ans = min(ans, step);
}
printf("%d\n", ans);
}
}
| 8 |
#include <bits/stdc++.h>
template <typename T>
inline T max(T a, T b) {
return a > b ? a : b;
}
template <typename T>
inline T min(T a, T b) {
return a < b ? a : b;
}
template <typename T>
inline T abs(T a) {
return a > 0 ? a : -a;
}
template <typename T>
inline bool repr(T &a, T b) {
return a < b ? a = b, 1 : 0;
}
template <typename T>
inline bool repl(T &a, T b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
inline T gcd(T a, T b) {
T t;
if (a < b) {
while (a) {
t = a;
a = b % a;
b = t;
}
return b;
} else {
while (b) {
t = b;
b = a % b;
a = t;
}
return a;
}
}
template <typename T>
inline T sqr(T x) {
return x * x;
}
struct Cg {
__attribute__((always_inline)) inline char operator()() { return getchar(); }
};
struct Cp {
__attribute__((always_inline)) inline void operator()(char x) { putchar(x); }
};
__attribute__((always_inline)) inline bool IS(char x) {
return x == 10 || x == 13 || x == ' ';
}
template <typename T>
struct Fr {
T P;
__attribute__((always_inline)) inline Fr &operator,(int &x) {
x = 0;
unsigned char t = P();
while ((t < '0' || t > '9') && t != '-') t = P();
bool f = 0;
if (t == '-') t = P(), f = 1;
x = t - '0';
for (t = P(); t >= '0' && t <= '9'; t = P()) x = x * 10 + t - '0';
if (f) x = -x;
return *this;
}
__attribute__((always_inline)) inline operator int() {
int x;
*this, x;
return x;
}
__attribute__((always_inline)) inline Fr &operator,(long long &x) {
x = 0;
unsigned char t = P();
while ((t < '0' || t > '9') && t != '-') t = P();
bool f = 0;
if (t == '-') t = P(), f = 1;
x = t - '0';
for (t = P(); t >= '0' && t <= '9'; t = P()) x = x * 10 + t - '0';
if (f) x = -x;
return *this;
}
__attribute__((always_inline)) inline operator long long() {
long long x;
*this, x;
return x;
}
__attribute__((always_inline)) inline Fr &operator,(char &x) {
for (x = P(); IS(x); x = P())
;
return *this;
}
__attribute__((always_inline)) inline operator char() {
char x;
*this, x;
return x;
}
__attribute__((always_inline)) inline Fr &operator,(char *x) {
char t = P();
for (; IS(t); t = P())
;
if (~t) {
for (; !IS(t) && ~t; t = P()) *x++ = t;
}
*x++ = 0;
return *this;
}
__attribute__((always_inline)) inline Fr &operator,(double &x) {
x = 0;
unsigned char t = P();
while ((t < '0' || t > '9') && t != '-') t = P();
bool f = 0;
if (t == '-') t = P(), f = 1;
x = t - '0';
for (t = P(); t >= '0' && t <= '9'; t = P()) x = x * 10 + t - '0';
if (t == '.') {
double u = 0.1;
for (t = P(); t >= '0' && t <= '9'; t = P(), u *= 0.1) x += u * (t - '0');
}
if (f) x = -x;
return *this;
}
__attribute__((always_inline)) inline operator double() {
double x;
*this, x;
return x;
}
__attribute__((always_inline)) inline Fr &operator,(long double &x) {
x = 0;
unsigned char t = P();
while ((t < '0' || t > '9') && t != '-') t = P();
bool f = 0;
if (t == '-') t = P(), f = 1;
x = t - '0';
for (t = P(); t >= '0' && t <= '9'; t = P()) x = x * 10 + t - '0';
if (t == '.') {
double u = 0.1;
for (t = P(); t >= '0' && t <= '9'; t = P(), u *= 0.1) x += u * (t - '0');
}
if (f) x = -x;
return *this;
}
__attribute__((always_inline)) inline operator long double() {
long double x;
*this, x;
return x;
}
__attribute__((always_inline)) inline Fr &operator,(unsigned int &x) {
x = 0;
unsigned char t = P();
while (t < '0' || t > '9') t = P();
x = t - '0';
for (t = P(); t >= '0' && t <= '9'; t = P()) x = x * 10 + t - '0';
return *this;
}
__attribute__((always_inline)) inline operator unsigned int() {
unsigned int x;
*this, x;
return x;
}
__attribute__((always_inline)) inline Fr &operator,(unsigned long long &x) {
x = 0;
unsigned char t = P();
while (t < '0' || t > '9') t = P();
x = t - '0';
for (t = P(); t >= '0' && t <= '9'; t = P()) x = x * 10 + t - '0';
return *this;
}
__attribute__((always_inline)) inline operator unsigned long long() {
unsigned long long x;
*this, x;
return x;
}
};
Fr<Cg> in;
template <typename T>
struct Fw {
T P;
__attribute__((always_inline)) inline Fw &operator,(int x) {
if (x) {
if (x < 0) P('-'), x = -x;
unsigned char s[10], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
__attribute__((always_inline)) inline Fw &operator()(int x) {
if (x) {
if (x < 0) P('-'), x = -x;
unsigned char s[10], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
__attribute__((always_inline)) inline Fw &operator,(unsigned int x) {
if (x) {
unsigned char s[10], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
__attribute__((always_inline)) inline Fw &operator()(unsigned int x) {
if (x) {
unsigned char s[10], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
__attribute__((always_inline)) inline Fw &operator,(long long x) {
if (x) {
if (x < 0) P('-'), x = -x;
unsigned char s[19], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
__attribute__((always_inline)) inline Fw &operator()(long long x) {
if (x) {
if (x < 0) P('-'), x = -x;
unsigned char s[19], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
__attribute__((always_inline)) inline Fw &operator,(unsigned long long x) {
if (x) {
unsigned char s[20], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
__attribute__((always_inline)) inline Fw &operator()(unsigned long long x) {
if (x) {
unsigned char s[20], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
__attribute__((always_inline)) inline Fw &operator,(char x) {
P(x);
return *this;
}
__attribute__((always_inline)) inline Fw &operator()(char x) {
P(x);
return *this;
}
__attribute__((always_inline)) inline Fw &operator,(const char *x) {
while (*x) P(*x++);
return *this;
}
__attribute__((always_inline)) inline Fw &operator()(const char *x) {
while (*x) P(*x++);
return *this;
}
__attribute__((always_inline)) inline Fw &operator()(double x, int y) {
if (y) {
double t = 0.5;
for (int i = y; i--;) t *= 0.1;
if (x >= 0)
x += t;
else
x -= t, P('-');
*this, (long long)(abs(x));
P('.');
if (x < 0) x = -x;
while (y--) {
x *= 10;
x -= floor(x * 0.1) * 10;
P(((int)x) % 10 + '0');
}
} else if (x >= 0)
*this, (long long)(x + 0.5);
else
*this, (long long)(x - 0.5);
;
return *this;
}
__attribute__((always_inline)) inline Fw &operator()(long double x, int y) {
if (y) {
double t = 0.5;
for (int i = y; i--;) t *= 0.1;
if (x >= 0)
x += t;
else
x -= t, P('-');
*this, (long long)(abs(x));
P('.');
if (x < 0) x = -x;
while (y--) {
x *= 10;
x -= floor(x * 0.1) * 10;
P(((int)x) % 10 + '0');
}
} else if (x >= 0)
*this, (long long)(x + 0.5);
else
*this, (long long)(x - 0.5);
;
return *this;
}
};
Fw<Cp> out;
struct vec {
double x, y;
vec() {}
vec(double a, double b) { x = a, y = b; }
inline vec &operator+=(const vec &a) {
x += a.x, y += a.y;
return *this;
}
inline vec &operator-=(const vec &a) {
x -= a.x, y -= a.y;
return *this;
}
inline vec &operator/=(const double &a) {
x /= a, y /= a;
return *this;
}
inline vec &operator*=(const double &a) {
x *= a, y *= a;
return *this;
}
inline vec operator+(const vec &b) const {
vec a = *this;
a += b;
return a;
}
inline vec operator-(const vec &b) const {
vec a = *this;
a -= b;
return a;
}
inline vec operator/(const double &b) const {
vec a = *this;
a /= b;
return a;
}
inline vec operator*(const double &b) const {
vec a = *this;
a *= b;
return a;
}
inline double operator*(const vec &a) const { return x * a.x + y * a.y; }
inline double operator%(const vec &a) const { return x * a.y - y * a.x; }
inline double sqrd() const { return sqr(x) + sqr(y); }
inline double d() { return sqrt(sqrd()); }
inline double a() { return atan2(y, x); }
};
inline double sqrdis(const vec &a, const vec &b) {
return sqr(a.x - b.x) + sqr(a.y - b.y);
}
inline double dis(const vec &a, const vec &b) { return sqrt(sqrdis(a, b)); }
inline vec rotl(const vec &a) { return vec(-a.y, a.x); }
inline vec rotr(const vec &a) { return vec(a.y, -a.x); }
struct line {
vec a, b;
line() {}
line(vec x, vec y) { a = x, b = y; }
inline vec pos(double x) { return a + b * x; }
};
inline double intf(const line &a, const line &b) {
return (b.b % (a.a - b.a)) / (a.b % b.b);
}
inline vec intsec(const line &a, const line &b) {
return a.a + a.b * intf(a, b);
}
inline line rotl(const line &a) { return line(a.a, rotl(a.b)); }
inline line rotr(const line &a) { return line(a.a, rotr(a.b)); }
const int N = 200005;
const double eps = 1e-7;
struct data {
double a, b, c, r;
inline double f() { return f(r); }
inline double f(double x) { return c + x * (b + a * x); }
};
int n, m, u, lp;
vec s[N];
double c, lt, p[N];
std::vector<data> f[N];
inline double cal(int a, int b, double x, double y) {
line la(s[a], s[a + 1] - s[a]), lb(s[b], s[b + 1] - s[b]);
vec u = la.pos(x / (p[a + 1] - p[a]));
vec v = lb.pos(y / (p[b + 1] - p[b]));
return sqrdis(u, v);
}
inline void _solve(int _a, int _b, double x, double y, double l) {
if (l < eps) return;
double u = cal(_a, _b, x, y), v = cal(_a, _b, x + l / 2, y + l / 2),
w = cal(_a, _b, x + l, y + l);
double a = (u + w - v * 2) / (l * l) * 2;
double b = (w - u - (l * lt * 2 + l * l) * a) / l;
double c = u - lt * lt * a - lt * b;
if (abs(a) < eps)
f[lp].push_back((data){a, b, c, lt + l});
else {
double t = -.5 * b / a;
if (t <= lt || t >= lt + l)
f[lp].push_back((data){a, b, c, lt + l});
else
f[lp].push_back((data){a, b, c, t}),
f[lp].push_back((data){a, b, c, lt + l});
}
}
inline void solve(int a, int b, double x, double y, double l) {
while (lt + l >= c) {
double t = min(l, c - lt);
_solve(a, b, x, y, t);
x += t, y += t, l -= t, lt = 0;
lp++;
}
_solve(a, b, x, y, l), lt += l;
}
inline void merge(std::vector<data> &a, std::vector<data> &b) {
std::vector<data> res;
auto add = [&](data x, data y, double l, double r) {
if (r - l < eps) return;
if (abs(x.a - y.a) < eps && abs(x.b - y.b) < eps && abs(x.c - y.c) < eps) {
res.push_back((data){x.a, x.b, x.c, r});
return;
}
bool lp = x.f(l) > y.f(l), rp = x.f(r) > y.f(r);
if (lp == rp) {
if (lp)
res.push_back((data){x.a, x.b, x.c, r});
else
res.push_back((data){y.a, y.b, y.c, r});
return;
}
double a = x.a - y.a, b = x.b - y.b, c = x.c - y.c, u, v;
if (abs(a) > eps) {
double ar = .5 / a;
u = -b * ar, v = sqrt(b * b - 4 * a * c) * ar;
if (u - v > l - eps && u - v < r + eps)
u -= v;
else
u += v;
} else {
u = -c / b;
}
if (lp)
res.push_back((data){x.a, x.b, x.c, u});
else
res.push_back((data){y.a, y.b, y.c, u});
if (rp)
res.push_back((data){x.a, x.b, x.c, r});
else
res.push_back((data){y.a, y.b, y.c, r});
};
int j = 0;
double al = 0, bl = 0;
for (int i = 0, iend = a.size(); i < iend; i++) {
for (; j < b.size() && b[j].r < a[i].r; j++) {
add(a[i], b[j], max(al, bl), b[j].r);
bl = b[j].r;
}
if (j < b.size()) add(a[i], b[j], max(al, bl), a[i].r);
al = a[i].r;
}
res.swap(a);
std::vector<data> tmp;
tmp.swap(b);
}
inline void work(int l, int r) {
if (l == r) return;
int t = (l + r) >> 1;
work(l, t), work(t + 1, r);
merge(f[l], f[t + 1]);
}
int main() {
in, n, m;
for (int i = 0, iend = n; i < iend; i++) in, s[i].x, s[i].y;
for (int i = 0, iend = n; i <= iend; i++) s[i + n] = s[i];
for (int i = 1, iend = n * 2; i <= iend; i++)
p[i] = p[i - 1] + dis(s[i], s[i - 1]);
c = p[n] / m;
int j = 0;
for (; p[j] < c; j++)
;
for (int i = 0, iend = n; i < iend; i++) {
int k = j;
for (; p[k] < p[i + 1] + c; k++)
;
if (j == k) {
solve(i, j - 1, 0, p[i] + c - p[j - 1], p[i + 1] - p[i]);
continue;
}
solve(i, j - 1, 0, p[i] + c - p[j - 1], p[j] - c - p[i]);
for (j++; j < k; j++) {
solve(i, j - 1, p[j - 1] - c - p[i], 0, p[j] - p[j - 1]);
}
solve(i, k - 1, p[k - 1] - c - p[i], 0, p[i + 1] + c - p[k - 1]);
j = k;
}
work(0, m - 1);
double ans = 1e9;
for (__typeof((f[0]).end()) i = (f[0]).begin(); i != (f[0]).end(); ++i)
repl(ans, i->f());
printf("%.10lf\n", sqrt(ans));
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long powm(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = (res * a) % 998244353;
a = (a * a) % 998244353;
b >>= 1;
}
return res;
}
long long findMMI_fermat(long long n, long long m) { return powm(n, m - 2); }
signed main(void) {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long q;
cin >> q;
while (q--) {
long long a, b, c, d;
cin >> a >> b >> c >> d;
long long x = a + b;
if (x % 2) {
if (c > 0 || d > 0) {
if (c > 0 && d > 0) {
cout << "Ya Ya Tidak Tidak" << '\n';
} else if (c > 0) {
if (a > 0)
cout << "Ya Ya Tidak Tidak" << '\n';
else
cout << "Tidak Ya Tidak Tidak" << '\n';
} else {
if (b > 0)
cout << "Ya Ya Tidak Tidak" << '\n';
else
cout << "Ya Tidak Tidak Tidak" << '\n';
}
} else {
if (a > 0 && b > 0) {
cout << "Ya Ya Tidak Tidak" << '\n';
} else if (a > 0) {
cout << "Ya Tidak Tidak Tidak" << '\n';
} else if (b > 0) {
cout << "Tidak Ya Tidak Tidak" << '\n';
}
}
} else {
if (a > 0 || b > 0) {
if (a > 0 && b > 0) {
cout << "Tidak Tidak Ya Ya" << '\n';
} else if (a > 0) {
if (c > 0)
cout << "Tidak Tidak Ya Ya" << '\n';
else
cout << "Tidak Tidak Tidak Ya" << '\n';
} else {
if (d > 0)
cout << "Tidak Tidak Ya Ya" << '\n';
else
cout << "Tidak Tidak Ya Tidak" << '\n';
}
} else {
if (c > 0 && d > 0) {
cout << "Tidak Tidak Ya Ya" << '\n';
} else if (c > 0) {
cout << "Tidak Tidak Ya Tidak" << '\n';
} else if (d > 0) {
cout << "Tidak Tidak Tidak Ya" << '\n';
}
}
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int w = INT_MAX, b = INT_MAX;
char A[8][8];
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 8; j++) {
cin >> A[i][j];
}
}
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 8; j++) {
if (A[i][j] == 'B') {
int k = i + 1;
int itung = 0;
bool cek = 1;
while (k < 8) {
if (A[k][j] == 'W') {
cek = 0;
break;
}
k++;
itung++;
}
if (cek) b = min(b, itung);
} else if (A[i][j] == 'W') {
int k = i - 1;
int itung = 0;
bool cek = 1;
while (k >= 0) {
if (A[k][j] == 'B') {
cek = 0;
break;
}
k--;
itung++;
}
if (cek) w = min(w, itung);
}
}
}
if (w <= b)
cout << 'A' << endl;
else
cout << 'B' << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, M;
cin >> n >> M;
int a[101] = {0}, t[n], c, sub, i, s = 0, j;
for (i = 0; i < n; i++) {
cin >> t[i];
}
for (i = 0; i < n; i++) {
s = s + t[i];
if (s <= M)
cout << "0" << endl;
else {
c = 0;
sub = s - M;
for (j = 100; j >= 0; j--) {
if (a[j] != 0) {
sub = sub - (a[j] * j);
if (sub <= 0) {
c = c + (a[j] - (abs(sub) / j));
break;
}
c = c + a[j];
}
}
cout << c << endl;
}
a[t[i]]++;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<string> v[150];
vector<string> ans;
int main() {
int n, m, i, j, cnt = 0;
cin >> n;
string s;
for (i = 1; i <= n; i++) {
cin >> s;
v[s.size()].push_back(s);
cnt += s.size();
}
char d;
cin >> d;
cnt = cnt * 2 / n;
for (i = 1; i <= 10; i++) {
sort(v[i].begin(), v[i].end());
}
for (i = 1; i <= cnt / 2 - (1 - cnt % 2); i++) {
for (j = 0; j < v[i].size(); j++) {
string t, r;
t = v[i][j] + d + v[cnt - i][j];
r = v[cnt - i][j] + d + v[i][j];
ans.push_back(min(t, r));
}
}
if (cnt % 2 == 0) {
for (i = 0; i < v[cnt / 2].size(); i += 2) {
ans.push_back(v[cnt / 2][i] + d + v[cnt / 2][i + 1]);
}
}
sort(ans.begin(), ans.end());
for (i = 0; i < ans.size(); i++) cout << ans[i] << endl;
}
| 6 |
#include<bits/stdc++.h>
#define ll long long
#define For(i,a,b) for(int i=a;i<b;i++)
#define rFor(i,a,b) for(int i=a;i>=b;i--)
#define mFor(it,m) for(auto it=m.begin(); it!=m.end(); it++)
using namespace std;
int main()
{
int t;
cin>>t;
while(t--)
{
ll n,x,count=0;
cin>>n>>x;
map<ll,ll> m;
ll a[n];
For(i,0,n)
{
cin>>a[i];
m[a[i]%x]++;
}
mFor(i,m)
{
if(i->second!=0)
{
ll y=x-i->first;
if(m[y])
{
if(m[y]==i->second)
count++;
else
{
count++;
count+=(abs(m[y]-m[i->first])-1);
}
m[y]=0;
m[i->first]=0;
}
else if(i->first==0)
{
count++;
}
else
{
count+=(i->second);
}
}
}
cout<<count<<"\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10;
int n, a[MAXN << 1], MX[MAXN << 1][19], MN[MAXN << 1][19], ans[MAXN], MXX,
MNN = 1e9;
int read() {
int sss = 0, fff = 1;
char ccc;
ccc = getchar();
while (ccc < '0' || ccc > '9') {
if (ccc == '-') fff = -1;
ccc = getchar();
}
while (ccc >= '0' && ccc <= '9')
sss = (sss << 1) + (sss << 3) + (ccc ^ '0'), ccc = getchar();
return sss * fff;
}
int MinST(int l, int r) {
int len = r - l + 1;
int k = log2(len);
if (a[MN[l][k]] < a[MN[r - (1 << k) + 1][k]]) return MN[l][k];
return MN[r - (1 << k) + 1][k];
}
int MaxST(int l, int r) {
int len = r - l + 1;
int k = log2(len);
if (a[MX[l][k]] > a[MX[r - (1 << k) + 1][k]]) return MX[l][k];
return MX[r - (1 << k) + 1][k];
}
int Min(int l, int r) {
int x = a[l - 1];
while (l < r) {
int mid = (l + r) >> 1;
if (a[MinST(l, mid)] * 2 >= x)
l = mid + 1;
else
r = mid;
}
return l;
}
int Max(int l, int r) {
int x = a[l - 1];
while (l < r) {
int mid = (l + r) >> 1;
if (a[MaxST(l, mid)] < x)
l = mid + 1;
else
r = mid;
}
return l;
}
int solve(int x) {
if (ans[x]) return ans[x];
int A = Min(x + 1, x + n), B = Max(x + 1, x + n);
if (A < B)
return ans[x] = A - x;
else
return ans[x] = B - x + solve((B - 1) % n + 1);
}
int main() {
n = read();
for (int i = 1; i <= n; i++)
a[i] = a[i + n] = read(), MX[i][0] = MN[i][0] = i,
MX[i + n][0] = MN[i + n][0] = i + n, MXX = max(MXX, a[i]),
MNN = min(MNN, a[i]);
if (MNN * 2 >= MXX) {
for (int j = 1; j <= n; j++) printf("-1 ");
return 0;
}
for (int k = 1; k <= 18; k++) {
int len = 1 << k;
for (int i = 1; i + len - 1 <= n * 2; i++) {
int j = i + len - 1, mid = i + (len / 2);
if (a[MX[i][k - 1]] < a[MX[mid][k - 1]])
MX[i][k] = MX[mid][k - 1];
else
MX[i][k] = MX[i][k - 1];
if (a[MN[i][k - 1]] > a[MN[mid][k - 1]])
MN[i][k] = MN[mid][k - 1];
else
MN[i][k] = MN[i][k - 1];
}
}
for (int i = 1; i <= n; i++) ans[i] = solve(i);
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int comp(const void* a, const void* b) { return (*(int*)a - *(int*)b); }
struct vidr {
int x;
int y;
};
int main() {
int a[100][100];
int m, n;
cin >> m >> n;
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
cin >> a[i][j];
}
}
int m1 = m;
bool q = true;
while (m1 % 2 == 0) {
for (int i = 0; i < m1 / 2; i++) {
for (int j = 0; j < n; j++) {
if (a[i][j] != a[m1 - i - 1][j]) {
q = false;
break;
}
}
if (!q) {
break;
}
}
if (!q) {
break;
}
m1 /= 2;
}
cout << m1;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
vector<int> v;
int r, g, b;
cin >> r >> g >> b;
v.push_back(r);
v.push_back(g);
v.push_back(b);
sort(v.begin(), v.end());
if (v[0] + v[1] <= v[2])
cout << v[0] + v[1] << endl;
else
cout << (v[0] + v[1] + v[2]) / 2 << endl;
v.clear();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
char a[2005][2005];
int main() {
int n = 0;
scanf("%d", &n);
int k = 0;
int a = 0, b = 0, c = 0, d = 0;
for (int i = 0; i < n; i++) {
scanf("%1d", &k);
if (k == 1 || k == 2 || k == 3) a = 1;
if (k == 1 || k == 4 || k == 7) b = 1;
if (k == 3 || k == 6 || k == 9) d = 1;
if (k == 7 || k == 9) c = 1;
if (k == 0) b = 1, c = 1, d = 1;
}
if (a + b + c + d == 4)
printf("YES\n");
else
printf("NO\n");
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int>> RLE(string s) {
vector<pair<int, int>> v;
for (int i = 0; i < s.size(); i++) {
if (v.size() and v.back().first == s[i] - 'a') {
v.back().second++;
} else
v.push_back({s[i] - 'a', 1});
}
return v;
}
int dp[2][26];
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
vector<pair<int, int>> v = RLE(s);
for (int j = 0; j < 26; j++) {
if (dp[(i % 2) ^ 1][j] > 0)
dp[i % 2][j] = 1;
else
dp[i % 2][j] = 0;
}
for (auto p : v) {
dp[i % 2][p.first] = max(dp[i % 2][p.first], p.second);
}
if (v.size() == 1) {
dp[i % 2][v[0].first] =
max(dp[i % 2][v[0].first],
(dp[(i % 2) ^ 1][v[0].first] + 1) * v[0].second +
dp[(i % 2) ^ 1][v[0].first]);
} else {
if (v[0].first == v.back().first and dp[(i % 2) ^ 1][v[0].first]) {
dp[i % 2][v[0].first] =
max(dp[i % 2][v[0].first], v[0].second + v.back().second + 1);
}
if (dp[(i % 2) ^ 1][v[0].first]) {
dp[i % 2][v[0].first] = max(dp[i % 2][v[0].first], 1 + v[0].second);
}
if (dp[(i % 2) ^ 1][v.back().first]) {
dp[i % 2][v.back().first] =
max(dp[i % 2][v.back().first], 1 + v.back().second);
}
}
for (int j = 0; j < 26; j++) {
dp[(i % 2) ^ 1][j] = dp[i % 2][j];
}
}
int res = 0;
for (int i = 0; i < 26; i++) {
res = max(res, dp[n % 2][i]);
}
cout << res << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T Abs(T first) {
return (first < 0 ? -first : first);
}
template <typename T>
T Sqr(T first) {
return (first * first);
}
string plural(string s) {
return (int((s).size()) && s[int((s).size()) - 1] == 'x' ? s + "en"
: s + "s");
}
const int INF = (int)1e9;
const double EPS = 1e-6;
const long double PI = acos(-1.0);
bool Read(int &first) {
char c, r = 0, n = 0;
first = 0;
for (;;) {
c = getchar();
if ((c < 0) && (!r)) return (0);
if ((c == '-') && (!r))
n = 1;
else if ((c >= '0') && (c <= '9'))
first = first * 10 + c - '0', r = 1;
else if (r)
break;
}
if (n) first = -first;
return (1);
}
bool ReadLL(long long &first) {
char c, r = 0, n = 0;
first = 0;
for (;;) {
c = getchar();
if ((c < 0) && (!r)) return (0);
if ((c == '-') && (!r))
n = 1;
else if ((c >= '0') && (c <= '9'))
first = first * 10 + c - '0', r = 1;
else if (r)
break;
}
if (n) first = -first;
return (1);
}
int main() {
if (0) freopen("in.txt", "r", stdin);
int N[2], M, K;
int i, j, k, a, b, c, first, second, z;
unsigned long long ans, cur;
static int V[2][100005];
static unsigned long long sum[2][100005];
Read(N[0]), Read(N[1]);
for (i = 0; i < 2; i++) {
for (j = 0; j < N[i]; j++) Read(V[i][j]);
sort(V[i], V[i] + N[i]);
reverse(V[i], V[i] + N[i]);
for (j = 0; j < N[i]; j++) sum[i][j + 1] = sum[i][j] + V[i][j];
}
ans = -1;
for (z = 0; z < 2; z++)
for (i = 1; i <= N[z]; i++) {
cur = sum[z][N[z]] - sum[z][i];
cur += sum[1 - z][N[1 - z]] * i;
if (ans < 0)
ans = cur;
else
ans = min(ans, cur);
}
cout << ans << endl;
return (0);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int N, K;
vector<int> adj[200005];
int dep[200005];
int par[200005];
int sz[200005];
long long cnttot[5];
long long dp[200005][5];
long long pass[200005][5];
long long add[200005][5];
inline int get(int x) {
while (x < 0) x += K;
while (x >= K) x -= K;
return x;
}
void dfs(int cur) {
sz[cur] = 1;
dep[cur] = dep[par[cur]] + 1;
pass[cur][0] = 1;
long long c[5];
for (int i = 0; i < K; i++) c[i] = 0;
for (int i = 0; i < adj[cur].size(); i++) {
int nxt = adj[cur][i];
if (nxt == par[cur]) continue;
par[nxt] = cur;
dfs(nxt);
sz[cur] += sz[nxt];
for (int j = 0; j <= K; j++) c[j] = c[j] + pass[nxt][get(j - 1)];
}
for (int j = 0; j < K; j++) pass[cur][j] += c[j];
for (int i = 0; i < adj[cur].size(); i++) {
int nxt = adj[cur][i];
if (nxt == par[cur]) continue;
for (int j = 0; j < K; j++) c[j] = c[j] - pass[nxt][get(j - 1)];
for (int j = 0; j < K; j++) {
for (int k = 0; k < K; k++) {
add[cur][get(j + k)] =
add[cur][get(j + k)] + (long long)(c[j] * pass[nxt][get(k - 1)]);
}
}
for (int j = 0; j < K; j++) c[j] = c[j] + pass[nxt][get(j - 1)];
for (int j = 0; j < K; j++) {
dp[cur][j] = dp[cur][j] + dp[nxt][j];
}
}
for (int j = 0; j < K; j++) {
dp[cur][j] = dp[cur][j] + pass[cur][j];
dp[cur][j] = dp[cur][j] + add[cur][j] / (long long)2;
}
}
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> N >> K;
memset(cnttot, 0, sizeof(cnttot));
memset(dp, 0, sizeof(dp));
memset(pass, 0, sizeof(pass));
memset(add, 0, sizeof(add));
for (int i = 0; i < N - 1; i++) {
int a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
par[1] = 1;
dep[1] = 0;
dfs(1);
long long ans = 0;
for (int i = 1; i < K; i++) cnttot[i] = dp[1][i];
for (int i = 1; i <= N; i++) {
long long res = (long long)sz[i];
res = (long long)(res * (long long)(sz[1] - sz[i]));
ans += res;
}
if (K == 1) {
cout << ans << endl;
return 0;
}
for (int i = 1; i < K; i++) {
ans = ans + (long long)((long long)cnttot[i] * (long long)(K - i));
}
ans = ans / (long long)K;
cout << ans << endl;
}
| 6 |
#include <bits/stdc++.h>
#define rep(i, l, r) for(int i = (l); i <= (r); i++)
#define per(i, r, l) for(int i = (r); i >= (l); i--)
#define mem(a, b) memset(a, b, sizeof a)
#define For(i, l, r) for(int i = (l), i##e = (r); i < i##e; i++)
using namespace std;
typedef long long ll;
const int N = 1e5 + 5;
int n, K, a[N];
ll f[N][40], ans[N];
vector <int> G[N];
void add(int u, int v) {
For(i, 0, K) f[u][(i + 1) % K] ^= f[v][i];
}
void dfs(int u, int fa) {
f[u][0] = a[u];
for(int v : G[u]) if(v ^ fa) dfs(v, u), add(u, v);
}
void Dfs(int u, int fa) {
For(i, K / 2, K) ans[u] ^= f[u][i];
for(int v : G[u]) if(v ^ fa) add(u, v), add(v, u), Dfs(v, u), add(v, u), add(u, v);
}
int main() {
#ifdef local
// freopen(".in", "r", stdin);
#endif
cin >> n >> K, K *= 2;
int u, v;
rep(i, 2, n) {
scanf("%d%d", &u, &v);
G[u].push_back(v), G[v].push_back(u);
}
rep(i, 1, n) scanf("%d", &a[i]);
dfs(1, 0), Dfs(1, 0);
rep(i, 1, n) printf("%d ", ans[i] != 0);
return 0;
} | 8 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.