solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
int main() {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
if (c == 0) {
if (a > b)
printf("+");
else if (b > a)
printf("-");
else
printf("0");
}
if (c != 0) {
if (a == b)
printf("?");
else if (a == (b + c))
printf("?");
else if (b == (a + c))
printf("?");
else if (a >= (b + c))
printf("+");
else if (b >= (a + c))
printf("-");
else if ((a + c) >= b && (b + c) >= a)
printf("?");
else
printf("invalid");
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n;
char space[1000100];
long long lpsD[1000100];
long long rpsU[1000100];
int main() {
cin >> n;
cin >> (space + 1);
long long cU = 0, cD = 0;
for (long long i = 1; i <= n; i++) {
if (space[i] == 'U') {
cU++;
} else {
cD++;
if (cD == 1)
lpsD[cD] = i;
else
lpsD[cD] = lpsD[cD - 1] + i;
}
}
cU = 0;
cD = 0;
for (long long i = n; i >= 1; i--) {
if (space[i] == 'U') {
cU++;
if (cU == 1)
rpsU[cU] = n + 1 - i;
else
rpsU[cU] = rpsU[cU - 1] + n + 1 - i;
} else {
cD++;
}
}
long long lU = 0, lD = 0, rU = cU, rD = cD;
for (long long i = 1; i <= n; i++) {
if (space[i] == 'U') {
rU--;
if (rD >= lU + 1) {
long long res = 0;
res += (rpsU[cU] - rpsU[cU - lU] - lU * (n + 1 - i)) * 2;
res += (lpsD[lD + lU + 1] - lpsD[lD] - (lU + 1) * i) * 2;
res += i;
cout << res << " ";
} else {
long long res = 0;
res += (lpsD[cD] - lpsD[cD - rD] - rD * i) * 2;
res += (rpsU[cU - lU + rD] - rpsU[cU - lU] - rD * (n + 1 - i)) * 2;
res += n + 1 - i;
cout << res << " ";
}
lU++;
} else {
rD--;
if (lU >= rD + 1) {
long long res = 0;
res += (lpsD[cD] - lpsD[cD - rD] - rD * i) * 2;
res +=
(rpsU[cU - lU + rD + 1] - rpsU[cU - lU] - (rD + 1) * (n + 1 - i)) *
2;
res += n + 1 - i;
cout << res << " ";
} else {
long long res = 0;
res += (rpsU[cU] - rpsU[cU - lU] - lU * (n + 1 - i)) * 2;
res += (lpsD[cD - rD + lU] - lpsD[cD - rD] - lU * i) * 2;
res += i;
cout << res << " ";
}
lD++;
}
}
cout << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e4 + 5;
int n, k, sol = 1e9, t[MAX][5];
char e[MAX], h[MAX], s[MAX];
pair<int, int> a[MAX];
void relax(int ans, char* h) {
if (ans < sol) {
sol = ans;
strcpy(s + 1, h + 1);
}
if (ans == sol && strcmp(h + 1, s + 1) == -1) strcpy(s + 1, h + 1);
}
void check(int d) {
int cnt = k, cost = 0;
for (int i = 1; i <= n; i++) {
h[i] = e[i];
if (e[i] == d) cnt--;
}
if (cnt <= 0) {
relax(cost, h);
return;
}
for (int k = 1; k < 10; k++) {
if (t[k][0] == 0) continue;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= t[k][0]; j++) {
int d1 = t[k][j] + '0';
if (h[i] == d1) {
if (d1 > d) {
cost += k;
cnt--;
h[i] = d;
}
break;
}
}
if (cnt == 0) break;
}
if (cnt == 0) break;
for (int i = n; i > 0; i--) {
for (int j = 1; j <= t[k][0]; j++) {
int d1 = t[k][j] + '0';
if (h[i] == d1) {
if (d1 < d) {
cost += k;
cnt--;
h[i] = d;
}
break;
}
}
if (cnt == 0) break;
}
if (cnt == 0) break;
}
if (cnt == 0) relax(cost, h);
}
int main() {
scanf("%d%d\n", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%c", &e[i]);
s[i] = '9';
}
for (int d = 0; d < 10; d++) {
for (int i = 0; i < 10; i++) {
a[i].first = abs(d - i);
a[i].second = i;
}
sort(a, a + 10);
for (int i = 0; i < 10; i++) t[i][0] = 0;
for (int i = 0; i < 10; i++)
t[a[i].first][++t[a[i].first][0]] = a[i].second;
check(d + '0');
}
printf("%d\n%s\n", sol, s + 1);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, abc, v = 0;
cin >> n >> m;
stack<int> a;
stack<int> b;
for (int i = 0; i != n; ++i) {
cin >> abc;
a.push(abc);
}
for (int i = 0; i != m; ++i) {
cin >> abc;
b.push(abc);
}
while (!a.empty()) {
if (!b.empty() && a.top() <= b.top())
b.pop();
else
++v;
a.pop();
}
cout << v << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool check(int a) {
if (a < 0) a = -a;
while (a != 0) {
if (a % 10 == 8) return 1;
a = a / 10;
}
return 0;
}
int main() {
int n, m, t = 0, sum = 0, A[105], ii = 1;
cin >> n;
for (int i = n + 1; i < 8888888888; i++) {
if (check(i) == 1) {
cout << i - n;
return 0;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1e9 + 7;
vector<long long int> z_function(string s) {
long long int n = s.length();
vector<long long int> z(n);
for (long long int i = 1, l = 0, r = 0; i < n; i++) {
if (i <= r) z[i] = min(z[i - l], r - i + 1);
while (i + z[i] < n && s[z[i]] == s[i + z[i]]) z[i]++;
if (z[i] + i > r) {
l = i;
r = i + z[i] - 1;
}
}
return z;
}
long long int binpow(long long int a, long long int b) {
long long int ans = 1;
while (b > 0) {
if (b & 1) ans = (ans * a) % mod;
a = (a * a) % mod;
b = b >> 1;
}
return ans;
}
signed main() {
long long int n, m;
cin >> n >> m;
string p;
cin >> p;
vector<long long int> z = z_function(p);
vector<long long int> y(m);
for (long long int i = 0; i < m; ++i) cin >> y[i];
long long int cnt = 0;
long long int l = 0;
long long int r = 0;
for (long long int i = 0; i < m; ++i) {
if (y[i] > r) {
cnt += y[i] - r - 1;
l = y[i];
r = y[i] + p.length() - 1;
} else if (l <= y[i] && r >= y[i]) {
if (z[y[i] - l] >= r - y[i] + 1) {
l = y[i];
r = y[i] + p.length() - 1;
} else {
cout << "0";
return 0;
}
}
}
cnt += n - r;
long long int ans = binpow(26, cnt);
cout << ans << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 100003, INF = 0x7f7f7f7f;
int n, m, d, affected[MaxN];
vector<int> e[MaxN];
int dist[MaxN];
int U, V, du[MaxN], dv[MaxN];
void dfs(int x, int* d = dist) {
for (auto i : e[x]) {
if (d[i] == INF) {
d[i] = d[x] + 1;
dfs(i, d);
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &d);
for (int i = 1; i <= m; ++i) scanf("%d", affected + i);
for (int i = 1; i < n; ++i) {
int u, v;
scanf("%d%d", &u, &v);
e[u].push_back(v), e[v].push_back(u);
}
memset(dist, 0x7f, sizeof dist);
dist[affected[1]] = 0;
dfs(affected[1]);
int mx = 1;
for (int i = 1; i <= m; ++i)
if (dist[affected[i]] > dist[affected[mx]]) mx = i;
U = mx;
memset(dist, 0x7f, sizeof dist);
dist[affected[U]] = 0;
dfs(affected[U]);
mx = U;
for (int i = 1; i <= m; ++i)
if (dist[affected[i]] > dist[affected[mx]]) mx = i;
V = mx;
memset(du, 0x7f, sizeof du);
du[affected[U]] = 0;
dfs(affected[U], du);
memset(dv, 0x7f, sizeof dv);
dv[affected[V]] = 0;
dfs(affected[V], dv);
int ans = 0;
for (int i = 1; i <= n; ++i) {
if (du[i] <= d && dv[i] <= d) ans++;
}
printf("%d\n", ans);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int a, n;
cin >> a;
n = a / 5;
if (a <= 5) {
cout << "1" << endl;
} else if (a > 5) {
if (a % 5 == 0) {
cout << n << endl;
} else {
cout << n + 1 << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, q;
cin >> n;
vector<int> v(n), pre(n + 1);
for (int i = 0; i < n; ++i) {
cin >> v[i];
pre[i + 1] = pre[i] + v[i];
}
cin >> q;
while (q--) {
int l, r;
cin >> l >> r;
cout << (pre[r] - pre[l - 1]) / 10 << '\n';
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int INF = 1e9;
const int base = 1e9;
const int MAX = 2e5;
const long double EPS = 1e-10;
const long double PI = acos(-1.);
int n, m;
int D, E, v;
int d[MAX];
int e[MAX];
int x1, x2, adlsdss, y2;
int drab() {
int cur = INF;
int pos = lower_bound(d, d + D, adlsdss) - d;
if (pos < D) {
cur = min(cur, abs(adlsdss - d[pos]) + abs(y2 - d[pos]) + abs(x1 - x2));
}
pos--;
if (pos >= 0) {
cur = min(cur, abs(adlsdss - d[pos]) + abs(y2 - d[pos]) + abs(x1 - x2));
}
return cur;
}
int lift() {
int cur = INF;
int pos = lower_bound(e, e + E, adlsdss) - e;
if (pos < E) {
cur = min(cur, abs(adlsdss - e[pos]) + abs(y2 - e[pos]) +
(abs(x1 - x2) + v - 1) / v);
}
pos--;
if (pos >= 0) {
cur = min(cur, abs(adlsdss - e[pos]) + abs(y2 - e[pos]) +
(abs(x1 - x2) + v - 1) / v);
}
return cur;
}
int solve() {
int best = INF;
if (x1 == x2) {
return abs(adlsdss - y2);
}
if (D) {
best = min(best, drab());
}
if (E) {
best = min(best, lift());
}
int x = adlsdss;
adlsdss = y2;
y2 = x;
if (D) {
best = min(best, drab());
}
if (E) {
best = min(best, lift());
}
return best;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m >> D >> E >> v;
for (int i = (0); i < (D); ++i) {
cin >> d[i];
}
for (int j = (0); j < (E); ++j) {
cin >> e[j];
}
int q;
cin >> q;
for (int i = (0); i < (q); ++i) {
cin >> x1 >> adlsdss >> x2 >> y2;
cout << solve() << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct Tpoint {
double x, y;
Tpoint() {}
Tpoint(double _x, double _y) {
x = _x;
y = _y;
}
inline void read() { scanf("%lf%lf", &x, &y); }
inline void show() { printf("%lf %lf\n", x, y); }
inline double norm() { return sqrt(((x) * (x)) + ((y) * (y))); }
};
inline Tpoint operator+(const Tpoint &a, const Tpoint &b) {
return Tpoint(a.x + b.x, a.y + b.y);
}
inline Tpoint operator-(const Tpoint &a, const Tpoint &b) {
return Tpoint(a.x - b.x, a.y - b.y);
}
inline Tpoint operator*(const Tpoint &a, const double &b) {
return Tpoint(a.x * b, a.y * b);
}
inline Tpoint operator/(const Tpoint &a, const double &b) {
return Tpoint(a.x / b, a.y / b);
}
inline double det(const Tpoint &a, const Tpoint &b) {
return a.x * b.y - a.y * b.x;
}
inline double dot(const Tpoint &a, const Tpoint &b) {
return a.x * b.x + a.y * b.y;
}
long long n, x, y, base;
long long A[1000005];
struct Tmat {
long long a[2][2];
inline void clear() { memset(a, 0, sizeof(a)); }
inline void diagonal() {
clear();
for (int i = 0; i < 2; ++i) a[i][i] = 1;
}
};
inline Tmat operator*(const Tmat &a, const Tmat &b) {
Tmat res;
res.clear();
for (int k = 0; k < 2; ++k)
for (int i = 0; i < 2; ++i)
for (int j = 0; j < 2; ++j) {
res.a[i][j] += a.a[i][k] * b.a[k][j];
res.a[i][j] %= base;
}
return res;
}
inline Tmat calc(const Tmat &a, long long t) {
Tmat res;
res.diagonal();
if (!t) return res;
res = calc(a, t >> 1);
res = res * res;
if (t & 1LL) res = res * a;
return res;
}
int main() {
cin >> n >> x >> y >> base;
long long s = 0;
for (int i = 0; i < n; ++i) {
int x;
scanf("%d", &x);
A[i] = x;
s += A[i];
s %= base;
}
if (n == 1) {
printf("%d\n", (int)s);
return 0;
}
sort(A, A + n);
Tmat a;
a.a[0][0] = 0;
a.a[0][1] = 1;
a.a[1][0] = 1;
a.a[1][1] = 1;
a = calc(a, x);
long long tmax = (A[n - 2] * a.a[1][0] + A[n - 1] * a.a[1][1]) % base;
a.a[0][0] = 1;
a.a[0][1] = 0;
a.a[1][0] = 1;
a.a[1][1] = 3;
a = calc(a, x);
s = (s * a.a[1][1] - (A[0] + A[n - 1]) * a.a[1][0]) % base;
if (s < 0) s += base;
a.a[0][0] = 1;
a.a[0][1] = 0;
a.a[1][0] = 1;
a.a[1][1] = 3;
a = calc(a, y);
s = (s * a.a[1][1] - (A[0] + tmax) * a.a[1][0]) % base;
if (s < 0) s += base;
printf("%d\n", (int)s);
return 0;
}
| 9 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
using pii = std::pair<long long, long long>;
using namespace std;
long long n, m, a, b, w;
vector<vector<pii>> adj;
vector<long long> ans;
long long dist[100005], parent[100005];
void dijkstra(long long s) {
for (long long i = (0); i < (n); i++) {
dist[i] = (long long)1e12;
parent[i] = -1;
}
dist[s] = 0;
priority_queue<pii, vector<pii>, greater<pii>> pq;
pq.push({0, s});
long long v, d, to, length;
while (!pq.empty()) {
d = pq.top().first;
v = pq.top().second;
pq.pop();
if (d != dist[v]) continue;
for (pii edge : adj[v]) {
length = edge.first;
to = edge.second;
if (dist[v] + length < dist[to]) {
dist[to] = dist[v] + length;
parent[to] = v;
pq.push({dist[to], to});
}
}
}
}
void getParents(long long x) {
if (parent[x] != -1) getParents(parent[x]);
ans.push_back(x + 1);
}
class CDijkstra {
public:
void solve(std::istream& in, std::ostream& out) {
in >> n >> m;
adj.resize(n);
for (long long i = (0); i < (m); i++) {
in >> a >> b >> w;
adj[a - 1].push_back({w, b - 1});
adj[b - 1].push_back({w, a - 1});
}
dijkstra(0);
getParents(n - 1);
if (ans[0] != 1)
out << -1 << "\n";
else
for (long long i = (0); i < (ans.size()); i++) out << ans[i] << " ";
out << "\n";
}
};
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
CDijkstra solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
int n;
vector<int> twos;
bool used[MAXN], np[MAXN];
vector<pair<int, int> > sol;
int main(void) {
cin >> n;
for (int i = 2; i <= n; i++) {
if (np[i]) continue;
for (int j = i * 2; j <= n; j += i) np[j] = 1;
}
for (int i = n; i >= 2; i--) {
if (np[i]) continue;
int x = i;
vector<int> curr;
while (x <= n) {
if (!used[x]) curr.push_back(x);
x += i;
}
if ((int)curr.size() == 1) continue;
if ((int)curr.size() % 2 == 0) {
for (int j = 0; j < curr.size(); j += 2) {
sol.push_back({curr[j], curr[j + 1]});
used[curr[j]] = 1;
used[curr[j + 1]] = 1;
}
} else {
sol.push_back({curr[0], curr[2]});
used[curr[0]] = 1;
used[curr[2]] = 1;
for (int j = 3; j < curr.size(); j += 2) {
if (j == curr.size() - 1) break;
sol.push_back({curr[j], curr[j + 1]});
used[curr[j]] = 1;
used[curr[j + 1]] = 1;
}
twos.push_back(curr[1]);
}
}
for (int i = 0; i < twos.size(); i += 2) {
if (i == twos.size() - 1) break;
if (!used[twos[i]] && !used[twos[i + 1]])
sol.push_back({twos[i], twos[i + 1]});
}
cout << sol.size() << endl;
for (int i = 0; i < sol.size(); i++)
cout << sol[i].first << ' ' << sol[i].second << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long int a, b, c, d, xb, xi, yb, yi, x, y, sag, ust;
int main() {
long long int t;
cin >> t;
while (t--) {
cin >> a >> b >> c >> d;
sag = b - a;
ust = d - c;
cin >> x >> y >> xb >> yb >> xi >> yi;
if (x >= xb && x <= xi && y >= yb && y <= yi) {
if ((xb == xi && a != 0 && b != 0) || (yb == yi && c != 0 && d != 0)) {
cout << "NO"
<< "\n";
continue;
}
if (x + sag <= xi && y + ust <= yi && x + sag >= xb && y + ust >= yb) {
cout << "YES"
<< "\n";
} else {
cout << "NO"
<< "\n";
}
} else {
cout << "NO";
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
const int INF = 0x3f3f3f3f;
void read(int &val) {
int x = 0;
int bz = 0;
char c;
for (c = getchar(); (c < '0' || c > '9') && c != '-'; c = getchar())
;
if (c == '-') {
bz = 1;
c = getchar();
}
for (; c >= '0' && c <= '9'; c = getchar()) x = x * 10 + c - 48;
if (bz) x = -x;
val = x;
}
vector<int> que[maxn];
int ans[maxn], n, m;
long long sum[maxn], ss[maxn];
int main() {
read(n);
read(m);
memset(sum, 0, sizeof(sum));
memset(ss, 0, sizeof(ss));
int a, b;
for (int i = 1; i <= n; i++) {
read(a);
read(b);
que[a].push_back(b);
}
int maxsz = 0;
for (int i = 1; i <= m; i++) {
sort(que[i].begin(), que[i].end());
reverse(que[i].begin(), que[i].end());
int sz = que[i].size();
maxsz = max(sz, maxsz);
for (int j = 0; j <= sz - 1; j++) {
sum[i] += que[i][j];
if (sum[i] >= 0) {
ss[j] += sum[i];
} else
break;
}
}
long long ans = -1;
for (int i = 0; i <= maxsz - 1; i++) {
ans = max(ss[i], ans);
}
printf("%lld\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void print(vector<long long int> array) {
cout << "\n****\n";
for (auto it = array.begin(); it != array.end(); it++) {
cout << *it << " ";
}
cout << "\n****\n";
}
int main() {
std::ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n, temp;
cin >> n;
vector<int> arr(n, 0);
vector<int> count(n, 0);
for (int i = 0; i < n; i++) {
cin >> temp;
count[temp] += 1;
}
long long int res = 0;
for (int i = 0; i < n; i++) {
res += max(0, count[i] - 1);
}
cout << res + 1;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool ok(const string& a, const string& b) {
if (a.size() != b.size()) return false;
for (int i = 0; i < a.size(); i++)
if (not(b[i] == '.' or b[i] == a[i])) return false;
return true;
}
int main() {
vector<string> P = {"vaporeon", "jolteon", "flareon", "espeon",
"umbreon", "leafeon", "glaceon", "sylveon"};
int n;
string s;
cin >> n >> s;
for (auto& cand : P)
if (ok(cand, s)) {
cout << cand << endl;
break;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long mas[1010];
unordered_map<long long, int> sootv;
long long num[100100];
long long gcd(long long a, long long b) {
if (!a) return b;
return gcd(b % a, a);
}
int main() {
int n;
long long k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> mas[i];
}
if (k == 1) {
cout << 1 << endl;
int minidx = 1;
for (int i = 0; i < n; i++) {
if (mas[i] < mas[minidx]) minidx = i;
}
cout << minidx + 1;
return 0;
}
vector<long long> divs;
vector<long long> rdivs;
for (long long i = 1; i * i <= k; i++) {
if (k % i == 0) {
divs.push_back(i);
if (i * i != k) {
rdivs.push_back(k / i);
}
}
}
for (auto it = rdivs.rbegin(); it != rdivs.rend(); it++) {
divs.push_back(*it);
}
int cnt = 1;
sootv.rehash((int)(divs).size() * 5);
for (int i = 0; i < (int)(divs).size(); i++) {
sootv.emplace(divs[i], cnt);
num[cnt] = divs[i];
cnt++;
}
int oo = 1e9;
vector<vector<int> > dp(n + 3);
vector<vector<long long> > sum(n + 3);
vector<vector<int> > lst(n + 3);
for (int i = 0; i < (int)(dp).size(); i++) {
dp[i].resize(cnt + 3);
lst[i].resize(cnt + 3);
sum[i].resize(cnt + 3);
for (int j = 0; j < (int)(dp[i]).size(); j++) {
dp[i][j] = oo;
}
for (int j = 0; j < (int)(lst[i]).size(); j++) {
lst[i][j] = -1;
}
for (int j = 0; j < (int)(sum[i]).size(); j++) {
sum[i][j] = (long long)oo * (long long)oo;
}
}
dp[0][sootv[k]] = 0;
sum[0][sootv[k]] = 0;
int res = oo;
for (int i = 0; i < n; i++) {
for (int divi = 1; divi < cnt; divi++) {
if (dp[i][divi] >= oo) continue;
if (dp[i + 1][divi] > dp[i][divi] ||
dp[i + 1][divi] == dp[i][divi] && sum[i + 1][divi] > sum[i][divi]) {
lst[i + 1][divi] = divi;
dp[i + 1][divi] = dp[i][divi];
sum[i + 1][divi] = sum[i][divi];
}
long long nxt = num[divi] / gcd(num[divi], mas[i]);
if (nxt == num[divi]) continue;
int idx = sootv[nxt];
if (dp[i + 1][idx] > dp[i][divi] + 1 ||
dp[i + 1][idx] == dp[i][divi] + 1 &&
sum[i + 1][idx] > sum[i][divi] + mas[i]) {
lst[i + 1][idx] = divi;
dp[i + 1][idx] = dp[i][divi] + 1;
sum[i + 1][idx] = sum[i][divi] + mas[i];
}
}
}
res = dp[n][sootv[1]];
if (res == oo) {
res = -1;
cout << res << endl;
return 0;
}
cout << res << endl;
vector<int> path;
int cur = sootv[1];
for (int i = n; i >= 1; i--) {
int l = lst[i][cur];
if (l != cur) {
path.push_back(i);
}
cur = l;
if ((int)(path).size() == res) break;
}
for (int i = (int)(path).size() - 1; i >= 0; i--) printf("%d ", path[i]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int num = 0;
char c = getchar();
for (; c < '0' || c > '9'; c = getchar())
;
for (; c >= '0' && c <= '9'; c = getchar())
num = (num << 1) + (num << 3) + (c ^ 48);
return num;
}
vector<int> a;
long long dp[40][2];
inline void solve(vector<int> s, int p) {
if (s.empty() || p < 0) return;
vector<int> L, R;
int cnt1 = 0, cnt2 = 0;
long long ans1 = 0, ans2 = 0;
for (int i = 0; i < s.size(); ++i) {
int x = s[i];
if ((x >> p) & 1) {
ans2 += cnt1;
++cnt2;
R.push_back(x);
} else {
ans1 += cnt2;
++cnt1;
L.push_back(x);
}
}
dp[p][0] += ans2;
dp[p][1] += ans1;
solve(L, p - 1);
solve(R, p - 1);
}
int main() {
int n = read();
for (int i = 1; i <= n; ++i) {
int x = read();
a.push_back(x);
}
reverse(a.begin(), a.end());
solve(a, 30);
long long Ans = 0;
int res = 0;
for (int i = 30; ~i; --i) {
if (dp[i][0] > dp[i][1])
Ans += dp[i][1], res ^= 1 << i;
else
Ans += dp[i][0];
}
printf("%lld %d", Ans, res);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 105;
struct Edge {
int v;
long long gcd, lcm;
Edge *nxt;
} buf[MaxN * MaxN * 2], *g[MaxN], *p;
void add(int u, int v, int gcd, int lcm) {
p->v = v;
p->gcd = gcd;
p->lcm = lcm;
p->nxt = g[u];
g[u] = p++;
}
int n, m, g1[MaxN], l1[MaxN];
bool ok;
long long ax[MaxN];
bool vst[MaxN];
long long Gcd(long long x, long long y) {
if (x < y) swap(x, y);
return y == 0 ? x : Gcd(y, x % y);
}
void dfs(int u, long long x) {
ax[u] = x;
vst[u] = 1;
if (!ok) return;
for (Edge *now = g[u]; now; now = now->nxt) {
int v = now->v, g = now->gcd, l = now->lcm;
if (vst[v]) {
long long G = Gcd(ax[u], ax[v]);
if (G != (long long)g || ax[u] * ax[v] / G != (long long)l) {
ok = 0;
}
} else {
x = (long long)g * l / ax[u];
ax[v] = x;
long long G = Gcd(ax[u], ax[v]);
if (G != (long long)g || ax[u] * ax[v] / G != (long long)l) {
ok = 0;
}
dfs(v, x);
}
}
}
int Set[MaxN];
int find(int x) {
if (Set[x] == x) return x;
return Set[x] = find(Set[x]);
}
void sol() {
if (m == 0) {
puts("YES");
for (int i = 0; i < n; i++) printf("1%c", i == n - 1 ? '\n' : ' ');
return;
}
bool get = 0, all = 1;
for (int k = 1; k <= n; k++)
if (find(k) == k) {
get = 0;
for (int i = 1; i <= l1[k] / g1[k]; i++)
if (l1[k] / g1[k] % i == 0 && Gcd(l1[k] / g1[k] / i, i) == 1LL) {
memset(vst, 0, sizeof(vst));
ok = 1;
dfs(k, (long long)i * g1[k]);
if (ok) {
get = 1;
break;
}
}
if (!get) all = 0;
}
if (!all)
puts("NO");
else {
puts("YES");
for (int i = 1; i <= n; i++) {
printf("%I64d", ax[i]);
printf("%c", i == n ? '\n' : ' ');
}
}
}
struct EDGE {
int x, y, g, l;
} e[MaxN * MaxN];
int main() {
p = buf;
memset(g, 0, sizeof(g));
scanf("%d%d", &n, &m);
ok = 1;
for (int i = 1; i <= n; i++) {
g1[i] = l1[i] = 1;
Set[i] = i;
}
for (int i = 0; i < m; i++) {
int x, y, a, b;
scanf("%d%d%d%d", &x, &y, &a, &b);
e[i].x = x;
e[i].y = y;
e[i].g = a;
e[i].l = b;
Set[find(x)] = find(y);
add(x, y, a, b);
add(y, x, a, b);
if (b % a) ok = 0;
}
if (!ok) {
puts("NO");
return 0;
}
for (int i = 0; i < m; i++)
if (e[i].x == find(e[i].x) || e[i].y == find(e[i].x)) {
g1[find(e[i].x)] = e[i].g;
l1[find(e[i].x)] = e[i].l;
}
sol();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, s;
cin >> n >> s;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
int num = n / 2;
sort(arr, arr + n);
long long sum = 0;
for (int i = 0; i < n; i++) {
if (i < num) {
sum += max(0, arr[i] - s);
} else if (i == num) {
sum += abs(arr[i] - s);
} else if (i > num) {
sum += max(0, s - arr[i]);
}
}
cout << sum;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 16, K = 225;
struct HASH {
size_t operator()(const pair<long long, long long> &x) const {
return hash<long long>()((x.first) ^ ((x.second) << 32));
}
};
int dx[4] = {0, 0, -1, 1}, dy[4] = {1, -1, 0, 0};
int n, m;
int len = 0;
long long pw[N];
string str[N];
unordered_map<pair<long long, long long>, int, HASH> dis;
bool good(pair<long long, long long> p, int i, int j) {
int cur = (i * m + j);
for (int k = 0; k < len - 1 - 5; k++)
if (p.first / pw[k] % K == cur) return false;
for (int k = 0; k < min(len - 1, 5); k++)
if (p.second / pw[k] % K == cur) return false;
return true;
}
bool in_bound(int i, int j) {
return i >= 0 && i < n && j >= 0 && j < m && str[i][j] != '#';
}
pair<long long, long long> getnxt(pair<long long, long long> p, int i, int j) {
p.first *= K;
p.first += p.second / pw[4];
p.first %= pw[max(len - 5, 0)];
p.second *= K;
p.second += (i * m + j);
p.second %= pw[min(len, 5)];
return p;
}
int main() {
pw[0] = 1;
for (int i = 1; i < 6; i++) pw[i] = pw[i - 1] * K;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> str[i];
pair<long long, long long> ori;
queue<pair<long long, long long> > que;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
char c = str[i][j];
if (c >= '1' && c <= '9') {
int x = c - '0';
len = max(len, x);
x--;
if (x >= 5)
ori.first += (i * m + j) * pw[x - 5];
else
ori.second += (i * m + j) * pw[x];
}
}
}
que.push(ori);
dis[ori] = 0;
while (!que.empty()) {
pair<long long, long long> p = que.front();
que.pop();
int curdis = dis[p];
int ci = (int)(p.second % K / m), cj = (int)(p.second % K % m);
for (int d = 0; d < 4; d++) {
int ni = ci + dx[d], nj = cj + dy[d];
if (in_bound(ni, nj) && good(p, ni, nj)) {
if (str[ni][nj] == '@') {
return cout << curdis + 1 << endl, 0;
}
pair<long long, long long> nxt = getnxt(p, ni, nj);
if (!dis.count(nxt)) {
que.push(nxt);
dis[nxt] = curdis + 1;
}
}
}
}
cout << "-1" << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > str;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
str.push_back(make_pair(x, y));
}
long long cnt = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
int nm1 = str[i].second - str[j].second;
int dm1 = str[i].first - str[j].first;
for (int k = j + 1; k < n; k++) {
int nm2 = str[k].second - str[j].second;
int dm2 = str[k].first - str[j].first;
if (nm1 * dm2 != nm2 * dm1) cnt++;
}
}
}
printf("%I64d\n", cnt);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool cmp(pair<long long, long long> a, pair<long long, long long> b) {
if (a.first == b.first)
return a.second < b.second;
else
return a.first < b.first;
}
long long exp(long long a, long long b) {
long long ans = 1;
while (b != 0) {
if (b % 2) ans = ans * a;
a = a * a;
b /= 2;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long a, b;
cin >> a >> b;
long long ans = 0;
for (long long i = (long long)1; i < (long long)a + 1; i++) {
long long val = i / 5 + 1;
long long a = val * 5 - i;
long long x = b - a;
if (x < 0) continue;
long long k = x / 5;
k++;
ans += k;
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T min(T a, T b, T c) {
return min(a, min(b, c));
}
template <class T>
T min(T a, T b, T c, T d) {
return min(a, min(b, min(c, d)));
}
template <class T>
T max(T a, T b, T c) {
return max(a, max(b, c));
}
template <class T>
T max(T a, T b, T c, T d) {
return max(a, max(b, max(c, d)));
}
bool cmp(const int &a, const int &b) { return a > b; }
long long GCD(long long a, long long b) { return (a % b) ? GCD(b, a % b) : b; }
long long f[1027][5 * 1027];
long long power(int n, int k) {
long long res = 1LL;
for (int i = (1); i <= (k); ++i) {
if (res > 1000000000000000007LL / n) return 1000000000000000007LL + 1LL;
res *= n;
}
return res;
}
bool inBit(int i, int j) { return (1 << j) & i; }
int addBit(int i, int j) { return (1 << j) | i; }
int main() {
int n;
scanf("%d", &n);
vector<int> vc;
int _n = n;
for (int i = (2); i <= (n); ++i) {
if (n % i == 0) {
vc.push_back(i);
}
}
vector<int> primes;
n = _n;
for (int i = (2); i <= (40); ++i) {
bool check = 1;
for (int j = (2); j <= (i - 1); ++j) {
if (i % j == 0) {
check = 0;
break;
}
}
if (check) primes.push_back(i);
}
for (int i = (1); i <= (n); ++i) {
for (int j = (0); j <= ((1 << 12) - 1); ++j)
f[i][j] = 1000000000000000007LL;
}
f[1][0] = 1LL;
long long ans = 1000000000000000007LL;
for (int i = (1); i <= (n); ++i) {
for (int bit = (0); bit <= ((1 << 12) - 1); ++bit) {
if (f[i][bit] == 1000000000000000007LL) continue;
for (int j = (0); j <= ((int)vc.size() - 1); ++j) {
if (i * vc[j] > n) continue;
for (int k = (0); k <= ((int)primes.size() - 1); ++k) {
int new_i = i * vc[j];
int new_bit = addBit(bit, k);
if (!inBit(bit, k)) {
if (f[i][bit] > 1000000000000000007LL / power(primes[k], vc[j] - 1))
continue;
f[new_i][new_bit] =
min(f[new_i][new_bit], f[i][bit] * power(primes[k], vc[j] - 1));
}
}
}
ans = min(ans, f[n][bit]);
}
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline void file() { freopen("test.in", "r", stdin); }
char buf[1 << 21], *p1 = buf, *p2 = buf;
inline int getc() {
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2)
? EOF
: *p1++;
}
inline int read() {
register int ret = 0, f = 0;
char ch = getc();
while (!isdigit(ch)) {
if (ch == '-') f = 1;
ch = getc();
}
while (isdigit(ch)) {
ret = ret * 10 + ch - 48;
ch = getc();
}
return f ? -ret : ret;
}
int n, k;
long long sum;
long long a[500005], b[500005];
inline int calc(long long mid) {
priority_queue<pair<long long, bool> > q;
register int ret = 0;
sum = 0;
for (register int i = 1; i <= n; ++i) {
q.push(make_pair(-(a[i] - mid), 1));
const long long tmp = -q.top().first + b[i];
if (tmp < 0) {
ret += q.top().second;
sum += tmp;
q.pop();
q.push(make_pair(b[i], 0));
}
}
return ret;
}
int main() {
n = read();
k = read();
for (register int i = 1; i <= n; ++i) a[i] = read();
for (register int i = 1; i <= n; ++i) b[i] = read();
long long l = 0, r = 0x7f7f7f7f;
while (l < r) {
long long mid = (l + r + 1) >> 1;
if (calc(mid) <= k)
l = mid;
else
r = mid - 1;
}
calc(l);
printf("%lld", sum + l * k);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int t, n;
double maxx = 0, maxy = 0;
bool check(double ang) {
maxx = maxy = 0;
for (int i = (0); i < (2 * n); i++) {
double x = cos(i * (M_PI / n) + ang);
double y = sin(i * (M_PI / n) + ang);
maxx = max(maxx, x);
maxy = max(maxy, y);
}
return maxx < maxy;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> t;
cout << fixed << setprecision(8);
while (t--) {
cin >> n;
double L = 0, R = M_PI / n;
while (R - L > 1e-10) {
double M = L + (R - L) / 2;
if (check(M)) {
L = M;
} else {
R = M;
}
}
double r = 0.5 / sin(M_PI / (2 * n));
cout << maxx * 2 * r << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, sum;
set<pair<int, int> > myset;
set<pair<int, int> >::iterator it;
int main() {
cin >> n;
myset.insert({0, 0});
for (int i = 1; i <= n; i++) {
int time, x;
x = sum + 20;
cin >> time;
it = myset.lower_bound({time - 90 + 1, 0});
if (it != myset.end()) {
if (it != myset.begin()) it--;
x = min(x, it->second + 50);
}
it = myset.lower_bound({time - 1440 + 1, 0});
if (it != myset.end()) {
if (it != myset.begin()) it--;
x = min(x, it->second + 120);
}
cout << x - sum << '\n';
sum = x;
myset.insert({time, x});
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
char s[4][100010];
void print() {
printf("YES\n");
for (int i = 0; i < 4; i++) printf("%s\n", s[i]);
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++)
for (int j = 0; j < 4; j++) s[j][i] = '.';
int las = 0;
if (k == 1 || k == 3) {
int mid = n / 2;
if (k == 1) {
s[1][mid] = '#';
print();
} else {
s[1][mid - 1] = '#';
s[1][mid + 1] = '#';
s[2][mid] = '#';
print();
}
return 0;
}
for (int i = 1; i < n - 1 && k > 1; i++) {
s[1][i] = '#';
s[2][i] = '#';
las = i + 1;
k -= 2;
}
if (k == 1) {
for (int i = 2; i < n - 2 && k == 1; i++)
if (s[1][i] == '#') {
if (las != n - 1) {
s[1][i] = '.';
s[1][las] = '#';
s[2][las] = '#';
k = 0;
} else {
printf("NO");
return 0;
}
}
if (k == 1) {
printf("NO");
return 0;
}
}
printf("YES\n");
for (int i = 0; i < 4; i++) printf("%s\n", s[i]);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int Read() {
int x = 0, flag = 1;
char ch = 0;
while (ch < '0' || ch > '9') {
if (ch == '-') flag = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + ch - 48;
ch = getchar();
}
return x * flag;
}
void Write(int x) {
if (x < 0) x = -x, putchar('-');
if (x > 9) Write(x / 10);
putchar(x % 10 + 48);
}
int n, m;
int edgenum, Edge[200005 << 1], head[200005], nxt[200005 << 1];
void addedge(int x, int y) {
Edge[++edgenum] = y;
nxt[edgenum] = head[x];
head[x] = edgenum;
}
pair<int, int> cover[200005];
int father[200005], dep[200005];
vector<int> p[3];
void addpath(int id, bool tag, int x, int y) {
vector<int> t;
t.clear();
bool flag = 0;
if (dep[x] < dep[y]) swap(x, y), flag = 1;
if (tag)
t.push_back(x), t.push_back(y);
else
while (x != father[y]) t.push_back(x), x = father[x];
if (flag) reverse(t.begin(), t.end());
for (int i = 0, sz = t.size(); i < sz - 1; i++) p[id].push_back(t[i]);
}
void work(int d1, int u1, int d2, int u2, int st) {
puts("YES");
int ed = (dep[u1] > dep[u2]) ? u1 : u2;
addpath(0, 0, st, ed);
addpath(1, 0, st, d1);
addpath(1, 1, d1, u1);
addpath(1, 0, u1, ed);
addpath(2, 0, st, d2);
addpath(2, 1, d2, u2);
addpath(2, 0, u2, ed);
for (int i = 0; i < 3; i++) p[i].push_back(ed);
for (int i = 0; i < 3; i++) {
int sz = p[i].size();
Write(sz);
(putchar(' '));
for (int j = 0; j < sz; j++)
Write(p[i][j]), (j == sz - 1) ? (putchar('\n')) : (putchar(' '));
}
exit(0);
}
bool vis[200005 << 1];
inline int anti(int x) { return ((x - 1) ^ 1) + 1; }
void dfs(int now, int fa) {
dep[now] = dep[fa] + 1;
father[now] = fa;
for (int i = head[now]; i; i = nxt[i]) {
if (vis[i]) continue;
vis[i] = vis[anti(i)] = 1;
int tmp = Edge[i];
if (!dep[tmp])
dfs(tmp, now);
else {
int x = now;
while (x != tmp) {
if (cover[x].first) work(now, tmp, cover[x].first, cover[x].second, x);
cover[x] = make_pair(now, tmp);
x = father[x];
}
}
}
}
int main() {
n = Read(), m = Read();
for (int i = 1; i <= m; i++) {
int x = Read(), y = Read();
addedge(x, y);
addedge(y, x);
}
for (int i = 1; i <= n; i++)
if (!dep[i]) {
dep[i] = 1;
dfs(i, 0);
}
puts("NO");
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
bool sortbysec(const pair<int, int> &a, const pair<int, int> &b) {
return (a.second < b.second);
}
bool isPrime(int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
int main() {
int t = 1;
while (t--) {
int n;
cin >> n;
vector<string> arr;
long long sum = 0;
for (int j = 0; j < n; j++) {
string s;
cin >> s;
arr.push_back(s);
}
int ans = 0;
bool A[10001] = {false};
for (int j = 0; j < n; j++) {
if (A[j] == false) {
for (int k = 0; k < n; k++) {
if (k != j && A[k] == false) {
string str1 = arr[j];
string str2 = arr[k];
str1 = str1 + str2;
stringstream geek(str1);
long long x = 0;
geek >> x;
if (x % 3 == 0) {
ans++;
A[k] = true;
A[j] = true;
break;
}
str1 = arr[k];
str2 = arr[j];
string str3 = str1 + str2;
stringstream geek1(str3);
long long x1 = 0;
geek1 >> x1;
if (x1 % 3 == 0) {
ans++;
A[k] = true;
A[j] = true;
break;
}
}
}
}
}
cout << ans << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline int setBit(int N, int pos) { return N = N | (1 << pos); }
inline int resetBit(int N, int pos) { return N = N & ~(1 << pos); }
inline bool checkBit(int N, int pos) { return (bool)(N & (1 << pos)); }
vector<vector<int> > v;
void induction(int n) {
for (int i = (n % 2 == 0) ? 5 : 6; i <= n; i += 2) {
v.push_back({1, i, i + 1});
v.push_back({1, i, i + 1});
for (int j = 2; j < i; j++) {
int a = j, b = j + 1;
if (b >= i) b = 2;
v.push_back({a, i, b, i + 1});
}
}
}
void print() {
printf("%d\n", (int)v.size());
for (auto x : v) {
printf("%d", (int)x.size());
for (auto y : x) {
printf(" %d", y);
}
puts("");
}
}
int main() {
int n, i;
scanf("%d", &n);
if (n == 3) {
v.push_back({1, 2, 3});
v.push_back({1, 2, 3});
} else if (n % 2 == 0) {
for (i = 1; i <= 4; i++) {
int a = i, b = i + 1, c = i + 2;
if (b > 4) b %= 4;
if (c > 4) c %= 4;
v.push_back({a, b, c});
}
induction(n);
} else {
v.push_back({5, 4, 2});
v.push_back({3, 1, 5});
v.push_back({3, 1, 5});
v.push_back({4, 5, 2, 3});
v.push_back({4, 3, 2, 1});
v.push_back({4, 2, 1});
induction(n);
}
print();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e3 + 5;
deque<int> node[N], cpy[N];
int n, m;
int main() {
cin >> n >> m;
int temp = m;
while (m--) {
int u, v;
cin >> u >> v;
node[u].push_back(v);
}
for (auto i = 1; i <= (long long)(n); i++) {
sort(((node[i]).begin()), ((node[i]).end()));
int idx = lower_bound(((node[i]).begin()), ((node[i]).end()), i) -
node[i].begin();
if (idx != ((int)((node[i]).size()))) {
while (idx--) {
node[i].push_back(node[i].front());
node[i].pop_front();
}
}
}
for (auto i = 1; i <= (long long)(n); i++) {
for (auto j = 1; j <= (long long)(n); j++) cpy[j] = node[j];
int curr = temp;
int steps = 0;
multiset<int> ms;
if (!cpy[i].empty()) {
ms.insert(cpy[i].back());
cpy[i].pop_back(), curr--;
}
int idx = i;
while (curr > 0 || !ms.empty()) {
idx++;
if (idx > n) idx = 1;
steps++;
ms.erase(idx);
if (!cpy[idx].empty())
ms.insert(cpy[idx].back()), cpy[idx].pop_back(), curr--;
}
cout << steps << " ";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long N = pow(2, 32);
map<long long, long long> factorize(long long n) {
map<long long, long long> ans;
for (long long i = 2; i * i <= n; i++) {
while (n % i == 0) {
ans[i]++;
n /= i;
}
}
if (n > 1) {
ans[n]++;
n = 1;
}
return ans;
}
void FAST() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
long long binpow(long long a, long long b, long long m) {
a %= m;
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
long long answer(long long sum, vector<vector<long long>> a, long long n,
long long m) {
long long cnt1 = 0, cnt0 = 0;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
if (i + j == sum || i + j == n + m - 2 - sum) {
if (a[i][j])
cnt1++;
else
cnt0++;
}
}
}
return min(cnt0, cnt1);
}
int main() {
FAST();
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
long long x;
cin >> x;
long long m;
cin >> m;
long long l = x, r = x;
long long tl, tr;
bool act = 0;
while (m--) {
cin >> tl >> tr;
if (!(tr < l || tl > r)) {
l = min(l, tl);
r = max(r, tr);
}
}
cout << r - l + 1 << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 1e5;
int F[MaxN];
void UpdatePosition(int position, int value)
{
for (int x = position; x < MaxN; x |= x + 1)
{
F[x] += value;
}
}
int GetPosition(int position)
{
int result = 0;
for (int x = position; x >= 0; x &= x + 1, --x)
{
result += F[x];
}
return result;
}
int GetSegment(int l, int r)
{
return GetPosition(r) - GetPosition(l - 1);
}
int main() {
int n, q;
cin >> n >> q;
string s;
cin >> s;
for (int i = 0; i < n; ++i)
{
UpdatePosition(i, s[i] - 'a' + 1);
}
for (int i = 0; i < q; ++i)
{
int l, r;
cin >> l >> r;
cout << GetSegment(l - 1, r - 1) << '\n';
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
bool pq(int x) {
for (int i = 2; i * i <= x; i++) {
if (x % i == 0) {
return false;
}
}
return true;
}
int main() {
int n;
cin >> n;
if (n == 2) {
cout << 1;
return 0;
}
if (n == 3) {
cout << 1;
return 0;
}
if (n == 4) {
cout << 2;
return 0;
}
if (n % 2 == 0) {
cout << 2;
return 0;
}
if (pq(n)) {
cout << 1;
return 0;
}
if (pq(n - 2)) {
cout << 2;
return 0;
}
cout << 3;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int N;
int A[300005];
int sum[300005];
int cnt[2];
int main() {
ios::sync_with_stdio(0);
cin >> N;
for (int i = 1; i <= N; i++) {
long long x;
cin >> x;
for (int j = 0; j < 60; j++) A[i] += (x >> j) % 2;
}
long long ans = 0;
for (int i = 1; i <= N; i++) {
sum[i] = (sum[i - 1] + A[i]) % 2;
if (i >= 60) cnt[sum[i - 60]]++;
ans += cnt[sum[i]];
int maxElement = 0, cur = 0;
for (int j = i; j > 0 && j > i - 59; j--) {
maxElement = max(maxElement, A[j]);
cur += A[j];
if (cur % 2 == 0 && cur / 2 >= maxElement) ans++;
}
}
cout << ans << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
char plate[50][50][50];
int k, n, m, count;
void flood(int x, int y, int z);
int main() {
int i, j, s, e;
while (scanf("%d %d %d", &k, &n, &m) == 3) {
count = 0;
for (i = 0; i < k; i++) {
for (j = 0; j < n; j++) {
scanf("%s", plate[i][j]);
}
}
scanf("%d %d", &s, &e);
flood(0, s - 1, e - 1);
printf("%d\n", count);
}
return 0;
}
void flood(int x, int y, int z) {
if (plate[x][y][z] == '.') {
plate[x][y][z] = '#';
count++;
if (x < k - 1) flood(x + 1, y, z);
if (x > 0) flood(x - 1, y, z);
if (y < n - 1) flood(x, y + 1, z);
if (z < m - 1) flood(x, y, z + 1);
if (y > 0) flood(x, y - 1, z);
if (z > 0) flood(x, y, z - 1);
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int k;
bool debug = false;
int main() {
int h, ss = 0, ah;
scanf("%d%d%d", &n, &m, &h);
for (int i = 1, x; i <= m; i++) {
scanf("%d", &x);
ss += x;
if (i == h) ah = x;
}
if (ss < n) {
puts("-1");
return 0;
}
if (ss - ah < n - 1) {
puts("1");
return 0;
}
if (n == 1) {
puts("0");
return 0;
}
double p = 1;
for (int i = ss - ah - (n - 1) + 1; i <= ss - ah; i++) {
p *= i;
}
for (int i = ss - n + 1; i <= ss - 1; i++) {
p /= i;
}
printf("%.10lf\n", 1 - p);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
long long A, total = 0;
scanf("%d%lld", &n, &A);
vector<int> d(n);
for (int &i : d) {
scanf("%d", &i);
total += i;
}
for (int i : d) {
total -= i;
int l = 1, r = min((long long)i, A - (n - 1));
if (total < A) {
l = A - total;
}
printf("%d ", i - (r - l + 1));
total += i;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long binexp(long long x, long long n, long long m) {
if (!n)
return 1;
else if (n & 1)
return (x % m) * binexp((x % m) * (x % m), n / 2, m) % m;
else if (!(n & 1))
return binexp((x % m) * (x % m), n / 2, m) % m;
return 0;
}
int32_t solve(long long _, long long _t) {
long long a, b;
cin >> a >> b;
if (a == 0 || b == 0) return cout << 0 << '\n', 0;
if (a < b) swap(a, b);
long long x = a - b;
long long ans = x;
if (x > b) ans = min({a / 2, b});
a -= 2ll * x;
b -= x;
if (a > 0 && b > 0) ans += 2 * max(a, 0ll) / 3;
cout << ans << '\n';
return 0;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cerr.tie(0);
long long _ = 1;
cin >> _;
long long _t = _;
while (_--) solve(_, _t);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long b;
int n, k;
pair<int, int> a[100100];
int main() {
cin >> n >> k >> b;
for (int i = 0; i < n; i++) {
cin >> a[i].first;
a[i].first = -a[i].first;
a[i].second = i;
}
sort(a, a + n - 1);
for (int i = 0; i < k; i++) b += a[i].first;
if (b >= 0) {
cout << n << endl;
return 0;
}
int ans = 1 << 30;
for (int i = 0; i < k; i++) ans = min(ans, a[i].second);
b -= a[k - 1].first;
for (int i = k; i < n; i++)
if (b + a[i].first < 0) ans = min(ans, a[i].second);
cout << ans + 1 << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 9;
int n, t, u, b, a[N], mt[N], topo[N], mark[N];
vector<int> g[N], fen[N];
vector<pair<int, int> > Fen[N];
void dfs(int x);
void Add(int x, int y, int val) {
while (y < int(fen[x].size())) {
fen[x][y] += val;
y += (y & -y);
}
}
int Get(int x, int y) {
int res = 0;
while (y) {
res += fen[x][y];
y -= (y & -y);
}
return res;
}
void add_Fen(int x, pair<int, int> p) {
while (x < N) {
Fen[x].push_back(p);
x += (x & -x);
}
}
void read() {
cin >> n;
fill(mt, mt + N, n + 1);
for (int i = 1; i < n + 1; i++) {
scanf("%d", &a[i]);
;
if (a[i] < 0) a[i] = n + 1;
mt[a[i]] = i;
}
}
void make() {
for (int i = 1; i < N; i++) Fen[i].push_back(make_pair(0, 0));
for (int i = 1; i < n + 1; i++) add_Fen(i, make_pair(mt[i], i));
for (int i = 1; i < N; i++) {
sort(Fen[i].begin(), Fen[i].end());
reverse(Fen[i].begin() + 1, Fen[i].end());
}
for (int i = 1; i < N; i++) {
while (fen[i].size() < (i & -i) + 1) fen[i].push_back(0);
for (int j = 1; j < fen[i].size(); j++) Add(i, j, 1);
}
}
void find_and_mark(int x, pair<int, int> p) {
int l = 0, r = Fen[x].size(), mid;
while (l + 1 < r) {
mid = (l + r) / 2;
if (p <= Fen[x][mid])
l = mid;
else
r = mid;
}
Add(x, l, -1);
}
void set_mark(int x) {
mark[x] = 1;
pair<int, int> p = make_pair(mt[x], x);
while (x < N) {
find_and_mark(x, p);
x += (x & -x);
}
}
void dfs_adj(int x, int y, int u) {
int l = 0, r = fen[x].size(), mid;
while (l + 1 < r) {
mid = (l + r) / 2;
if (y < Fen[x][mid].first)
l = mid;
else
r = mid;
}
int k = Get(x, l);
while (k) {
int li = 0, ri = l;
while (li + 1 < ri) {
mid = (li + ri) / 2;
if (Get(x, mid) < 1)
li = mid;
else
ri = mid;
}
dfs(Fen[x][ri].second);
k = Get(x, l);
}
}
void find_adj(int x, int y, int u) {
while (x) {
dfs_adj(x, y, u);
x -= (x & -x);
}
}
void dfs(int x) {
set_mark(x);
find_adj(a[x] - 1, x, x);
if (!mark[mt[x]] && mt[x] != n + 1) dfs(mt[x]);
topo[x] = ++t;
}
void solve() {
for (int i = 1; i < n + 1; i++)
if (!mark[i]) dfs(i);
for (int i = 1; i < n + 1; i++) printf("%d ", topo[i]);
}
int main() {
read();
make();
solve();
}
| 11 |
#include <bits/stdc++.h>
template <typename T>
inline void Swap(T &a, T &b) {
T t = a;
a = b;
b = t;
}
int n, m;
struct Edge {
int v, nxt;
Edge() {}
Edge(int _v, int _nxt) : v(_v), nxt(_nxt){};
} E[100000 + 10];
int nE, head[100000 + 10];
inline void EdgeInit() {
nE = 0;
memset(head, -1, sizeof(head));
}
inline void AddEdge(int u, int v) {
E[nE] = Edge(v, head[u]);
head[u] = nE++;
}
int isCapital[100000 + 1], cnt;
bool ok;
int s[2][100000 + 1];
void dfs(int u) {
if (isCapital[u] == -1) {
ok = false;
return;
}
isCapital[u] = 1;
for (int i = head[u], v = E[i].v; i != -1; i = E[i].nxt, v = E[i].v) dfs(v);
}
int main() {
scanf("%d%d", &n, &m);
int now = 0, last = 1;
bool flag = false;
EdgeInit();
scanf("%d", &s[now][0]);
for (int i = 1; i <= s[now][0]; i++) scanf("%d", &s[now][i]);
Swap(now, last);
for (int i = 2, p; i <= n; i++) {
scanf("%d", &s[now][0]);
for (int i = 1; i <= s[now][0]; i++) scanf("%d", &s[now][i]);
flag = false;
for (p = 1; p <= s[now][0] && p <= s[last][0]; p++)
if (s[last][p] != s[now][p]) {
if (s[last][p] < s[now][p]) {
AddEdge(s[now][p], s[last][p]);
} else {
if (isCapital[s[now][p]] != 1 && isCapital[s[last][p]] != -1)
isCapital[s[last][p]] = 1, isCapital[s[now][p]] = -1;
else {
puts("No");
return 0;
}
}
flag = true;
break;
}
if (!flag && s[last][0] > s[now][0]) {
puts("No");
return 0;
}
Swap(now, last);
}
ok = true;
for (int i = 1; i <= m; i++)
if (isCapital[i] == 1) dfs(i);
if (ok) {
puts("Yes");
for (int i = 1; i <= m; i++)
if (isCapital[i] == 1) cnt++;
printf("%d\n", cnt);
for (int i = 1; i <= m; i++)
if (isCapital[i] == 1) printf("%d ", i);
} else {
puts("No");
return 0;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int n = s.length();
int x1 = 0, x2 = 0, x3 = 0, x;
char vowel[5] = {'a', 'e', 'i', 'o', 'u'};
for (int i = 0; i < n; i++) {
x = 1;
for (int j = 0; j < 5; j++) {
if (s[i] == vowel[j]) x = 0;
}
x3 = x2, x2 = x1, x1 = x;
if (i >= 2) {
if (x1 * x2 * x3 == 1 && !(s[i] == s[i - 1] && s[i - 1] == s[i - 2])) {
cout << " ";
x2 = 0, x3 = 0;
}
}
cout << s[i];
}
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
const int N = 210;
int n, m, q, c[30][2];
std::vector<int> g[N << 1];
std::string s, ss;
bool b[N << 1];
bool dfs(int u) {
if (b[u <= n ? u + n : u - n]) return false;
b[u] = true;
for (int v : g[u])
if (!b[v] && !dfs(v)) return false;
return true;
}
bool chk(int x) {
int i, e, f;
for (i = 1; i <= n * 2; i++) b[i] = false;
for (i = 1; i <= x; i++)
if (!dfs(i + (ss[s[i] - 'a'] != 'V') * n)) return false;
for (; i <= n; i++)
if (b[i])
s[i] = c[0][0] + 'a';
else if (b[i + n])
s[i] = c[0][1] + 'a';
else {
e = c[0][0];
f = c[0][1];
if (e > f) e ^= f ^= e ^= f;
if (dfs(i + (ss[e] != 'V') * n))
s[i] = e + 'a';
else if (dfs(i + (ss[f] != 'V') * n))
s[i] = f + 'a';
else
return false;
}
return true;
}
int main() {
int i, a, b, x;
char ca, cb;
std::cin >> ss;
m = ss.size();
for (i = a = b = m; ~i; i--)
(i < m && ss[i] == 'V' ? a = i : b = i), c[i][0] = a, c[i][1] = b;
scanf("%d%d", &n, &q);
while (q--) {
scanf("%d", &a);
do ca = getchar();
while (ca <= 32);
scanf("%d", &b);
do cb = getchar();
while (cb <= 32);
g[a + (ca != 'V') * n].push_back(b + (cb != 'V') * n);
g[b + (cb == 'V') * n].push_back(a + (ca == 'V') * n);
}
std::cin >> s;
s = "\r" + s;
if (chk(n)) return std::cout << s << std::endl, 0;
if (c[0][0] == m || c[0][1] == m) return puts("-1"), 0;
for (i = n; i >= 1; i--) {
a = c[s[i] - 'a' + 1][0];
b = c[s[i] - 'a' + 1][1];
if (a > b) a ^= b ^= a ^= b;
if (a < m) {
s[i] = a + 'a';
if (chk(i)) return std::cout << s << std::endl, 0;
}
if (b < m) {
s[i] = b + 'a';
if (chk(i)) return std::cout << s << std::endl, 0;
}
}
puts("-1");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
using ill = long long;
class solution {
public:
const ill mod = 998244353, maxN = 200000;
ill quickPow(ill a, ill n, ill p) {
ill ans = 1;
while (n) {
if (n & 1) ans = ans * a % p;
a = a * a % p;
n >>= 1;
}
return ans;
}
void solve() {
ill n, k;
cin >> n >> k;
vector<ill> fac(n + 1, 1);
for (ill x = 1; x <= n; ++x) fac[x] = (fac[x - 1] * x) % mod;
vector<ill> ine(n + 1, -1);
ine[n] = quickPow(fac[n], mod - 2, mod);
for (ill x = n - 1; x >= 0; --x) ine[x] = (ine[x + 1] * (x + 1)) % mod;
auto C = [&](ill a, ill b) {
return ((fac[a] * ine[a - b]) % mod * ine[b]) % mod;
};
if (k == 0) {
cout << fac[n] << '\n';
} else if (k >= n) {
cout << "0\n";
} else {
ill ans = 0, add = 1;
for (ill ak = 0; k + ak <= n - 1; ++ak) {
ans = (ans +
(quickPow(n - k - ak, n, mod) * C(n - k, ak) * add + mod) % mod +
mod) %
mod;
add *= -1;
}
ans = (ans * C(n, n - k) + mod) % mod;
cout << (ans * 2 + mod) % mod << '\n';
}
}
};
int main() {
ios_base::sync_with_stdio(false);
std::cin.tie(NULL);
std::cout.tie(NULL);
solution sln1;
sln1.solve();
cout.flush();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
int n;
cin >> n;
int a[n][n];
int dp[2][n][n];
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) cin >> a[i][j];
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
for (int v = 0; v < 2; v++) dp[v][i][j] = -100000000;
dp[1][0][0] = a[0][0];
for (int k = 1; k <= n + n - 2; k++) {
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) dp[0][i][j] = dp[1][i][j];
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) dp[1][i][j] = -100000000;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (i == j) {
if (i > 0 && j > 0)
dp[1][i][j] = max(dp[1][i][j], dp[0][i - 1][j - 1] + a[i][k - i]);
if (i < k && j < k)
dp[1][i][j] = max(dp[1][i][j], dp[0][i][j] + a[i][k - i]);
if (i > 0 && j < k)
dp[1][i][j] = max(dp[1][i][j], dp[0][i - 1][j] + a[i][k - i]);
if (i < k && j > 0)
dp[1][i][j] = max(dp[1][i][j], dp[0][i][j - 1] + a[i][k - i]);
} else {
if (i > 0 && j > 0)
dp[1][i][j] = max(dp[1][i][j],
dp[0][i - 1][j - 1] + a[i][k - i] + a[j][k - j]);
if (i < k && j < k)
dp[1][i][j] =
max(dp[1][i][j], dp[0][i][j] + a[i][k - i] + a[j][k - j]);
if (i > 0 && j < k)
dp[1][i][j] =
max(dp[1][i][j], dp[0][i - 1][j] + a[i][k - i] + a[j][k - j]);
if (i < k && j > 0)
dp[1][i][j] =
max(dp[1][i][j], dp[0][i][j - 1] + a[i][k - i] + a[j][k - j]);
}
}
cout << dp[1][n - 1][n - 1] << "\n";
}
| 6 |
//Created by Hemant Raj
#include<bits/stdc++.h>
#include <iomanip>
#include<algorithm>
#include<vector>
#include<string>
#include <unordered_map>
#include<set>
using namespace std;
typedef long long int ll;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef pair<int, int> pi;
typedef vector<pair<int,int>> vpi;
typedef vector<pair<int,int>> vpl;
#define max(a, b) (a < b ? b : a)
#define foo(x,y) x/y+x
#define min(a, b) ((a > b) ? b : a)
//#define mod 1e18 + 7
#define INF 1000000000000000003
#define kick(x) cout << "Case #" << x << ": ";
#define lb lower_bound
#define ub upper_bound
#define mine *min_element
#define maxe *max_element
#define pb push_back
#define POB pop_back
#define MP make_pair
//#define mod 1e9+7
#define F first
#define S second
#define ceil(x,a) ((x + a - 1)/(a))
#define all(v) v.begin(), v.end()
#define fast_io ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#define read_ar(ar, n,k) for (int ele = k; ele < n+k; ele++)cin>>ar[ele];
#define print_ar(ar, n,k) for (int ele = k; ele < n+k; ele++)cout<<ar[ele]<<" ";
bool sortbysec(const pair<int, int> &a, const pair<int, int> &b) {return (a.second < b.second);}
//Prime_Seive
bool prime[1000000+9]; void seive(){ ll N=1e6+1; memset(prime,true,sizeof(prime)); prime[0]=false; prime[1]=false; for(ll i=2;i*i<=N;i++){ if(prime[i]){ for(ll j=i*i;j<=N;j+=i){ prime[j]=false;}}}}
// check whether the given number is pow of 2
bool isPowerOfTwo(int x) {return (x && !(x & (x - 1)));}
bool is_prime(int n){
if(n<=1)
return false;
if(n<=3)
return true;
if(n%2==0||n%3==0)
return false;
for(int i=5;i*i<=n;i=i+6)
if (n%i==0||n%(i+2)==0)
return false;
return true;
}
// DFS
/*
int const G=100000;
int vist[G];
vector<int> edge[G];
void DFS(int sv){
vist[sv]=1;
for(int i=0;i<edge[sv].size();i++){
if(vist[edge[sv][i]]==0){
DFS(edge[sv][i]);
}
}
}
*/
// BIPARTIDE TEST
/*
int clr[G];
bool BPTT(int v,int c){
vist[v]=1;
clr[v]=c;
for(auto child:edge[v]){
if(vist[child]==0){
if(BPTT(child,1^c)==false)
return false;
}
else{
if(clr[v]==clr[child]){
return false;
}
}
}
return true;
}
int cnt=1;
*/
/*
ll bfs(int sv){
queue<int>pn;
pn.push(sv);
vst[sv]=1;
ll temp=ar[sv];
while(!pn.empty()){
int x=pn.front();
vst[x]=1;
pn.pop();
for(int i=0;i<edge[x].size();i++){
if(!vst[edge[x][i]]){
pn.push(edge[x][i]);
temp=min(temp,ar[edge[x][i]]);
}
}
}
//cout<<temp<<" ";
return temp;
}
*/
//////////// In_Out_Timer ////////////////
/*
int timer=1;
int const N=100005;
vector<int> edge[N];
int vist[N];
int In[N];
int Out[N];
void In_Out_DFS(int v){
vist[v]=1;
In[v]=timer++;
for(auto chd: edge[v]){
if(vist[chd]==0){
In_Out_DFS(chd);
}
}
Out[v]=timer++;
}
*/
/////// Cycle Detection in Graph ///////////
/*
int const N=100005;
vector<int> edge[N];
int vist[N];
bool Cycle_DFS(int node,int par){
vist[node]=1;
for(auto child : edge[node]){
if(vist[child]==0){
if(Cycle_DFS(child,node)==true)return true;
}
else{
if(child!=par){
return true;
}
}
}
return false;
}
*/
//bool prime[1000000+9]; void seive(){ ll N=1e6+1; memset(prime,true,sizeof(prime)); prime[0]=false; prime[1]=false; for(ll i=2;i*i<=N;i++){ if(prime[i]){ for(ll j=i*i;j<=N;j+=i){ prime[j]=false;}}}}
int dp[1005][1005][3];
int n;
int fun(int pos,int p,int dir){
int mod=1e9+7;
if(pos<=0)return 1;
else if(pos>n)return 1;
//cout<<dp[pos][p][dir]<<" ";
if(dp[pos][p][dir]!=-1)return dp[pos][p][dir];
dp[pos][p][dir]=0;
if(dir){
dp[pos][p][dir]+=(fun(pos+1,p,1));
dp[pos][p][dir]=dp[pos][p][dir]%mod;
if(p>1){
dp[pos][p][dir]+=(fun(pos-1,p-1,0));
dp[pos][p][dir]=dp[pos][p][dir]%mod;
}
}
else{
dp[pos][p][dir]+=(fun(pos-1,p,0));
dp[pos][p][dir]=dp[pos][p][dir]%mod;
if(p>1){
dp[pos][p][dir]+=(fun(pos+1,p-1,1));
dp[pos][p][dir]=dp[pos][p][dir]%mod;
}
}
return dp[pos][p][dir];
}
void hemant(){
//int n,k;
int k;
cin>>n>>k;
memset(dp,-1,sizeof(dp));
cout<<fun(1,k,1)<<"\n";
}
int main(){
#ifndef ONLINE_JUDGE
// for getting input from input.txt
freopen("input_hemant.txt", "r", stdin);
// for writing output to output.txt
freopen("hemant_output.txt", "w", stdout);
#endif
fast_io;
int t=1;
cin>>t;
for(int i=1;i<=t;i++){
hemant();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
int main() {
int n, t[20050];
scanf("%d", &n);
long long int max = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &t[i]);
max += t[i];
}
long long int sum;
for (int i = 3; i <= (n); i++) {
if (n % i == 0) {
int z = n / i, k = 1;
while (k + (i - 1) * z <= n) {
sum = 0;
for (int j = k; j <= n; j += z) {
sum = sum + t[j];
}
k++;
if (sum >= max) max = sum;
}
}
}
printf("%I64d", max);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<pair<long long int, long long int> > v;
long long int n, x, c = 0;
cin >> n;
for (int i = 0; i < n; i++) {
long long int a, b;
cin >> a >> b;
v.push_back(make_pair(a, b));
}
sort(v.begin(), v.end());
long long int i = 0;
x = v[0].second;
while (i < n) {
if (v[i].first <= x) i++;
if (v[i].second < x) x = v[i].second;
if (v[i].first > x || i >= n) {
c++;
x = v[i].second;
}
}
cout << c;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[410];
int num[110];
int b[410];
struct Node {
int v, index;
} node[410];
bool cmp(Node t1, Node t2) { return t1.v < t2.v; }
int p1[210], p2[210];
vector<int> vec[110];
int main() {
int n;
while (scanf("%d", &n) == 1) {
for (int i = 0; i <= 100; i++) vec[i].clear();
for (int i = 0; i < 2 * n; i++) scanf("%d", &a[i]);
for (int i = 0; i < 2 * n; i++) {
node[i].v = a[i];
node[i].index = i;
vec[a[i]].push_back(i);
}
int now = 0;
for (int i = 10; i < 100; i++) {
int sz = min(2, (int)vec[i].size());
for (int j = 0; j < sz; j++) {
b[vec[i].back()] = now;
now ^= 1;
vec[i].pop_back();
}
}
for (int i = 10; i < 100; i++) {
int sz = vec[i].size();
for (int j = 0; j < sz; j++) {
b[vec[i].back()] = now;
now ^= 1;
vec[i].pop_back();
}
}
set<int> st[2];
for (int i = 0; i < 2 * n; i++) {
st[b[i]].insert(a[i]);
}
printf("%d\n", st[0].size() * st[1].size());
for (int i = 0; i < 2 * n; i++) {
if (b[i] == 0)
printf("1");
else
printf("2");
if (i < 2 * n - 1)
printf(" ");
else
printf("\n");
}
continue;
sort(node, node + 2 * n, cmp);
int cnt1 = 0, cnt2 = 0;
for (int i = 0; i < 2 * n; i++) {
if (i % 2 == 0) {
b[node[i].index] = 0;
p1[cnt1++] = node[i].v;
} else {
b[node[i].index] = 1;
p2[cnt2++] = node[i].v;
}
}
cnt1 = unique(p1, p1 + cnt1) - p1;
cnt2 = unique(p2, p2 + cnt2) - p2;
printf("%d\n", cnt1 * cnt2);
for (int i = 0; i < 2 * n; i++) {
if (b[i] == 0)
printf("1");
else
printf("2");
if (i < 2 * n - 1)
printf(" ");
else
printf("\n");
}
continue;
memset(num, 0, sizeof(num));
for (int i = 0; i < 2 * n; i++) num[a[i]]++;
int ff = 0;
for (int i = 10; i <= 99; i++) {
if (num[i] == 0) continue;
if (num[i] % 2 == 0) {
int cnt = num[i] / 2;
int cc = 0;
for (int j = 0; j < 2 * n; j++)
if (a[j] == i) {
if (cc < cnt)
b[j] = 0;
else
b[j] = 1;
cc++;
}
continue;
}
int cnt = num[i] / 2;
int cc = 0;
for (int j = 0; j < 2 * n; j++)
if (a[j] == i) {
if (cc == num[i] - 1) {
b[j] = ff;
continue;
}
if (cc < cnt)
b[j] = 0;
else
b[j] = 1;
cc++;
}
ff ^= 1;
}
int num1 = 0;
memset(num, 0, sizeof(num));
for (int i = 0; i < 2 * n; i++)
if (b[i] == 0) num[a[i]]++;
for (int i = 10; i < 100; i++)
if (num[i]) num1++;
int num2 = 0;
memset(num, 0, sizeof(num));
for (int i = 0; i < 2 * n; i++)
if (b[i] == 1) num[a[i]]++;
for (int i = 10; i < 100; i++)
if (num[i]) num2++;
printf("%d\n", num1 * num2);
for (int i = 0; i < 2 * n; i++) {
if (b[i] == 0)
printf("1");
else
printf("2");
if (i < 2 * n - 1)
printf(" ");
else
printf("\n");
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int spend[60 + 5][60 + 5][60 + 5];
int best[1005][60 + 5][60 + 5];
int n, m;
int res(int fr, int to, int k) {
fr -= 1;
to -= 1;
return best[k][fr][to];
}
int main() {
int R;
cin >> n >> m >> R;
for (typeof(m) car = 0; car < (m); ++car) {
for (typeof(n) fr = 0; fr < (n); ++fr)
for (typeof(n) to = 0; to < (n); ++to) cin >> spend[car][fr][to];
}
for (typeof(m) car = 0; car < (m); ++car) {
for (typeof(n) k = 0; k < (n); ++k)
for (typeof(n) fr = 0; fr < (n); ++fr)
for (typeof(n) to = 0; to < (n); ++to) {
spend[car][fr][to] =
min(spend[car][fr][to], spend[car][fr][k] + spend[car][k][to]);
}
}
for (typeof(n) fr = 0; fr < (n); ++fr)
for (typeof(n) to = 0; to < (n); ++to) {
best[0][fr][to] = spend[0][fr][to];
for (typeof(m) car = 0; car < (m); ++car)
best[0][fr][to] = min(best[0][fr][to], spend[car][fr][to]);
}
for (typeof(1) k = (1); k < (1001); ++k) {
for (typeof(n) fr = 0; fr < (n); ++fr)
for (typeof(n) to = 0; to < (n); ++to)
best[k][fr][to] = best[k - 1][fr][to];
for (typeof(n) fr = 0; fr < (n); ++fr) best[k][fr][fr] = 0;
for (typeof(n) t = 0; t < (n); ++t)
for (typeof(n) fr = 0; fr < (n); ++fr)
for (typeof(n) to = 0; to < (n); ++to) {
best[k][fr][to] =
min(best[k][fr][to], best[k - 1][fr][t] + best[0][t][to]);
}
}
for (typeof(R) _ = 0; _ < R; ++_) {
int fr, to, K;
cin >> fr >> to >> K;
cout << res(fr, to, K) << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int matrix[300][300];
int main() {
int n;
cin >> n;
long long sum = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> matrix[i][j];
sum += matrix[i][j];
}
}
sum /= 2;
int k;
cin >> k;
for (int i = 0; i < k; i++) {
sum = 0;
int a, b, c;
cin >> a >> b >> c;
a--;
b--;
matrix[a][b] = matrix[b][a] = min(matrix[a][b], c);
for (int x = 0; x < n; x++) {
for (int y = 0; y < n; y++) {
matrix[x][y] =
min(matrix[x][y], matrix[x][a] + matrix[a][b] + matrix[b][y]);
matrix[x][y] =
min(matrix[x][y], matrix[x][b] + matrix[b][a] + matrix[a][y]);
sum += matrix[x][y];
}
}
if (i != 0) cout << " ";
cout << sum / 2;
}
cout << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int parent[111111];
int child[111111];
double ans[111111];
int n;
int main(void) {
scanf("%d", &n);
child[1] = 1;
for (int i = 2; i <= n; i++) {
scanf("%d", &parent[i]);
child[i] = 1;
}
for (int i = n; i >= 1; i--) {
child[parent[i]] += child[i];
}
ans[1] = 1;
for (int i = 2; i <= n; i++) {
ans[i] = ans[parent[i]] + 0.5 * (1 + child[parent[i]] - child[i]);
}
for (int i = 1; i <= n; i++) {
printf("%.10f ", ans[i]);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int w, h, k;
cin >> w >> h >> k;
int ans = 0;
for (int i = 1; i <= k; i++) {
ans += (w + h - 2) * 2;
w -= 4;
h -= 4;
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
const long double eps = 0.00000001;
const long long MOD = 1e9 + 7;
const double PI = 3.141592653589793238463;
using namespace std;
long long ans, k;
int n, m;
long long a[25][25];
map<pair<pair<int, int>, long long>, long long> cnt;
int half;
bool isOK(int x, int y) {
if (x >= 1 && x <= n && y >= 1 && y <= m) return true;
return false;
}
void dfs(int x, int y, long long res) {
res ^= a[x][y];
if (x + y == half) {
cnt[{{x, y}, res}]++;
return;
}
if (isOK(x + 1, y)) dfs(x + 1, y, res);
if (isOK(x, y + 1)) dfs(x, y + 1, res);
}
void back_dfs(int x, int y, long long res) {
if (x + y == half) {
ans += cnt[{{x, y}, (res ^ k)}];
return;
}
res ^= a[x][y];
if (isOK(x - 1, y)) back_dfs(x - 1, y, res);
if (isOK(x, y - 1)) back_dfs(x, y - 1, res);
}
int main() {
fflush(stdin);
cout << fixed, cout.precision(18);
ios_base::sync_with_stdio(false);
int i, j;
cin >> n >> m >> k;
for (i = 1; i <= n; ++i)
for (j = 1; j <= m; ++j) cin >> a[i][j];
half = (m + n) / 2 + 1;
dfs(1, 1, 0ll);
back_dfs(n, m, 0ll);
cout << ans;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
cout << "25" << '\n';
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int i, x, y, n, j, ar[100000], a[100000], co, r, m, k, ga[32][2];
string s, f;
char t = 'a';
int main(int argc, char** argv) {
cin >> s >> f;
x = f.length();
y = 1;
while (j <= (x - 1)) {
if (f[j] == s[i]) {
if (y <= x) {
y++;
i++;
}
}
j++;
}
cout << y;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool getmin(T& a, const T& b) {
return b < a ? (a = b, true) : false;
}
template <typename T>
inline bool getmax(T& a, const T& b) {
return b > a ? (a = b, true) : false;
}
const int maxn = 1e5 + 5;
const long long INF = 4e18 + 5;
int n;
long long x[maxn], y[maxn], z[maxn];
inline bool check(const long long& Maxdis, long long& ansx, long long& ansy,
long long& ansz) {
const long long sign[4][3] = {{1, 1, 1}, {-1, 1, 1}, {1, -1, 1}, {1, 1, -1}};
long long L[4] = {-INF, -INF, -INF, -INF}, R[4] = {INF, INF, INF, INF};
for (int i = 0; i < n; i++)
for (int j = 0; j < 4; j++)
getmax(L[j], sign[j][0] * x[i] + sign[j][1] * y[i] + sign[j][2] * z[i] -
Maxdis),
getmin(R[j], sign[j][0] * x[i] + sign[j][1] * y[i] +
sign[j][2] * z[i] + Maxdis);
for (int i = 0; i < 4; i++)
if (L[i] > R[i]) return 0;
for (int rep = 0; rep < 2; rep++) {
long long A = L[1] + ((L[1] & 1) == rep), B = L[2] + ((L[2] & 1) == rep),
C = L[3] + ((L[3] & 1) == rep);
if (A <= R[1] && B <= R[2] && C <= R[3]) {
bool flag = 0;
if (A + B + C < L[0]) {
long long dif = L[0] - A - B - C;
if (dif & 1) dif++;
if (A + B + C + dif > R[0]) continue;
if (R[1] - A >= dif)
A += dif, flag = 1;
else {
dif -= ((R[1] & 1) == rep ? R[1] - 1 : R[1]) - A;
A = R[1];
if ((A & 1) == rep) A--;
if (R[2] - B >= dif)
B += dif, flag = 1;
else {
dif -= ((R[2] & 1) == rep ? R[2] - 1 : R[2]) - B;
B = R[2];
if ((B & 1) == rep) B--;
if (R[3] - C >= dif) C += dif, flag = 1;
}
}
} else if (A + B + C <= R[0])
flag = 1;
if (flag) {
assert((B + C) % 2 == 0 && (A + C) % 2 == 0 && (A + B) % 2 == 0);
ansx = (B + C) / 2, ansy = (A + C) / 2, ansz = (A + B) / 2;
return 1;
}
}
}
return 0;
}
int main() {
int tc;
scanf("%d", &tc);
while (tc--) {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%lld%lld%lld", x + i, y + i, z + i);
long long L = 0, R = INF, ansx, ansy, ansz;
while (L != R) {
long long M = L + ((R - L) >> 1);
if (check(M, ansx, ansy, ansz))
R = M;
else
L = M + 1;
}
check(L, ansx, ansy, ansz);
printf("%lld %lld %lld\n", ansx, ansy, ansz);
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int dest[3123][3123];
bool vis[3123];
vector<vector<int> > adj;
void bfs(int st) {
memset(vis, 0, sizeof vis);
queue<int> q;
q.push(st);
dest[st][st] = 0;
vis[st] = 1;
while (q.size()) {
int u = q.front();
q.pop();
for (int i = 0; i < (int)adj[u].size(); i++) {
int v = adj[u][i];
if (!vis[v]) {
q.push(v);
vis[v] = 1;
dest[st][v] = dest[st][u] + 1;
}
}
}
}
int n, m, u, v;
vector<vector<pair<int, int> > > vec;
vector<vector<pair<int, int> > > vecinv;
int get_best_n(const vector<int>& lst, int my_node) {
for (int i = 0; i < (int)vec[my_node].size(); i++) {
int cur_node = vec[my_node][i].second;
for (int j = 0; j < (int)lst.size(); j++) {
if (cur_node == lst[j]) goto skp;
}
return cur_node;
skp:;
}
return -1;
}
int get_best_n2(const vector<int>& lst, int my_node) {
for (int i = 0; i < (int)vecinv[my_node].size(); i++) {
int cur_node = vecinv[my_node][i].second;
for (int j = 0; j < (int)lst.size(); j++) {
if (cur_node == lst[j]) goto skp;
}
return cur_node;
skp:;
}
return -1;
}
int main() {
memset(dest, -1, sizeof dest);
scanf("%d%d", &n, &m);
adj.resize(n);
while (m--) {
scanf("%d%d", &u, &v);
u--, v--;
adj[u].push_back(v);
}
for (int i = 0; i < n; i++) {
bfs(i);
}
vec.resize(n);
vecinv.resize(n);
for (int st = 0; st < n; st++) {
for (int ed = 0; ed < n; ed++) {
if (st != ed && dest[st][ed] != -1) {
vec[st].push_back(make_pair(dest[st][ed], ed));
vecinv[ed].push_back(make_pair(dest[st][ed], st));
}
}
}
for (int i = 0; i < n; i++) {
sort(vec[i].rbegin(), vec[i].rend());
while (vec[i].size() > 4) vec[i].pop_back();
sort(vecinv[i].rbegin(), vecinv[i].rend());
while (vecinv[i].size() > 4) vecinv[i].pop_back();
}
vector<int> lst(4, 0);
int mx = 0;
vector<int> ans;
for (int n2 = 0; n2 < n; n2++) {
lst[1] = n2;
for (int n3 = 0; n3 < n; n3++) {
if (n2 != n3 && dest[n2][n3] != -1) {
lst[2] = n3;
int n1, n4;
n4 = get_best_n(lst, n3);
lst[3] = n4;
n1 = get_best_n2(lst, n2);
lst[0] = n1;
bool isbad = 0;
for (int i = 0; i < (int)lst.size(); i++) {
if (lst[i] == -1) isbad = 1;
}
if (!isbad) {
int tmp = 0;
for (int i = 1; i < lst.size(); i++) {
tmp += dest[lst[i - 1]][lst[i]];
}
if (tmp > mx) {
mx = tmp;
ans = lst;
}
}
lst[0] = -1;
lst[3] = -1;
n1 = get_best_n2(lst, n2);
lst[0] = n1;
n4 = get_best_n(lst, n3);
lst[3] = n4;
isbad = 0;
for (int i = 0; i < lst.size(); i++) {
if (lst[i] == -1) isbad = 1;
}
if (!isbad) {
int tmp = 0;
for (int i = 1; i < lst.size(); i++) {
tmp += dest[lst[i - 1]][lst[i]];
}
if (tmp > mx) {
mx = tmp;
ans = lst;
}
}
lst[0] = -1;
lst[3] = -1;
lst[2] = -1;
}
}
lst[1] = -1;
}
for (int i = 0; i < 4; i++) {
printf("%d%c", ans[i] + 1, " \n"[i == 3]);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct point {
int next, to, w;
} ar[64000];
int a[64000], head[64000], art(1), dep[64000], T[64000], n, m, g, ans;
inline bool bfs();
inline int dfs(int, int);
inline void read(int&), link(int, int, int);
int main() {
read(n), read(m), read(g);
for (int i(1); i <= n; ++i) read(a[i]);
for (int i(1), j; i <= n; ++i)
read(j), a[i] ? link(i, n + m + 2, j) : link(n + m + 1, i, j);
for (int i(1), j, sex, w, K, f; i <= m; ++i) {
read(sex), read(w), read(K), ans += w;
for (j = 1; j <= K; ++j)
read(a[j]),
sex ? link(a[j], n + i, 0x3f3f3f3f) : link(n + i, a[j], 0x3f3f3f3f);
read(f), sex ? link(n + i, n + m + 2, w + (f ? g : 0))
: link(n + m + 1, n + i, w + (f ? g : 0));
}
int flow, maxflow(0);
while (bfs())
while (flow = dfs(n + m + 1, 0x3f3f3f3f)) maxflow += flow;
return printf("%d", ans - maxflow), 0;
}
inline int dfs(int x, int flow) {
if (x == n + m + 2) return flow;
int r(flow);
for (int i(head[x]), j; r && i; i = ar[i].next)
if (ar[i].w && dep[ar[i].to] == dep[x] + 1) {
j = dfs(ar[i].to, min(r, ar[i].w));
if (!j) dep[ar[i].to] = 0;
ar[i].w -= j, ar[i ^ 1].w += j, r -= j;
}
return flow - r;
}
inline bool bfs() {
memset(dep, 0, sizeof(dep));
int L(0), R(1);
dep[T[1] = n + m + 1] = 1;
while (L++ < R)
for (int i(head[T[L]]); i; i = ar[i].next)
if (ar[i].w && !dep[ar[i].to]) {
dep[ar[i].to] = dep[T[L]] + 1;
T[++R] = ar[i].to;
if (ar[i].to == n + m + 2) return 1;
}
return 0;
}
inline void link(int u, int v, int w) {
ar[++art] = {head[u], v, w}, head[u] = art;
ar[++art] = {head[v], u, 0}, head[v] = art;
}
inline void read(int& x) {
x ^= x;
register char c;
while (c = getchar(), c < '0' || c > '9')
;
while (c >= '0' && c <= '9')
x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long n;
cin >> n;
vector<long long> c(n), p(n);
vector<array<long long, 3>> groups;
for (long long i = 0; i < n; i++) {
cin >> c[i] >> p[i];
groups.push_back({p[i], c[i], i + 1});
}
sort(groups.rbegin(), groups.rend());
long long k;
cin >> k;
set<array<long long, 2>> r;
for (long long i = 0; i < k; i++) {
long long size;
cin >> size;
r.insert({size, i + 1});
}
long long cust_alloted = 0, money_earned = 0;
vector<array<long long, 2>> res;
for (long long i = 0; i < n; i++) {
long long ready_to_pay = groups[i][0], capacity = groups[i][1],
cust_id = groups[i][2];
auto itr = r.lower_bound({capacity, 0});
if (itr == r.end()) continue;
cust_alloted++;
money_earned += ready_to_pay;
res.push_back({cust_id, (*itr)[1]});
r.erase(itr);
}
cout << res.size() << " " << money_earned << "\n";
for (long long i = 0; i < (long long)res.size(); i++) {
cout << res[i][0] << " " << res[i][1] << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int aux2[10] = {0, 3, 3, 3, 2, 2, 2, 1, 1, 1},
aux1[10] = {1, 0, 1, 2, 0, 1, 2, 0, 1, 2};
int main() {
int n;
cin >> n;
char aux[n];
int x[n - 1], y[n - 1], all[n];
for (int i = 0; i < n; i++) {
cin >> aux[i];
all[i] = aux[i] - '0';
if (i > 0) {
x[i - 1] = aux1[all[i]] - aux1[all[i - 1]];
y[i - 1] = aux2[all[i]] - aux2[all[i - 1]];
}
}
bool ok;
for (int i = 0; i <= 9; i++) {
int curx = aux1[i], cury = aux2[i];
if (i == all[0]) continue;
ok = false;
for (int j = 0; j < n - 1; j++) {
curx += x[j];
cury += y[j];
if (curx < 0 || curx > 2 || cury > 3 || cury <= 0) {
if (curx != 1 || cury != 0) {
ok = true;
break;
}
}
}
if (!ok) break;
}
ok ? cout << "YES" : cout << "NO";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long double z, t = 0;
int n;
char x[200005], y[200005];
long long s[200005], f[256];
int main() {
scanf("%d\n", &n);
gets(x);
gets(y);
for (int i = 0; i < n; i++) {
f[y[i]] += i + 1;
s[i] = f[x[i]];
}
z = 0;
for (int i = 0; i < n; i++) {
z += s[i] * (n - i);
}
for (int i = 0; i < n; i++) {
f[y[i]] = 0;
s[x[i]] = 0;
}
for (int i = 0; i < n; i++) {
s[i] = f[y[i]];
f[x[i]] += i + 1;
}
for (int i = 0; i < n; i++) {
z += s[i] * (n - i);
}
for (int i = 1; i <= n; i++) t += 1ll * (n - i + 1) * (n - i + 1);
z /= t;
cout << fixed << setprecision(10) << z << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 55;
int n, m, k;
int main() {
scanf("%d %d %d", &n, &m, &k);
char to[1000];
scanf("%*s %s", to);
int di = 1;
if (to[0] == 'h') di = -1;
char s[10000];
scanf("%s", s);
int len = strlen(s);
bool good = true;
for (int i = 0; i < len && good; ++i) {
if (s[i] == '0') {
if (di == 1) {
if (m > k && m != n) m++;
if (m < k && m != 1) m--;
} else {
if (m < k && m != 1) m--;
if (m > k && m != n) m++;
}
k += di;
if (m == k) {
printf("Controller %d\n", i + 1);
good = false;
}
if (k == 1 || k == n) di *= -1;
} else {
if (di == 1)
m = 1;
else
m = n;
k += di;
if (k == 1 || k == n) di *= -1;
}
}
if (good) printf("Stowaway\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
long long cnt, ans, n;
int main() {
scanf("%I64d", &n);
cnt = 1;
while (n > cnt * 9) {
ans += 9, n -= cnt * 9;
cnt *= 10;
}
while (n > 0) ans += n % 10, n /= 10;
printf("%I64d", ans);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1E5 + 10, INF = 1E9 + 10;
int n, k, a[N], m, b[N], cnt[N];
int t[N * 4];
int pos(int v) { return lower_bound(b + 1, b + m + 1, v) - b; }
void update(int k, int l, int r, int i, int v) {
if (i < l || i > r) return;
if (l == r) {
cnt[i] += v;
t[k] = (cnt[i] == 1) ? b[i] : -INF;
return;
}
int mid = (l + r) / 2;
update(k * 2, l, mid, i, v);
update(k * 2 + 1, mid + 1, r, i, v);
t[k] = max(t[k * 2], t[k * 2 + 1]);
}
int main() {
scanf("%d %d", &n, &k);
for (int i = (1), _b = (n); i <= _b; ++i) scanf("%d", a + i), b[i] = a[i];
sort(b + 1, b + n + 1);
m = unique(b + 1, b + n + 1) - b - 1;
for (int i = (1), _b = (m * 4); i <= _b; ++i) t[i] = -INF;
for (int i = (1), _b = (k - 1); i <= _b; ++i) update(1, 1, m, pos(a[i]), 1);
int j = 1;
for (int i = (k), _b = (n); i <= _b; ++i) {
update(1, 1, m, pos(a[i]), 1);
for (; i - j + 1 > k; ++j) update(1, 1, m, pos(a[j]), -1);
if (t[1] == -INF)
puts("Nothing");
else
printf("%d\n", t[1]);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, s, a[100], ans;
long long jc[100];
map<long long, long long> q[110];
void dfs1(long long x, long long y, long long sum, long long ji) {
if (ji > m) return;
if (x > y) {
q[ji][sum]++;
return;
}
dfs1(x + 1, y, sum, ji);
dfs1(x + 1, y, sum + a[x], ji);
if (a[x] <= 20) dfs1(x + 1, y, sum + jc[a[x]], ji + 1);
}
void dfs2(long long x, long long y, long long sum, long long ji) {
if (ji > m) return;
if (sum > s) return;
if (x > y) {
for (long long i = 0; i <= m - ji; i++) {
ans += q[i][s - sum];
}
return;
}
dfs2(x + 1, y, sum, ji);
dfs2(x + 1, y, sum + a[x], ji);
if (a[x] <= 20) dfs2(x + 1, y, sum + jc[a[x]], ji + 1);
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
jc[1] = 1ll;
for (long long i = 2; i <= 20; i++) jc[i] = jc[i - 1] * i;
cin >> n >> m >> s;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
}
dfs1(1, (n + 1) / 2, 0, 0);
dfs2((n + 1) / 2 + 1, n, 0, 0);
cout << ans << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int c = 0, n, a, b, i;
cin >> n;
for (i = 0; i < n; i++) {
cin >> a >> b;
if (b - a >= 2) c++;
}
cout << c;
}
| 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
inline int mymax(int a, int b) { return a < b ? b : a; }
inline int mymin(int a, int b) { return a > b ? b : a; }
inline long long mymax(long long a, long long b) { return a < b ? b : a; }
inline long long mymin(long long a, long long b) { return a > b ? b : a; }
int n, m, k;
int buy[11][110];
int sell[11][110];
int cnt[11][110];
int main() {
cin >> n >> m >> k;
for (int i = 0; i < (n); ++i) {
string unused;
cin >> unused;
for (int j = 0; j < (m); ++j) {
cin >> buy[i][j] >> sell[i][j] >> cnt[i][j];
}
}
long long res = 0;
for (int a = 0; a < (n); ++a) {
for (int b = 0; b < (n); ++b) {
vector<pair<int, int> > v;
for (int i = 0; i < (m); ++i) {
int d = sell[b][i] - buy[a][i];
int c = cnt[a][i];
if (d > 0 && c > 0) v.push_back(make_pair(d, c));
}
sort((v).begin(), (v).end());
int c = 0;
long long r = 0;
while (c < k && !v.empty()) {
++c;
r += v.back().first;
--v.back().second;
if (!v.back().second) v.pop_back();
}
res = max(res, r);
}
}
cout << res;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
a[i] = 1;
}
for (int i = 0; i < n - 1; i++) {
for (int j = 1; j < n; j++) {
a[j] += a[j - 1];
}
}
cout << a[n - 1] << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200009;
const long long MAXN = 0x7f7f7f7f7f7f7f7f;
int n, m;
long long tree[N * 4], tag[N * 4];
long long v[N];
void build(int k, int l, int r) {
if (l == r) {
tree[k] = v[l];
return;
}
int mid = (l + r) / 2;
build(k * 2, l, mid);
build(k * 2 + 1, mid + 1, r);
tree[k] = min(tree[k * 2], tree[k * 2 + 1]);
}
void modify(int k, int l, int r, int x, int y, int val) {
if (l >= x && r <= y) {
tag[k] += val;
return;
}
int mid = (l + r) / 2;
if (mid >= x) modify(k * 2, l, mid, x, y, val);
if (mid < y) modify(k * 2 + 1, mid + 1, r, x, y, val);
tree[k] = min(tree[k * 2] + tag[k * 2], tree[k * 2 + 1] + tag[k * 2 + 1]);
}
long long query(int k, int l, int r, int x, int y) {
if (l >= x && r <= y) {
return tree[k] + tag[k];
}
int mid = (l + r) / 2;
long long left = MAXN, right = MAXN;
if (mid >= x) left = query(k * 2, l, mid, x, y);
if (mid < y) right = query(k * 2 + 1, mid + 1, r, x, y);
return min(left, right) + tag[k];
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld", &v[i]);
}
build(1, 1, n);
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
int x, y;
long long val;
scanf("%d%d", &x, &y);
x++, y++;
char op;
op = getchar();
if (op == '\n') {
if (x <= y) {
printf("%lld\n", query(1, 1, n, x, y));
} else {
long long ans;
ans = query(1, 1, n, 1, y);
ans = min(ans, query(1, 1, n, x, n));
printf("%lld\n", ans);
}
} else {
scanf("%lld", &val);
if (x <= y) {
modify(1, 1, n, x, y, val);
} else {
modify(1, 1, n, x, n, val);
modify(1, 1, n, 1, y, val);
}
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void func() {
int a;
for (int i = 0; i < 4000; i++) a = i;
}
int gcd(int a, int b) {
if (b == 0) {
return a;
} else {
return gcd(b, a % b);
}
}
int main() {
int t;
scanf("%d", &t);
int arr[t];
func();
int aa[4000];
for (int i = 0; i < t; i++) {
scanf("%d", &arr[i]);
}
sort(arr, arr + t);
int g = gcd(arr[0], arr[1]);
for (int i = 2; i < t; i++) g = gcd(g, arr[i]);
int m = (arr[t - 1] / g - t);
if (m % 2 == 0)
cout << "Bob";
else
cout << "Alice";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<pair<int, int> > Lev(N);
for (int i = 0; i < N; ++i) {
cin >> Lev[i].first >> Lev[i].second;
}
vector<vector<int> > graph(N);
for (int i = 0; i < N; ++i) {
for (int j = i + 1; j < N; ++j) {
if (Lev[i].first == Lev[j].first || Lev[i].second == Lev[j].second) {
graph[i].push_back(j);
graph[j].push_back(i);
}
}
}
queue<int> q;
vector<bool> used(N);
int kol = -1;
int v;
for (;;) {
bool t = false;
for (int i = 0; i < N; ++i) {
if (!used[i]) {
v = i;
used[i] = true;
q.push(v);
t = true;
++kol;
break;
}
}
while (!q.empty()) {
int v = q.front();
q.pop();
for (int i = 0; i < graph[v].size(); ++i) {
int to = graph[v][i];
if (!used[to]) {
used[to] = true;
q.push(to);
}
}
}
if (!t) {
break;
}
}
cout << kol;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2000 + 77;
int n, m, gp[N], t = 2, dis[N], top[N], sz[N], sum[N], A, ts;
vector<int> a[N], b[N];
bool M[N];
bitset<N> T;
void dfs(int v, int prev) {
M[v] = 1;
top[v] = dis[v];
for (int u : a[v]) {
if (u == prev) {
continue;
}
if (M[u]) {
top[v] = min(top[v], top[u]);
continue;
}
dis[u] = dis[v] + 1;
dfs(u, v);
top[v] = min(top[v], top[u]);
}
}
void dfs_calc(int v) {
M[v] = 1;
for (int u : a[v]) {
if (M[u]) {
continue;
}
if (top[u] == dis[u]) {
gp[u] = t;
t++;
} else {
gp[u] = gp[v];
}
dfs_calc(u);
}
}
void dfs_down(int v, int prev) {
for (int u : b[v]) {
if (u == prev) {
continue;
}
dfs_down(u, v);
ts += sum[u] * sz[v];
sum[v] += sum[u];
}
sum[v] += sz[v];
}
int Calc(int c) {
ts = 0;
memset(sum, 0, sizeof(sum));
for (int i = 0; i <= n; i++) {
T[i] = 0;
}
T[0] = 1;
dfs_down(c, c);
for (int u : b[c]) {
T = T | (T << sum[u]);
}
int ans = 0;
for (int i = 0; i <= n; i++) {
if (T[i] == 0) {
continue;
}
ans = max(ans, i * (n - i - sz[c]));
}
ans += ts;
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int v, u;
cin >> v >> u;
a[v].push_back(u);
a[u].push_back(v);
}
dfs(1, 1);
memset(M, 0, sizeof(M));
gp[1] = 1;
dfs_calc(1);
for (int i = 1; i <= n; i++) {
sz[gp[i]]++;
for (int u : a[i]) {
if (gp[u] == gp[i]) {
continue;
}
b[gp[u]].push_back(gp[i]);
}
}
for (int i = 1; i < t; i++) {
sort(b[i].begin(), b[i].end());
b[i].resize(unique(b[i].begin(), b[i].end()) - b[i].begin());
}
for (int i = 1; i < t; i++) {
A = max(A, Calc(i));
}
for (int i = 1; i < t; i++) {
A += sz[i] * sz[i];
}
cout << A;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
void solve(long long zt) {
int n;
cin >> n;
vector<string> arr;
vector<pair<pair<char, char>, int>> brr;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
map<char, int> mp;
for (int j = 0; j < s.length(); j++) {
mp[s[j]]++;
}
if (mp.size() == 1) {
auto it = mp.begin();
brr.push_back(make_pair(make_pair(it->first, it->first), it->second));
} else if (mp.size() == 2) {
auto it = mp.begin();
char x = it->first;
int sum = 0;
sum += it->second;
char y;
it++;
y = it->first;
sum += it->second;
brr.push_back(make_pair(make_pair(x, y), s.length()));
}
}
int maxi = INT_MIN;
for (int i = 0; i < 25; i++) {
for (int j = i + 1; j < 26; j++) {
char x = 97 + i;
int y = 97 + j;
int sum = 0;
for (int k = 0; k < brr.size(); k++) {
if (brr[k].first.first == x && brr[k].first.second == y ||
brr[k].first.first == x && brr[k].first.second == x ||
brr[k].first.first == y && brr[k].first.second == y) {
sum += brr[k].second;
}
}
if (sum > 0) {
maxi = max(maxi, sum);
}
}
}
for (int i = 0; i < 26; i++) {
char x = 97 + i;
int sum = 0;
for (int k = 0; k < brr.size(); k++) {
if (brr[k].first.first == x && brr[k].first.second == x) {
sum += brr[k].second;
}
}
maxi = max(maxi, sum);
}
cout << maxi << endl;
}
int main() {
long long t;
t = 1;
long long z = 0;
while (t--) {
z++;
solve(z);
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
long long a, b, c, d;
long long x[4];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> x[0] >> x[1] >> x[2] >> d;
sort(x, x + 3);
a = x[0];
b = x[1];
c = x[2];
long long ab = abs(a - b);
long long bc = abs(b - c);
if (ab >= d && bc >= d) {
cout << 0 << endl;
return 0;
} else if (ab < d && bc >= d) {
cout << d - ab << endl;
} else if (ab >= d && bc < d) {
cout << d - bc << endl;
} else {
cout << d - bc + d - ab << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
char ans[n][n];
char s1 = 'W', s2 = 'B';
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < n; j++) {
if (j % 2 == 0)
ans[i][j] = s1;
else
ans[i][j] = s2;
}
char t = s1;
s1 = s2;
s2 = t;
}
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < n; j++) {
cout << ans[i][j];
}
cout << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 2e5 + 10;
int a[maxn], b[maxn];
vector <ll> v[maxn];
set <int> s;
int main () {
ios_base::sync_with_stdio(false);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
cin >> b[i];
v[a[i]].push_back(b[i]);
}
for (int i = 1; i <= n; i++) {
sort(v[i].begin(), v[i].end());
for (int j = 1; j < v[i].size(); j++) {
v[i][j] += v[i][j - 1];
}
s.insert(i);
}
for (int i = 1; i <= n; i++) {
ll ans = 0;
vector <int> r;
for (int j : s) {
if (v[j].size() < i) {
r.push_back(j);
continue;
}
ans += v[j].back();
if (v[j].size() % i) {
ans -= v[j][v[j].size() % i - 1];
}
}
for (int j : r) {
s.erase(j);
}
cout << ans << " ";
}
cout << "\n";
for (int i = 1; i <= n; i++) {
v[i].clear();
}
s.clear();
}
return 0;
} | 3 |
#include <bits/stdc++.h>
const int MAXN = (int)1e5 + 5;
const int MODN = (int)1e9 + 7;
int inf = 0x3f3f3f3f;
using namespace std;
char str[MAXN];
int num[MAXN];
int a[MAXN];
int main() {
int n, m;
while (scanf("%d%d%d%d%d%d%d", &a[0], &a[1], &a[2], &a[3], &a[4], &a[5],
&n) != EOF) {
int sum1 = a[0] + a[1] + a[2];
int sum2 = a[3] + a[4] + a[5];
int need = (sum1 % 5 == 0 ? sum1 / 5 : sum1 / 5 + 1) +
(sum2 % 10 == 0 ? sum2 / 10 : sum2 / 10 + 1);
if (need <= n)
puts("YES");
else
puts("NO");
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
mt19937 mt_rand(
chrono::high_resolution_clock::now().time_since_epoch().count());
const long long hashSize = 3;
long long mod[hashSize];
const long long N = 2e5 + 50;
long long ans = 0;
struct hash_number {
long long a[hashSize];
hash_number() { fill(a, a + hashSize, 0ll); }
hash_number(long long x) {
for (long long i = (0); i <= (hashSize - 1); ++i) {
a[i] = x % mod[i];
}
}
hash_number operator+(hash_number x) {
hash_number res = hash_number();
for (long long i = (0); i <= (hashSize - 1); ++i) {
res.a[i] = (a[i] + x.a[i]) % mod[i];
}
return res;
}
bool operator==(const hash_number &x) {
for (long long i = (0); i <= (hashSize - 1); ++i) {
if (a[i] != x.a[i]) return false;
}
return true;
}
} val[N], c[10][10], s;
vector<pair<long long, long long> > g[N];
long long n, m, k;
void solve(long long lvl, hash_number hashNumber) {
if (lvl == k) {
if (hashNumber == s) ++ans;
return;
}
for (long long i = 1; i <= lvl + 1; i++) {
solve(lvl + 1, hashNumber + c[lvl + 1][i]);
}
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
mod[0] = 1e9 + 7;
mod[1] = 998244353;
mod[2] = uniform_int_distribution<long long>(1e8, 1e9)(mt_rand);
cin >> n >> m >> k;
for (long long i = 0; i < m; i++) {
long long u, v, w;
cin >> u >> v >> w;
g[u].emplace_back(w, v);
}
uniform_int_distribution<long long> rg(1ll, 1e18);
for (long long i = 1; i <= n; i++) {
val[i] = hash_number(rg(mt_rand));
s = s + val[i];
}
for (long long u = 1; u <= n; u++) {
long long d = g[u].size();
sort(g[u].begin(), g[u].end());
for (long long q = 1; q <= d; q++) {
c[d][q] = c[d][q] + val[g[u][q - 1].second];
}
}
solve(0, hash_number());
cout << ans << '\n';
}
| 7 |
#include <bits/stdc++.h>
#include <iostream>
#include "stack"
#include "queue"
#define scan(x) scanf("%lld",&x)
#define mod 1000000007
#define pb push_back
#define mk make_pair
#define f first
#define s second
using namespace std;
typedef long long int lli;
void solve()
{
lli r,b,d;
cin>>r>>b>>d;
if((r*b-1) == d)
{
cout<<"YES"<<endl;
}
else
{
cout<<"NO"<<endl;
}
}
int main()
{
//memset(dp,-1,sizeof(dp));
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
lli t = 1;
cin>>t;
while(t--)
{
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000;
const int Maxn = 1e6;
const long long MAX = -1e18;
struct Dn {
int x, l;
};
int n, m, a, b, ans = 0;
int ind[Maxn];
vector<Dn> JQ[Maxn];
bool check() {
queue<int> Q;
for (int i = 1; i <= n; i++)
if (ind[i] == 0) Q.push(i);
while (!Q.empty()) {
if (Q.size() > 1) return false;
int S = Q.front();
Q.pop();
for (int i = 0; i < JQ[S].size(); i++) {
ind[JQ[S][i].x]--;
if (ind[JQ[S][i].x] == 0) {
Q.push(JQ[S][i].x);
ans = max(ans, JQ[S][i].l);
}
}
}
return true;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d %d", &a, &b);
JQ[a].push_back((Dn){b, i});
ind[b]++;
}
if (check())
printf("%d", ans);
else
printf("-1\n");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1500, M = 1500, INF = 0x3f3f3f3f;
int di[] = {-1, 1, 0, 0};
int dj[] = {0, 0, -1, 1};
char cc[N][M + 1];
int ii[N][M], jj[N][M];
int qu[N * M];
int n, m;
bool bfs(int si, int sj) {
int head = 0, cnt = 0;
ii[si][sj] = si, jj[si][sj] = sj, qu[head + cnt++] = si * m + sj;
while (cnt) {
int ij = qu[cnt--, head++];
int i = ij / m, j = ij % m;
int i_ = ii[i][j], j_ = jj[i][j];
for (int h = 0; h < 4; h++) {
int ti = i + di[h], tj = j + dj[h];
int ti_ = i_ + di[h], tj_ = j_ + dj[h];
if (ti < 0)
ti += n;
else if (ti >= n)
ti -= n;
if (tj < 0)
tj += m;
else if (tj >= m)
tj -= m;
if (cc[ti][tj] == '#') continue;
if (ii[ti][tj] != INF) {
if (ii[ti][tj] == ti_ && jj[ti][tj] == tj_) continue;
return true;
}
ii[ti][tj] = ti_, jj[ti][tj] = tj_, qu[head + cnt++] = ti * m + tj;
}
}
return false;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> cc[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) ii[i][j] = INF;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (cc[i][j] == 'S') {
cc[i][j] = '.';
cout << (bfs(i, j) ? "Yes" : "No") << '\n';
return 0;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
set<int> S;
set<int>::iterator it;
pair<int, int> diff[300000 + 1];
long long rmq[2][18 + 1][300000 + 1];
long long profit[300000 + 1];
int two[300000 + 1];
int d[300000 + 1];
int c[300000 + 1];
int N, A;
void Build() {
int i, j, l;
for (i = 2; i <= 300000; i++) two[i] = two[i / 2] + 1;
for (i = 1; i <= N; i++) rmq[0][0][i] = rmq[1][0][i] = profit[i];
for (l = 0; l <= 1; l++)
for (i = 1; (1 << i) <= N; i++)
for (j = 1; j <= N - (1 << i) + 1; j++) {
rmq[l][i][j] = rmq[l][i - 1][j];
if (l == 0 && rmq[l][i][j] > rmq[l][i - 1][j + (1 << i - 1)])
rmq[l][i][j] = rmq[l][i - 1][j + (1 << i - 1)];
if (l == 1 && rmq[l][i][j] < rmq[l][i - 1][j + (1 << i - 1)])
rmq[l][i][j] = rmq[l][i - 1][j + (1 << i - 1)];
}
}
long long getSegment(int first, int second, int l) {
int k = two[second - first + 1];
int is_zero = 0;
long long aux;
if (first == 0) is_zero = 1, first++;
if (l == 0)
if (rmq[l][k][first] > rmq[l][k][second + 1 - (1 << k)])
aux = rmq[l][k][second + 1 - (1 << k)];
else
aux = rmq[l][k][first];
if (l == 1)
if (rmq[l][k][first] < rmq[l][k][second + 1 - (1 << k)])
aux = rmq[l][k][second + 1 - (1 << k)];
else
aux = rmq[l][k][first];
if (l == 0 && is_zero == 1) aux = min(aux, 0LL);
if (l == 1 && is_zero == 1) aux = max(aux, 0LL);
return aux;
}
long long Solve(int i) {
int st, dr;
long long temp;
it = S.lower_bound(diff[i].second);
dr = *it;
--it;
st = *it;
temp = getSegment(diff[i].second + 1, dr, 1) -
getSegment(st, diff[i].second, 0) -
(1LL * diff[i].first * diff[i].first);
return temp;
}
int main() {
int i, j, k;
long long res = 0;
cin >> N >> A;
for (i = 1; i <= N; i++) cin >> d[i] >> c[i];
for (i = 1; i <= N; i++) res = max(res, 0LL + A - c[i]);
for (i = 1; i <= N; i++) profit[i] = profit[i - 1] + A - c[i];
Build();
for (i = 1; i < N; i++) diff[i] = {d[i + 1] - d[i], i};
sort(diff + 1, diff + N);
reverse(diff + 1, diff + N);
S.insert(0);
S.insert(N);
for (i = 1; i < N; i = j) {
for (j = i; j < N && diff[i].first == diff[j].first; j++)
res = max(res, Solve(j));
for (k = i; k < j; k++) S.insert(diff[k].second);
}
cout << res;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long n;
int k;
long long a[100004];
int main() {
scanf("%lld%d", &n, &k);
for (int i = 1; i <= k; i++) a[i] = i;
long long sum = ((1LL + k) * k) >> 1;
if (n < sum) return puts("NO"), 0;
long long p = n / sum, r = n % sum;
for (int i = 1; i <= k; i++) a[i] *= p;
long long h = r / k;
r %= k;
for (int i = 1; i <= k; i++) a[i] += h;
for (int i = k; i > 1; i--) {
long long now = min(r, (a[i - 1] << 1) - a[i]);
if (i < k) now = min(now, a[i + 1] - a[i] - 1);
r -= now;
a[i] += now;
}
if (k >= 2 && a[1] + r < a[2]) {
a[1] += r;
r = 0;
}
if (r)
return puts("NO"), 0;
else
puts("YES");
for (int i = 1; i <= k; i++) printf("%lld ", a[i]);
puts("");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
long long dp[N];
void solve() {
int n, q;
cin >> n >> q;
for (int i = 1; i <= n; i++) {
char c;
cin >> c;
int val = 1;
if (c == '-') val *= -1;
if (i % 2 == 0) val *= -1;
dp[i] = dp[i - 1] + val;
}
while (q--) {
int l, r;
cin >> l >> r;
long long temp = dp[r] - dp[l - 1];
if (temp == 0)
cout << "0\n";
else if (temp % 2 != 0)
cout << "1\n";
else
cout << "2\n";
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) solve();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline int max(int a, int b) { return a < b ? b : a; }
inline int min(int a, int b) { return a > b ? b : a; }
inline long long max(long long a, long long b) { return a < b ? b : a; }
inline long long min(long long a, long long b) { return a > b ? b : a; }
const int mod = 1e9 + 7;
const int N = 1e6 + 10;
const long long INF = 1e18;
long long power(long long x, long long y) {
long long t = 1;
while (y > 0) {
if (y % 2)
y -= 1, t = t * x % mod;
else
y /= 2, x = x * x % mod;
}
return t;
}
long long tw;
long long sum(long long x) {
x %= mod;
return (x * (x + 1) % mod) * tw % mod;
}
int pp = N * 10;
int main() {
long long ans = 0;
tw = power(2, mod - 2);
long long n, m;
scanf("%lld%lld", &n, &m);
if (m <= pp) {
for (int i = 1; i < m + 1; ++i) ans += n % i;
printf("%lld\n", ans % mod);
exit(0);
}
long long c = pp;
for (int i = 1; i < c + 1; ++i) ans += n % i;
ans %= mod;
ans += (n % mod * ((m - c) % mod)) % mod;
for (int i = N; i > 0; i--) {
long long x = n / i;
if (x >= c) {
long long h = min(m, x);
ans -= ((sum(h) - sum(c)) % mod) * i % mod;
ans = (ans % mod + mod) % mod;
c = h;
}
}
printf("%lld\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long x = 0;
for (int i = 2; i <= n - 1; i++) x = x + i * (i + 1);
cout << x << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<int> vec, vec2, vec3, vec4, v, p;
long long t, n, k, flag;
long long m, sum, cnt, ans;
vector<vector<int>> graph;
vector<int> visited;
queue<long long> pq, pq2;
map<long long, long long> mp, mpp, mpc;
const int sss = 1e6 + 1;
const int sss2 = 1e5 + 2;
bool sortBy(pair<char, int> &a, pair<char, int> &b) {
return a.second > b.second;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> t;
while (t--) {
cin >> n;
vec.resize(n);
for (int i = 0; i < n; ++i) cin >> vec[i];
reverse(vec.begin(), vec.end());
for (int i = 0; i < n; ++i) cout << vec[i] << " ";
cout << '\n';
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#define ll long long
int main() {
ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
int tt;
cin >> tt;
while(tt --) {
string s;
cin >> s;
int cnt[2] = {}, ans = 0;
for(char c : s) {
if(c == '(') {
cnt[0] ++;
}
if(c == ')' and cnt[0] > 0) {
cnt[0] --;
ans ++;
}
if(c == '[') {
cnt[1] ++;
}
if(c == ']' and cnt[1] > 0) {
cnt[1] --;
ans ++;
}
}
cout << ans << "\n";
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1111;
char s[maxn][maxn];
int vis[maxn], tmp[maxn];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", s[i]);
int ans = 0;
if (n == 1) {
cout << 0 << endl;
} else {
for (int j = 0; j < m; j++) {
int ok = 1;
memset(tmp, 0, sizeof tmp);
for (int i = 0; i < n - 1; i++) {
if (s[i][j] > s[i + 1][j] && !vis[i]) {
ok = 0;
break;
}
if (s[i][j] < s[i + 1][j]) tmp[i] = 1;
}
if (ok) {
for (int k = 0; k < n; k++) vis[k] |= tmp[k];
} else {
ans++;
}
}
cout << ans << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > matr;
int n, m, h, t;
int num_same(int v, int u) {
int ans = 0;
if (matr[v].size() < matr[u].size()) {
for (int i = 0; i < matr[v].size(); i++) {
if (binary_search(matr[u].begin(), matr[u].end(), matr[v][i])) ans++;
}
} else {
for (int i = 0; i < matr[u].size(); i++) {
if (binary_search(matr[v].begin(), matr[v].end(), matr[u][i])) ans++;
}
}
return ans;
}
void hydro(int v, int u, int ns) {
if (matr[v].size() - 1 < h || matr[u].size() - 1 < t ||
matr[v].size() + matr[u].size() - ns < h + t)
return;
vector<int> heads, tails;
int i = 0, j = 0;
while (i < matr[v].size() && j < matr[u].size()) {
if (matr[v][i] == matr[u][j]) {
i++;
j++;
continue;
}
if (matr[v][i] == u) {
i++;
continue;
}
if (matr[u][j] == v) {
j++;
continue;
}
if (matr[v][i] < matr[u][j]) {
if (heads.size() < h) heads.push_back(matr[v][i]);
i++;
} else {
if (tails.size() < t) tails.push_back(matr[u][j]);
j++;
}
}
for (; heads.size() < h && i < matr[v].size(); i++)
if (matr[v][i] != u) heads.push_back(matr[v][i]);
for (; tails.size() < t && j < matr[u].size(); j++)
if (matr[u][j] != v) tails.push_back(matr[u][j]);
i = 0;
j = 0;
for (; (tails.size() < t || heads.size() < h) && i < matr[v].size() &&
j < matr[u].size();) {
if (matr[v][i] == matr[u][j]) {
if (heads.size() < h) {
heads.push_back(matr[v][i]);
i++;
j++;
continue;
}
if (tails.size() < t) {
tails.push_back(matr[u][j]);
i++;
j++;
continue;
}
break;
}
if (matr[v][i] < matr[u][j])
i++;
else
j++;
}
if (heads.size() != h || tails.size() != t) return;
cout << "YES" << endl;
cout << v + 1 << " " << u + 1 << endl;
for (int i = 0; i < h; i++) cout << heads[i] + 1 << " ";
cout << endl;
for (int i = 0; i < t; i++) cout << tails[i] + 1 << " ";
cout << endl;
exit(0);
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m >> h >> t;
matr.resize(n);
vector<pair<int, int> > rebr(m);
for (int i = 0; i < m; i++) {
cin >> rebr[i].first >> rebr[i].second;
rebr[i].first--;
rebr[i].second--;
matr[rebr[i].first].push_back(rebr[i].second);
matr[rebr[i].second].push_back(rebr[i].first);
}
for (int i = 0; i < n; i++) sort(matr[i].begin(), matr[i].end());
for (int i = 0; i < m; i++) {
int u = rebr[i].first, v = rebr[i].second;
int ns = num_same(v, u) + 2;
hydro(u, v, ns);
hydro(v, u, ns);
}
cout << "NO" << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a, b;
cin >> n >> a >> b;
long long s = 6 * n;
bool sw = false;
if (s <= a * b) return cout << a * b << "\n" << a << " " << b, 0;
if (a > b) {
sw = true;
swap(a, b);
}
long long mn = 1000000000000000001, ma = a, mb = b;
for (long long i = a; i <= 100000; i++) {
long long bb = s / i;
if (s % i != 0) bb++;
if (bb < b) break;
if (i * bb - s < mn && i <= bb) {
ma = i;
mb = bb;
mn = i * bb - s;
}
}
mn = ma * mb - s;
if (sw) swap(ma, mb);
cout << mn + s << "\n" << ma << " " << mb;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long maxval(long long a, long long b);
long long minval(long long a, long long b);
long long gcd(long long u, long long v);
long long Ndig(long long n);
bool ispoweroftwo(long long n);
bool isvowel(char x);
long long chartoint(char ch);
long long CEIL(long long x, long long y);
long long FLOOR(long long x, long long y);
long long sumdigits(long long n) {
long long sum = 0;
while (n > 0) {
sum += n % 10;
n = n / 10;
}
return sum;
}
int main() {
long long t;
cin >> t;
while (t--) {
int n;
cin >> n;
int count = 0;
int array[n];
for (long long i = 0; i < n; ++i) {
int a;
cin >> a;
array[i] = a;
}
sort(array, array + n);
for (long long i = 0; i < n - 1; ++i) {
if (array[i + 1] - array[i] > 1) {
count++;
}
}
if (count >= 1) {
cout << "NO";
} else {
cout << "YES";
}
cout << endl;
}
}
long long maxval(long long a, long long b) {
if (a > b) return a;
return b;
}
long long minval(long long a, long long b) {
if (a < b) return a;
return b;
}
long long gcd(long long u, long long v) {
if (v == 0) return u;
return gcd(v, u % v);
}
long long Ndig(long long n) { return floor(log10(n)) + 1; }
bool ispoweroftwo(long long x) { return x && (!(x & (x - 1))); }
bool isvowel(char x) {
return (x == 'a' || x == 'e' || x == 'i' || x == 'o' || x == 'u');
}
long long chartoint(char ch) {
if (ch >= 'A' && ch <= 'Z')
return (ch - 'A');
else if (ch >= '0' && ch <= '9')
return (ch - '0');
else if (ch >= 'a' && ch <= 'z')
return (ch - 'a');
else
return 0;
}
long long CEIL(long long x, long long y) {
if (x % y == 0)
return (x / y);
else
return (x / y + 1);
}
long long FLOOR(long long x, long long y) {
if (x % y == 0)
return (x / y);
else
return (x / y - 1);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n == 1) {
cout << 9 << ' ' << 8;
} else {
cout << n * 4 << ' ' << n * 3;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void fast() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
inline int D() {
int m;
cin >> m;
return m;
}
inline long long lD() {
long long m;
cin >> m;
return m;
}
inline double dD() {
double m;
cin >> m;
return m;
}
int arr[3005];
int main() {
fast();
int n = D(), m = D();
for (int i = 0; i < m; ++i) arr[i] = D();
sort(arr, arr + m);
if (arr[m - 1] == n || arr[0] == 1) {
cout << "NO"
<< "\n";
return 0;
}
int c = 0;
for (int i = 0; i < m - 1; ++i)
if (arr[i + 1] - arr[i] == 1)
c++;
else if (c >= 2)
break;
else
c = 0;
if (c >= 2)
cout << "NO"
<< "\n";
else
cout << "YES"
<< "\n";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long double EPS = (long double)1e-9L;
const double PI = 3.141592653589793238462;
const int INF = 2e9 + 7;
const long long LINF = 9e18 + 7;
const int N = 2e5 + 7;
int p[N];
vector<int> ans[N];
void init(int n) {
for (int i = 0; i < (int)(n); ++i) p[i] = i;
}
int find(int x) { return p[x] == x ? x : p[x] = find(p[x]); }
void merge(int x, int y) {
x = find(x);
y = find(y);
if (x == y) return;
if (rand() % 2) swap(x, y);
p[x] = y;
}
int main() {
string s;
cin >> s;
stack<int> s0, s1;
int n = s.size();
init(n);
for (int i = 0; i < (int)(n); ++i) {
if (s[i] == '1') {
if (!s0.empty()) {
merge(s0.top(), i);
s1.push(i);
s0.pop();
continue;
}
cout << -1 << endl;
return 0;
}
s0.push(i);
if (!s1.empty()) {
merge(s1.top(), i);
s1.pop();
continue;
}
}
if (!s1.empty()) {
cout << -1 << endl;
return 0;
}
for (int i = 0; i < (int)(n); ++i) {
ans[find(i)].push_back(i);
}
int cnt = 0;
for (int i = 0; i < (int)(n); ++i) {
cnt += !ans[i].empty();
}
cout << cnt << endl;
for (int i = 0; i < (int)(n); ++i) {
if (ans[i].empty()) continue;
cout << ans[i].size() << ' ';
for (int j = 0; j < (int)(ans[i].size()); ++j) {
cout << ans[i][j] + 1 << ' ';
}
cout << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int sgu(int abc) {
if (abc > 0) return abc;
return 0;
}
int max(int a, int b) {
if (a > b)
return a;
else
return b;
}
int min(int a, int b) {
if (a < b)
return a;
else
return b;
}
vector<int> g[1000001];
bool u[1000001];
int n, m, k, p, num;
void dfs(int z) {
u[z] = true;
for (int i = 0; i < g[z].size(); i++)
if (!u[g[z][i]]) {
dfs(g[z][i]);
num++;
}
}
int main() {
int shiits;
memset(u, false, sizeof(u));
int x, y, maxx = 0;
cin >> n >> m >> k;
for (int i = 1; i <= m; i++) {
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
for (int i = 1; i <= n; i++)
if (!u[i]) {
num = 1;
p++;
dfs(i);
maxx += min(k, num);
}
if (k == 1)
cout << sgu(p - k - 1);
else
cout << sgu(p - maxx / 2 - 1);
return 0;
}
| 7 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.