solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void join(vector<T>& arr, string sep) {
bool first = true;
for (auto t : arr) {
if (first) {
first = false;
cout << t;
} else {
cout << sep << t;
}
}
cout << "\n";
}
string convertToNewString(vector<char>& qq) {
string s(qq.begin(), qq.end());
string newString = "@";
for (int i = 0; i < s.size(); i++) {
newString += "#" + s.substr(i, 1);
}
newString += "#$";
return newString;
}
string longestPalindromeSubstringSuffix(const string& s, long long left,
long long right) {
if (left > right) return "";
vector<char> qq;
for (long long i = (long long)(left); i < (long long)(right + 1); ++i) {
qq.push_back(s[i]);
}
string Q = convertToNewString(qq);
vector<int> P(Q.size(), 0);
int c = 0, r = 0;
for (int i = 1; i < Q.size() - 1; i++) {
int iMirror = c - (i - c);
if (r > i) {
P[i] = min(r - i, P[iMirror]);
}
while (Q[i + 1 + P[i]] == Q[i - 1 - P[i]]) {
P[i]++;
}
if (i + P[i] > r) {
c = i;
r = i + P[i];
}
}
int maxPalindrome = 0;
int centerIndex = 0;
for (int i = 1; i < Q.size() - 1; i++) {
if (P[i] > maxPalindrome) {
{
int start = (i - 1 - P[i]) / 2;
int end = start + P[i];
if (end != qq.size()) continue;
maxPalindrome = P[i];
centerIndex = i;
}
}
}
string ss(qq.begin(), qq.end());
return ss.substr((centerIndex - 1 - maxPalindrome) / 2, maxPalindrome);
}
string longestPalindromeSubstringPrefix(const string& s, long long left,
long long right) {
if (left > right) return "";
vector<char> qq;
for (long long i = (long long)(left); i < (long long)(right + 1); ++i) {
qq.push_back(s[i]);
}
string Q = convertToNewString(qq);
vector<int> P(Q.size(), 0);
int c = 0, r = 0;
for (int i = 1; i < Q.size() - 1; i++) {
int iMirror = c - (i - c);
if (r > i) {
P[i] = min(r - i, P[iMirror]);
}
while (Q[i + 1 + P[i]] == Q[i - 1 - P[i]]) {
P[i]++;
}
if (i + P[i] > r) {
c = i;
r = i + P[i];
}
}
int maxPalindrome = 0;
int centerIndex = 0;
for (int i = 1; i < Q.size() - 1; i++) {
if (P[i] > maxPalindrome) {
{
int start = (i - 1 - P[i]) / 2;
if (start != 0) continue;
maxPalindrome = P[i];
centerIndex = i;
}
}
}
string ss(qq.begin(), qq.end());
return ss.substr((centerIndex - 1 - maxPalindrome) / 2, maxPalindrome);
}
void solve() {
string s;
cin >> s;
long long i = 0;
long long n = s.size();
if (n <= 1) {
cout << s << "\n";
return;
}
deque<char> starts;
deque<char> ends;
while (i < n / 2 && s[i] == s[n - 1 - i]) {
starts.push_back(s[i]);
ends.push_front(s[i]);
i++;
}
long long left = i;
long long right = n - 1 - i;
string prefix = longestPalindromeSubstringPrefix(s, left, right);
string suffix = longestPalindromeSubstringSuffix(s, left, right);
if (suffix.size() > prefix.size()) swap(prefix, suffix);
cout << string(starts.begin(), starts.end()) << prefix
<< string(ends.begin(), ends.end()) << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int tt;
cin >> tt;
for (int t = 1; t <= tt; t++) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
string s;
int n;
vector<int> ans;
bool check(int cl, int b, int turn) {
if (turn == n) return true;
for (int i = 1; i < s.size(); i++) {
bool k = true;
if (s[i] == '1' && i > cl && i != b) {
if (check(i - cl, i, turn + 1)) {
ans.push_back(i);
k = false;
}
}
if (k == false) return true;
}
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> s;
cin >> n;
s = " " + s;
if (check(0, 0, 0) == true) {
cout << "YES\n";
for (int i = ans.size() - 1; i >= 0; i--) cout << ans[i] << " ";
} else
cout << "NO";
}
| 4 |
#include <bits/stdc++.h>
int main(void) {
int t;
scanf("%d", &t);
while (t--) {
int l, i, f = 0;
scanf("%d", &l);
char a[l + 1];
scanf("%s", a);
for (i = 0; i < l / 2; i++) {
if (a[i] == a[l - 1 - i] || abs(a[i] - a[l - i - 1]) == 2)
continue;
else {
f = 1;
break;
}
}
if (f == 0)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, n, x, y, loc;
cin >> n >> x >> y;
int a[n + 1];
for (i = 1; i <= n; i++) {
cin >> a[i];
}
for (i = 1; i <= n; i++) {
int flag = 0;
for (j = i - x; j <= i + y; j++) {
if (j >= 1 && j <= n) {
if (a[i] <= a[j]) {
loc = i;
} else {
flag = 1;
break;
}
}
}
if (flag == 1)
continue;
else {
goto finish;
}
}
finish:
cout << loc;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long M = 10004205361450474;
long long dp[10010][6];
long long t[10010];
int main() {
for (int i = 1; i <= 10000; i++) dp[i][0] = 0;
for (int j = 1; j <= 4; j++)
for (int i = 1; i <= 10000; i++) {
long long now = i;
dp[i][j] = dp[i][j - 1];
now = min(i + dp[i][j - 1] + 1, (long long)10000);
for (int k = 1; k <= i; k++) {
if (now == 10000) {
dp[i][j] += (dp[now][j - 1] + 1) * (i - k + 1);
break;
}
dp[i][j] += dp[now][j - 1] + 1;
now = min(now + dp[now][j - 1] + 1, (long long)10000);
}
}
long long now = 1;
for (int i = 4; i >= 0; i--) {
long long num = now;
t[0] = now - 1;
int tot = 0;
for (int j = 1; j <= min(now, (long long)10000); j++) {
num += dp[min(num, (long long)10000)][i];
if (num > M) break;
t[++tot] = num;
num++;
}
printf("%d ", tot);
for (int j = 1; j <= tot; j++) printf("%I64d ", t[j]);
printf("\n");
fflush(stdout);
int pos;
scanf("%d", &pos);
if (pos < 0) return 0;
now = t[pos] + 1;
}
return ~~(0 - 0);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b;
string s;
cin >> a >> b >> s;
int dix = 1, diy = 1;
if (a < 0) dix = -1, a = -a;
if (b < 0) diy = -1, b = -b;
map<char, int> dx, dy;
dx['U'] = 0;
dx['D'] = 0;
dx['L'] = -1;
dx['R'] = 1;
dy['U'] = 1;
dy['D'] = -1;
dy['L'] = 0;
dy['R'] = 0;
long long mx = 0, my = 0;
for (int i = 0; i < (int)(s.size()); i++) {
mx += dix * dx[s[i]];
my += diy * dy[s[i]];
}
bool ok = false;
long long x = 0, y = 0;
for (int _ = 0; _ < (int)(1000); _++) {
if (x < a - 200) {
if (mx <= 0) break;
long long t = (a - 200 - x) / mx;
x += t * mx;
y += t * my;
}
if (y < b - 200) {
if (my <= 0) break;
long long t = (b - 200 - y) / my;
x += t * mx;
y += t * my;
}
if (x == a && y == b) ok = true;
for (int i = 0; i < (int)(s.size()); i++) {
x += dix * dx[s[i]];
y += diy * dy[s[i]];
if (x == a && y == b) ok = true;
}
}
puts(ok ? "Yes" : "No");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char a[55];
scanf("%s", a);
int len = strlen(a);
int count = 0, c = 0;
for (int i = 0; i < len - 1; i++) {
if (a[i] == a[i + 1]) count++;
}
for (int i = 0; i < len; i++) {
if (a[i] != a[len - i - 1]) {
c++;
}
}
if (count == len - 1)
cout << 0 << endl;
else if (c == 0)
cout << len - 1 << endl;
else
cout << len << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int x[100000];
int y[100000];
int n, a;
const double PI = acos(-1);
double normalize(double theta) {
if (theta < -PI) theta += 2 * PI;
if (theta >= PI) theta -= 2 * PI;
return theta;
}
bool seen[100005];
bool can(double r) {
vector<pair<double, int> > events;
for (int i = 0; i < n; i++) {
double R = hypot(x[i] + a, y[i]);
double d = hypot(x[i] - a, y[i]);
if (R + d <= r) continue;
if (R + r <= d) continue;
if (r + d <= R) continue;
double base = atan2(y[i], a - x[i]);
double theta = acos((r * r + d * d - R * R) / (2 * r * d));
events.push_back(pair<double, int>(normalize(base - theta), i));
events.push_back(pair<double, int>(normalize(base + theta), i));
}
sort(events.begin(), events.end());
stack<int> s;
memset(seen, 0, sizeof(seen));
for (auto out : events) {
if (seen[out.second]) {
if ((int)(s).size() == 0 || s.top() - out.second) return true;
s.pop();
} else {
s.push(out.second);
seen[out.second] = true;
}
}
return false;
}
void solve() {
cin >> n >> a;
for (int i = 0; i < n; i++) cin >> x[i] >> y[i];
double lhs = 0;
double rhs = 2 * a;
for (int qq = 0; qq < 50; qq++) {
double mid = (lhs + rhs) / 2;
if (can(mid))
rhs = mid;
else
lhs = mid;
}
cout << fixed << setprecision(12) << rhs << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
}
| 12 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
const long long INF = 1e9;
const long long MOD = 1e9 + 7;
const int NMAX = 50;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
vector<long long> del(long long n) {
vector<long long> ans;
long long i = 1;
for (i = 1; i * i < n; i++) {
if (n % i == 0) {
ans.push_back(i);
ans.push_back(n / i);
}
}
if (n % i == 0) ans.push_back(i);
sort((ans).begin(), (ans).end());
return ans;
}
void solve() {
int n, x;
cin >> n >> x;
int Max = INT_MIN;
bool kek = false;
int ans = INT_MAX;
for (int i = 0; i < n; i++) {
int y;
cin >> y;
if (y > x)
ans = min(ans, 2);
else
ans = min(int(ceil(x / double(y))), ans);
}
cout << ans << "\n";
}
int main() {
srand(time(0));
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) solve();
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct hammer {
double x[4];
double y[4];
} box[200];
int n, m;
double xt;
double yt;
int main() {
cin >> n;
box[1].x[3] = box[1].y[3] = 0;
box[1].x[2] = 10;
box[1].y[2] = 0;
double agg = 10 * cos(acos(-1) * 72.0 / 180.0);
double aee = 10 * sin(acos(-1) * 72.0 / 180.0);
box[1].x[1] = 10 + agg;
box[1].y[1] = aee;
box[1].x[0] = 5;
box[1].y[0] = aee + 10 * sin(acos(-1) * 36.0 / 180.0);
xt = -agg;
yt = aee;
for (int i = 2; i <= n; i++) {
box[i].x[3] = box[i - 1].x[2] + 2 * agg;
box[i].y[3] = 0;
box[i].x[2] = box[i].x[3] + 10;
box[i].y[2] = 0;
box[i].x[1] = box[i].x[2] + agg;
box[i].y[1] = box[i - 1].y[1];
box[i].x[0] = box[i].x[3] + 5;
box[i].y[0] = box[i - 1].y[0];
}
if (n == 1) {
cout << 5 << endl;
printf("%.10f %.10f\n", xt, yt);
for (int i = 0; i < 4; i++)
printf("%.10f %.10f\n", box[1].x[i], box[1].y[i]);
cout << 1 << " " << 2 << " " << 3 << " " << 4 << " " << 5 << endl;
cout << 1 << " " << 3 << " " << 5 << " " << 2 << " " << 4 << " " << 1
<< endl;
} else {
cout << n * 4 + 1 << endl;
printf("%.10f %.10f\n", xt, yt);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 4; j++)
printf("%.10f %.10f\n", box[i].x[j], box[i].y[j]);
}
cout << 1 << " " << 2 << " " << 3 << " " << 4 << " " << 5 << endl;
for (int i = 2; i <= n; i++) {
cout << i * 4 - 5 << " ";
cout << 4 * i - 2 << " ";
cout << i * 4 - 1 << " ";
cout << i * 4 << " ";
cout << i * 4 + 1 << endl;
}
cout << 1 << " ";
for (int i = 2; i <= n; i++) cout << i * 4 - 5 << " ";
cout << n * 4 - 1 << " ";
for (int i = n; i >= 2; i--)
cout << i * 4 + 1 << " " << i * 4 - 2 << " " << i * 4 << " " << i * 4 - 5
<< " ";
cout << 5 << " " << 2 << " " << 4 << " " << 1 << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, x = 1;
char str[10];
for (i = 0; i < 8; i++) {
scanf("%s", str);
for (j = 0; j < 7; j++)
if (str[j] == str[j + 1]) {
x = 0;
break;
}
}
if (x == 1)
printf("YES");
else
printf("NO");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a, b, c;
int main() {
cin >> a >> b;
if (a == b)
cout << a;
else
cout << 2;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T>
inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
int n, m;
bool isPrime[10000005];
int sp[10000005];
map<int, int> num;
map<int, int> den;
vector<int> up;
vector<int> down;
void sieve() {
memset(isPrime, 1, sizeof(isPrime));
memset(sp, 0, sizeof(sp));
isPrime[1] = 0;
for (int i = 2; i * i < 10000005; ++i) {
if (isPrime[i]) {
sp[i] = i;
for (int j = i * 2; j < 10000005; j += i) {
isPrime[j] = 0;
if (!sp[j]) sp[j] = i;
}
}
}
for (int i = 2; i < 10000005; ++i)
if (!sp[i]) sp[i] = i;
}
bool marked[10000005];
int main() {
scanf("%d %d", &n, &m);
sieve();
memset(marked, 0, sizeof(marked));
up.resize(n);
down.resize(m);
for (int i = 0; i < n; ++i) scanf("%d", &up[i]);
for (int i = 0; i < m; ++i) scanf("%d", &down[i]);
for (int j = 0; j < ((int)(up.size())); ++j) {
int curr = up[j];
while (curr > 1) {
num[sp[curr]]++;
curr /= sp[curr];
}
}
for (int j = 0; j < ((int)(down.size())); ++j) {
int curr = down[j];
while (curr > 1) {
den[sp[curr]]++;
curr /= sp[curr];
}
}
int szUp = 0;
int szDown = 0;
map<int, int>::iterator it = num.begin();
vector<pair<long long, int> > ansUp;
vector<pair<long long, int> > ansDown;
for (; it != num.end(); ++it) {
int primeUp = it->first;
int powerUp = it->second;
int primeDown = primeUp;
int powerDown = 0;
if (den.find(primeDown) != den.end()) {
powerDown = den[primeDown];
marked[primeDown] = 1;
if (powerUp > powerDown) {
powerUp -= powerDown;
powerDown = 0;
} else {
powerDown -= powerUp;
powerUp = 0;
}
}
if (powerUp != 0) ansUp.push_back(pair<long long, int>(primeUp, powerUp));
if (powerDown != 0)
ansDown.push_back(pair<long long, int>(primeDown, powerDown));
}
it = den.begin();
for (; it != den.end(); ++it) {
if (!marked[it->first]) {
szDown += it->second;
ansDown.push_back(pair<long long, int>(it->first, it->second));
}
}
szUp = ((int)(ansUp.size()));
szDown = ((int)(ansDown.size()));
if (szUp == 0) {
szUp++;
ansUp.push_back(pair<int, int>(1, 1));
}
if (szDown == 0) {
ansDown.push_back(pair<int, int>(1, 1));
szDown++;
}
vector<int> upFin;
vector<int> downFin;
for (int j = 0; j < ((int)(ansUp.size())); ++j) {
int cnt = ansUp[j].second;
while (cnt--) upFin.push_back(ansUp[j].first);
}
for (int j = 0; j < ((int)(ansDown.size())); ++j) {
int cnt = ansDown[j].second;
while (cnt--) downFin.push_back(ansDown[j].first);
}
int sz = ((int)(upFin.size()));
vector<int> ahoUp;
sort(upFin.rbegin(), upFin.rend());
sort(downFin.rbegin(), downFin.rend());
priority_queue<int, std::vector<int>, std::greater<int> > pq;
int cnt = 0;
int i = 0;
for (; i < sz && cnt < 100000; ++i) {
pq.push(upFin[i]);
++cnt;
}
for (; i < sz; ++i) {
int num = pq.top();
pq.pop();
num *= upFin[i];
pq.push(num);
}
while (!pq.empty()) {
ahoUp.push_back(pq.top());
pq.pop();
}
sz = ((int)(downFin.size()));
vector<int> ahoDown;
i = 0;
cnt = 0;
for (; i < sz && cnt < 100000; ++i) {
pq.push(downFin[i]);
++cnt;
}
for (; i < sz; ++i) {
int num = pq.top();
pq.pop();
num *= downFin[i];
pq.push(num);
}
while (!pq.empty()) {
ahoDown.push_back(pq.top());
pq.pop();
}
printf("%d %d", ((int)(ahoUp.size())), ((int)(ahoDown.size())));
puts("");
for (int j = 0; j < ((int)(ahoUp.size())); ++j) printf("%d ", ahoUp[j]);
puts("");
for (int j = 0; j < ((int)(ahoDown.size())); ++j) printf("%d ", ahoDown[j]);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long id = 1, x, y, q, i, j;
long double s, ans, temp;
vector<long long> a;
cin >> q;
cin >> x >> y;
a.push_back(y);
s = y * 1.0;
for (i = 1; i < q; i++) {
scanf("%lld", &x);
if (x == 2) {
ans = a.back() * 1.0000 -
(a.back() * 1.0 + s) / ((id + 1.0000000) * 1.000000);
cout << std::setprecision(9) << ans << endl;
} else {
cin >> y;
a.push_back(y);
while (id < a.size()) {
temp = (s + a.back() + a[id]) / (id + 2.00000000);
if (temp < a[id])
break;
else {
s += a[id];
id++;
}
}
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
vector<int> v[maxn];
int f[maxn];
int du[maxn];
int n;
struct node {
int cnt, deep;
};
int pos;
void work() {
queue<node> q;
node c;
c.cnt = 1;
c.deep = 0;
q.push(c);
int ans = -1;
pos = -1;
while (!q.empty()) {
node d = q.front();
q.pop();
f[d.cnt] = 1;
if (ans < d.deep) {
ans = d.deep;
pos = d.cnt;
}
for (int i = 0; i < v[d.cnt].size(); i++) {
if (f[v[d.cnt][i]]) continue;
c.deep = d.deep + 1;
c.cnt = v[d.cnt][i];
q.push(c);
}
}
}
void bfs() {
queue<node> q;
node c;
c.cnt = pos;
c.deep = 0;
q.push(c);
int ans = -1;
while (!q.empty()) {
node d = q.front();
q.pop();
f[d.cnt] = 1;
if (ans < d.deep) {
ans = d.deep;
pos = d.cnt;
}
for (int i = 0; i < v[d.cnt].size(); i++) {
if (f[v[d.cnt][i]]) continue;
c.deep = d.deep + 1;
c.cnt = v[d.cnt][i];
q.push(c);
}
}
printf("%d\n", ans);
}
int main() {
int m;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
v[a].push_back(b);
v[b].push_back(a);
du[b]++;
}
work();
memset(f, 0, sizeof(f));
bfs();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> dp(2002);
vector<int> cumdp(2002);
int main() {
ios_base::sync_with_stdio(false);
string s;
cin >> s;
dp[0] = 1;
int n = s.length();
cumdp[0] = 1;
for (register int i = 1; i < n; i++) {
dp[i] = 1;
for (register int j = 0; j < i; j++) {
if (s[i] >= s[j] && dp[i] < dp[j] + 1) {
dp[i] = dp[j] + 1;
}
}
cumdp[i] = max(cumdp[i - 1], dp[i]);
}
string t = "";
for (register int i = 0; i < n; i++) {
t += '0';
}
stack<int> st;
st.push(0);
for (register int i = 1; i < n; i++) {
if (cumdp[i] == cumdp[i - 1]) {
t[st.top()] = '1';
st.pop();
} else {
st.push(i);
}
}
cout << t << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
set<pair<int, int> > a, b;
int f[100005], g[100005];
int main() {
int n, s, l, i, x = 0;
scanf("%d%d%d", &n, &s, &l);
for (i = 1; i <= n; i++) scanf("%d", &g[i]);
a.clear();
b.clear();
f[0] = 0;
for (i = 1; i <= n; i++) {
a.insert(make_pair(g[i], i));
while (a.rbegin()->first - a.begin()->first > s) {
b.erase(make_pair(f[x], x));
x++;
a.erase(make_pair(g[x], x));
}
if (i >= l && a.size() >= l) {
if (f[i - l] >= 0) b.insert(make_pair(f[i - l], i - l));
}
if (b.size() == 0)
f[i] = -1;
else
f[i] = b.begin()->first + 1;
}
printf("%d\n", f[n]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, k = 0, c = 1, a[6], res[2], n = 0;
cin >> a[0] >> a[1] >> a[2] >> a[3] >> a[4] >> a[5];
sort(a, a + 6);
for (i = 1; i < 6; i++) {
if (a[i] != a[i - 1]) c++;
}
if (c > 3)
cout << "Alien\n";
else if (c == 1)
cout << "Elephant\n";
else {
for (i = 0; i < 3; i++) {
if (a[i] == a[i + 1] && a[i] == a[i + 2] && a[i] == a[i + 3]) {
j = a[i];
break;
}
}
for (i = 0; i < 6; i++) {
if (a[i] != j) {
res[k] = a[i];
k++;
} else
n++;
}
if (n < 4)
cout << "Alien\n";
else if (n == 5)
cout << "Bear\n";
else {
if (res[0] == res[1])
cout << "Elephant\n";
else
cout << "Bear\n";
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int mp[27][27];
int dp[111][111][26];
bool flag[111][111][26];
char s[111];
inline void checkmax(int &a, int b) {
if (a < b) a = b;
}
int main() {
int i, j, k, n, m;
scanf("%s", s);
scanf("%d", &k);
scanf("%d", &n);
for (i = 1; i <= n; i++) {
getchar();
char ch1, ch2;
scanf("%c", &ch1);
getchar();
scanf("%c%d", &ch2, &m);
mp[ch1 - 'a'][ch2 - 'a'] = m;
}
memset(flag, 0, sizeof(flag));
for (i = 0; i < 26; i++) {
if (s[0] - 'a' == i) {
dp[0][0][i] = 0;
flag[0][0][i] = true;
} else if (k > 0) {
dp[0][1][i] = 0;
flag[0][1][i] = true;
}
}
for (i = 0; i < strlen(s) - 1; i++) {
for (j = 0; j <= k; j++)
for (int x = 0; x < 26; x++) {
if (!flag[i][j][x]) continue;
for (int y = 0; y < 26; y++)
if (s[i + 1] - 'a' == y) {
if (!flag[i + 1][j][y]) dp[i + 1][j][y] = dp[i][j][x] + mp[x][y];
flag[i + 1][j][y] = true;
checkmax(dp[i + 1][j][y], dp[i][j][x] + mp[x][y]);
} else if (j < k) {
if (!flag[i + 1][j + 1][y])
dp[i + 1][j + 1][y] = dp[i][j][x] + mp[x][y];
flag[i + 1][j + 1][y] = true;
checkmax(dp[i + 1][j + 1][y], dp[i][j][x] + mp[x][y]);
}
}
}
m = -999999999;
for (i = 0; i <= k; i++) {
for (j = 0; j < 26; j++) {
if (flag[strlen(s) - 1][i][j]) checkmax(m, dp[strlen(s) - 1][i][j]);
}
}
cout << m << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
long long n, k;
cin >> n >> k;
vector<long long> d;
for (long long i = 1; i * i <= n; i++) {
if (n % i == 0) {
d.push_back(i);
if ((n / i) != i) {
d.push_back(n / i);
}
}
}
sort(d.begin(), d.end());
if (k > d.size()) {
cout << -1 << endl;
} else {
cout << d[k - 1] << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int MOD = 1000000007;
long long power(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
void solve() {
int n, ans = 1;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
;
vector<int> dp(1000001, 0);
for (int i = n - 1; i >= 0; i--) {
dp[a[i]] = 1;
for (int j = 2 * a[i]; j <= 1e6; j += a[i]) {
dp[a[i]] = max(dp[a[i]], dp[j] + 1);
}
ans = max(ans, dp[a[i]]);
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int v, k;
edge(int _v, int _k) {
v = _v;
k = _k;
}
};
const int N = 1e5 + 5;
int n, ptr[N], f[N], par[N];
vector<edge> a[N];
vector<int> vec;
void enter() {
scanf("%d", &n);
for (int(i) = (1), _b = (n - 1); (i) <= _b; ++(i)) {
int u, v, k;
scanf("%d%d%d", &u, &v, &k);
a[u].push_back(edge(v, k));
a[v].push_back(edge(u, k));
}
}
void dfs() {
vector<int> stk;
par[1] = -1;
f[1] = 0;
stk.push_back(1);
while (!stk.empty()) {
int u = stk.back();
if (ptr[u] == a[u].size()) {
for (int(i) = (0), _b = (a[u].size() - 1); (i) <= _b; ++(i)) {
int v = a[u][i].v;
if (par[v] == u) {
f[u] += (f[v] == 0 && a[u][i].k == 2) ? f[v] + 1 : f[v];
if (f[v] == 0 && a[u][i].k == 2) vec.push_back(v);
}
}
ptr[u] = 0;
stk.pop_back();
continue;
}
for (; ptr[u] < a[u].size();) {
int v = a[u][ptr[u]++].v;
if (!par[v]) {
par[v] = u;
stk.push_back(v);
break;
}
}
}
}
void solve() {
dfs();
printf("%d\n", (int)vec.size());
for (int(i) = (0), _b = (vec.size() - 1); (i) <= _b; ++(i))
printf("%d ", vec[i]);
}
int main() {
enter();
solve();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
string s;
cin >> s;
while (m--) {
int l, r;
char c1, c2;
cin >> l >> r >> c1 >> c2;
for (int i = l - 1; i < r; i++) {
if (s[i] == c1) s[i] = c2;
}
}
cout << s;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void deb(initializer_list<T> l) {
for (auto &e : l) cout << e << ' ';
cout << '\n';
}
void solve() {
vector<long long> e(4);
for (auto &g : e) cin >> g;
sort(e.begin(), e.end());
cout << e[3] - e[0] << ' ' << e[3] - e[1] << ' ' << e[3] - e[2] << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int t{1};
while (t--) solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
bool mat[1000][1000];
int ans[1000][1000];
bool visited[1000][1000];
int way[4][2] = {{0, 1}, {-1, 0}, {1, 0}, {0, -1}};
bool inGrid(int i, int j, int N, int M) {
return ((0 <= i && i < N) && (0 <= j && j < M));
}
int realAnswers[1000 * 1000], counter = 0;
int N, M;
void DFS(int y, int x) {
visited[y][x] = 1;
ans[y][x] = counter;
for (long long i = 0; i < (long long)4; i++) {
int desty = y + way[i][0];
int destx = x + way[i][1];
if (inGrid(desty, destx, N, M)) {
if (!visited[desty][destx] && mat[desty][destx]) {
DFS(desty, destx);
}
if (mat[desty][destx] == false) {
realAnswers[counter]++;
}
}
}
}
int main() {
int K;
cin >> N >> M >> K;
for (long long i = 0; i < (long long)N; i++)
for (long long j = 0; j < (long long)M; j++) {
char a;
cin >> a;
if (a == '.') mat[i][j] = true;
}
for (long long i = 0; i < (long long)N; i++)
for (long long j = 0; j < (long long)M; j++)
if (!visited[i][j] && mat[i][j]) {
DFS(i, j);
counter++;
}
for (long long i = 0; i < (long long)K; i++) {
int y, x;
cin >> y >> x;
y--;
x--;
cout << realAnswers[ans[y][x]] << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
static inline void canhazfast() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
}
template <typename T>
T gcd(T a, T b) {
return b == 0 ? a : gcd(b, a % b);
}
template <typename T>
T extgcd(T a, T b, T &x, T &y) {
T x0 = 1, y0 = 0, x1 = 0, y1 = 1;
while (b) {
T q = a / b;
a %= b;
swap(a, b);
x0 -= q * x1;
swap(x0, x1);
y0 -= q * y1;
swap(y0, y1);
}
x = x0;
y = y0;
return a;
}
static inline int ctz(unsigned x) { return __builtin_ctz(x); }
static inline int ctzll(unsigned long long x) { return __builtin_ctzll(x); }
static inline int clz(unsigned x) { return __builtin_clz(x); }
static inline int clzll(unsigned long long x) { return __builtin_clzll(x); }
static inline int popcnt(unsigned x) { return __builtin_popcount(x); }
static inline int popcntll(unsigned long long x) {
return __builtin_popcountll(x);
}
static inline int bsr(unsigned x) { return 31 ^ clz(x); }
static inline int bsrll(unsigned long long x) { return 63 ^ clzll(x); }
int main() {
canhazfast();
static char s[100016];
int n;
int all = 1, pre = 0, suf = 0;
int ans;
cin >> s;
n = strlen(s);
for (int i = 0, l = 0; i < n; ++i) {
if (!i || s[i] != s[i - 1])
++l;
else
l = 1;
all = max(all, l);
}
cerr << "all " << all << '\n';
if (all == n) return cout << n, 0;
for (int i = 0; i < n; ++i) {
if (i && s[i] == s[i - 1]) break;
++pre;
}
cerr << "pre " << pre << '\n';
for (int i = n - 1; i >= 0; --i) {
if (i + 1 != n && s[i] == s[i + 1]) break;
++suf;
}
cerr << "suf " << suf << '\n';
ans = all;
if (s[0] != s[n - 1]) ans = max(ans, pre + suf);
cout << ans;
return 0;
}
| 4 |
// Problem: B. DMCA
// Contest: Codeforces - April Fools Day Contest 2021
// URL: https://codeforces.com/contest/1505/problem/B
// Memory Limit: 256 MB
// Time Limit: 1000 ms
//
// Powered by CP Editor (https://cpeditor.org)
#include <bits/stdc++.h>
#define pb push_back
#define eb emplace_back
using namespace std;
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
const int N = 2e5 + 10;
int calc(int n) {
int ret = 0;
while (n) {
ret += n % 10;
n /= 10;
}
return ret;
}
void solve() {
int n;
cin >> n;
while (n >= 10) {
n = calc(n);
}
cout << n;
}
int main() {
// ios_base::sync_with_stdio(false);
int T = 1;
// scanf("%d", &T);
while (T--) {
solve();
}
return 0;
} | 4 |
#include <bits/stdc++.h>
using namespace std;
#pragma warning(disable : 4996)
const double eps = 1e-9;
struct point {
double x, y;
};
bool comp(double x, double y) {
if (x + eps < y)
return true;
else
return false;
}
int main(void) {
vector<point> points[4];
vector<double> angles[4];
vector<double> angle;
const double pi = 3.141592653589;
int n, i, j;
cin >> n;
point tmp;
for (i = 0; i < n; i++) {
cin >> tmp.x >> tmp.y;
if (tmp.x >= 0 && tmp.y > 0) points[0].push_back(tmp);
if (tmp.x > 0 && tmp.y <= 0) points[1].push_back(tmp);
if (tmp.x <= 0 && tmp.y < 0) points[2].push_back(tmp);
if (tmp.x < 0 && tmp.y >= 0) points[3].push_back(tmp);
}
for (j = 0; j < 4; j++) angles[j].resize(points[j].size());
for (i = 0; i < (int)points[0].size(); i++) {
double cos;
double x1, y1, x2, y2;
x1 = 0;
y1 = 1;
x2 = points[0][i].x;
y2 = points[0][i].y;
cos = (x1 * x2 + y1 * y2) * (x1 * x2 + y1 * y2) /
((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2));
cos = sqrt(cos);
angles[0][i] = acos(cos);
}
for (i = 0; i < (int)points[1].size(); i++) {
double cos;
double x1, y1, x2, y2;
x1 = 1;
y1 = 0;
x2 = points[1][i].x;
y2 = points[1][i].y;
cos = (x1 * x2 + y1 * y2) * (x1 * x2 + y1 * y2) /
((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2));
cos = sqrt(cos);
angles[1][i] = acos(cos);
}
for (i = 0; i < (int)points[2].size(); i++) {
double cos;
double x1, y1, x2, y2;
x1 = 0;
y1 = -1;
x2 = points[2][i].x;
y2 = points[2][i].y;
cos = (x1 * x2 + y1 * y2) * (x1 * x2 + y1 * y2) /
((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2));
cos = sqrt(cos);
angles[2][i] = acos(cos);
}
for (i = 0; i < (int)points[3].size(); i++) {
double cos;
double x1, y1, x2, y2;
x1 = -1;
y1 = 0;
x2 = points[3][i].x;
y2 = points[3][i].y;
cos = (x1 * x2 + y1 * y2) * (x1 * x2 + y1 * y2) /
((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2));
cos = sqrt(cos);
angles[3][i] = acos(cos);
}
for (i = 0; i < (int)angles[0].size(); i++) {
angle.push_back(angles[0][i] * 180 / pi);
}
for (i = 0; i < (int)angles[1].size(); i++) {
angle.push_back(angles[1][i] * 180 / pi + 90);
}
for (i = 0; i < (int)angles[2].size(); i++) {
angle.push_back(angles[2][i] * 180 / pi + 180);
}
for (i = 0; i < (int)angles[3].size(); i++) {
angle.push_back(angles[3][i] * 180 / pi + 270);
}
sort(angle.begin(), angle.end(), comp);
double ans = 360;
if (n == 1) {
printf("0");
return 0;
}
if (n == 2) {
ans = (angle[1] - angle[0] > 180 + eps ? 360 - (angle[1] - angle[0])
: angle[1] - angle[0]);
printf("%.10f", ans);
return 0;
}
for (i = 0; i < n - 1; i++) {
if (360 - (angle[i + 1] - angle[i]) + eps < ans)
ans = 360 - (angle[i + 1] - angle[i]);
}
if (360 - (360 + angle[0] - angle[n - 1]) + eps < ans)
ans = 360 - (360 + angle[0] - angle[n - 1]);
printf("%.10f", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1e9 + 7;
vector<int> solve(int n, const vector<int> &sender,
const vector<vector<int> > &mention) {
int m = sender.size();
if (0) {
for (int i = (int)(0); i < (int)(m); i++) {
cout << sender[i] << ":";
for (int j = (int)(0); j < (int)(mention[i].size()); j++) {
cout << " " << mention[i][j];
}
cout << endl;
}
}
vector<vector<int> > dp(m + 1, vector<int>(n, 1));
for (int i = (int)(0); i < (int)(m); i++) {
if (sender[i] >= 0) {
for (int j = (int)(0); j < (int)(n); j++) {
dp[i + 1][j] = 0;
}
dp[i + 1][sender[i]] = 1;
} else {
for (int j = (int)(0); j < (int)(mention[i].size()); j++) {
dp[i + 1][mention[i][j]] = 0;
}
}
if (i >= 1) {
for (int j = (int)(0); j < (int)(n); j++) {
bool ok = false;
for (int k = (int)(0); k < (int)(n); k++) {
if (j == k) continue;
if (dp[i][k] == 1) {
ok = true;
break;
}
}
dp[i + 1][j] &= ok ? 1 : 0;
}
}
}
bool ok = false;
int v = -1;
for (int i = (int)(0); i < (int)(n); i++) {
if (dp[m][i]) {
ok = true;
v = i;
}
}
if (not ok) {
return vector<int>();
}
vector<int> ret(m, -1);
ret[m - 1] = v;
for (int i = m - 2; i >= 0; --i) {
for (int j = (int)(0); j < (int)(n); j++) {
if (j == ret[i + 1]) continue;
if (dp[i + 1][j]) {
ret[i] = j;
}
}
}
return ret;
}
int main(void) {
int tt;
cin >> tt;
while (tt--) {
int n;
cin >> n;
vector<string> name(n);
map<string, int> name_v;
for (int i = (int)(0); i < (int)(n); i++) {
cin >> name[i];
name_v[name[i]] = i;
}
int m;
cin >> m;
cin.ignore();
vector<string> lines(m);
vector<int> sender(m);
vector<vector<int> > mention(m);
for (int i = (int)(0); i < (int)(m); i++) {
getline(cin, lines[i]);
stringstream is(lines[i]);
string t;
getline(is, t, ':');
if (t == "?") {
sender[i] = -1;
} else {
assert(name_v.count(t));
sender[i] = name_v[t];
}
vector<int> words;
string rest;
getline(is, rest);
size_t pos;
size_t prev = 0;
while ((pos = rest.find_first_of(" ,.?!", prev)) != string::npos) {
if (pos > prev) {
string word = rest.substr(prev, pos - prev);
if (name_v.count(word)) {
mention[i].push_back(name_v[word]);
}
}
prev = pos + 1;
}
if (prev < rest.size()) {
string word = rest.substr(prev);
if (name_v.count(word)) {
mention[i].push_back(name_v[word]);
}
}
}
vector<int> sol = solve(n, sender, mention);
if (sol.size() == 0) {
cout << "Impossible" << endl;
} else {
for (int j = (int)(0); j < (int)(m); j++) {
if (sender[j] == -1) {
cout << name[sol[j]];
cout << lines[j].substr(1) << endl;
} else {
cout << lines[j] << endl;
}
}
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000;
int n, k, x, y, pre[1111], dp[1111], dpp[1111], mx, num[1111], ans;
vector<int> c[111111];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= k; i++) {
scanf("%d%d", &x, &y);
c[y].push_back(n - x + 1);
}
for (int i = 0; i <= maxn + 1; i++) dpp[i] = -1e9;
dpp[0] = 0;
for (int i = 1; i <= n; i++) {
mx = min(maxn, n - i + 1);
pre[0] = dpp[0];
for (int j = 1; j <= mx; j++) pre[j] = max(pre[j - 1], dpp[j]);
memset(num, 0, sizeof(num));
for (int j = 0; j < c[i].size(); j++) {
if (c[i][j] <= mx) num[c[i][j]]++;
}
for (int j = 1; j <= mx; j++) num[j] += num[j - 1];
dp[0] = max(dpp[0], dpp[1]);
for (int j = 1; j <= mx; j++) {
dp[j] = max(dpp[j + 1], pre[j] - (j + 1) * j / 2 - 2) + 3 * num[j];
}
for (int j = 0; j <= mx; j++) dpp[j] = dp[j];
}
for (int i = 0; i <= mx; i++) ans = max(ans, dp[i]);
printf("%d\n", 3 * k - ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 234567;
int n, w, k;
struct Song {
int pleasure;
int length;
int id;
Song() {}
inline bool operator<(const Song &other) const {
if (length != other.length) {
return length < other.length;
}
return id < other.id;
}
};
Song a[N];
struct MagicSet {
multiset<Song> full;
multiset<Song> partial;
int pleasure, length;
MagicSet() {
pleasure = 0;
length = 0;
full.clear();
partial.clear();
}
void optimize() {
while (!full.empty() && partial.size() < w) {
auto it = full.end();
it--;
length -= it->length;
length += (it->length + 1) / 2;
partial.insert(*it);
full.erase(it);
}
while (true) {
if (full.empty() || partial.empty()) {
break;
}
auto it = full.end();
it--;
auto itt = partial.begin();
if (it->length > itt->length) {
length -= it->length;
length += (it->length + 1) / 2;
length -= (itt->length + 1) / 2;
length += itt->length;
partial.insert(*it);
full.insert(*itt);
partial.erase(itt);
full.erase(it);
} else {
break;
}
}
}
inline void insert(const Song &x) {
pleasure += x.pleasure;
length += x.length;
full.insert(x);
optimize();
}
inline void erase(const Song &x) {
pleasure -= x.pleasure;
if (full.find(x) != full.end()) {
full.erase(full.find(x));
length -= x.length;
} else {
partial.erase(partial.find(x));
length -= (x.length + 1) / 2;
}
optimize();
}
};
int main() {
scanf("%d%d%d", &n, &w, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i].pleasure);
}
for (int i = 0; i < n; i++) {
scanf("%d", &a[i].length);
a[i].id = i;
}
int ans = 0;
MagicSet s;
int low = 0;
for (int i = 0; i < n; i++) {
s.insert(a[i]);
while (low <= i && s.length > k) {
s.erase(a[low]);
low++;
}
ans = max(ans, s.pleasure);
}
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long sq(long long x) { return x * x; }
long long first(long long l, long long p) {
long long w = l / p;
long long p2 = l % p;
long long p1 = p - p2;
return p1 * sq(w) + p2 * sq(w + 1);
}
void solve() {
long long n, k;
cin >> n >> k;
vector<long long int> a(n);
for (auto &it : a) cin >> it;
priority_queue<pair<long long, pair<long long int, long long int>>> second;
long long ans = 0, d = k - n;
for (auto it : a) {
second.push({first(it, 1) - first(it, 2), {it, 2}});
ans += sq(it);
}
while (d) {
pair<long long, pair<long long int, long long int>> v = second.top();
second.pop();
ans -= v.first;
second.push({first(v.second.first, v.second.second) -
first(v.second.first, v.second.second + 1),
{v.second.first, v.second.second + 1}});
d--;
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.precision(20);
long long t = 1;
while (t--) {
solve();
cout << endl;
}
cin.get();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> n;
map<long long, long long> mp;
string st = "codeforces";
for (int i = 0; i < 10; i++) {
mp[i] = 1;
}
long long sum = 1;
int in = 0;
while (sum < n) {
if (in == 10) in = 0;
sum /= mp[in];
mp[in]++;
sum = sum * mp[in];
in++;
}
for (int i = 0; i < 10; i++) {
for (int j = 0; j < mp[i]; j++) cout << st[i];
}
cout << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, k, mi, ma, ans, test, digit, t;
cin >> t;
while (t--) {
cin >> a >> k;
ans = a;
for (int i = 1; i < k; ++i) {
mi = 10;
ma = 0;
test = ans;
a = ans;
while (a > 0) {
digit = a % 10;
mi = min(mi, digit);
ma = max(ma, digit);
a = a / 10;
}
ans = test + (mi * ma);
if (mi == 0) break;
}
cout << ans << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
struct sofa {
int x1, y1, x2, y2;
int minx() { return min(x1, x2); }
int maxx() { return max(x1, x2); }
int miny() { return min(y1, y2); }
int maxy() { return max(y1, y2); }
};
sofa sofas[maxn];
int cntup[maxn], cntdo[maxn], cntle[maxn], cntri[maxn];
int preup[maxn], bacdo[maxn], prele[maxn], bacri[maxn];
int d, n, m;
int cntl, cntr, cntt, cntb;
int main() {
cin >> d >> n >> m;
for (int i = 1; i <= d; i++) {
cin >> sofas[i].x1 >> sofas[i].y1 >> sofas[i].x2 >> sofas[i].y2;
cntup[sofas[i].minx()]++;
cntdo[sofas[i].maxx()]++;
cntle[sofas[i].miny()]++;
cntri[sofas[i].maxy()]++;
}
for (int i = 1; i <= n; i++) preup[i] = preup[i - 1] + cntup[i];
for (int i = n; i >= 1; i--) bacdo[i] = bacdo[i + 1] + cntdo[i];
for (int j = 1; j <= m; j++) prele[j] = prele[j - 1] + cntle[j];
for (int j = m; j >= 1; j--) bacri[j] = bacri[j + 1] + cntri[j];
cin >> cntl >> cntr >> cntt >> cntb;
for (int i = 1; i <= d; i++) {
int ncntl = prele[sofas[i].maxy() - 1];
int ncntr = bacri[sofas[i].miny() + 1];
int ncntt = preup[sofas[i].maxx() - 1];
int ncntb = bacdo[sofas[i].minx() + 1];
if (sofas[i].maxy() != sofas[i].miny()) {
ncntl--;
ncntr--;
}
if (sofas[i].maxx() != sofas[i].minx()) {
ncntt--;
ncntb--;
}
if (ncntt == cntl && ncntb == cntr && ncntl == cntt && ncntr == cntb) {
cout << i << endl;
return 0;
}
}
cout << -1 << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
while (t--) {
long long int a[3], s = 0;
for (int i = 0; i < 3; i++) {
cin >> a[i];
}
sort(a, a + 3);
if (a[2] > a[1] + a[0]) {
cout << a[0] + a[1] << endl;
} else {
cout << (a[0] + a[1] + a[2]) / 2 << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long sum(vector<long long> arr) {
long long s = 0;
for (int i = 0; i < arr.size(); i++) s += arr[i];
return s;
}
int main() {
int n, i;
long long x;
cin >> n;
vector<long long> arr, arr1;
for (i = 0; i < n; i++) {
cin >> x;
arr.push_back(x);
}
for (i = 0; i < n - 1; i++) {
cin >> x;
arr1.push_back(x);
}
long long res = sum(arr) - sum(arr1);
arr.clear();
for (i = 0; i < n - 2; i++) {
cin >> x;
arr.push_back(x);
}
cout << res << endl;
cout << sum(arr1) - sum(arr);
}
| 1 |
#include<bits/stdc++.h>
#define ll long long
#define fori(i,init,end) for(ll i=init;i<end;i++)
#define makearr(arr,n) ll arr[n]; fori(i,0,n) cin>>arr[i];
#define fastio ios_base::sync_with_stdio(false); cin.tie(NULL);
using namespace std;
void solve()
{
ll n,k;
cin>>n>>k;
while(k>3)
{
cout<<1<<" ";
k--;
n--;
}
if(n%3==0)
{
cout<<n/3<<" "<<n/3<<" "<<n/3<<"\n";
return;
}
if(n%2==0)
{
ll temp=n/2;
if(n%4==0)
cout<<temp<<" "<<temp/2<<" "<<temp/2<<"\n";
else
cout<<temp-1<<" "<<temp-1<<" "<<2<<"\n";
return;
}
cout<<n/2<<" "<<n/2<<" "<<1<<"\n";
}
int main()
{
fastio;
ll t;
cin>>t;
while(t--)
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5;
long long x[N], m[N];
vector<long long> solve(long long n) {
if (n <= 1) return vector<long long>(1, n);
long long p = 1;
while (p < n) p <<= 1;
if (p > n) p >>= 1;
--p;
int bits = 0;
for (long long temp = p; temp > 0; temp >>= 1) ++bits;
vector<long long> res(bits, (p + 1) / 2);
long long rem = n - p;
p = 1;
for (int i = 0; i < bits; ++i, p <<= 1) {
long long ones = rem / p / 2 * p;
if ((rem / p) & 1) ones += rem % p;
res[i] += ones;
}
res.push_back(rem);
return res;
}
long long calc(int at) {
vector<long long> a = solve(x[at] - 1);
vector<long long> b = solve(x[at] + m[at] - 1);
for (size_t i = 0; i < a.size(); ++i) b[i] -= a[i];
long long res = 0, p = 1;
for (size_t i = 0; i < b.size(); ++i, p <<= 1)
if (b[i] & 1) res += p;
return res;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%lld%lld", &x[i], &m[i]);
long long res = calc(0);
for (int i = 1; i < n; ++i) res ^= calc(i);
if (res)
puts("tolik");
else
puts("bolik");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxv = 10000001;
const int maxq = 4000;
int r[maxv];
void calc() {
for (int i = 1; i <= maxq; ++i) {
int t = i * i;
for (int j = t, jj = 1; j < maxv; ++jj, j += t) r[j] = jj;
}
}
int main() {
calc();
int a, n;
cin >> a >> n;
long long R = 0;
for (int i = a; i < a + n; ++i) R += r[i];
cout << R << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int n_n = n * n;
int answer = 0;
for (int a = 1; a <= n; a++) {
for (int b = a; b <= n; b++) {
int c = (a * a) + (b * b);
if (c > n_n) {
break;
}
int temp = sqrt(c);
temp *= temp;
if (temp == c) {
answer++;
}
}
}
cout << answer;
return 0;
};
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 23;
const int MOD = 1e9 + 9;
const int MAXN = 1e3 + 100;
string name[MAXN];
int main() {
ios_base::sync_with_stdio(0);
string s, cur = "";
cin >> s;
int slen = s.length();
int ans = 0, level = 0;
for (int i = 0; i < slen; ++i) {
if (isalpha(s[i])) {
cur += s[i];
} else if (cur != "") {
for (int j = 0; j < level; ++j) {
if (cur == name[j]) {
cerr << "cur"
<< ": " << cur << " ";
;
cerr << "name[j]"
<< ": " << name[j] << "\n";
;
++ans;
}
}
name[level] = cur;
++level;
cur = "";
}
if (s[i] == '.') --level;
}
cout << ans << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
long long vvod, n;
vector<long long> mas;
long long ost(long long div, long long mod) {
if (div >= 0) {
return div % mod;
} else {
return mod - (div * -1 % mod);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> vvod;
mas.push_back(vvod);
}
cout << 1 << ' ' << n << '\n';
if (n > 1) {
for (int i = 0; i < n; i++) {
cout << n * -1 * ost(mas[i], n - 1) << ' ';
mas[i] += n * -1 * ost(mas[i], n - 1);
}
} else {
cout << 0;
}
if (n > 1) {
cout << '\n' << 1 << ' ' << n - 1 << '\n';
for (int i = 0; i < n - 1; i++) {
cout << 0 - mas[i] << ' ';
}
} else {
cout << '\n' << 1 << ' ' << 1 << '\n' << 0;
}
cout << '\n' << n << ' ' << n << '\n' << 0 - mas[n - 1];
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
string s;
cin >> n >> s;
int a[n], cnt = 0;
for (int i = 0; i < n; i++) {
if (s[i] == 'R') {
a[i] = 0;
} else if (s[i] == 'G') {
a[i] = 1;
} else {
a[i] = 2;
}
}
for (int i = 1; i < n - 1; i++) {
if (a[i] == a[i - 1]) {
cnt++;
if (a[i] == a[i + 1]) {
a[i] = (a[i + 1] + 1) % 3;
} else {
a[i] = 3 - a[i - 1] - a[i + 1];
}
}
}
if (n > 1 && a[n - 1] == a[n - 2]) {
cnt++;
a[n - 1] = (a[n - 2] + 1) % 3;
}
cout << cnt << "\n";
for (int i = 0; i < n; i++) {
if (a[i] == 0) {
cout << "R";
} else if (a[i] == 1) {
cout << "G";
} else {
cout << "B";
}
}
cout << "\n";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000 * 1000;
int lens[N];
int k;
long long solve(long long a, long long b) {
k = 0;
for (long long i = 1; i * i <= b; ++i)
if (b % i == 0) lens[k++] = i;
long long ans = 2 * (a + b) + 2;
long long x = a + b;
int l = 0;
for (long long i = 1; i * i <= x; ++i) {
if (x % i == 0) {
while (l + 1 < k && lens[l + 1] <= i) ++l;
if (b / lens[l] <= x / i) ans = min(ans, (i + x / i) * 2);
}
}
return ans;
}
int main() {
long long a, b;
scanf("%lld%lld", &a, &b);
printf("%lld\n", min(solve(a, b), solve(b, a)));
return 0;
}
| 6 |
#include <bits/stdc++.h>
template <typename T>
std::istream& operator>>(std::istream& input, std::vector<T>& v) {
for (T& a : v) input >> a;
return input;
}
void answer(unsigned v) { std::cout << v << '\n'; }
void solve(unsigned n, unsigned k, const std::vector<unsigned>& a) {
const size_t c = a.size();
unsigned t = 0, p = 0;
for (size_t i = 0; i < c; ++i) {
p += (a[i] - t - 1) / k + 1;
t = a[i];
}
p += (n - (c == 0 ? 0 : a[c - 1])) / k;
answer(p);
}
int main() {
unsigned n, k;
std::cin >> n >> k;
size_t c;
std::cin >> c;
std::vector<unsigned> a(c);
std::cin >> a;
solve(n, k, a);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 50;
int xx[4] = {0, 0, -1, 1};
int yy[4] = {1, -1, 0, 0};
const long long mod = 1e9 + 7;
long long c, n, k;
double d;
int a[maxn];
queue<pair<int, int> > q;
long long ans[maxn];
int b[maxn], m;
multiset<pair<int, int> > v[maxn];
int check(int x) {
if (v[x].size() == 0) return 0;
multiset<pair<int, int> >::iterator it = v[x].end();
it--;
int y = it->second;
return (v[x].size() - 1) * n + (y - x + n) % n;
}
int main() {
ios::sync_with_stdio(false);
vector<pair<int, int> > be, en;
while (cin >> n >> m) {
for (int i = 1; i <= m; i++) cin >> a[i] >> b[i];
for (int i = 1; i <= m; i++) {
v[a[i]].insert(make_pair(-(-1 * a[i] + b[i] + n) % n, b[i]));
}
for (int i = 1; i <= n; i++) {
int num = check(i);
for (int j = 1; j <= n; j++) {
if (num > 0) {
ans[j] = max(ans[j], num + (i - j + n) % n);
}
}
}
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
cout << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5 * 100005;
vector<int> a[maxn];
int n, m, k, lim;
int head[maxn], Next[maxn * 2], to[maxn * 2], tot = 0;
int d[maxn], fa[maxn], size[maxn];
bool vis[maxn];
void add(int x, int y) {
to[++tot] = y;
Next[tot] = head[x];
head[x] = tot;
}
void dfs_tree(int x, int f) {
size[x] = 1;
for (int i = head[x]; i; i = Next[i]) {
int y = to[i];
if (y == f || vis[y]) continue;
d[y] = d[x] + 1;
fa[y] = x;
vis[y] = 1;
dfs_tree(y, x);
size[x] += size[y];
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
lim = ceil((double)n * 1.0 / k);
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
add(x, y);
add(y, x);
}
vis[1] = 1;
d[1] = 1;
dfs_tree(1, 0);
int pos = 0;
for (int i = 1; i <= n; i++) {
if (d[i] >= lim) {
puts("PATH");
pos = i;
printf("%d\n", d[i]);
while (pos) {
printf("%d ", pos);
pos = fa[pos];
}
printf("\n");
return 0;
}
}
int cnt = 0;
puts("CYCLES");
for (int i = 1; i <= n; i++) {
if (size[i] == 1) {
int p1 = 0, p2 = 0;
for (int j = head[i]; j; j = Next[j]) {
int y = to[j];
if (y == fa[i]) continue;
if (!p1)
p1 = y;
else {
if (!p2) {
p2 = y;
break;
}
}
}
if (d[p1] < d[p2]) swap(p1, p2);
int c1 = d[i] - d[p1] + 1, c2 = d[i] - d[p2] + 1, c3 = d[p1] - d[p2] + 2;
if (c1 > 3 && c1 % 3 != 0) {
cnt++;
pos = i;
while (pos != fa[p1]) {
a[cnt].push_back(pos);
pos = fa[pos];
}
} else if (c2 > 3 && c2 % 3 != 0) {
cnt++;
pos = i;
while (pos != fa[p2]) {
a[cnt].push_back(pos);
pos = fa[pos];
}
} else if (c3 > 3 && c3 % 3 != 0) {
cnt++;
pos = p1;
while (pos != fa[p2]) {
a[cnt].push_back(pos);
pos = fa[pos];
}
a[cnt].push_back(i);
}
}
if (cnt == k) break;
}
for (int i = 1; i <= cnt; i++) {
printf("%d\n", a[i].size());
for (int j = 0; j < a[i].size(); j++) printf("%d ", a[i][j]);
printf("\n");
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
const long long inf = 4e18;
int n, l;
long long lx = -inf, rx = inf, ly = -inf, ry = inf;
void rd(int &x) { std::cin >> x; }
void rd(long long &x) { std::cin >> x; }
void prints(char *x) { puts(x); }
struct P {
long long t, x, y, k;
int w;
inline void in() {
long long p, q;
rd(t), rd(p), rd(q);
if ((t ^ p ^ q) & 1) prints("NO"), exit(0);
k = t / l, w = t % l;
x = (p + q + t) / 2, y = (q - p + t) / 2;
}
inline bool operator<(const P &o) const { return w < o.w; }
} p[N];
int main() {
rd(n), rd(l);
for (int i = 1; i <= n; i++) p[i].in();
sort(p + 1, p + n + 1);
p[++n].k = -1, p[n].w = l;
for (int i = 1; i <= n; i++) {
long long k = p[i].k - p[i - 1].k;
int w = p[i].w - p[i - 1].w;
if (!k) {
if (p[i].x - p[i - 1].x - w > 0 || p[i].x - p[i - 1].x < 0)
prints("NO"), exit(0);
if (p[i].y - p[i - 1].y - w > 0 || p[i].y - p[i - 1].y < 0)
prints("NO"), exit(0);
} else if (k > 0) {
lx = max(lx, (long long)ceil(1.0L * (p[i].x - p[i - 1].x - w) / k));
rx = min(rx, (long long)floor(1.0L * (p[i].x - p[i - 1].x) / k));
ly = max(ly, (long long)ceil(1.0L * (p[i].y - p[i - 1].y - w) / k));
ry = min(ry, (long long)floor(1.0L * (p[i].y - p[i - 1].y) / k));
} else {
lx = max(lx, (long long)ceil(1.0L * (p[i].x - p[i - 1].x) / k));
rx = min(rx, (long long)floor(1.0L * (p[i].x - p[i - 1].x - w) / k));
ly = max(ly, (long long)ceil(1.0L * (p[i].y - p[i - 1].y) / k));
ry = min(ry, (long long)floor(1.0L * (p[i].y - p[i - 1].y - w) / k));
}
}
if (lx > rx || ly > ry) prints("NO"), exit(0);
for (int i = 1; i <= n; i++) {
int dx = (p[i].x - p[i].k * lx) - (p[i - 1].x - p[i - 1].k * lx);
int dy = (p[i].y - p[i].k * ly) - (p[i - 1].y - p[i - 1].k * ly);
int t = p[i].w - p[i - 1].w, x = 0, y = 0;
while (t--)
if (x < dx) {
++x;
if (y < dy)
putchar('U'), ++y;
else
putchar('R');
} else {
if (y < dy)
putchar('L'), ++y;
else
putchar('D');
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0) return a;
long long hcf = gcd(b, a % b);
return hcf;
}
long long findhcf(long long *arr, int n) {
long long num = arr[0];
for (int i = 1; i < n; i++) {
num = gcd(arr[i], num);
if (num == 1) return 1;
}
return num;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int A, B, C, D;
cin >> A >> B >> C >> D;
if (A == 0) {
if (B != 0) {
if (B % 2 == 0) {
if (D == 0)
cout << "Tidak "
<< "Tidak "
<< "Ya "
<< "Tidak" << '\n';
else
cout << "Tidak "
<< "Tidak "
<< "Ya "
<< "Ya" << '\n';
} else {
if (D == 0)
cout << "Tidak "
<< "Ya "
<< "Tidak "
<< "Tidak" << '\n';
else
cout << "Ya "
<< "Ya "
<< "Tidak "
<< "Tidak" << '\n';
}
} else {
if (C != 0 and D != 0)
cout << "Tidak "
<< "Tidak "
<< "Ya "
<< "Ya" << '\n';
else if (C == 0 and D != 0)
cout << "Tidak "
<< "Tidak "
<< "Tidak "
<< "Ya" << '\n';
else if (C != 0 and D == 0)
cout << "Tidak "
<< "Tidak "
<< "Ya "
<< "Tidak" << '\n';
else
cout << "Tidak "
<< "Tidak "
<< "Tidak "
<< "Tidak" << '\n';
}
} else {
if (B != 0) {
int a = A + B;
if (a % 2 == 0)
cout << "Tidak "
<< "Tidak "
<< "Ya "
<< "Ya" << '\n';
else
cout << "Ya "
<< "Ya "
<< "Tidak "
<< "Tidak" << '\n';
} else {
if (A % 2 == 0) {
if (C == 0)
cout << "Tidak "
<< "Tidak "
<< "Tidak "
<< "Ya" << '\n';
else
cout << "Tidak "
<< "Tidak "
<< "Ya "
<< "Ya" << '\n';
} else {
if (C != 0)
cout << "Ya "
<< "Ya "
<< "Tidak "
<< "Tidak" << '\n';
else
cout << "Ya "
<< "Tidak "
<< "Tidak "
<< "Tidak" << '\n';
}
}
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int l, n, ans, a[100 + 5], b[100 + 5], vis[3000 + 5][100 + 5][5],
memo[3000 + 5][100 + 5][5];
int dp(int now, int last, int state) {
if (now == l) return 1;
if (now > l) return 0;
if (memo[now][last][state] > -1) return memo[now][last][state];
int i, k, ret = 0;
if (!state)
k = b[last];
else
k = a[last];
for (i = 0; i < n; i++) {
if (i == last) continue;
if (k == a[i]) ret = (ret + dp(now + a[i], i, 0)) % 1000000007;
if (k == b[i] && a[i] != b[i])
ret = (ret + dp(now + b[i], i, 1)) % 1000000007;
}
memo[now][last][state] = ret;
return ret;
}
int main() {
int i;
memset(memo, -1, sizeof(memo));
scanf("%d %d", &n, &l);
for (i = 0; i < n; i++) scanf("%d %d", &a[i], &b[i]);
for (i = 0; i < n; i++) {
if (a[i] != b[i])
ans =
(((ans + dp(a[i], i, 0)) % 1000000007) + dp(b[i], i, 1)) % 1000000007;
else
ans = (ans + dp(a[i], i, 0)) % 1000000007;
}
printf("%d\n", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 105;
int a[maxn];
int main() {
int t;
cin >> t;
while (t--) {
int n, d;
cin >> n >> d;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
if (n == 1) {
cout << a[1] << endl;
} else {
for (int i = 2; i <= n; i++) {
if (d < i - 1) break;
if (a[i] == 0) continue;
if (d / (i - 1) <= a[i]) {
a[1] += d / (i - 1);
a[i] = 0;
break;
} else {
a[1] += a[i];
d -= (i - 1) * a[i];
a[i] = 0;
}
}
cout << a[1] << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define erorp(x) cout<<#x<<"={"<<(x.F)<<" , "<<x.S<<"}"<<endl;
#define print(v,r) f(i,0,r) cout<<v[i]<<" "; cout<<endl;
#define Get(x,y) scanf("%I64d%I64d",&x,&y);
#define is_bit(x,y) (x%(1<<(y+1))>=(1<<y))
#define eror(x) cout<<#x<<'='<<(x)<<endl;
#define f_(i,a,b) for(int i=a;i>=b;i--)
#define Gett(x,y) scanf("%d%d",&x,&y);
#define f(i,a,b) for(int i=a;i<b;i++)
#define get(x) scanf("%I64d",&x);
#define gett(x) scanf("%d",&x);
#define maxm(a,b) a=max(a,b);
#define minm(a,b) a=min(a,b);
#define Add(x,y) x=(x+y)%mod
#define lst(x) x[x.size()-1]
#define sz(x) int(x.size())
#define mp make_pair
#define ll long long
#define pb push_back
#define S second
#define F first
const int N=305,mod=998244353;
int n,ans,dp[N][N][N][2],pd[N][N][2][2],sum[N][N][2],res[N];
vector<int> g[N];
ll pow(ll x,ll y,ll mod){return(!y?1:pow(x*x%mod,y/2,mod)*(y&1?x:1))%mod;}
void dfs(int x,int par){
vector<int> v(2);
f(i,0,n)
f(j,0,n)
if(i<=j)
dp[x][i][j][(i==0)]=1;
f(p,0,g[x].size()){
int u=g[x][p];
if(u!=par){
dfs(u,x);
f(i,0,n)
f(j,i,n){
v[0]=v[1]=0;
f(k,0,2)
f(oi,max(i-1,0),i+2){
f(ok,0,2){
if(ok || oi==i+1){
Add(v[k||(oi==i-1)],1ll*dp[x][i][j][k]*dp[u][oi][j][ok]%mod);
}
}
}
dp[x][i][j][0]=v[0];
dp[x][i][j][1]=v[1];
}
}
}
}
int main(){
cin>>n;
f(i,1,n){
int u,v;
cin>>u>>v;
g[u].pb(v);
g[v].pb(u);
}
dfs(1,0);
f(i,0,n)
f(j,0,n)
Add(res[j],dp[1][i][j][1]);
f(i,1,n)
Add(ans,1ll*(res[i]-res[i-1]+mod)*i%mod);
Add(ans,n+1);
ans=(ans-pow(2,n,mod)+mod)%mod;
cout<<1ll*ans*pow(pow(2,n,mod),mod-2,mod)%mod;
} | 12 |
#include <bits/stdc++.h>
using namespace std;
const long INF = (long)1e09;
int n, m, k, p = 0, id, inv, minv, ans, d = -2;
int main() {
scanf("%d", &n);
if (n == 3) {
cout << 5;
return 0;
}
if (n == 1) {
cout << 1;
return 0;
}
for (m = 3; (m * m + 1) / 2 < n; m += 2)
;
printf("%d", m);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[100050], b[100050];
long double x[100050];
int main() {
int n, p;
scanf("%d%d", &n, &p);
for (int(i) = 0; (i) < (n); (i)++) {
scanf("%d%d", &a[i], &b[i]);
}
long long sum = 0;
for (int(i) = 0; (i) < (n); (i)++) sum += a[i];
if (sum <= p) {
printf("%d\n", -1);
return 0;
}
long double ans = 0;
long double l = 0, r = 1e14 + 20;
for (int k = 0; k < 60; k++) {
long double mid = (l + r) / 2;
for (int i = 0; i < n; i++) {
x[i] = (((0) > (mid * a[i] - b[i])) ? (0) : (mid * a[i] - b[i]));
x[i] /= mid;
}
long double sum = 0;
for (int(i) = 0; (i) < (n); (i)++) {
sum += x[i];
}
if (sum <= p)
l = mid, ans = (((ans) > (mid)) ? (ans) : (mid));
else
r = mid;
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long BASE = 1e9 + 7;
const long double EPS = 1e-9;
const long long EPS_INT = 1e12;
inline long long gcd(long long a, long long b) {
long long r;
while (b) {
r = a % b;
a = b;
b = r;
}
return a;
}
inline long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
inline long long fpow(long long a, long long n, long long p = BASE) {
long long r = 1;
for (; n; n >>= 1) {
if (n & 1) r = r * a % p;
a = a * a % p;
}
return r;
}
inline long long addmod(long long a, long long b, long long p = BASE) {
a = (a + b);
if (a > p) a -= p;
return a;
}
inline long long submod(long long a, long long b, long long p = BASE) {
a = (a - b);
if (a < 0) a += p;
return a;
}
inline long long multi(long long a, long long b, long long p = BASE) {
return a * b % p;
}
inline long long inverse(long long a, long long p = BASE) {
return fpow(a, p - 2, p);
}
inline long long maximize(long long& a, long long b) {
if (a < b) a = b;
return a;
}
inline long long minimize(long long& a, long long b) {
if (a > b) a = b;
return a;
}
const int MAX = (long long)1e6;
struct Point {
long long x, y, z;
long long id;
long long distance(Point t) {
long long k = (t.x - this->x) * (t.x - this->x) +
(t.y - this->y) * (t.y - this->y) +
(t.z - this->z) * (t.z - this->z);
return k;
}
};
struct Dis {
long long id, distance, idMin;
};
bool cmp(Dis a, Dis b) { return a.distance < b.distance; }
Point arrA[MAX + 1];
Dis arrB[MAX + 1];
void solves();
int main() {
if (fopen("output.out", "w")) {
}
if (fopen("input.inp", "r")) {
freopen("input.inp", "r", stdin);
} else {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
solves();
return 0;
}
void solves() {
long long t;
long long a, b, c;
cin >> t;
while (t--) {
long long res = 0;
long long res2 = 0;
cin >> a >> b >> c;
long long a1, b1, c1;
a1 = a;
b1 = b;
c1 = c;
res += min(a, b / 2) * 3;
if (a * 2 >= b)
b = 0;
else
b -= a * 2;
res += min(b, c / 2) * 3;
res2 += min(b1, c1 / 2) * 3;
if (b1 >= c1 / 2)
b1 -= c1 / 2;
else
b1 = 0;
res2 += min(a1, b1 / 2) * 3;
cout << max(res, res2) << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2005;
string s;
long long dp[N][N];
bool pl[N][N];
inline void go() {
int n = int(s.size());
for (int i = int(0); i < int(n); ++i) pl[0][i] = pl[1][i] = true;
for (int tam = int(2); tam < int(n + 1); ++tam)
for (int i = int(0); i < int(n - tam + 1); ++i)
pl[tam][i] = pl[tam - 2][i + 1] && (s[i] == s[i + tam - 1]);
for (int i = int(0); i < int(n); ++i) dp[1][i] = 1;
for (int tam = int(2); tam < int(n + 1); ++tam)
for (int i = int(0); i < int(n - tam + 1); ++i) {
dp[tam][i] = dp[tam - 1][i + 1] + dp[tam - 1][i] - dp[tam - 2][i + 1];
if (pl[tam][i]) dp[tam][i]++;
}
}
inline void count() {
long long ans = 0;
int n = int(s.size());
for (int i = int(0); i < int(n - 1); ++i) {
long long ref = dp[i + 1][0];
if (i) ref -= dp[i][0];
ans += ref * dp[n - i - 1][i + 1];
}
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> s;
go();
count();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string x, y;
cin >> x >> y;
for (int i = x.length() - 1; i >= 0; i--) {
while (x[i] < 'z') {
++x[i];
if (x < y) {
cout << x << endl;
return 0;
}
}
if (x[i] == 'z') {
x[i] = 'a';
}
}
cout << "No such string" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, m;
cin >> n >> m;
vector<long long> v(1001, 0);
for (int i = 0; i < n; i++) {
long long input;
cin >> input;
v[input]++;
}
long long ans = 0;
for (int i = 0; i < m; i++) {
long long input;
cin >> input;
if (v[input] != 0) ans = input;
}
if (ans == 0)
cout << "NO"
<< "\n";
else {
cout << "YES"
<< "\n"
<< 1 << " " << ans << "\n";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int tt = 1;
cin >> tt;
while (tt--) {
solve();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000001;
int nums[maxn];
pair<int, int> stk[maxn];
int main() {
int N = 0;
scanf("%d", &N);
int M = 0, MPos = -1, MNum = 1;
for (int i = 0; i < N; i++) {
scanf("%d", &nums[i]);
if (M < nums[i]) {
M = nums[i];
MPos = i;
MNum = 1;
} else if (M == nums[i]) {
MNum++;
}
}
long long answer = 0;
int ssize = 0;
for (int j = 0; j < N; j++) {
int cur = (j + MPos) % N;
int freq = 0;
while (ssize > 0 && stk[ssize - 1].first <= nums[cur]) {
if (stk[ssize - 1].first == nums[cur]) freq = stk[ssize - 1].second;
answer += stk[--ssize].second;
}
if (ssize > 0) answer += 1;
stk[ssize++] = make_pair(nums[cur], freq + 1);
}
while (ssize > 1) {
if (MNum > 1 || ssize > 2) answer += stk[ssize - 1].second;
ssize--;
}
printf("%I64d", answer);
printf("\n");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using std::max;
using std::pair;
const int maxn = 1000010, maxk = 19;
const int P = 1000000009;
int n;
pair<int, int> a[maxn];
int w[maxn][maxk];
int l[maxn], r[maxn], lb[maxn], rb[maxn];
pair<int, int> f[maxn];
inline int gmax(const int &x, const int &y) {
return a[x].second > a[y].second ? x : y;
}
int build(int x, int y) {
int k = (int)(log((double)y - x + 1) / log(2.));
int p = gmax(w[x][k], w[y - (1 << k) + 1][k]);
lb[p] = x, rb[p] = y;
if (x != p) l[p] = build(x, p - 1);
if (y != p) r[p] = build(p + 1, y);
return p;
}
inline int max(const pair<int, int> &a) { return max(a.first, a.second); }
inline pair<int, int> operator+(const pair<int, int> &a,
const pair<int, int> &b) {
return pair<int, int>(1 + max(a.second + max(b), b.second + max(a)),
max(a) + max(b));
}
pair<int, int> sol(int k) {
if (k) f[k] = sol(l[k]) + sol(r[k]);
return f[k];
}
pair<int, int> sol(int k, int x, int y) {
if (!k) return f[0];
if (lb[k] >= x && rb[k] <= y) return f[k];
if (k < x) return sol(r[k], x, y);
if (k > y) return sol(l[k], x, y);
return sol(r[k], x, y) + sol(l[k], x, y);
}
int main() {
int k, A, B, C, D, m, i, j, q, x, y, R;
scanf("%d%d", &n, &k);
for (i = 1; i <= k; ++i) scanf("%d%d", &a[i].first, &a[i].second);
scanf("%d%d%d%d", &A, &B, &C, &D);
for (i = k + 1; i <= n; ++i)
a[i].first = ((long long)A * a[i - 1].first + B) % P,
a[i].second = ((long long)C * a[i - 1].second + D) % P;
sort(a + 1, a + n + 1);
for (m = 0; (1 << m) <= n; ++m)
;
for (i = 1; i <= n; ++i) w[i][0] = i;
for (j = 1; j < m; ++j)
for (i = 1; i + (1 << j) - 1 <= n; ++i)
w[i][j] = gmax(w[i][j - 1], w[i + (1 << j - 1)][j - 1]);
R = build(1, n);
f[0] = pair<int, int>(0, -1), sol(R);
scanf("%d", &q);
while (q--) {
scanf("%d%d", &x, &y);
x = lower_bound(a + 1, a + n + 1, pair<int, int>(x, 0)) - a;
y = lower_bound(a + 1, a + n + 1, pair<int, int>(y + 1, 0)) - a - 1;
printf("%d\n", max(sol(R, x, y)));
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int st[100100], ed[100100], vst[100100];
pair<pair<int, int>, int> p[100100];
set<pair<int, int> > s;
set<pair<int, int> >::iterator it;
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int r, c;
scanf("%d %d", &r, &c);
st[i] = n - c + 1;
ed[i] = r;
}
for (int i = 1; i <= m; i++)
p[i] = pair<pair<int, int>, int>(pair<int, int>(st[i], ed[i]), i);
sort(p + 1, p + m + 1);
for (int i = 1, j = 1; i <= n; i++) {
for (j; j <= m; j++) {
if (p[j].first.first > i) break;
s.insert(pair<int, int>(p[j].first.second, p[j].second));
}
while (!s.empty()) {
it = s.begin();
if ((*it).first < i) {
s.erase(*it);
continue;
}
break;
}
if (!s.empty()) {
it = s.begin();
vst[(*it).second] = 1;
s.erase(*it);
}
}
int ans = 0;
for (int i = 1; i <= m; i++)
if (vst[i]) ans++;
cout << ans << endl;
for (int i = 1; i <= m; i++)
if (vst[i]) printf("%d ", i);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[200105];
int xMove[] = {0, 1, 0, -1, 1, 1, -1, -1, 2, 2, -2, -2, 1, 1, -1, -1};
int yMove[] = {1, 0, -1, 0, 1, -1, 1, -1, 1, -1, 1, -1, 2, -2, 2, -2};
int main() {
cin.tie(0), cout.tie(0);
ios_base::sync_with_stdio(0);
cout.setf(ios::fixed);
cout.precision(10);
int TC = 1;
int n, m, k, q;
{
cin >> n;
vector<int> vec(n);
for (int &v : vec) cin >> v;
int ans = 0, cur = 0;
for (int j = 0; j <= 30; j++) {
cur = 0;
for (int i = 0; i < n; i++) {
cur += vec[i];
if (cur < 0 or vec[i] > j)
cur = 0;
else
ans = max(ans, cur - j);
}
}
cout << ans << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2036;
int a[N];
int c[N], r[N], d, d2;
int sc[N], sr[N], sd, sd2;
const int ITER = 1999;
int main() {
int n;
scanf("%d", &n);
for (int i = (0); i < (int)(n * n); i++) scanf("%d", a + i);
int s = accumulate(a, a + n * n, 0) / n;
int sco = 1999;
while (sco > 0) {
int cur = 0;
memset(c, 0, sizeof(c)), memset(r, 0, sizeof(r));
d = d2 = 0;
random_shuffle(a, a + n * n);
for (int i = (0); i < (int)(n); i++)
for (int j = (0); j < (int)(n); j++) {
int id = i * n + j;
r[i] += a[id];
c[j] += a[id];
if (i == j) d += a[id];
if (i + j == n - 1) d2 += a[id];
}
sco = 0;
for (int i = (0); i < (int)(n); i++) {
sco += (sr[i] = abs(r[i] - s));
sco += (sc[i] = abs(c[i] - s));
}
sco += (sd = abs(d - s));
sco += (sd2 = abs(d2 - s));
if (sco == 0) break;
for (int iter = (0); iter < (int)(ITER); iter++) {
int first, second;
do {
first = rand() % (n * n);
second = rand() % (n * n);
} while (a[first] == a[second]);
int i1 = first / n, j1 = first % n;
int i2 = second / n, j2 = second % n;
int df = a[second] - a[first];
int nr1 = i1 == i2 ? r[i1] : r[i1] + df;
int nc1 = j1 == j2 ? c[j1] : c[j1] + df;
int nr2 = i1 == i2 ? r[i2] : r[i2] - df;
int nc2 = j1 == j2 ? c[j2] : c[j2] - df;
int nd = d + (i1 == j1 ? df : 0) + (i2 == j2 ? -df : 0);
int nd2 = d2 + (i1 + j1 == n - 1 ? df : 0) + (i2 + j2 == n - 1 ? -df : 0);
int tr1 = abs(nr1 - s) - sr[i1];
int tc1 = abs(nc1 - s) - sc[j1];
int tr2 = abs(nr2 - s) - sr[i2];
int tc2 = abs(nc2 - s) - sc[j2];
int td = abs(nd - s) - sd;
int td2 = abs(nd2 - s) - sd2;
int upd = tr1 + tc1 + tr2 + tc2 + td + td2;
if (upd < 0) {
sco += upd;
swap(a[first], a[second]);
r[i1] += df;
c[j1] += df;
r[i2] -= df;
c[j2] -= df;
if (i1 == j1) d += df;
if (i1 + j1 == n - 1) d2 += df;
if (i2 == j2) d -= df;
if (i2 + j2 == n - 1) d2 -= df;
sr[i1] += tr1;
sc[j1] += tc1;
sr[i2] += tr2;
sc[j2] += tc2;
sd += td;
sd2 += td2;
if (sco == 0) goto OUT;
}
}
}
OUT:
printf("%d\n", s);
for (int i = (0); i < (int)(n * n); i++)
printf("%d%c", a[i], i % n == n - 1 ? '\n' : ' ');
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
class Solution {
public:
void solve(std::istream &in, std::ostream &out) {
long long n, k, l;
in >> n >> k >> l;
std::vector<long long> a(n * k);
for (auto &el : a) in >> el;
std::sort(a.begin(), a.end());
std::vector<bool> b(n * k);
auto l_ind = std::upper_bound(a.begin(), a.end(), a[0] + l) - a.begin();
long long cnt = 0;
for (long long i = 0; i < l_ind; i += k) {
b[i] = true;
++cnt;
}
if (cnt < n)
for (long long j = l_ind - 1; j >= 0; j--) {
if (!b[j]) {
b[j] = true;
++cnt;
}
if (cnt == n) break;
}
if (cnt < n) return void(out << "0\n");
long long res = 0;
for (long long i = 0; i < n * k; ++i)
if (b[i]) res += a[i];
out << res << '\n';
}
};
void solve(std::istream &in, std::ostream &out) {
out << std::setprecision(12);
Solution solution;
solution.solve(in, out);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
istream &in = cin;
ostream &out = cout;
solve(in, out);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, n;
string s;
cin >> n;
for (i = 0; i < n; i++) {
s += "a";
}
for (i = 2; i < n; i = i + 4) {
s[i] = 'b';
if (i + 1 < n) {
s[i + 1] = 'b';
}
}
cout << s << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-7;
bool g[5][5];
int main() {
int m;
cin >> m;
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
g[a - 1][b - 1] = true;
g[b - 1][a - 1] = true;
}
for (int i = 0; i < 5; ++i)
for (int j = i + 1; j < 5; ++j)
for (int k = j + 1; k < 5; ++k)
if (g[i][j] && g[i][k] && g[j][k] || !g[i][j] && !g[i][k] && !g[j][k]) {
cout << "WIN";
return 0;
}
cout << "FAIL";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, m;
char ch[255][255];
int main() {
cin >> m >> n;
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) {
cin >> ch[i][j];
ch[i + n][j] = ch[i][j];
}
}
for (long long i = 1; i <= m; i++) {
for (long long j = 1; j <= n; j++) {
cout << ch[j][i] << ch[j][i];
}
cout << endl;
for (long long j = 1; j <= n; j++) {
cout << ch[j][i] << ch[j][i];
}
cout << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void err(istream_iterator<string> it) { cerr << endl; }
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << ", ";
err(++it, args...);
}
void solve() {
int n, m;
cin >> n >> m;
vector<vector<int>> adj(n);
vector<vector<int>> pos(n);
for (int i = 0; i < n; ++i) pos[i].emplace_back(i);
while (m-- > 0) {
int u, v;
cin >> u >> v;
--u;
--v;
adj[u].emplace_back(v);
adj[v].emplace_back(u);
pos[u].emplace_back((u + 1) * 1000 + v + 1);
pos[v].emplace_back((u + 1) * 1000 + v + 1);
}
for (int i = 0; i < n; ++i) {
cout << pos[i].size() << endl;
for (auto y : pos[i]) {
cout << (i + 1) << " " << (y + 1) << endl;
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0, f = 0;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = 1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
return f ? -x : x;
}
int dp[210][210], n;
int main() {
n = read();
dp[1][1] = 1;
dp[0][0] = 1;
for (int i = 2; i <= n; i++) {
for (int j = 0; j <= i; j++) {
if (j == 0)
dp[i][j] = dp[i - 2][j];
else
dp[i][j] = (dp[i - 2][j] + dp[i - 1][j - 1]) % 2;
}
}
printf("%d\n", n);
for (int i = 0; i <= n; i++) printf("%d ", dp[n][i]);
printf("\n%d\n", n - 1);
for (int i = 0; i <= n - 1; i++) printf("%d ", dp[n - 1][i]);
return 0 * printf("\n");
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long n, q;
long long a[300005], dp_child[300005], dp_par[300005], con[300005];
long long now, tin[300005], tout[300005], up[300005][19], val[300005][19],
val2[300005][19];
vector<pair<long long, long long> > g[300005];
void get_child(long long u, long long p) {
for (auto e : g[u])
if (e.first != p) {
long long v = e.first, w = e.second;
get_child(v, u);
dp_child[u] += max(0ll, dp_child[v] + a[v] - 2 * w);
con[v] = max(0ll, dp_child[v] + a[v] - 2 * w);
}
}
void get_par(long long u, long long p) {
for (auto e : g[u])
if (e.first != p) {
long long v = e.first, w = e.second;
long long t = max(0ll, dp_child[u] - con[v]);
dp_par[v] = max(0ll, dp_par[u] + a[u] - 2 * w + t);
get_par(v, u);
}
}
void dfs(long long u, long long p) {
tin[u] = ++now;
for (long long i = 1; i <= 18; i++) {
up[u][i] = up[up[u][i - 1]][i - 1];
val[u][i] = val[u][i - 1] + val[up[u][i - 1]][i - 1];
val2[u][i] = val2[u][i - 1] + val2[up[u][i - 1]][i - 1];
}
for (auto e : g[u])
if (e.first != p) {
long long v = e.first, w = e.second;
up[v][0] = u;
val[v][0] = a[v] - w + dp_child[v];
val2[v][0] = con[v];
dfs(v, u);
}
tout[u] = now;
}
bool is_ancestor(long long u, long long v) {
return (tin[u] <= tin[v] && tout[u] >= tout[v]);
}
long long lca(long long u, long long v) {
if (is_ancestor(u, v)) return u;
if (is_ancestor(v, u)) return v;
for (long long i = 18; i >= 0; i--)
if (!is_ancestor(up[u][i], v)) u = up[u][i];
return up[u][0];
}
long long solve(long long u, long long v) {
long long r = lca(u, v), res = 0;
for (long long i = 18; i >= 0; i--) {
if (!is_ancestor(up[u][i], r)) {
res += val[u][i] - val2[u][i];
u = up[u][i];
}
if (!is_ancestor(up[v][i], r)) {
res += val[v][i] - val2[v][i];
v = up[v][i];
}
}
if (u != r) res += val[u][0] - val2[u][0];
if (v != r) res += val[v][0] - val2[v][0];
return res + a[r] + dp_child[r] + dp_par[r];
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> q;
for (long long i = 1; i <= n; i++) cin >> a[i];
for (long long i = 1; i <= n - 1; i++) {
long long u, v, w;
cin >> u >> v >> w;
g[u].push_back({v, w});
g[v].push_back({u, w});
}
get_child(1, 0);
get_par(1, 0);
tin[0] = -1000000000000000000;
tout[0] = 1000000000000000000;
dfs(1, 0);
while (q--) {
long long u, v;
cin >> u >> v;
cout << solve(u, v) << "\n";
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int num[100000];
int n;
int indexa, indexb;
int suma, sumb;
suma = sumb = 0;
indexa = indexb = 1;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> num[i];
}
suma += num[0];
sumb += num[n - 1];
if (n == 1) {
cout << "1 0" << endl;
} else if (n == 2) {
cout << indexa << " " << indexb << endl;
} else {
for (int i = 1, j = n - 2; i <= j;) {
if (n == 3) {
if (suma <= sumb) {
indexa++;
break;
} else {
indexb++;
break;
}
}
if (suma <= sumb) {
suma += num[i];
indexa++;
i++;
} else {
sumb += num[j];
indexb++;
j--;
}
}
cout << indexa << " " << indexb << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000009;
const int MOD = 1000000007;
vector<string> v;
int n, m;
void borra(int p) {
for (int i = 0; i < n; i++) {
v[i].erase(v[i].begin() + p);
}
}
int problem() {
int flag = 1;
int filaP = 0;
for (int i = 1; i < n; i++) {
if (v[i] < v[i - 1]) {
flag = 0;
filaP = i;
}
}
if (flag) return -1;
if (filaP > 0) {
int j;
for (j = 0; j < m && v[filaP][j] == v[filaP - 1][j]; j++)
;
if (v[filaP][j] < v[filaP - 1][j]) return j;
}
return -1;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
v.push_back(s);
}
int p = problem();
int cnt = 0;
while (p != -1) {
borra(p);
cnt++;
p = problem();
}
cout << cnt << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int k[30][100002];
void die() {
printf("NO");
exit(0);
}
int l[100001], r[100001], v[100001], ans[100000];
int main() {
int n, m, i, j, a, b, c;
scanf("%d%d", &n, &m);
for (i = 0; i < m; i++) scanf("%d%d%d", l + i, r + i, v + i);
for (i = 0; i < m; i++) {
for (j = 0; j < 30; j++) {
int t = (v[i] >> j) & 1;
if (t) k[j][l[i]]++, k[j][r[i] + 1]--;
}
}
for (i = 1; i <= n; i++)
for (j = 0; j < 30; j++) k[j][i] += k[j][i - 1];
for (i = 1; i <= n; i++)
for (j = 0; j < 30; j++)
if (k[j][i]) k[j][i] = 1;
for (i = 1; i <= n; i++)
for (j = 0; j < 30; j++) k[j][i] += k[j][i - 1];
int diff;
for (i = 0; i < m; i++) {
for (j = 0; j < 30; j++) {
int t = (v[i] >> j) & 1;
if (!t && k[j][r[i]] - k[j][l[i] - 1] == r[i] - l[i] + 1) die();
}
}
for (i = 0; i < n; i++)
for (j = 0; j < 30; j++) ans[i] |= (k[j][i + 1] - k[j][i]) << j;
printf("YES\n");
for (i = 0; i < n; i++) printf("%d ", ans[i]);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long a[] = {0, 74, 7744, 777444, 77774444, 7777744444};
long long b[] = {0, 47, 4477, 444777, 44447777, 4444477777};
long long ans = 1e18;
void dfs(long long x, long long n, int L1, int L2) {
if (L1 == 0 && L2 == 0) {
if (x >= n) ans = min(x, ans);
return;
}
if (L1) dfs(x * 10 + 4, n, L1 - 1, L2);
if (L2) dfs(x * 10 + 7, n, L1, L2 - 1);
}
int main() {
long long n;
cin >> n;
long long x = n;
int len = 0;
while (x) {
len++;
x /= 10;
}
if (len & 1)
cout << b[len / 2 + 1] << '\n';
else {
if (n > a[len / 2])
cout << b[len / 2 + 1] << '\n';
else {
int L1 = len / 2, L2 = len / 2;
dfs(0, n, L1, L2);
cout << ans << '\n';
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)101;
int a[N][N], n, m, q, t[N * N], r[N * N], c[N * N], x;
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= q; i++) {
scanf("%d", &t[i]);
if (t[i] == 1) {
scanf("%d", &r[i]);
} else if (t[i] == 2) {
scanf("%d", &c[i]);
} else {
int rw, cl;
scanf("%d%d%d", &rw, &cl, &x);
for (int j = i - 1; j >= 1; j--) {
if (t[j] == 1 && r[j] == rw) {
cl = cl % m + 1;
}
if (t[j] == 2 && c[j] == cl) {
rw = rw % n + 1;
}
}
a[rw][cl] = x;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
printf("%d%c", a[i][j], " \n"[j == m]);
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100004;
char s[N];
int sum[N][4];
char t[N];
vector<int> cntZero, pos;
int main() {
int n;
scanf("%s", s + 1);
n = strlen(s + 1);
int i, j;
int cntz = 0, cnto = 0, cntt = 0;
for (i = 1; i <= n; i++) {
if (s[i] == '2') {
pos.push_back(i);
cntt++;
} else if (s[i] == '1')
cnto++;
else
cntz++;
for (j = 0; j < 3; j++)
sum[i][j] = sum[i - 1][j] + (((s[i] - '0') == j) ? 1 : 0);
}
sum[n + 1][0] = sum[n][0];
sum[n + 1][1] = sum[n][1];
sum[n + 1][2] = sum[n][2];
pos.push_back(n + 1);
j = n;
int val = 0;
for (i = pos.size() - 1; i > 0; i--) {
int cnt = sum[pos[i]][0] - sum[pos[i - 1]][0];
val = val + cnt;
while (cnt > 0) {
t[j] = '0';
cnt--;
j--;
}
t[j] = '2';
j--;
}
for (i = 1; i <= cntz - val; i++) t[i] = '0';
for (i = cntz - val + 1; i <= j; i++) t[i] = '1';
printf("%s\n", t + 1);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int ask(string s) {
cout << s << endl;
int k;
cin >> k;
if (!k) exit(0);
return k;
}
int main() {
int x, y, n = ask("a") + 1;
string s(n, 'a');
x = n == 301 ? n : ask(s);
x == n&& ask(string(n - 1, 'b'));
for (char& c : s) {
c = 'b';
y = ask(s);
if (x < y)
c = 'a';
else
x = y;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = (long long)1e9 + 9;
map<pair<int, int>, int> number;
struct cube {
int x;
int y;
int num;
cube() { x = y = num; }
cube(int _x, int _y, int _num) {
x = _x;
y = _y;
num = _num;
}
};
bool operator<(const cube &left, const cube &right) {
return left.num < right.num;
}
bool checkgood(int x, int y, set<cube> &v) {
if (!(v.count(cube(x, y, number[make_pair(x, y)])))) return false;
for (int dx = -1; dx <= 1; dx++)
if (v.count(cube(x + dx, y + 1, number[make_pair(x + dx, y + 1)]))) {
int cntr = 0;
for (int ndx = -1; ndx <= 1; ndx++)
if (v.count(cube(x + dx + ndx, y, number[make_pair(x + dx + ndx, y)])))
cntr++;
assert(cntr > 0);
if (cntr == 1) return false;
}
return true;
}
void solve(int n) {
vector<long long> npow(n + 1, 0);
npow[0] = 1;
for (int i = 1; i <= n; i++) npow[i] = (npow[i - 1] * n) % mod;
vector<long long> ans(n);
set<cube> all, good;
number.clear();
int x, y;
vector<pair<int, int> > temp;
for (int i = 0; i < n; i++) {
scanf(" %d %d", &x, &y);
temp.push_back(make_pair(x, y));
number[make_pair(x, y)] = i + 1;
all.insert(cube(x, y, i + 1));
}
for (int i = 0; i < n; i++)
if (checkgood(temp[i].first, temp[i].second, all))
good.insert(cube(temp[i].first, temp[i].second, i + 1));
bool Min = false;
for (int i = n - 1; i >= 0; i--) {
assert(!good.empty());
assert((int)good.size() <= (int)all.size());
cube cur;
if (Min)
cur = *good.begin();
else
cur = *good.rbegin();
ans[i] = cur.num;
good.erase(cur);
all.erase(cur);
for (int dx = -1; dx <= 1; dx++)
if (number.count(make_pair(cur.x + dx, cur.y - 1)))
if (checkgood(cur.x + dx, cur.y - 1, all))
good.insert(cube(cur.x + dx, cur.y - 1,
number[make_pair(cur.x + dx, cur.y - 1)]));
for (int dx = -2; dx <= 2; dx++)
if (number.count(make_pair(cur.x + dx, cur.y)))
if (!checkgood(cur.x + dx, cur.y, all))
good.erase(
cube(cur.x + dx, cur.y, number[make_pair(cur.x + dx, cur.y)]));
Min ^= true;
}
reverse(ans.begin(), ans.end());
long long answer = 0;
for (int i = 0; i < n; i++) answer *= n, answer += ans[i] - 1, answer %= mod;
cout << answer << endl;
}
int main() {
int n;
while (cin >> n) solve(n);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int MOD = 1000000007;
long long int inverse(long long int i) {
if (i == 1) return 1;
return (MOD - ((MOD / i) * inverse(MOD % i)) % MOD + MOD) % MOD;
}
int main() {
int t;
cin >> t;
while (t--) {
int n, k, l;
cin >> n >> k >> l;
int d[n + 1];
int h[2 * k];
for (int i = 0; i <= k; ++i) h[i] = i;
for (int i = k + 1; i < 2 * k; ++i) h[i] = 2 * k - i;
for (int i = 1; i <= n; ++i) cin >> d[i];
int ans1[n + 1][2 * k];
for (int i = 0; i < 2 * k; ++i) {
if (d[n] + h[i] <= l) {
ans1[n][i] = 1;
} else
ans1[n][i] = 0;
}
for (int i = n - 1; i >= 1; --i) {
for (int j = 0; j < 2 * k; ++j) {
if (d[i] + h[j] > l) {
ans1[i][j] = 0;
continue;
}
int flag = 0;
int flag4 = 0;
for (int c = j; c < 2 * k; ++c) {
if (d[i] + h[c] <= l && ans1[i + 1][(c + 1) % (2 * k)] == 1) flag = 1;
if (d[i] + h[c] > l) {
flag4 = 1;
break;
}
}
if (flag4 == 0) {
for (int c = 0; c < j; ++c) {
if (d[i] + h[c] <= l && ans1[i + 1][(c + 1) % (2 * k)] == 1)
flag = 1;
if (d[i] + h[c] > l) {
break;
}
}
}
ans1[i][j] = flag;
}
}
int flag2 = 0;
for (int j = 0; j < 2 * k; ++j) {
if (ans1[1][j]) flag2 = 1;
}
if (flag2)
cout << "Yes\n";
else
cout << "No\n";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long f = 1, x = 0;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') f = -f;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int main() {
int n = read();
vector<int> vec, ans(n + 1, 0);
for (int i = 1; i <= n; i++) {
vec.push_back(read());
}
sort(vec.begin(), vec.end());
int cur1 = 0, cur2 = n - 1;
for (int i = 2; i <= n; i += 2) {
ans[i] = vec[cur1++];
}
for (int i = 1; i <= n; i += 2) {
ans[i] = vec[cur1++];
}
int cnt = 0;
for (int i = 2; i < n; i++) {
if (ans[i - 1] > ans[i] && ans[i] < ans[i + 1]) cnt++;
}
printf("%d\n", cnt);
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
printf("\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int degree[n], xorsum[n];
queue<int> Q;
int used = 0;
for (int i = 0; i < n; ++i) {
cin >> degree[i] >> xorsum[i];
if (degree[i] == 1) Q.push(i);
if (degree[i] == 0) {
used++;
}
}
vector<pair<int, int> > ans;
while (!Q.empty()) {
int from = Q.front();
Q.pop();
used++;
if (degree[from] == 0) {
continue;
}
degree[from]--;
int to = xorsum[from];
xorsum[from] = 0;
if (to >= n) assert(false);
ans.push_back(make_pair(from, to));
xorsum[to] ^= from;
if (degree[to] == 0) assert(false);
degree[to]--;
if (degree[to] == 1) Q.push(to);
}
cout << ans.size() << endl;
for (size_t i = 0; i < ans.size(); ++i)
cout << ans[i].first << " " << ans[i].second << endl;
return 0;
}
| 3 |
using namespace std;
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <sstream>
#include <queue>
#include <deque>
#include <bitset>
#include <iterator>
#include <list>
#include <stack>
#include <map>
#include <unordered_map>
#include <set>
#include <functional>
#include <numeric>
#include <utility>
#include <climits>
#include <chrono>
#include <cmath>
#include <cassert>
#include <iomanip>
#define pb push_back
#define ppb pop_back
#define all(x) (x).begin(),(x).end()
#define pii pair<int, int>
//const long long mod = 1e9 + 7;
//const long double pi = 3.14159265358979323846264338327950288419716939937510;
//const double err = 1e-6;
//template <typename T>
//inline T gcd(T a, T b) { while (b != 0) swap(b, a %= b); return a; }
//inline int64_t lcm(int64_t a, int64_t b) { return a/(gcd<int64_t>(a, b)) * b;}
//vector<int> lp, primes;
//void linSieve(int n){
// for(int i = 0; i <= n; i++)
// lp.push_back(0);
// for(int i = 2; i <= n; i++){
// if(lp[i] == 0){
// lp[i] = i;
// primes.push_back(i);
// }
// for(int j = 0; j < (int)primes.size() && primes[j] <= lp[i] && i*primes[j] < n; j++)
// lp[i*primes[j]] = primes[j];
// }
//}
//vector<int64_t> fact(100001, 1);
//vector<int64_t> factinv(100001, 1);
//int64_t fpow(int64_t b, int64_t e){
// if(e == 0)
// return 1;
// int64_t temp = fpow(b, e/2);
// if(e % 2 == 0) return (temp*temp)%mod;
// return (b*((temp*temp)%mod))%mod;
//}
//int64_t inv(int64_t x){
// return fpow(x, mod-2); // fermat's little theorem 1 = a^(n-1) => a^(-1) = a^(n-2)
//}
//void prefac(){
// for(int i = 1; i <= 100000; i++){
// fact[i] = (fact[i-1]* i) % mod;
// factinv[i] = inv(fact[i]) % mod;
// }
//}
//int64_t nck(int64_t n, int64_t k){
// if(k < 0 || k > n) return 0;
// return (fact[n]*((factinv[k]%mod)*((factinv[n-k])%mod)%mod))%mod;
//}
void helper(){
int n;
cin >> n;
vector<int> d(n);
for(auto &it :d)
cin >> it;
sort(d.begin(), d.end());
int64_t sum = 0, count = 0, res = 0;
for(int i = 1; i < n; i++){
res += d[i]-d[i-1];
count++;
sum += d[i-1];
res -= d[i]*count - sum;
}
cout << res << '\n';
}
int32_t main(){
ios_base::sync_with_stdio(0);
cin.tie(nullptr);
cout.tie(nullptr);
int t;
cin >> t;
while(t--) helper();
// helper();
return 0;
} | 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
int dp[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
dp[i] = a[i];
}
for (int i = n - 2; i >= 0; i--) {
if (dp[i] == 0) {
continue;
} else {
if (dp[i] == dp[i + 1] && dp[i] != 3) {
dp[i] = 0;
} else {
if (dp[i] != dp[i + 1] && dp[i] != 3) {
dp[i] = dp[i];
} else if (dp[i] != dp[i + 1] && dp[i] == 3) {
if (dp[i + 1] != 0) {
dp[i] = 3 - dp[i + 1];
}
}
}
}
}
int ans = 0;
for (int i = 0; i < n; i++) {
if (dp[i] == 0) ans++;
}
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
string s;
cin >> s;
int m;
scanf("%d", &m);
int l, r, k;
char sw[10002];
for (int i = 0; i < m; ++i) {
scanf("%d%d%d", &l, &r, &k);
--l;
--r;
k = k % (r - l + 1);
for (int j = l; j <= r; ++j) {
sw[j] = s[j];
}
for (int j = r; j >= l + k; --j) {
s[j] = s[j - k];
}
for (int j = 0; j < k; ++j) {
s[l + j] = sw[r - k + j + 1];
}
}
std::cout << s;
}
int main(int argc, char *argv[]) {
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1e9;
int main() {
string s, t;
cin >> s >> t;
s = "##" + s;
t = "##" + t;
vector<vector<int> > dp(s.size() + 1, vector<int>(t.size() + 1, INF));
dp[0][0] = 0;
for (int i = 1; i < s.size(); i++) {
for (int j = 1; j < t.size(); j++) {
dp[i][j] = min(dp[i][j], dp[i - 1][j - 1] + (int)(s[i] != t[j]));
dp[i][j] = min(dp[i][j], dp[i - 1][j] + 1);
dp[i][j] = min(dp[i][j], dp[i][j - 1] + 1);
}
}
int i = (int)s.size() - 1;
int j = (int)t.size() - 1;
cout << dp[i][j] << endl;
vector<vector<string> > ans(3);
while (min(i, j) != 0) {
if (dp[i][j] == dp[i - 1][j - 1] + (int)(s[i] != t[j])) {
if (s[i] != t[j]) {
stringstream buf;
buf << "REPLACE"
<< " " << j - 1 << " " << t[j];
ans[2].push_back(buf.str());
}
i--, j--;
} else if (dp[i][j] == dp[i - 1][j] + 1) {
stringstream buf;
buf << "DELETE"
<< " " << i - 1;
ans[0].push_back(buf.str());
i--;
} else if (dp[i][j] == dp[i][j - 1] + 1) {
stringstream buf;
buf << "INSERT"
<< " " << j - 1 << " " << t[j];
ans[1].push_back(buf.str());
j--;
}
}
reverse((ans[1]).begin(), (ans[1]).end());
for (auto v : ans) {
for (auto x : v) {
cout << x << endl;
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long mod = 20071027;
const double eps = 1e-6;
template <class T>
T gcd(T a, T b) {
if (!b) return a;
return gcd(b, a % b);
}
const int maxn = 2e3 + 10, sgm_sz = 26;
long long a[maxn], n, k, dp[maxn];
inline long long d(long long x, long long y) { return (x > y) ? x - y : y - x; }
int check(long long x) {
for (int i = 1; i <= n; i++) {
dp[i] = i - 1;
for (int j = 1; j < i; j++)
if (d(a[i], a[j]) <= (i - j) * x) dp[i] = min(dp[i], dp[j] + i - j - 1);
if (dp[i] + n - i <= k) return 1;
}
return 0;
}
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
long long l = -1, r = 2e9 + 10;
while (l + 1 < r) {
if (check(((l + r) >> 1)))
r = ((l + r) >> 1);
else
l = ((l + r) >> 1);
}
cout << r << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
long long n, x;
cin >> n >> x;
vector<long long> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
sort(v.begin(), v.end());
long long cnt = 1, i = n - 1, team = 0;
while (i >= 0 && v[i] > x) {
++team;
--i;
}
for (; i >= 0; --i) {
if (cnt * v[i] >= x) {
cnt = 0;
++team;
}
++cnt;
}
cout << team << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long d[100005];
long long c[100005];
long long a[100005];
int main() {
long long n, p, q, r;
while (cin >> n >> p >> q >> r) {
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
if (i == 0) {
d[i] = a[i] * p;
} else {
d[i] = max(a[i] * p, d[i - 1]);
}
}
for (int i = n - 1; i >= 0; i--) {
if (i == n - 1) {
c[i] = a[i] * r;
} else {
c[i] = max(c[i + 1], a[i] * r);
}
}
long long ans = -1e19;
for (int i = 0; i < n; i++) {
ans = max(ans, c[i] + d[i] + a[i] * q);
}
cout << ans << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000000;
int n, m;
long long a[200100];
long long fibo[200100];
int main() {
fibo[0] = fibo[1] = 1;
for (int i = 2; i < 200100; i++) {
fibo[i] = (fibo[i - 2] + fibo[i - 1]) % mod;
}
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%lld", a + i);
}
for (int ttt = 1; ttt <= m; ttt++) {
int type;
scanf("%d", &type);
if (type == 1) {
int x, v;
scanf("%d %d", &x, &v);
a[x] = v;
} else if (type == 2) {
int l, r;
scanf("%d %d", &l, &r);
long long ans = 0;
for (int i = l; i <= r; i++) {
ans = (ans + fibo[i - l] * a[i] % mod) % mod;
}
printf("%lld\n", ans);
}
}
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
#define fo(i,n) for(int i=0;i<n;i++)
#define Fo(i,k,n) for(i=k;k<n?i<n:i>n;k<n?i+=1:i-=1)
#define ll long long
#define l long
#define PI 3.1415926535897932384626
int main() {
int t = 1;
cin >> t;
int n;
while (t--)
{
cin>>n;
int arr[n];
fo(i,n){
cin>>arr[i];
}
fo(i,n){
if(arr[i]%2 == 0){
cout<<arr[i]<<" ";
}
}
fo(i,n){
if(arr[i]%2 != 0){
cout<<arr[i]<<" ";
}
}
cout<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
set<pair<int, int> > vp;
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
if (n == 0) {
cout << 0 << ' ' << 1 << endl;
cout << 0 << ' ' << m << endl;
cout << 0 << ' ' << 0 << endl;
cout << 0 << ' ' << m - 1 << endl;
return 0;
} else if (m == 0) {
cout << 1 << ' ' << 0 << endl;
cout << n << ' ' << 0 << endl;
cout << 0 << ' ' << 0 << endl;
cout << n - 1 << ' ' << 0 << endl;
return 0;
}
vp.insert(make_pair(n, m));
vp.insert(make_pair(0, 0));
vp.insert(make_pair(0, m));
vp.insert(make_pair(n, 0));
vp.insert(make_pair(n - 1, m - 1));
vp.insert(make_pair(1, 1));
vp.insert(make_pair(n - 1, 1));
vp.insert(make_pair(1, m - 1));
vp.insert(make_pair(n - 1, m));
vp.insert(make_pair(n, m - 1));
vp.insert(make_pair(0, 1));
vp.insert(make_pair(1, 0));
vector<pair<int, int> > num;
pair<int, int> ans[4];
double maxi = 0.;
for (set<pair<int, int> >::iterator x = vp.begin(); x != vp.end(); ++x) {
for (set<pair<int, int> >::iterator y = vp.begin(); y != vp.end(); ++y) {
if (y == x) continue;
for (set<pair<int, int> >::iterator z = vp.begin(); z != vp.end(); ++z) {
if (z == y || z == x) continue;
for (set<pair<int, int> >::iterator t = vp.begin(); t != vp.end();
++t) {
if (t == z || t == y || t == x) continue;
pair<int, int> tmp[4];
int arr[4] = {0, 1, 2, 3};
tmp[0].first = x->first;
tmp[0].second = x->second;
tmp[1].first = y->first;
tmp[1].second = y->second;
tmp[2].first = z->first;
tmp[2].second = z->second;
tmp[3].first = t->first;
tmp[3].second = t->second;
double dis = 0.;
do {
double dis = 0.;
dis +=
sqrt((double)((tmp[arr[0]].first - tmp[arr[1]].first) *
(tmp[arr[0]].first - tmp[arr[1]].first) +
(tmp[arr[0]].second - tmp[arr[1]].second) *
(tmp[arr[0]].second - tmp[arr[1]].second)));
dis +=
sqrt((double)((tmp[arr[1]].first - tmp[arr[2]].first) *
(tmp[arr[1]].first - tmp[arr[2]].first) +
(tmp[arr[1]].second - tmp[arr[2]].second) *
(tmp[arr[1]].second - tmp[arr[2]].second)));
dis +=
sqrt((double)((tmp[arr[2]].first - tmp[arr[3]].first) *
(tmp[arr[2]].first - tmp[arr[3]].first) +
(tmp[arr[2]].second - tmp[arr[3]].second) *
(tmp[arr[2]].second - tmp[arr[3]].second)));
if (dis > maxi) {
maxi = dis;
for (int i = 0; i < 4; i++) ans[i] = tmp[arr[i]];
}
} while (next_permutation(arr, arr + 4));
}
}
}
}
for (int i = 0; i < 4; i++) {
cout << ans[i].first << ' ' << ans[i].second << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
vector<set<int>> adj;
vector<int> leaf;
void dfs(int cur, int par) {
for (int x : adj[cur]) {
if (x == par) continue;
dfs(x, cur);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int tt;
cin >> tt;
while (tt--) {
cin >> n >> k;
adj = vector<set<int>>(n);
leaf = vector<int>(n);
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
--x;
--y;
adj[x].insert(y);
adj[y].insert(x);
}
queue<int> qq;
for (int i = 0; i < n; i++) {
if (adj[i].size() == 1) qq.push(i);
}
int ans = 0;
while (!qq.empty()) {
int cur = qq.front();
qq.pop();
ans += leaf[cur] / k;
leaf[cur] %= k;
if (leaf[cur] == 0 && adj[cur].size() == 1) {
int x = *adj[cur].begin();
adj[x].erase(cur);
adj[cur].erase(x);
if (++leaf[x] >= k) qq.push(x);
}
}
cout << ans << '\n';
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 100, INF = 2e9 + 100;
string s;
long long n, x1, y11, x2, y2, dx, dy;
bool check(long long k) {
long long X = dx * k;
long long Y = dy * k;
X += x1;
Y += y11;
if (abs(x2 - X) + abs(y2 - Y) <= n * k) return true;
return false;
}
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> x1 >> y11 >> x2 >> y2 >> n >> s;
for (long long i = 0; i < n; i++) {
if (s[i] == 'U') dy++;
if (s[i] == 'D') dy--;
if (s[i] == 'L') dx--;
if (s[i] == 'R') dx++;
}
long long st = -1, e = INF;
while (e - st > 1) {
long long m = (st + e) / 2;
if (check(m))
e = m;
else
st = m;
}
if (e == INF) return cout << -1, 0;
x1 += dx * (e - 1);
y11 += dy * (e - 1);
for (long long i = 0; i < n; i++) {
if (s[i] == 'U') y11++;
if (s[i] == 'D') y11--;
if (s[i] == 'L') x1--;
if (s[i] == 'R') x1++;
if (abs(x2 - x1) + abs(y2 - y11) <= (e - 1) * n + i + 1)
return cout << (e - 1) * n + i + 1, 0;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200007, inf = 0x3f3f3f3f, M = 1000000007;
vector<int> edges[N];
pair<long long, long long> cnt[N];
long long a[N];
pair<long long, long long> dfs(int u, int prev) {
long long par, imp;
par = imp = 0;
for (int v : edges[u]) {
if (v == prev) continue;
pair<long long, long long> aux = dfs(v, u);
imp += aux.first;
par += aux.second;
}
par++;
cnt[u] = make_pair(par, imp);
return cnt[u];
}
inline long long mul(long long a, long long b) { return (a % M * b % M) % M; }
long long solve(int u, int prev, int imp = 0) {
long long tot = 0, aux = 0;
long long par = cnt[1].first, impar = cnt[1].second;
for (int v : edges[u]) {
if (v == prev) continue;
tot += solve(v, u, !imp);
tot %= M;
if (imp == 0) {
aux += mul(a[u], mul(cnt[v].second, par - cnt[v].second) -
mul(cnt[v].first, impar - cnt[v].first) + M);
par -= cnt[v].second;
impar -= cnt[v].first;
} else {
aux += mul(a[u], mul(cnt[v].second, impar - cnt[v].second) -
mul(cnt[v].first, par - cnt[v].first) + M);
par -= cnt[v].first;
impar -= cnt[v].second;
}
aux %= M;
}
if (imp == 0) {
aux += (a[u] * (cnt[1].first - cnt[u].first + M) % M) % M;
} else
aux += (a[u] * (cnt[1].second - cnt[u].first + M) % M) % M;
aux %= M;
tot += (2 * aux + a[u]) % M;
tot %= M;
return tot;
}
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
a[i] = (a[i] + M) % M;
}
for (int i = 1; i < n; ++i) {
int u, v;
cin >> u >> v;
edges[u].push_back(v);
edges[v].push_back(u);
}
dfs(1, -1);
cout << solve(1, -1) << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string temp;
bool freda, rinbow;
int n;
cin >> n;
string* list = new string[n];
getline(cin, temp);
for (int i = 0; i < n; i++) getline(cin, list[i]);
for (int i = 0; i < n; i++) {
freda = rinbow = false;
if (list[i] == " " || list[i].length() < 5) {
cout << "OMG>.< I don't know!" << endl;
continue;
}
if (list[i].substr(0, 5) == "miao.") rinbow = true;
if (list[i].substr(list[i].length() - 5, 5) == "lala.") freda = true;
if (freda && rinbow || !(freda || rinbow))
cout << "OMG>.< I don't know!" << endl;
else if (freda)
cout << "Freda's" << endl;
else if (rinbow)
cout << "Rainbow's" << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int r, c;
cin >> r >> c;
set<int> row;
set<int> col;
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
char c;
cin >> c;
if (c == 'S') {
row.insert(i);
col.insert(j);
}
}
}
int x = row.size();
int y = col.size();
int ans = (r - x) * c + (c - y) * r - (r - x) * (c - y);
cout << max(ans, 0) << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int q;
cin >> q;
string a[1010], b[1010], c[1010];
for (long long i = 1; i <= q; i++) cin >> a[i] >> b[i], c[i] = a[i];
int f[1010];
for (long long i = 1; i <= q; i++) {
f[i] = i;
for (long long j = 1; j <= q; j++) {
if (b[f[i]] == a[j]) {
f[i] = (int)j;
}
}
}
int res = 0;
set<string> use;
use.insert(b[f[1]]);
a[1] = b[f[1]];
for (long long i = 1; i <= q; i++) {
set<string> m = use;
m.insert(b[f[i]]);
if (m.size() > use.size()) {
a[i] = b[f[i]];
use = m;
}
}
for (long long i = 1; i <= q; i++)
if (a[i] != c[i]) res++;
cout << res << endl;
for (long long i = 1; i <= q; i++)
if (a[i] != c[i]) cout << c[i] << " " << a[i] << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
int getbit(T x, int pos) {
return (x >> (pos - 1)) & 1;
}
template <class T>
void turn_on(T &x, int pos) {
x = x | ((T)1 << (pos - 1));
}
template <class T>
void turn_off(T &x, int pos) {
x = x & ~((T)1 << (pos - 1));
}
int read_int() {
char r;
bool start = false, neg = false;
int ret = 0;
while (true) {
r = getchar();
if ((r - '0' < 0 || r - '0' > 9) && r != '-' && !start) continue;
if ((r - '0' < 0 || r - '0' > 9) && r != '-' && start) break;
if (start) ret *= 10;
start = true;
if (r == '-')
neg = true;
else
ret += r - '0';
}
if (!neg)
return ret;
else
return -ret;
}
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
const long long oo = 1e18 + 7;
const int MOD = 1e9 + 7;
long long n;
long long t[50];
long long tm[50];
long long res[50];
void solve() {
memset(res, 0, sizeof(res));
cin >> n;
n--;
int id = 1;
while (t[id] < n) {
id++;
}
long long N = t[id];
long long T = 1;
for (int i = 1; i <= id; i++) {
long long s = 0;
long long tmp = 1;
for (int j = i; j <= id; j++) {
if (j == i) {
s += (id - j + 1);
continue;
}
s += tmp * 1LL * (id - j + 1);
tmp *= 2;
}
long long x = N - n;
x /= s;
x = min(x, T);
N -= x * s;
res[i] = T - x;
T += res[i];
}
if (N != n) {
cout << -1;
return;
}
cout << id << '\n';
for (int i = 1; i <= id; i++) cout << res[i] << ' ';
}
int main() {
srand(time(NULL));
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
t[1] = 2;
long long s = 2;
long long tmp = 1;
tm[1] = 1;
for (int i = 2; i <= 49; i++) {
tmp *= 2;
s += tmp;
tm[i] = tmp;
t[i] = t[i - 1] + s;
}
int T;
cin >> T;
while (T--) {
solve();
cout << '\n';
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int c, d, m, n, k, s = 0;
cin >> c >> d >> n >> m >> k;
if (k >= m * n)
cout << "0";
else {
int x = n * m - k;
if (c > n * d)
s = ceil((float)x * d);
else {
s = x / n * c + min(c, x % n * d);
}
cout << s;
}
}
| 3 |