solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
struct hash_pair {
template <class T1, class T2>
size_t operator()(const pair<T1, T2> &p) const {
auto hash1 = hash<T1>{}(p.first);
auto hash2 = hash<T2>{}(p.second);
return hash1 ^ hash2;
}
};
long long int n, m;
vector<long long int> adj[1];
bool visited[1];
long long int start[1];
long long int end[1];
long long int parent[1];
long long int level[1];
vector<long long int> dfs_order;
void dfs(long long int node) {
visited[node] = true;
for (long long int next : adj[node]) {
if (!visited[next]) {
parent[next] = node;
level[next] = level[node] + 1;
dfs(next);
}
}
}
long long int dist[1];
void bfs(long long int start) {
memset(dist, -1, sizeof dist);
queue<long long int> q;
dist[start] = 0;
q.push(start);
while (!q.empty()) {
long long int v = q.front();
q.pop();
for (long long int e : adj[v]) {
if (dist[e] == -1) {
dist[e] = dist[v] + 1;
q.push(e);
}
}
}
}
long long int lift(long long int a, long long int dist,
vector<vector<long long int>> &up) {
for (long long int i = 0; i < 20; i++) {
if (dist & (1 << i)) {
a = up[a][i];
}
}
return a;
}
void preprocesslift(vector<vector<long long int>> &up) {
for (long long int j = 1; j < 20; j++) {
for (long long int i = 1; i <= n; i++) {
if (up[i][j - 1] != -1) {
up[i][j] = up[up[i][j - 1]][j - 1];
}
}
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t;
cin >> t;
while (t > 0) {
long long int n, k;
cin >> n >> k;
if (n == 1)
cout << "0\n";
else {
long long int h = 1;
long long int comp = 2;
for (long long int i = 0;; i++) {
if (comp >= n) break;
if (comp <= k) {
comp *= 2;
h++;
} else
break;
}
if (comp < n) {
long long int temp = n - comp;
h += temp / k;
if ((temp % k) != 0) h++;
}
cout << h << "\n";
}
t--;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 510;
const long long INF = 10000000000000000LL;
const long long inf = 5000000000000LL;
int n;
int nx, ny;
int times;
long long v[MAXN][MAXN];
long long ex[MAXN], ey[MAXN];
long long slack[MAXN];
int ux[MAXN], uy[MAXN], mx[MAXN], my[MAXN], pre[MAXN];
template <class T>
inline void freshmin(T &a, const T &b) {
if (a > b) a = b;
}
void match(int y) {
while (y) {
my[y] = pre[y];
swap(y, mx[pre[y]]);
}
}
void bfs(int sx) {
for (int y = 1; y <= ny; ++y) slack[y] = INF;
queue<int> Q;
Q.push(sx);
++times;
while (1) {
while (!Q.empty()) {
int x = Q.front();
Q.pop();
ux[x] = times;
long long gap;
for (int y = 1; y <= ny; ++y)
if (uy[y] != times && (gap = ex[x] + ey[y] - v[x][y]) <= slack[y]) {
pre[y] = x;
if (!gap) {
uy[y] = times;
if (!my[y])
return match(y);
else
Q.push(my[y]);
} else
slack[y] = gap;
}
}
long long d = INF;
for (int y = 1; y <= ny; ++y)
if (uy[y] != times) freshmin(d, slack[y]);
for (int x = 1; x <= nx; ++x)
if (ux[x] == times) ex[x] -= d;
for (int y = 1; y <= ny; ++y)
if (uy[y] == times)
ey[y] += d;
else
slack[y] -= d;
for (int y = 1; y <= ny; ++y)
if (uy[y] != times && !slack[y]) {
uy[y] = times;
if (!my[y])
return match(y);
else
Q.push(my[y]);
}
}
}
void KM() {
for (int y = 1; y <= ny; ++y) {
my[y] = 0;
ey[y] = 0;
uy[y] = 0;
}
for (int x = 1; x <= nx; ++x) {
mx[x] = 0;
ex[x] = *max_element(v[x] + 1, v[x] + ny + 1);
ux[x] = 0;
}
for (int x = 1; x <= nx; ++x) bfs(x);
long long ans = 0;
for (int y = 1; y <= ny; ++y) ans += v[my[y]][y];
cout << ans << endl;
}
int main() {
scanf("%d", &n);
for (long long x = 1; x <= n; x++) {
long long a, b, c;
scanf("%lld%lld%lld", &a, &b, &c);
for (long long i = 1; i <= n; i++) {
long long tm = i - 1;
tm = min(c, tm);
long long p = a - b * tm;
if (p > 0) v[x][i] = p;
}
}
nx = ny = n;
KM();
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
#pragma GCC optimize("tree-vectorize")
#pragma GCC target("sse4")
using namespace std;
using lint = long long;
using pii = pair<int, int>;
using pll = pair<lint, lint>;
template <typename T>
using vc = vector<T>;
template <typename T>
using vvc = vector<vector<T>>;
template <typename T>
inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T>
inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
constexpr lint ten(int n) { return n == 0 ? 1 : ten(n - 1) * 10; }
class F1FlyingSortEasyVersion {
public:
void solve(std::istream& in, std::ostream& out) {
ios_base::sync_with_stdio(false);
in.tie(nullptr), out.tie(nullptr);
int tt;
in >> tt;
while (tt--) {
int N;
in >> N;
map<int, int> id;
for (int i = (0); i < (N); ++i) {
int a;
in >> a;
id[a] = i;
}
int mx = 0, len = 0, last = -1;
for (auto& p : id) {
if (last < p.second)
++len;
else
len = 1;
chmax(mx, len);
last = p.second;
}
out << N - mx << '\n';
}
}
};
int main() {
F1FlyingSortEasyVersion solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long n;
vector<long long> used;
vector<long long> order;
vector<vector<long long>> g, gr;
void dfs(long long v) {
used[v] = 1;
for (int i = 0; i < g[v].size(); ++i) {
long long to = g[v][i];
if (!used[to]) dfs(to);
}
order.push_back(v);
}
vector<long long> res;
void dfs2(long long v) {
res.push_back(v);
used[v] = 1;
for (int i = 0; i < gr[v].size(); ++i) {
long long to = gr[v][i];
if (!used[to]) {
dfs2(to);
}
}
}
map<string, long long> mapp;
int main() {
long long m;
cin >> n >> m;
g.resize(2 * n);
gr.resize(2 * n);
vector<pair<long long, long long>> door(n, {-1, -1});
for (int i = 0; i < m; ++i) {
long long x, y, c;
cin >> x >> y >> c;
--x;
--y;
if (c == 1) {
g[x].push_back(y);
g[y + n].push_back(x + n);
g[y].push_back(x);
g[x + n].push_back(y + n);
gr[y].push_back(x);
gr[x + n].push_back(y + n);
gr[x].push_back(y);
gr[y + n].push_back(x + n);
} else {
g[x].push_back(y + n);
g[x + n].push_back(y);
g[y + n].push_back(x);
g[y].push_back(x + n);
gr[y + n].push_back(x);
gr[y].push_back(x + n);
gr[x].push_back(y + n);
gr[x + n].push_back(y);
}
}
used.clear();
used.resize(2 * n);
for (int i = 0; i < used.size(); ++i) {
if (!used[i]) {
dfs(i);
}
}
reverse(order.begin(), order.end());
used.clear();
used.resize(2 * n);
vector<long long> comp(2 * n);
long long num = -1;
for (int i = 0; i < order.size(); ++i) {
long long v = order[i];
if (!used[v]) {
++num;
res.clear();
dfs2(v);
for (int j = 0; j < res.size(); ++j) {
comp[res[j]] = num;
}
}
}
for (int i = 0; i < n; ++i) {
if (comp[i] == comp[i + n]) {
cout << "Impossible" << endl;
return 0;
}
}
vector<long long> ans;
for (int i = 0; i < n; ++i) {
if (comp[i] < comp[i + n]) {
} else {
ans.push_back(i);
}
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); ++i) cout << ans[i] + 1 << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int idx[100010], F[100010];
long long int mod = 1e9 + 7;
void build_failure_function(string &pattern) {
int m = pattern.length();
F[0] = F[1] = 0;
for (int i = 2; i <= m; i++) {
int j = F[i - 1];
while (1) {
if (pattern[j] == pattern[i - 1]) {
F[i] = j + 1;
break;
}
if (j == 0) {
F[i] = 0;
break;
}
j = F[j];
}
}
}
void KMP(string &text, string &pattern) {
int n = text.length(), m = pattern.length();
build_failure_function(pattern);
int i = 0, j = 0;
while (1) {
if (j == n) break;
if (text[j] == pattern[i]) {
i++;
j++;
if (i == m) {
idx[j - 1] = 1;
i = F[i];
}
} else if (i > 0)
i = F[i];
else
j++;
}
}
int main() {
string s, t;
cin >> s >> t;
int L = s.length(), m = t.length();
for (int i = 0; i < L; i++) idx[i] = 0;
KMP(s, t);
long long int dp[100010], cum[100010], dcum[100010];
for (int i = 0; i < L; i++) cum[i] = 0, dp[i] = 0, dcum[i] = 0;
for (int i = 0; i < L; i++) {
if (idx[i]) {
int T = i - m + 1;
dp[i] = T + 1;
if (T) dp[i] = (dcum[T - 1] + dp[i]) % mod;
} else if (i)
dp[i] = dp[i - 1];
cum[i] = dp[i];
if (i) cum[i] = (cum[i] + cum[i - 1]) % mod;
dcum[i] = cum[i];
if (i) dcum[i] = (dcum[i] + dcum[i - 1]) % mod;
}
printf("%lld\n", cum[L - 1]);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int b[n];
for (int i = 0; i < n; i++) {
cin >> b[i];
}
long long int ans = -1;
map<long long int, long long int> m;
for (int i = 0; i < n; i++) {
int j = i + 1;
m[j - b[i]] += b[i];
ans = max(ans, m[j - b[i]]);
}
cout << ans << endl;
}
| 2 |
#include<iostream>
#include<cmath>
using namespace std;
#define EPS 1e-8
int dfs(double remain, int n, double a, int denominator) {
if(fabs(remain) < EPS) return 1;
if(remain < EPS) return 0;
if(n <= 0) return 0;
if(remain - ((double) n) / ((double) denominator) > EPS) return 0;
int result = 0;
for(int i=denominator; i<=a; i++) {
if(a / ((double) i) < EPS) break;
result += dfs(remain - 1.0 / ((double) i), n - 1, a / ((double) i), i);
}
return result;
}
int main() {
double p, q, a;
int n;
while(cin>>p>>q>>a>>n, p+q+a+n) {
cout<<dfs(p/q,n,a,1)<<endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
inline int ab(int x) { return x > 0 ? x : -x; }
int par[1010], ex[1010];
int find(int x) { return par[x] == x ? x : (par[x] = find(par[x])); }
int n;
int x[1010], y[1010], xi[1010], yi[1010];
vector<int> xs, ys;
vector<pair<int, int> > gx[1010], gy[1010];
int w[1010][1010][2];
int can(int mid) {
for (int i = 0; i < n; i++) {
par[i] = i;
ex[i] = 0;
}
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (x[i] == x[j] && ab(y[i] - y[j]) <= mid ||
y[i] == y[j] && ab(x[i] - x[j]) <= mid) {
par[find(i)] = find(j);
}
}
}
int c = 0;
for (int i = 0; i < n; i++) {
ex[find(i)] = 1;
}
for (int i = 0; i < n; i++) {
c += ex[i];
}
if (c == 1) return 1;
if (c > 4) return 0;
int t[4];
for (int i = 0; i < xs.size(); i++) {
for (int j = 0; j < ys.size(); j++) {
int px = w[i][j][0], py = w[i][j][1];
t[0] = t[1] = t[2] = t[3] = -1;
if (px > 0 && ab(ys[j] - gx[i][px - 1].first) <= mid) {
t[0] = find(gx[i][px - 1].second);
}
if (px < gx[i].size() && ab(ys[j] - gx[i][px].first) <= mid) {
t[1] = find(gx[i][px].second);
}
if (py > 0 && ab(xs[i] - gy[j][py - 1].first) <= mid) {
t[2] = find(gy[j][py - 1].second);
}
if (py < gy[j].size() && ab(xs[i] - gy[j][py].first) <= mid) {
t[3] = find(gy[j][py].second);
}
sort(t, t + 4);
int u = unique(t, t + 4) - t;
if (t[0] == -1) --u;
if (c == u) return 1;
}
}
if (c > 2) return 0;
for (int i = 0; i < xs.size(); i++) {
for (int j = 1; j < gx[i].size(); j++) {
if (gx[i][j].first - gx[i][j - 1].first <= 2ll * mid) {
if (find(gx[i][j].second) != find(gx[i][j - 1].second)) return 1;
}
}
}
for (int i = 0; i < ys.size(); i++) {
for (int j = 1; j < gy[i].size(); j++) {
if (gy[i][j].first - gy[i][j - 1].first <= 2ll * mid) {
if (find(gy[i][j].second) != find(gy[i][j - 1].second)) return 1;
}
}
}
return 0;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d%d", &x[i], &y[i]);
xs.push_back(x[i]);
ys.push_back(y[i]);
}
sort(xs.begin(), xs.end());
sort(ys.begin(), ys.end());
xs.resize(unique(xs.begin(), xs.end()) - xs.begin());
ys.resize(unique(ys.begin(), ys.end()) - ys.begin());
for (int i = 0; i < n; i++) {
xi[i] = lower_bound(xs.begin(), xs.end(), x[i]) - xs.begin();
yi[i] = lower_bound(ys.begin(), ys.end(), y[i]) - ys.begin();
gx[xi[i]].push_back(make_pair(y[i], i));
gy[yi[i]].push_back(make_pair(x[i], i));
}
for (int i = 0; i < xs.size(); i++) {
sort(gx[i].begin(), gx[i].end());
}
for (int i = 0; i < ys.size(); i++) {
sort(gy[i].begin(), gy[i].end());
}
for (int i = 0; i < xs.size(); i++) {
for (int j = 0; j < ys.size(); j++) {
int px = lower_bound(gx[i].begin(), gx[i].end(), make_pair(ys[j], -1)) -
gx[i].begin();
w[i][j][0] = px;
int py = lower_bound(gy[j].begin(), gy[j].end(), make_pair(xs[i], -1)) -
gy[j].begin();
w[i][j][1] = py;
}
}
int lo = 0, hi = 2000000001;
if (!can(hi)) {
puts("-1");
return 0;
}
while (lo + 1 < hi) {
int mid = (hi - lo) / 2 + lo;
if (can(mid)) {
hi = mid;
} else {
lo = mid;
}
}
printf("%d\n", hi);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long M = 1e9 + 7;
long long mod(long long a, long long m) {
if (a == 0)
return 0;
else
return (a % m + m) % m;
}
int mod(string num, int a) {
int res = 0;
for (int i = 0; i < num.length(); i++)
res = (res * 10 + (int)num[i] - '0') % a;
return res;
}
long long d, x, y;
void extendedEuclid(int A, int B) {
if (B == 0) {
d = A;
x = 1;
y = 0;
} else {
extendedEuclid(B, A % B);
int temp = x;
x = y;
y = temp - (A / B) * y;
}
}
long long modInverse(int A, int M) {
extendedEuclid(A, M);
return (x % M + M) % M;
}
long long poow(long long a, long long b, long long m) {
if (b % 2 == 0)
return (((long long)pow(a, b / 2) % m) * ((long long)pow(a, b / 2) % m)) %
m;
else
return (((long long)pow(a, (b - 1) / 2) % m) *
((long long)pow(a, (b + 1) / 2) % m)) %
m;
}
bool subsum(long long ar[], long long s, long long n) {
if (n == 0 && s != 0)
return false;
else if (s <= 0)
return true;
else if (ar[n - 1] > s)
return subsum(ar, s, n - 1);
else
return (subsum(ar, s - ar[n - 1], n - 1) || subsum(ar, s, n - 1));
}
int binarySearch(int arr[], int l, int r, int x) {
if (r >= l) {
int mid = l + (r - l) / 2;
if (arr[mid] == x) return mid;
if (arr[mid] > x) return binarySearch(arr, l, mid - 1, x);
return binarySearch(arr, mid + 1, r, x);
}
return -1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long t, n, q, k, i, h, m, c, u, f, j, p, r, s, b, d;
cin >> t;
while (t--) {
cin >> p;
int o[p], e[p];
q = r = 0;
for (i = 0; i < p; i++) {
cin >> s;
if (s % 2 == 0)
e[q++] = s;
else
o[r++] = s;
}
sort(o, o + r);
sort(e, e + q);
if (q % 2 == 0 && r % 2 == 0)
cout << "YES"
<< "\n";
else {
f = 0;
for (i = 0; i < r; i++)
if ((binarySearch(e, 0, q - 1, o[i] - 1) != -1) ||
(binarySearch(e, 0, q - 1, o[i] + 1) != -1)) {
f = 1;
break;
}
if (f == 1)
cout << "YES"
<< "\n";
else
cout << "NO"
<< "\n";
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
long long n;
cin >> n >> s;
long long c8 = 0, x;
for (long long i = 0; i < n; ++i) {
if (s[i] == '8') c8++;
}
x = (n - 11) / 2;
if (c8 <= x) {
cout << "NO\n";
return 0;
}
string s2;
long long idx = -1;
for (long long i = 0; i < n; ++i) {
if (s[i] == '8' && x > 0) {
x--;
continue;
}
if (s[i] == '8' && x == 0) {
idx = s2.size();
break;
}
s2.push_back(s[i]);
}
x = (n - 11) / 2;
if (idx > x) {
cout << "NO\n";
} else {
cout << "YES\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base ::sync_with_stdio(0), cin.tie(0), cout.tie(0);
;
long long cnt = 0;
long long ans = 0;
long long n, m = 0;
string s[1005];
long long posC = 0;
cin >> n;
if (n % 2 == 0) {
ans = n * (n / 2);
} else {
ans = (n * n) / 2 + 1;
}
cout << ans << endl;
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= n; j++) {
if (i % 2 == 1 and j % 2 == 1 or i % 2 == 0 and j % 2 == 0) {
cout << "C";
} else {
cout << ".";
}
}
cout << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int t, n, m, ans;
vector<vector<int>> gh, used;
int dx[8] = {1, 1, 1, 0, 0, -1, -1, -1};
int dy[8] = {1, 0, -1, 1, -1, 1, 0, -1};
bool onseg(double x1, double y1, double x2, double y2, double x, double y) {
double d1 = sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));
double d2 = sqrt((x - x2) * (x - x2) + (y - y2) * (y - y2));
double d3 = sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
return abs(d3 - d2 - d1) < 1e-9;
}
void bfs(int y, int x) {
if (gh[y][x] == 0) return;
if (used[y][x]) return;
used[y][x] = true;
vector<pair<int, int>> todo, temp, bunch;
int cx, cy, nx, ny;
todo.push_back({y, x});
bunch.push_back({y, x});
while (true) {
if (todo.empty()) break;
for (int i = 0; i < todo.size(); i++) {
cy = todo[i].first, cx = todo[i].second;
for (int j = 0; j < 8; j++) {
ny = cy + dy[j];
nx = cx + dx[j];
if (ny >= 0 && ny < n && nx >= 0 && nx < m) {
if (used[ny][nx] == 0) {
temp.push_back({ny, nx});
bunch.push_back({ny, nx});
used[ny][nx] = 1;
}
}
}
}
todo = temp;
temp.clear();
}
if (bunch.size() % 4) return;
int len = bunch.size() / 4;
int topx, topy, btx, bty;
topx = bunch[0].second, topy = bunch[0].first;
btx = topx + len, bty = topy + len;
bool sq = true;
for (int j = 1; j < bunch.size(); j++) {
int nx = bunch[j].second, ny = bunch[j].first;
if (!onseg(topx, topy, btx, topy, nx, ny) &&
!onseg(topx, topy, topx, bty, nx, ny) &&
!onseg(btx, bty, btx, topy, nx, ny) &&
!onseg(btx, bty, topx, bty, nx, ny)) {
sq = false;
break;
}
}
if (sq) {
ans++;
return;
}
sq = true;
topx = bunch[0].second, topy = bunch[0].first;
btx = topx, bty = topy + 2 * len;
for (int j = 1; j < bunch.size(); j++) {
int nx = bunch[j].second, ny = bunch[j].first;
if (!onseg(topx, topy, topx - len, topy + len, nx, ny) &&
!onseg(topx, topy, topx + len, topy + len, nx, ny) &&
!onseg(btx, bty, topx - len, topy + len, nx, ny) &&
!onseg(btx, bty, topx + len, topy + len, nx, ny)) {
sq = false;
break;
}
}
if (sq) {
ans++;
}
}
void solve() {
cin >> n >> m;
gh = used = vector<vector<int>>(n, vector<int>(m));
ans = 0;
char ch;
int val;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> ch;
val = ch - '0';
if (val == 0) used[i][j] = 1;
gh[i][j] = val;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
if (used[i][j] == 0) bfs(i, j);
}
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> t;
while (t--) solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
char board[n][m];
char tog = 'B';
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < m; j++) {
board[i][j] = tog;
tog = (tog == 'W') ? 'B' : 'W';
}
}
board[n - 1][0] = 'B';
board[n - 1][1] = 'B';
tog = 'W';
for (int j = 2; j < m; j++) {
board[n - 1][j] = tog;
tog = (tog == 'W') ? 'B' : 'W';
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cout << board[i][j];
}
cout << "\n";
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<int> bubbleSteps(vector<int> planks, int steps, int np) {
for (int k = 0; k < steps; k++) {
for (int kk = 0; kk < (np - k - 1); kk++) {
if (planks[kk] > planks[kk + 1]) {
int tmp = planks[kk];
planks[kk] = planks[kk + 1];
planks[kk + 1] = tmp;
}
}
}
return planks;
}
int main() {
int times;
cin >> times;
for (int i = 0; i < times; i++) {
int np;
cin >> np;
vector<int> planks;
for (int i = 0; i < np; i++) {
int x;
cin >> x;
planks.push_back(x);
}
planks = bubbleSteps(planks, 2, np);
int count = 0;
for (int i = 0; i < planks.size() - 2; i++) {
if (count < planks[planks.size() - 2] - 1) count++;
}
cout << count << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> nums(2 * n + 1, 0), even, odd;
for (int i = 1; i <= 2 * n; i++) {
cin >> nums[i];
if (nums[i] % 2)
odd.push_back(i);
else
even.push_back(i);
}
vector<pair<int, int> > ans;
for (int i = 0; i + 1 < odd.size(); i += 2)
ans.push_back({odd[i], odd[i + 1]});
for (int i = 0; i + 1 < even.size(); i += 2)
ans.push_back({even[i], even[i + 1]});
for (int i = 0; i < n - 1; i++)
cout << ans[i].first << " " << ans[i].second << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
double EPS = 1e-10;
int D[1000000];
double sum[1000000];
double maxi[1000000];
double maxiL[1000000];
double maxiR[1000000];
int W;
void init() {
for (int i = 0; i < (W); ++i)
maxiL[i + W] = maxiR[i + W] = maxi[i + W] = max(sum[i + W], 0.0);
for (int i = (W)-1; i >= (1); --i) {
sum[i] = sum[2 * i] + sum[2 * i + 1];
maxiL[i] = max(sum[2 * i] + maxiL[2 * i + 1], maxiL[2 * i]);
maxiR[i] = max(sum[2 * i + 1] + maxiR[2 * i], maxiR[2 * i + 1]);
maxi[i] =
max(maxiR[2 * i] + maxiL[2 * i + 1], max(maxi[2 * i], maxi[2 * i + 1]));
}
}
double getMaxiL(int b, int v, int l, int r) {
if (b == r) return maxiL[v];
int mid = (l + r) / 2;
double result = getMaxiL(min(b, mid), 2 * v, l, mid);
if (mid + 1 <= b) {
result = max(result, sum[2 * v] + getMaxiL(b, 2 * v + 1, mid + 1, r));
}
return result;
}
double getMaxiR(int a, int v, int l, int r) {
if (a == l) return maxiR[v];
int mid = (l + r) / 2;
double result = getMaxiR(max(a, mid + 1), 2 * v + 1, mid + 1, r);
if (a <= mid) {
result = max(result, sum[2 * v + 1] + getMaxiR(a, 2 * v, l, mid));
}
return result;
}
double getMaxi(int a, int b, int v, int l, int r) {
if (l == a && b == r) return maxi[v];
int mid = (l + r) / 2;
double result = 0;
if (a <= mid) {
result = max(result, getMaxi(a, min(b, mid), 2 * v, l, mid));
}
if (mid + 1 <= b) {
result = max(result, getMaxi(max(a, mid + 1), b, 2 * v + 1, mid + 1, r));
}
if (a <= mid && mid + 1 <= b) {
result = max(result, getMaxiR(a, 2 * v, l, mid) +
getMaxiL(b, 2 * v + 1, mid + 1, r));
}
return result;
}
double getMaxi(int a, int b) { return getMaxi(a, b, 1, 0, W - 1); }
int main() {
int N, M, C;
cin >> N >> M >> C;
W = 1;
while (W < N) W <<= 1;
for (int i = 0; i < (N); ++i) cin >> D[i];
for (int i = 0; i < (N - 1); ++i) {
sum[W + i] = (D[i + 1] - D[i]) * 0.5;
}
for (int i = 0; i < (N - 1); ++i) {
double p;
cin >> p;
sum[W + i] -= p / 100 * C;
}
init();
for (int i = 0; i < (2 * W); ++i) {
}
double result = 0.0;
for (int i = 0; i < (M); ++i) {
int a, b;
cin >> a >> b;
--a, --b;
result += getMaxi(a, b - 1);
}
printf("%0.6lf\n", result);
}
| 3 |
#include<iostream>
using namespace std;
int main(){
int H,W,h,w;
cin>>H>>W>>h>>w;
cout<<H*W-(h*W+H*w-h*w)<<endl;
}
| 0 |
#include<cstdio>
#include<vector>
#include<string.h>
#include<cassert>
using namespace std;
int dx[4] = { 1, -1, 0, 0 };
int dy[4] = { 0, 0, 1, -1 };
int map[22][22];
int ans = 100;
int tx,ty;
void dfs(int map[22][22],int depth) {
if(depth >= 10 || depth >= ans) return;
int sx=-1,sy=-1,px,py;
for(int i=0; i<22; i++) {
for(int j=0; j<22; j++) {
if(map[i][j]==2) sx=i,sy=j;
// printf("%d ",map[i][j]);
}
// printf("\n");
}
//printf("%d %d\n",sx,sy);
for(int i=0; i<4; i++) {
px = sx;
py = sy;
if(map[px+dx[i]][py+dy[i]]==1 || map[px+dx[i]][py+dy[i]]==-1) continue;
while(1) {
if(map[px+dx[i]][py+dy[i]] == -1) break;
if(map[px+dx[i]][py+dy[i]] == 0) {
px += dx[i];
py += dy[i];
continue;
}
if(map[px+dx[i]][py+dy[i]] == 1) {
int nmap[22][22];
for(int k=0; k<22; k++)
for(int j=0; j<22; j++)
nmap[k][j] = map[k][j];
nmap[sx][sy]=0;
nmap[px][py]=2;
nmap[px+dx[i]][py+dy[i]] = 0;
dfs(nmap,depth+1);
break;
}
if(map[px+dx[i]][py+dy[i]] == 3) {
ans = min(ans,depth+1);
// printf("depth : %d\n",depth);
return;
}
}
}
return;
}
int main() {
int w,h,t;
while(1) {
scanf("%d %d",&w,&h);
if(!w) break;
memset(map, -1, sizeof(map));
ans = 100;
for(int i=1; i<=h; i++)
for(int j=1; j<=w; j++) {
scanf("%d",map[i]+j);
}
dfs(map ,0);
printf("%d\n",(ans==100) ? -1 : ans);
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, k;
int arr[100010];
long long cnt = 0;
bool check(long long g) {
long long tres = 0;
for (int i = 0; i < n; ++i) {
tres += g < arr[i] ? g : arr[i];
}
if (tres <= k) cnt = k - tres;
return tres <= k;
};
int main() {
cin >> n >> k;
long long sum = 0;
for (int i = 0; i < n; ++i) {
cin >> arr[i];
sum += arr[i];
}
if (k == sum) {
cout << endl;
exit(0);
}
long long l = 0L;
long long r = 1e15;
while (l < r) {
long long cur = (l + r) >> 1L;
if (!check(cur))
r = cur - 1;
else
l = cur + 1;
}
l = (l + r) >> 1L;
while (!check(l)) --l;
if (check(l + 1)) ++l;
vector<int> res;
if (cnt == 0) {
for (int i = 0; i < n; ++i)
if (arr[i] - l > 0) cout << i + 1 << " ";
exit(0);
}
for (int i = 0; i < n; ++i) {
if (arr[i] - l > 0) {
if (arr[i] - l > 1) res.push_back(i);
--cnt;
if (cnt == 0) {
for (int j = i + 1; j < n; ++j) {
if (arr[j] - l > 0) cout << j + 1 << " ";
}
for (int i = 0; i < res.size(); ++i) {
cout << res[i] + 1 << " ";
}
exit(0);
}
}
}
cout << -1 << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int dp, pre[810], p[810], tt[810], g[810], vis[810], dis[810], z[100010],
now[810], s, t, a[100010], sum[100010];
int n, m, i, L[100010], R[100010], flag, j, ans;
void link(int x, int y, int z) {
dp++;
pre[dp] = p[x];
p[x] = dp;
tt[dp] = y;
g[dp] = z;
dp++;
pre[dp] = p[y];
p[y] = dp;
tt[dp] = x;
g[dp] = 0;
}
int min(int a, int b) {
if (a < b) return a;
return b;
}
int bfs() {
int i, head, tail;
memcpy(now, p, sizeof(p));
memset(vis, 0, sizeof(vis));
head = 0;
tail = 1;
vis[s] = 1;
dis[s] = 0;
z[tail] = s;
do {
head++;
i = p[z[head]];
while (i) {
if ((vis[tt[i]] == 0) && (g[i] > 0)) {
vis[tt[i]] = 1;
dis[tt[i]] = dis[z[head]] + 1;
tail++;
z[tail] = tt[i];
}
i = pre[i];
}
} while (head != tail);
return vis[t];
}
int dfs(int u, int flow) {
int ans, tmp, i;
if (u == t) return flow;
i = now[u];
ans = 0;
while (i) {
if ((dis[u] + 1 == dis[tt[i]]) && (g[i] > 0)) {
tmp = dfs(tt[i], min(flow - ans, g[i]));
ans += tmp;
g[i] -= tmp;
if (i % 2 == 1)
g[i + 1] += tmp;
else
g[i - 1] += tmp;
if (flow == ans) return flow;
}
i = pre[i];
now[u] = i;
}
if (flow > ans) dis[u] = 1;
return ans;
}
int main() {
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i <= m; i++) scanf("%d%d", &L[i], &R[i]);
for (i = 2; i <= 35000; i++) {
flag = 0;
for (j = 1; j <= n; j++)
if (a[j] % i == 0) {
flag = 1;
while (a[j] % i == 0) {
sum[j]++;
a[j] = a[j] / i;
}
}
if (flag) {
dp = 0;
memset(p, 0, sizeof(p));
s = 0;
t = n + 1;
for (j = 1; j <= n; j++)
if (j % 2 == 0)
link(j, t, sum[j]);
else
link(s, j, sum[j]);
for (j = 1; j <= m; j++)
if (L[j] % 2 == 0)
link(R[j], L[j], 0x37373737);
else
link(L[j], R[j], 0x37373737);
while (bfs()) ans = ans + dfs(s, 0x37373737);
for (j = 1; j <= n; j++) sum[j] = 0;
}
flag = 0;
}
for (i = 1; i <= n; i++)
if (a[i] > 1) {
flag = a[i];
for (j = 1; j <= n; j++)
while (a[j] % flag == 0) {
sum[j]++;
a[j] = a[j] / flag;
}
dp = 0;
memset(p, 0, sizeof(p));
s = 0;
t = n + 1;
for (j = 1; j <= n; j++)
if (j % 2 == 0)
link(j, t, sum[j]);
else
link(s, j, sum[j]);
for (j = 1; j <= m; j++)
if (L[j] % 2 == 0)
link(R[j], L[j], 0x37373737);
else
link(L[j], R[j], 0x37373737);
while (bfs()) ans = ans + dfs(s, 0x37373737);
for (j = 1; j <= n; j++) sum[j] = 0;
}
printf("%d", ans);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int x, l;
int cnt = 0;
for (int i = 0; i < n; i++) {
cnt = 0;
cin >> x;
if (x % 7 != 0) {
cnt++;
}
x /= 7;
cout << x + cnt << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
struct seg_tree_lazy {
int S, H;
T zero;
vector<T> value;
U noop;
vector<bool> dirty;
vector<U> prop;
seg_tree_lazy<T, U>(int _S, T _zero = T(), U _noop = U()) {
zero = _zero, noop = _noop;
for (S = 1, H = 1; S < _S;) S *= 2, H++;
value.resize(2 * S, zero);
dirty.resize(2 * S, false);
prop.resize(2 * S, noop);
}
void apply(int i, U &update) {
value[i] = update(value[i]);
if (i < S) {
prop[i] = prop[i] + update;
dirty[i] = true;
}
}
void rebuild(int i) {
for (int l = i / 2; l; l /= 2) {
T combined = value[2 * l] + value[2 * l + 1];
value[l] = prop[l](combined);
}
}
void propagate(int i) {
for (int h = H; h > 0; h--) {
int l = i >> h;
if (dirty[l]) {
apply(2 * l, prop[l]);
apply(2 * l + 1, prop[l]);
prop[l] = noop;
dirty[l] = false;
}
}
}
void upd(int i, int j, U update) {
i += S, j += S;
propagate(i), propagate(j);
for (int l = i, r = j; l <= r; l /= 2, r /= 2) {
if ((l & 1) == 1) apply(l++, update);
if ((r & 1) == 0) apply(r--, update);
}
rebuild(i), rebuild(j);
}
T query(int i, int j) {
i += S, j += S;
propagate(i), propagate(j);
T res_left = zero, res_right = zero;
for (; i <= j; i /= 2, j /= 2) {
if ((i & 1) == 1) res_left = res_left + value[i++];
if ((j & 1) == 0) res_right = value[j--] + res_right;
}
return res_left + res_right;
}
};
const int SIGMA = 10;
bool ok(char c) {
if (c < 'a') return false;
return c - 'a' < SIGMA;
}
struct node {
int len;
char left, right;
int trans[100];
node(char c = 0, int _len = 0) {
len = _len;
left = c, right = c;
memset(trans, 0, sizeof(trans));
}
int &operator()(int i, int j) { return trans[10 * i + j]; }
node operator+(const node &n) const {
node res(0, 0);
res.len = len + n.len;
res.left = left;
res.right = n.right;
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; j++) {
res(i, j) = trans[10 * i + j] + n.trans[10 * i + j];
}
}
if (ok(right) && ok(n.left)) {
res(right - 'a', n.left - 'a')++;
}
return res;
}
};
struct update {
char rep;
update(char _rep = 0) { rep = _rep; }
update operator+(const update &u) const {
if (u.rep == 0) return *this;
return u;
}
node operator()(const node &n) {
if (rep == 0) return n;
node res(rep, n.len);
res(rep - 'a', rep - 'a') = n.len - 1;
return res;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0), cout.precision(15);
int N, M, K;
string str;
cin >> N >> M >> K >> str;
seg_tree_lazy<node, update> st(N);
for (int i = 0; i < N; i++) {
st.value[st.S + i] = node(str[i], 1);
}
for (int i = st.S - 1; i > 0; i--)
st.value[i] = st.value[2 * i] + st.value[2 * i + 1];
int type, i, j;
string query;
char let;
for (int q = 0; q < M; q++) {
cin >> type;
if (type == 1) {
cin >> i >> j >> let;
i--, j--;
st.upd(i, j, update(let));
} else {
cin >> query;
node root = st.query(0, N - 1);
int ans = 1;
for (int a = 0; a < K; a++) {
for (int b = 0; b <= a; b++) {
ans += root(query[a] - 'a', query[b] - 'a');
}
}
cout << ans << "\n";
}
}
return 0;
}
| 5 |
/* User : efficientSloth
Date : 04/01/2021
Time : 20:05:45
*/
#define STANDALONE
#include<bits/stdc++.h>
using namespace std;
#define int long long int
#define forn(i,n) for(int i = 0; i < (int)n; i++) // single incremental for loop starting at 0
#define forsn(i,s,n) for(int i = (int)s; i < (int)n; i++) //single incremental for loop starting at s
#define forstl(a,b) for(auto &a : b) //for loop iterating over STL container b
#define srt(x) std::sort(x.begin(), x.end()); //sorts the container x
#define rev(x) std::reverse(x.begin(), x.end()); //reverses the container x
#define str std::string //string abbr
#define ll long long int //long long int abbr
#define nll "" //empty string abbr
#define br " " //space abbr
#define nl std::endl //newline abbr
#define in(a) std::cin >> a;//single input abbr
#define in2(a, b) std::cin >> a >> b;//...
#define in3(a, b, c) std::cin >> a >> b >> c;//...
#define in4(a, b, c, d) std::cin >> a >> b >> c >> d;//...
#define in5(a, b, c, d, e) std::cin >> a >> b >> c >> d >> e;//...
#define in6(a, b, c, d, e, f) std::cin >> a >> b >> c >> d >> e >> f;//...
#define in7(a, b, c, d, e, f, g) std::cin >> a >> b >> c >> d >> e >> f >> g;//...
#define in8(a, b, c, d, e, f, g, h) std::cin >> a >> b >> c >> d >> e >> f >> g >> h;//...
#define din(a) int a = 0;std::cin >> a;//declares and takes in an integer
#define din2(a, b) int a = 0, b = 0; std::cin >> a >> b;//...
#define din3(a, b, c) int a = 0, b = 0, c = 0; std::cin >> a >> b >> c;//..
#define din4(a, b, c, d) int a = 0, b = 0, c = 0, d = 0; std::cin >> a >> b >> c >> d;//...
#define din5(a, b, c, d, e) int a = 0, b = 0, c = 0, d = 0, e = 0; std::cin >> a >> b >> c >> d >> e;//...
#define din6(a, b, c, d, e, f) int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0; std::cin >> a >> b >> c >> d >> e >> f;//...
#define din7(a, b, c, d, e, f, g) int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0, g = 0; std::cin >> a >> b >> c >> d >> e >> f >> g;//...
#define din8(a, b, c, d, e, f, g, h) int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0, g = 0, h = 0; std::cin >> a >> b >> c >> d >> e >> f >> g >> h;//...
#ifdef Debug
#define dout(a) std::cout << a;//set output if debug flag is passed
#define dout2(a, b) std::cout << a << br << b;//...
#define dout3(a, b, c) std::cout << a << br << b << br << c;//...
#define dout4(a, b, c, d) std::cout << a << br << b << br << c << br << d;//...
#define dout5(a, b, c, d, e) std::cout << a << br << b << br << c << br << d << br << e;//...
#define dout6(a, b, c, d, e, f) std::cout << a << br << b << br << c << br << d << br << e << br << f;//...
#define dout7(a, b, c, d, e, f, g) std::cout << a << br << b << br << c << br << d << br << e << br << f << br << g;//...
#define dout8(a, b, c, d, e, f, g, h) std::cout << a << br << b << br << c << br << d << br << e << br << f << br << g << br << h;//...
#define douts(a) dout2(a,nll)//...
#define doutn(a) std::cout << a << nl;//...
#endif
#ifndef Debug
#define dout(a)//If Debug flag not passed
#define dout2(a, b)//...
#define dout3(a, b, c)//...
#define dout4(a, b, c, d)//...
#define dout5(a, b, c, d, e)//...
#define dout6(a, b, c, d, e, f)//...
#define dout7(a, b, c, d, e, f, g)//...
#define dout8(a, b, c, d, e, f, g, h)//...
#define douts(a)//...
#define doutn(a)//...
#endif
#define out(a) std::cout << a;//set output
#define out2(a, b) std::cout << a << br << b;//...
#define out3(a, b, c) std::cout << a << br << b << br << c;//...
#define out4(a, b, c, d) std::cout << a << br << b << br << c << br << d;//...
#define out5(a, b, c, d, e) std::cout << a << br << b << br << c << br << d << br << e;//...
#define out6(a, b, c, d, e, f) std::cout << a << br << b << br << c << br << d << br << e << br << f;//...
#define out7(a, b, c, d, e, f, g) std::cout << a << br << b << br << c << br << d << br << e << br << f << br << g;//...
#define out8(a, b, c, d, e, f, g, h) std::cout << a << br << b << br << c << br << d << br << e << br << f << br << g << br << h;//...
#define outs(a) out2(a,nll)//...
#define outn(a) std::cout << a << nl;//...
#define pii std::pair<int, int>
#define pll std::pair<ll, ll>
#define mll std::map<ll,ll>
#define msi std::map<str, int>
#define mis std::map<int, str>
#define mss std::map<str, str>
#define mii std::map<int, int>
#define mci std::map<char, int>
#define si std::set<int>
#define sll std::set<ll>
#define ss std::set<str>
#define sb std::set<bool>
#define sc std::set<char>
#define vi std::vector<int>
#define vll std::vector<long long int>
#define vb std::vector<bool>
#define vs std::vector<str>
#define vpii std::vector<pii>
#define vvi std::vector<vector<int> >
#define vvll std::vector<vector<ll> >
#define PI 2 * acos(0.0)
template<typename T> inline void incontainer(std::vector<T> &v) {for(size_t i = 0; i < v.size(); i++){in(v[i]);}}
template<typename T> inline void outcontainer(std::vector<T> &v) {for(size_t i = 0; i < v.size(); i++){outs(v[i]);}out(nl);}
template<typename T> inline void inmatrix(std::vector<std::vector<T> > & v) {for(size_t i = 0; i < v.size(); i++){for(size_t j = 0; j < v[i].size(); j++){in(v[i][j])}}}
template<typename T> inline void outmatrix(std::vector<std::vector<T> > & v) {for(size_t i = 0; i < v.size(); i++){outcontainer(v[i]); out(nl);}}
inline vs split(char c, str s){vs v;str temp = "";forn(i,s.size()){if(s[i] == c){if(temp != ""){v.push_back(temp);temp = "";}}else{temp = temp + s[i];}}if(temp != ""){v.push_back(temp);}return v;}
template<typename T> inline bool isodd(T x) {return ((x % 2) == 1);}
inline bool findchar(char c, str s) {return (s.find(c) != str::npos);}
inline int stringdiff(const str &a, const str &b) {int cnt = 0;forn(i,min(a.size(),b.size())){if(a[i] != b[i]){cnt++;}}return cnt;}
/*****
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;
}
ll binexpp(ll a, ll b, ll m)
{
a %= m;
ll res = 1;
while(b > 0)
{
if(b & 1)
{
res = res * a % m;
}
a = (a * a) % m;
b >>= 1;
}
return res;
}
ll binexp(ll a, ll b, ll m)
{
if(isPrime(m))
{
return binexpp(a, (b % (m-1)), m);
}
return binexpp(a, b, m);
}
#define fibval 1000001
vll fib(fibval);
void fibonacci()
{
fib[0] = 0;
fib[1] = 1;
for(int i = 2; i < fibval; i++)
{
fib[i] = fib[i-1] + fib[i-2];
}
}
*****/
#ifdef STANDALONE
int n;
vi a;
vi dp;
int f(int ind)
{
if(ind >= n)
{
return 0;
}
if(dp[ind] != -1)
{
return dp[ind];
}
dp[ind] = a[ind] + f(ind + a[ind]);
return dp[ind];
}
signed main()
{
int t = 1;
std::cin >> t;
while(t-- > 0)
{
in(n);
a.clear();
a.resize(n);
dp.clear();
dp.resize(n,-1);
incontainer(a);
int maxv = 0;
forn(i,n)
{
maxv = max(maxv, f(i));
}
outn(maxv);
}
}
#endif
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[4000], b[4000];
int s[4000], t[4000];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < n; ++i) b[i] = a[i];
sort(b, b + n);
int cnt = 0;
for (int i = 0; i < n; ++i) {
if (a[i] == b[i]) continue;
for (int j = i + 1; j < n; ++j) {
if (b[i] == a[j]) {
s[cnt] = i;
t[cnt] = j;
swap(a[i], a[j]);
++cnt;
break;
}
}
}
cout << cnt << endl;
for (int i = 0; i < cnt; ++i) cout << s[i] << " " << t[i] << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int lim = 3e5 + 5;
const int blk = 550;
struct qst {
int ql, qr, qk, qi;
};
qst qur[lim];
int arr[lim], ans[lim], cnt[lim];
bool comp(const qst& a, const qst& b) {
int ba = a.ql / blk, bb = b.ql / blk;
if (ba < bb)
return 1;
else if (ba > bb)
return 0;
else
return a.qr < b.qr;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, q;
cin >> n >> q;
for (int i = 0; i < n; ++i) cin >> arr[i];
for (int i = 0; i < q; ++i) {
cin >> qur[i].ql >> qur[i].qr >> qur[i].qk;
qur[i].qk = (qur[i].qr - qur[i].ql + 1) / qur[i].qk;
qur[i].qi = i;
}
sort(qur, qur + q, comp);
default_random_engine eng;
uniform_int_distribution<int> gen(0, 1e9);
int cl = 0, cr = -1;
for (int i = 0; i < q; ++i) {
int ql = qur[i].ql - 1, qr = qur[i].qr - 1, qk = qur[i].qk;
while (cl < ql) --cnt[arr[cl++]];
while (cl > ql) ++cnt[arr[--cl]];
while (cr > qr) --cnt[arr[cr--]];
while (cr < qr) ++cnt[arr[++cr]];
int res = 1e9;
for (int i = 0; i < 300; ++i) {
int idx = ql + gen(eng) % (qr - ql + 1);
if (cnt[arr[idx]] > qk) res = min(arr[idx], res);
}
res = (res == 1e9 ? -1 : res);
ans[qur[i].qi] = res;
}
for (int i = 0; i < q; ++i) cout << ans[i] << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, s[1111111], gr[1111111];
int calc() {
int r = 0;
gr[0] = -1;
for (int i = 0; i < n; ++i) {
int j = i - 1;
while (j != -1 && s[j] < s[i]) j = gr[j];
gr[i] = j;
if (j != -1) r = max(r, s[j] ^ s[i]);
}
return r;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", &s[i]);
int r = calc();
reverse(s, s + n);
r = max(r, calc());
printf("%d\n", r);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
long double x1, y1, r1, x2, y2, r2;
cin >> x1 >> y1 >> r1 >> x2 >> y2 >> r2;
long double d = sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
long double r = min(r1, r2);
long double R = max(r1, r2);
long double area;
if (d > R + r)
area = 0;
else if (d <= R - r) {
area = 3.1415926535897932384626433 * r * r;
} else {
long double phi = acos((d * d + r * r - R * R) / (2 * d * r)) * 2;
long double theta = acos((d * d + R * R - r * r) / (2 * d * R)) * 2;
long double area1 = 0.5 * theta * R * R - 0.5 * R * R * sin(theta);
long double area2 = 0.5 * phi * r * r - 0.5 * r * r * sin(phi);
area = area1 + area2;
}
cout << fixed << showpoint << setprecision(20) << area << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int mex(const vector<int> &nimbers) {
unordered_set<int> set;
for (auto &nimber : nimbers) set.insert(nimber);
for (int i = 0; i < INT_MAX; i++) {
bool exclude = set.find(i) == set.end();
if (!exclude) continue;
return i;
}
assert(false);
}
int x, y, z;
const int STATE_M = 5;
using state = vector<vector<int>>;
state cal_nxt_state(const state &s) {
auto res = s;
int res0_nxt = mex({s[0][STATE_M - x], s[1][STATE_M - y], s[2][STATE_M - z]});
int res1_nxt = mex({s[0][STATE_M - x], s[2][STATE_M - z]});
int res2_nxt = mex({s[0][STATE_M - x], s[1][STATE_M - y]});
res[0].push_back(res0_nxt);
res[1].push_back(res1_nxt);
res[2].push_back(res2_nxt);
for (int i = 0; i < 3; i++) res[i].erase(res[i].begin());
return res;
}
map<state, int> state2idx;
vector<state> states;
int circle_start;
int circle_length;
void pre_cal() {
state2idx.clear();
states.clear();
state cur(3, vector<int>(STATE_M, 0));
while (!state2idx.count(cur)) {
state2idx[cur] = states.size();
states.push_back(cur);
cur = cal_nxt_state(cur);
}
circle_start = state2idx[cur];
circle_length = (int)states.size() - circle_start;
}
using ll = long long;
int get_grundy(ll n, int pre_move) {
n = max(n, 0ll);
state nth_state;
if (n < circle_start) {
nth_state = states[n];
} else {
n -= circle_start;
n %= circle_length;
nth_state = states[circle_start + n];
}
return nth_state[pre_move].back();
}
const int N = 3e5 + 7;
ll a[N];
int nimber[N];
void solve() {
int n;
cin >> n >> x >> y >> z;
for (int i = 0; i < n; i++) cin >> a[i];
pre_cal();
for (int i = 0; i < n; i++) nimber[i] = get_grundy(a[i], 0);
int nim_sum = 0;
for (int i = 0; i < n; i++) nim_sum ^= nimber[i];
int result = 0;
for (int i = 0; i < n; i++) {
int nim_sum_exc_nimi = nim_sum ^ nimber[i];
ll ai_after_move[3] = {a[i] - x, a[i] - y, a[i] - z};
for (int move = 0; move < 3; move++) {
int new_nimi = get_grundy(ai_after_move[move], move);
int new_nim_sum = nim_sum_exc_nimi ^ new_nimi;
if (new_nim_sum == 0) result++;
}
}
cout << result << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int tcase;
cin >> tcase;
for (int icase = 0; icase < tcase; icase++) solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int P = 1e9 + 7;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long qpow(long long a, long long n) {
long long r = 1 % P;
for (a %= P; n; a = a * a % P, n >>= 1)
if (n & 1) r = r * a % P;
return r;
}
void exgcd(long long a, long long b, long long &d, long long &first,
long long &second) {
b ? exgcd(b, a % b, d, second, first),
second -= a / b *first : first = 1, second = 0, d = a;
}
long long inv(long long first) {
return first <= 1 ? 1 : inv(P % first) * (P - P / first) % P;
}
int main() {
set<string> s;
string str;
cin >> str;
int n = str.size();
for (int i = 1; i <= n; ++i) {
s.insert(str);
str = str.back() + str;
str.pop_back();
}
cout << s.size() << '\n';
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
unordered_map<int, int> maps;
for (int i = 0; i < n; i++) {
int a, x;
cin >> a >> x;
maps[a] = x;
}
int m;
cin >> m;
for (int i = 0; i < m; i++) {
int b, y;
cin >> b >> y;
if (maps.count(b) == 0) {
maps[b] = y;
} else {
maps[b] = max(maps[b], y);
}
}
long long int sum = 0;
for (auto it = maps.begin(); it != maps.end(); it++) {
sum += it->second;
}
cout << sum << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool check[1000005];
int prime[1000005];
int main() {
memset(check, false, sizeof(check));
int pos = 0;
for (int i = 2; i <= 1000005; i++) {
if (!check[i]) prime[++pos] = i;
for (int j = 1; j <= pos && i * prime[j] < 1000005; j++) {
check[i * prime[j]] = true;
if (i % prime[j] == 0) break;
}
}
int x2;
scanf("%d", &x2);
for (int i = pos; i >= 1; i--) {
if (x2 % prime[i] == 0) {
int minn = 1000005, tmp = x2 - prime[i] + 1;
for (int j = 1; j <= pos; j++) {
if (x2 / prime[j] != (tmp - 1) / prime[j] &&
(tmp - 1) / prime[j] != 0) {
minn = min(minn, (tmp - 1) / prime[j] * prime[j] + 1);
}
}
printf("%d\n", minn);
return 0;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long b[104][104], c[104][104];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, i, j, k, ss = 0;
cin >> n;
string a[4][n];
for (i = 0; i < 4; i++)
for (j = 0; j < n; j++) cin >> a[i][j];
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
if ((i + j) % 2)
b[i][j] = 0;
else
b[i][j] = 1;
}
}
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
if ((i + j) % 2)
c[i][j] = 1;
else
c[i][j] = 0;
}
}
vector<long long> d1, d2;
for (i = 0; i < 4; i++) {
long long d = 0, dd = 0;
for (j = 0; j < n; j++) {
for (k = 0; k < n; k++) {
if (a[i][j][k] - '0' - b[j][k]) d++;
if (a[i][j][k] - '0' - c[j][k]) dd++;
}
}
d1.push_back(d);
d2.push_back(dd);
}
for (i = 0; i < 4; i++) ss += d2[i];
long long ans = 1000000007;
for (i = 0; i < 4; i++) {
for (j = i + 1; j < 4; j++) {
long long a1 = d1[i] + d1[j], a2 = ss - (d2[i] + d2[j]);
ans = min(ans, a1 + a2);
}
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
char s[520][520];
char q[520][520];
int main() {
int n, m;
scanf("%d", &n);
memset(s, '\0', sizeof(s));
memset(q, '\0', sizeof(q));
q[1][1] = '+', q[1][2] = '+', q[2][1] = '+', q[2][2] = '*';
s[1][1] = '+', s[1][2] = '+', s[2][1] = '+', s[2][2] = '*';
m = 2;
if (n == 0)
printf("+\n");
else {
while (--n) {
for (int i = 1; i <= m; ++i)
for (int j = 1; j <= m; ++j)
s[i][j] = q[i][j], s[i + m][j] = q[i][j], s[i][j + m] = q[i][j],
s[i + m][j + m] = q[i][j] == '+' ? '*' : '+';
for (int i = 1; i <= m * 2; ++i)
for (int j = 1; j <= m * 2; ++j) q[i][j] = s[i][j];
m *= 2;
}
for (int i = 1; i <= m; ++i) printf("%s\n", s[i] + 1);
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int G = 1000 * 1000 + 10;
vector<int> e[G], cycle;
bool visited[G];
vector<vector<int> > sz[G];
int ans[G], odd[G];
void even_cycle(int x, int y) {
for (int i = 0; i < x; i++) {
ans[sz[x][y][i]] = sz[x][y + 1][i];
ans[sz[x][y + 1][i]] = sz[x][y][(i + 1) % x];
}
return;
}
void odd_cycle(int x, int y) {
int j = 0;
for (int i = 0; i < x; i += 2) {
odd[i] = sz[x][y][j];
j++;
}
int k = 1;
for (int i = j; i < x; i++) {
odd[k] = sz[x][y][i];
k += 2;
}
for (int i = 0; i < x; i++) {
ans[odd[i]] = odd[(i + 1) % x];
}
return;
}
void dfs(int v) {
visited[v] = true;
int u = e[v][0];
cycle.push_back(v);
if (!visited[u]) dfs(u);
return;
}
int main() {
int n, a;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a;
e[i].push_back(a);
}
for (int i = 1; i <= n; i++) {
if (!visited[i]) {
cycle.clear();
dfs(i);
sz[cycle.size()].push_back(cycle);
}
}
for (int i = 1; i <= n; i++) {
if (sz[i].size()) {
if (i % 2) {
for (int j = 0; j < sz[i].size(); j++) {
for (int k = 0; k < i; k++) odd[k] = 0;
odd_cycle(i, j);
}
} else {
if ((sz[i].size()) % 2) {
cout << -1;
return 0;
} else {
for (int j = 0; j < sz[i].size(); j += 2) {
even_cycle(i, j);
}
}
}
}
}
for (int i = 1; i <= n; i++) cout << ans[i] << ' ';
return 0;
}
| 5 |
#include <iostream>
#include <vector>
#include <unordered_set>
#include <set>
#include <algorithm>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
int s = n;
int log = 1;
while (s > 0) {
s = s / k;
++log;
}
vector<int> at_sum(log, 0);
vector<int> new_at(log, 0);
int m = at_sum.size();
for (int i = 0; i <= n - 1; ++i) {
vector<int> cur(log, 0);
int d = i;
int cur_ind = 0;
while (d > 0) {
cur[cur_ind] = d % k;
d = d / k;
++cur_ind;
}
int cur_num = 0;
int k_pow = 1;
for (int j = 0; j < m; ++j) {
int l = 0;
if (i % 2 == 0) {
l = 1;
} else {
l = -1;
}
new_at[j] = ((at_sum[j] + (l * cur[j])) % k + k) % k;
cur_num += k_pow * new_at[j];
k_pow *= k;
}
cout << cur_num << "\n" << flush;
int r;
cin >> r;
if (r == 1) {
break;
}
for (int j = 0; j < m; ++j) {
at_sum[j] = (new_at[j] - at_sum[j] + k) % k;
}
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long sum[200010];
long ans, n, m;
string s;
void deal(char c1, char c2, char c3) {
long i;
for (i = 0; i < n; i += 3) {
sum[i + 1] = (s[i] != c1) ? 1 : 0;
sum[i + 2] = (s[i + 1] != c2) ? 1 : 0;
sum[i + 3] = (s[i + 2] != c3) ? 1 : 0;
sum[i + 1] += sum[i];
sum[i + 2] += sum[i + 1];
sum[i + 3] += sum[i + 2];
}
for (i = 1; i <= n - m + 1; i++)
ans = (((ans) < (sum[i + m - 1] - sum[i - 1]))
? (ans)
: (sum[i + m - 1] - sum[i - 1]));
}
int main() {
long _;
for (scanf("%ld", &_); _; _--) {
scanf("%ld%ld", &n, &m);
cin >> s;
ans = ~(1 << 31);
deal('R', 'G', 'B');
deal('G', 'B', 'R');
deal('B', 'R', 'G');
printf("%ld\n", ans);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
int Kx[1000];
int Ky[1000];
int n, m, k;
struct wall {
int R, x, y;
};
wall C[10000];
double hypot(double x, double y) { return sqrt(x * x + y * y); }
int G[2000][2000];
int P[2000];
int aa[1000];
int bb[1000];
void build_graph() {
for (int i = 0; i < m; i++) {
bool flag = true;
int nn = 0;
G[i][i] = 0;
for (int j = i + 1; j < m; j++)
if (hypot(C[i].x - C[j].x, C[i].y - C[j].y) < C[i].R + C[j].R) {
nn++;
G[i][j] = nn;
flag = false;
}
P[i] = nn;
}
for (int j = 0; j < n; j++) {
aa[j] = -1;
for (int i = 0; i < m; i++)
if (hypot(C[i].x - Kx[j], C[i].y - Ky[j]) < C[i].R) {
aa[j] = i;
break;
}
}
for (int j = 0; j < n; j++) {
bb[j] = -1;
for (int i = 0; i < m; i++)
if (hypot(C[i].x - Kx[j], C[i].y - Ky[j]) < C[i].R) {
bb[j] = i;
break;
}
}
}
int set[10000] = {0};
int path(int a, int b, int i) {
a--;
b--;
int ai = aa[a];
int bi = bb[b];
if (ai == -1 && bi == -1) return 0;
if (ai == -1) return P[bi] + 1;
if (bi == -1) return P[ai] + 1;
int min = 111111;
int m1 = ai;
if (bi > m1) m1 = bi;
for (int i = m1; i < m; i++) {
if (G[ai][i] != -1 && G[bi][i] != -1)
if (G[ai][i] + G[bi][i] < min) min = G[ai][i] + G[bi][i];
}
if (min == 111111) min = P[ai] + P[bi] + 2;
return min;
}
int main() {
memset(G, 0xFF, sizeof(G));
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < n; i++) scanf("%d%d", Kx + i, Ky + i);
for (int i = 0; i < m; i++) scanf("%d%d%d", &C[i].R, &C[i].x, &C[i].y);
for (int i = 0; i < m; i++)
for (int j = i + 1; j < m; j++)
if (C[i].R > C[j].R) {
wall t;
t = C[i];
C[i] = C[j];
C[j] = t;
}
build_graph();
for (int i = 0; i < k; i++) {
int a, b;
scanf("%d%d", &a, &b);
printf("%d\n", path(a, b, i));
}
}
| 4 |
#define _USE_MATH_DEFINES
#define INF 0x3f3f3f3f
#include <cstdio>
#include <iostream>
#include <sstream>
#include <cmath>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <stack>
#include <limits>
#include <map>
#include <string>
#include <cstring>
#include <set>
#include <deque>
#include <bitset>
#include <list>
#include <cctype>
#include <utility>
using namespace std;
typedef long long ll;
typedef pair <int,int> P;
typedef pair <int,P > PP;
int tx[] = {0,1,0,-1};
int ty[] = {-1,0,1,0};
static const double EPS = 1e-8;
int dp[40000][5];
int main(){
int n;
while(~scanf("%d",&n)){
if(n==0) break;
memset(dp,0,sizeof(dp));
dp[0][0] = 1;
for(int i=1;i*i<=n;i++){
for(int k=1;k<=4;k++){
for(int j=i*i;j<=n;j++){
dp[j][k] += dp[j-i*i][k-1];
}
}
}
printf("%d\n",dp[n][4] + dp[n][3] + dp[n][2] + dp[n][1]);
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long s = 0;
for (long long i = 0; i <= n - 1; ++i) {
long long temp;
cin >> temp;
if (temp - s > 15) continue;
s = temp;
}
if (s + 15 < 90)
cout << s + 15 << endl;
else
cout << "90" << endl;
}
| 1 |
#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
struct Data{
string L;
int P,A,B,C,D,E,F,S,M;
int t;
int income;
double eff;
bool operator<(const Data& data)const{
if(eff != data.eff)return eff > data.eff;
return L < data.L;
}
};
int main(){
int N;
Data list[50];
while(1){
cin >>N;
if(N==0)break;
for(int i=0 ; i < N ; i++){
cin >>list[i].L>>list[i].P>>list[i].A>>list[i].B>>list[i].C>>list[i].D>>list[i].E>>list[i].F>>list[i].S>>list[i].M;
list[i].t=list[i].A+list[i].B+list[i].C+(list[i].D+list[i].E)*list[i].M;
list[i].income=(list[i].F*list[i].M*list[i].S)-list[i].P;
list[i].eff=(double)list[i].income/list[i].t;
}
sort(list,list+N);
for(int i=0 ; i < N ; i++){
cout <<list[i].L<<endl;
}
cout <<"#"<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2147483647;
const double PI = 3.141592653589793;
int a, b, n, m, k, i, j;
char t[20];
string s, tab[50][50];
int main() {
ifstream ifile("input.txt");
if (ifile) freopen("input.txt", "rt", stdin);
if (ifile) freopen("output.txt", "wt", stdout);
scanf("%d %d %d", &n, &m, &k);
while (k--) {
scanf("%s", &t);
if (t[0] == '+') {
scanf("%d %d %s", &a, &b, &t);
s = t;
for (i = a; i <= n; i++)
for (j = (i == a ? b : 1); j <= m; j++)
if (tab[i][j] == "") {
tab[i][j] = s;
i = n + 1;
j = m + 1;
}
} else {
scanf("%s", &t);
s = t;
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++)
if (tab[i][j] == s) {
printf("%d %d\n", i, j);
tab[i][j] = "";
i = n + 3;
j = m + 3;
}
if (i < n + 3) printf("-1 -1\n");
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, s;
int v[200010];
int f[200010];
int nxt[200010];
int getNxt(int cpoz, int spec) {
int ans = nxt[cpoz];
if (spec <= cpoz && spec > ans) ans = spec;
return ans;
}
int solve(int val) {
int csum = s;
int prv = s + 1;
while (csum > 0) {
int cr = getNxt(min(csum, prv - 1), val);
if (cr == 0 || cr == prv) return 1;
prv = cr;
if (1LL * csum > 1LL * f[cr] * cr)
csum -= f[cr] * cr;
else
csum %= cr;
}
return 0;
}
int main() {
cin >> s;
cin >> n;
for (int i = 1; i <= n; ++i) {
int x;
cin >> x;
++f[x];
}
for (int i = 1; i <= s; ++i) {
if (f[i] == 0)
nxt[i] = nxt[i - 1];
else
nxt[i] = i;
}
int sol = 0;
for (int cval = 1; cval < s; ++cval) {
++f[cval];
if (solve(cval)) {
sol = cval;
break;
}
--f[cval];
}
if (!sol)
cout << "Greed is good\n";
else
cout << sol << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
long long x, y;
long long n, w;
long long a[N];
long long p[N];
long long a1, a2;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.precision(17);
cin >> n >> w;
for (int i = 0; i < n; i++) cin >> a[i];
p[0] = a[0];
for (int i = 1; i < n; i++) p[i] = p[i - 1] + a[i];
x = *max_element(p, p + n);
y = *min_element(p, p + n);
a1 = w, a2 = 0;
if (x > 0) a1 = w - x;
if (y < 0) a2 = 0 - y;
if (a2 > a1)
cout << 0 << endl;
else
cout << a1 - a2 + 1 << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, s = 0, r = 0;
cin >> n;
int arr[n][2];
for (int i = 0; i < n; i++) {
cin >> arr[i][1] >> arr[i][2];
if (arr[i][1] != arr[i][2]) s++;
}
if (s > 0) {
cout << "rated";
} else {
for (int i = 0; i < n - 1; i++) {
if (arr[i][2] >= arr[i + 1][2]) r++;
}
if (r == n - 1)
cout << "maybe";
else
cout << "unrated";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000;
const int N = 400005;
const int MOD = 1000000007;
int n, p, q, sz;
pair<int, int> a[N];
inline double get(double x, int i, int j) {
double P, Q;
P = p - a[i].first * x;
Q = q - a[i].second * x;
return max(0.0, max(P / a[j].first, Q / a[j].second));
}
double ans = 1e20;
double calculate(int u, int v) {
double LEFT = 0, RIGHT = 1e6;
for (int it = 0; it < 67 && abs(LEFT - RIGHT) > 1e-8; ++it) {
double c1 = LEFT + (RIGHT - LEFT) / 3.0;
double c2 = RIGHT - (RIGHT - LEFT) / 3.0;
if (get(c1, u, v) + c1 > get(c2, u, v) + c2)
LEFT = c1;
else
RIGHT = c2;
}
return get(RIGHT, u, v) + RIGHT;
}
int nn;
pair<int, int> aa[N];
int main() {
clock_t st = clock();
scanf("%d%d%d", &n, &p, &q);
for (int i = 0; i < n; ++i) {
scanf("%d%d", &a[i].first, &a[i].second);
}
sort(a, a + n);
int mx = -1;
for (int i = n - 1; i >= 0; --i) {
if (a[i].second > mx) {
aa[nn++] = a[i];
}
mx = max(mx, a[i].second);
}
n = nn;
for (int i = 0; i < n; ++i) a[i] = aa[i];
if (n == 1) {
double ans = max(1.0 * p / a[0].first, 1.0 * q / a[0].second);
printf("%.9f\n", ans);
} else {
for (int i = 0; i < n; ++i) {
ans = min(ans, max(1.0 * p / a[i].first, 1.0 * q / a[i].second));
}
int C = n;
for (int i = n - C; i < n; ++i) {
int l = i, r = n - 1;
while (l + 2 < r) {
int c1 = l + (r - l) / 3;
int c2 = r - (r - l) / 3;
if (calculate(i, c1) > calculate(i, c2))
l = c1;
else
r = c2;
}
for (int j = l; j <= r; ++j) ans = min(ans, calculate(i, j));
if ((clock() - st) / 1.0 / CLOCKS_PER_SEC > 2.00) break;
}
printf("%.9f\n", ans);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
const int N = 1e5 + 7;
char s[N], t[N];
int n, m, sa[N], sb[N], ta[N], tb[N];
inline int read() {
int x = 0;
char c = getchar();
while (!isdigit(c)) c = getchar();
while (isdigit(c)) x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
return x;
}
int main() {
std::cin >> (s + 1) >> (t + 1);
n = strlen(s + 1), m = strlen(t + 1);
for (int i = 1; i <= n; ++i) {
sb[i] = sb[i - 1];
if (s[i] == 'A')
sa[i] = sa[i - 1] + 1;
else
++sb[i];
}
for (int i = 1; i <= m; ++i) {
tb[i] = tb[i - 1];
if (t[i] == 'A')
ta[i] = ta[i - 1] + 1;
else
++tb[i];
}
int q;
std::cin >> q;
while (q-- > 0) {
int a = read(), b = read(), c = read(), d = read(), ans = 1;
int db = tb[d] - tb[c - 1] - sb[b] + sb[a - 1];
int Sa = std::min(b - a + 1, sa[b]), Ta = std::min(d - c + 1, ta[d]);
if (db < 0 || Sa < Ta || db % 2 == 1) ans = 0;
bool pd = (Sa - Ta) % 3 > 0;
if (db - pd * 2 < 0) ans = 0;
if (sb[b] - sb[a - 1] == 0 && db && Sa == Ta) ans = 0;
printf("%d", ans);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000 + 10;
struct edge {
int u, v;
long long d;
bool o;
};
struct node {
int u;
long long d;
bool operator<(const node& zjz) const { return d > zjz.d; }
};
int n, m, s, t, Next[20000 + 100];
long long dis[maxn], L;
bool done[maxn];
vector<edge> e;
vector<int> G[maxn];
void add(int u, int v, long long d) {
bool o = 0;
if (!d) o = 1;
e.push_back((edge){u, v, d, o});
int k = e.size();
G[u].push_back(k - 1);
}
void updata(int k) {
for (int i = 0; i < k; i++)
if (e[2 * i].o) e[2 * i].d = e[2 * i + 1].d = 1;
for (int i = k; i < m; i++)
if (e[2 * i].o) e[2 * i].d = e[2 * i + 1].d = L;
}
long long dijkstra() {
memset(dis, -1, sizeof(dis));
memset(done, 0, sizeof(done));
priority_queue<node> Q;
dis[s] = 0;
Q.push((node){s, 0});
while (!Q.empty()) {
node zjz = Q.top();
Q.pop();
int u = zjz.u;
if (done[u]) continue;
done[u] = 1;
for (int i = 0; i < G[u].size(); i++) {
edge e1 = e[G[u][i]];
int v = e1.v;
if (dis[v] == -1 || (dis[v] > dis[u] + e1.d)) {
dis[v] = dis[u] + e1.d;
Q.push((node){v, dis[v]});
}
}
}
return dis[t];
}
int main() {
cin >> n >> m >> L >> s >> t;
for (int i = 0; i < m; i++) {
int u, v, d;
scanf("%d%d%d", &u, &v, &d);
add(u, v, d);
add(v, u, d);
}
int pos = m + 1;
for (int i = m; i >= 1; i--) {
if (e[2 * i - 2].o) pos = i;
Next[i] = pos;
}
Next[0] = pos;
updata(m);
long long d1 = dijkstra();
updata(0);
long long d2 = dijkstra();
if (d1 > L || d2 < L) {
cout << "NO";
return 0;
}
int l = 0, r = m, mid, k;
while (l <= r) {
mid = (l + r) / 2;
updata(mid);
long long d = dijkstra();
if (d >= L) {
k = mid;
l = mid + 1;
} else
r = mid - 1;
}
k++;
if (k <= m) {
updata(k);
long long d = dijkstra();
e[2 * k - 2].d -= (d - L);
e[2 * k - 1].d -= (d - L);
}
cout << "YES" << endl;
for (int i = 0; i < m; i++)
printf("%d %d %d\n", e[2 * i].u, e[2 * i].v, e[2 * i].d);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
vector<pair<int, int> > G[N], G1[N];
const long long INF = 1e15;
long long preday[N], lastday[N];
int n, m, k;
bool cmp1(pair<int, int> a, pair<int, int> b) {
return a.first == b.first ? (a.second < b.second) : (a.first < b.first);
}
bool cmp2(pair<int, int> a, pair<int, int> b) {
return a.first == b.first ? (a.second < b.second) : (a.first > b.first);
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= m; i++) {
int day, u, v, cost;
scanf("%d%d%d%d", &day, &u, &v, &cost);
if (!v) G[u].push_back(make_pair(day, cost));
if (!u) G1[v].push_back(make_pair(day, cost));
}
int l = -1, r = 1e9;
for (int i = 1; i <= n; i++) {
sort(G[i].begin(), G[i].end(), cmp1);
sort(G1[i].begin(), G1[i].end(), cmp2);
if (G[i].size()) l = max(l, G[i][0].first + 1);
if (G1[i].size()) r = min(G1[i][0].first - 1, r);
if (G[i].size() == 0 || G1[i].size() == 0) return 0 * puts("-1");
}
if (r - l + 1 < k || l == -1 || r == 1e9) return 0 * puts("-1");
for (int i = 1; i <= n; i++) {
long long now = INF;
preday[1] += now;
for (int j = 0; j < G[i].size(); j++) {
if (G[i][j].second < now) {
preday[G[i][j].first] -= now;
preday[G[i][j].first] += G[i][j].second;
now = G[i][j].second;
}
}
now = INF;
lastday[int(1e6)] += now;
for (int j = 0; j < G1[i].size(); j++) {
if (G1[i][j].second < now) {
lastday[G1[i][j].first] -= now;
lastday[G1[i][j].first] += G1[i][j].second;
now = G1[i][j].second;
}
}
}
for (int i = 2; i <= int(1e6); i++) preday[i] += preday[i - 1];
for (int i = int(1e6); i >= 1; i--) lastday[i] += lastday[i + 1];
long long ans = INF;
for (int i = l; i + k - 1 <= r; i++)
ans = min(ans, preday[i - 1] + lastday[i + k]);
printf("%lld\n", ans);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using VI = vector<int>;
using VVI = vector<VI>;
using PII = pair<int, int>;
using LL = long long;
using VL = vector<LL>;
using VVL = vector<VL>;
using PLL = pair<LL, LL>;
using VS = vector<string>;
#define ALL(a) begin((a)),end((a))
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define EB emplace_back
#define MP make_pair
#define SZ(a) int((a).size())
#define SORT(c) sort(ALL((c)))
#define RSORT(c) sort(RALL((c)))
#define UNIQ(c) (c).erase(unique(ALL((c))), end((c)))
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define FF first
#define SS second
template<class S, class T>
istream& operator>>(istream& is, pair<S,T>& p){
return is >> p.FF >> p.SS;
}
template<class S, class T>
ostream& operator<<(ostream& os, const pair<S,T>& p){
return os << p.FF << " " << p.SS;
}
template<class T>
void maxi(T& x, T y){
if(x < y) x = y;
}
template<class T>
void mini(T& x, T y){
if(x > y) x = y;
}
const double EPS = 1e-10;
const double PI = acos(-1.0);
const LL MOD = 1e9+7;
const LL INF = 1e18;
int main(){
cin.tie(0);
ios_base::sync_with_stdio(false);
LL N, M, C;
cin >> N >> M >> C;
vector<vector<PLL>> G(N);
LL sum = 0;
REP(i,M){
LL u, v, c;
cin >> u >> v >> c;
--u;
--v;
G[u].EB(v,c);
G[v].EB(u,c);
sum += c;
}
LL ans = sum;
VL d(N, INF);
d[0] = 0;
set<int> under;
priority_queue<PLL,vector<PLL>,greater<PLL>> pq;
pq.push(MP(0,0));
while(!pq.empty()){
PLL p = pq.top();
pq.pop();
if(d[p.SS] < p.FF) continue;
if(under.count(p.SS)) continue;
under.insert(p.SS);
for(auto&& e: G[p.SS]){
LL nd = e.SS + p.FF;
if(d[e.FF] <= nd) continue;
d[e.FF] = nd;
pq.push(MP(nd,e.FF));
}
for(auto&& e: G[p.SS]){
if(under.count(e.FF))
sum -= e.SS;
}
mini(ans, sum + p.FF * C);
}
cout << ans << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
double n, r;
cin >> n >> r;
double num = r * (sin(3.141592653589793 / n));
double den = 1 - sin(3.141592653589793 / n);
cout << setprecision(15);
cout << num / den;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double n, h;
int i;
cin >> n >> h;
double temp1 = sqrt(2.0 / 3.0);
double temp2 = sqrt(1.0 / 2.0);
if (n == 2) {
double temp = h * temp2;
printf("%.12lf\n", temp);
return 0;
}
vector<double> ans;
ans.push_back(h * sqrt((double)(n - 1) / (double)(n)));
for (i = n - 2; i >= 1; i--) {
ans.push_back(ans[n - 2 - i] * sqrt((double)(i) / (double)(i + 1)));
}
reverse(ans.begin(), ans.end());
int len = ans.size();
for (i = 0; i < n - 1; i++) printf("%.12lf ", ans[i]);
cout << endl;
return 0;
}
| 2 |
#include<iostream>
#define rep(i,n) for(int i=0;i<n;i++)
using namespace std;
int main(){
int n,m,s,g1,g2;
while(cin>>n>>m>>s>>g1>>g2,n){
s--,g1--,g2--;
int a,b,c,d[n][n];
rep(i,n)rep(j,n)d[i][j]=1<<20;
rep(i,m){
cin>>a>>b>>c;a--,b--;
d[a][b]=c;
}
rep(i,n)d[i][i]=0;
rep(k,n)rep(i,n)rep(j,n)if(d[i][j]>d[i][k]+d[k][j])d[i][j]=d[i][k]+d[k][j];
int ans=d[s][g1]+d[s][g2];
rep(i,n)if(ans>d[s][i]+d[i][g1]+d[i][g2])ans=d[s][i]+d[i][g1]+d[i][g2];
cout<<ans<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string S;
cin >> S;
string ans = "WA";
int A = 0;
if (S.at(0) == 'A') {
for (int i = 1; i < S.size(); i++) {
if (S.at(i) < 'a') A++;
}
}
if (A == 1) {
for (int i = 2; i < S.size() - 1; i++) {
if (S.at(i) == 'C') {
ans = "AC";
}
}
}
cout << ans << endl;
} | 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:108777216")
using namespace std;
int const MAX_N = 4 * 1024;
int const INT_INF = 1100000000;
long long const LL_INF = 1500000000000000000LL;
int n, s[MAX_N], p_sum[MAX_N];
int dp[MAX_N / 2 + 500][100][100];
void do_max(int& a, int b) { a = max(a, b); }
int get_p_sum(int a, int b) {
int val = p_sum[b];
if (a > 0) val -= p_sum[a - 1];
return val;
}
int get_end_p_sum(int a, int b) { return get_p_sum(n - 1 - b, n - 1 - a); }
int rec(int taked, int new_K, int bob_more) {
if (taked + (taked + bob_more) + new_K > n) return 0;
if (dp[taked][new_K][bob_more] > -INT_INF) return dp[taked][new_K][bob_more];
for (int new_take = new_K; new_take <= new_K + 1; new_take++)
if (taked + new_take + (taked + bob_more) <= n) {
int mn = INT_INF;
int mx = -INT_INF;
if (taked + new_take + (taked + bob_more + new_take) > n)
mx = max(mx, get_p_sum(taked, taked + new_take - 1));
for (int bob_take = new_take; bob_take <= new_take + 1; bob_take++)
if (taked + new_take + (taked + bob_more + bob_take) <= n)
mn = min(mn, get_p_sum(taked, taked + new_take - 1) -
get_end_p_sum(taked + bob_more,
(taked + bob_more + bob_take) - 1) +
rec(taked + new_take, bob_take,
bob_more + bob_take - new_take));
if (mn < INT_INF && mx > -INT_INF)
do_max(dp[taked][new_K][bob_more], max(mn, mx));
else if (mn < INT_INF)
do_max(dp[taked][new_K][bob_more], mn);
else if (mx > -INT_INF)
do_max(dp[taked][new_K][bob_more], mx);
}
return dp[taked][new_K][bob_more];
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &s[i]);
p_sum[0] = s[0];
for (int i = 1; i < n; i++) p_sum[i] = p_sum[i - 1] + s[i];
for (int i = 0; i < MAX_N / 2 + 500; i++)
for (int j = 0; j < 100; j++)
for (int k = 0; k < 100; k++) dp[i][j][k] = -INT_INF;
cout << rec(0, 1, 0);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ull = uint64_t;
using ll = int64_t;
using ld = long double;
const int N = 30228;
int a[N], b[N];
int ac, bc;
int l[N];
int r[N];
int main() {
#ifdef BZ
freopen("input.txt", "r", stdin);
#endif
ios_base::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr); cout.setf(ios::fixed); cout.precision(20);
int n;
string s, t;
cin >> n >> s >> t;
for (int i = 1; i < n; ++i) {
if (s[i] != s[i - 1]) {
a[ac++] = i;
}
if (t[i] != t[i - 1]) {
b[bc++] = i;
}
}
int ans = N * N;
bool eq = s[0] == t[0];
for (int i = -n - 1; i <= n + 1; ++i) {
if ((i % 2 == 0) != eq) {
continue;
}
int lc = 0, rc = 0;
if (i > 0) {
fill(l, l + i, 0);
lc = i;
} else {
fill(r, r + (-i), 0);
rc = -i;
}
copy(a, a + ac, l + lc);
copy(b, b + bc, r + rc);
lc += ac;
rc += bc;
while (lc < rc) {
l[lc++] = n;
}
while (rc < lc) {
r[rc++] = n;
}
int cur = 0;
for (int j = 0; j < lc; ++j) {
cur += abs(l[j] - r[j]);
}
ans = min(ans, cur);
}
cout << ans << "\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N=805;
int n,m,k;
char s[N][N];
int d[N][N],qx[N*N],qy[N*N];
int dx[4]={ 0, 0,-1, 1};
int dy[4]={-1, 1, 0, 0};
bool check(int x,int y){
return 1<=x&&x<=n&&1<=y&&y<=m&&s[x][y]!='#';
}
int main(){
cin >> n >> m >> k;
for (int i=1;i<=n;i++)
scanf("%s",s[i]+1);
memset(d,0,sizeof d);
int sx,sy;
for (int i=1;i<=n;i++)
for (int j=1;j<=m;j++)
if (s[i][j]=='S')
sx=i,sy=j;
int head=0,tail=0;
tail++;
qx[tail]=sx,qy[tail]=sy;
d[sx][sy]=1;
while (head<tail){
head++;
int x=qx[head],y=qy[head];
if (d[x][y]==k+1)
continue;
for (int i=0;i<4;i++){
int nx=x+dx[i],ny=y+dy[i];
if (!check(nx,ny)||d[nx][ny])
continue;
d[nx][ny]=d[x][y]+1;
tail++;
qx[tail]=nx,qy[tail]=ny;
}
}
int ans=23333;
for (int i=1;i<=n;i++)
for (int j=1;j<=m;j++)
if (s[i][j]!='#'&&d[i][j]){
if (i==1||j==1||i==n||j==m)
ans=1;
else {
ans=min(ans,(i-1+k-1)/k+1);
ans=min(ans,(j-1+k-1)/k+1);
ans=min(ans,(n-i+k-1)/k+1);
ans=min(ans,(m-j+k-1)/k+1);
}
}
cout << ans;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const double PI = atan(1.0) * 4;
int n, m, a, b;
unsigned long long int g, x, y, z;
unsigned long long int sum = 0;
unsigned long long int arr[3002][3002];
unsigned long long int data[3002][3002];
deque<pair<int, int>> dq;
void insert(int i, unsigned long long int no) {
while (!dq.empty() && dq.back().second >= no) dq.pop_back();
dq.push_back({i, no});
}
void erase(int i) {
while (!dq.empty() && dq.front().first <= i) dq.pop_front();
}
unsigned long long int top() { return dq.front().second; }
void slide_each_column(int col) {
dq.clear();
for (int i = 1; i < a; i++) insert(i, arr[i][col]);
for (int i = a; i < n + 1; i++) {
insert(i, arr[i][col]);
data[i - a + 1][col] = top();
erase(i - a + 1);
}
}
void slide_each_row(int row) {
dq.clear();
for (int i = 1; i < b; i++) insert(i, data[row][i]);
for (int i = b; i < m + 1; i++) {
insert(i, data[row][i]);
sum += top();
erase(i - b + 1);
}
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
cin >> n >> m >> a >> b;
cin >> g >> x >> y >> z;
for (int i = 1; i < n + 1; i++)
for (int j = 1; j < m + 1; j++) {
if (i == 1 && j == 1) {
arr[i][j] = g;
continue;
}
g = (g * x) % z;
g = g + y;
if (g >= z) g -= z;
arr[i][j] = g;
}
for (int i = 1; i < m + 1; i++) slide_each_column(i);
for (int i = 1; i < n - a + 2; i++) slide_each_row(i);
cout << sum << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 100000 + 7;
int main() {
long long n, Len, L[N], R[N], tsum = 0, cnt = -1;
long long ans = 0;
scanf("%lld", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld", &Len);
long long tmax = -1, tmin = 10000000, x, Flag = 0;
for (int j = 1; j <= Len; j++) {
scanf("%lld", &x);
if (x > tmin) Flag = 1;
tmax = max(tmax, x);
tmin = min(tmin, x);
}
if (Flag)
tsum++;
else {
cnt++;
L[cnt] = tmin;
R[cnt] = tmax;
}
}
sort(R, R + cnt + 1);
for (int i = 0; i <= cnt; i++) {
long long tt = upper_bound(R, R + cnt, L[i]) - R;
if (R[tt] > L[i]) ans += (cnt - tt + 1);
}
ans += tsum * (cnt + 1) * 2 + tsum * tsum;
cout << ans << endl;
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int K;
cin>>K;
string S;
cin>>S;
if(S.size()<=K) cout<<S<<endl;
else cout<<S.erase(K)+"..."<<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
bool test(string& s, int r) {
int x = 0, y = s.size() - 1;
bool ok = false;
while (x <= y) {
if (s[(x + r) % s.size()] != s[x]) ok = 1;
if (s[(x + r) % s.size()] != s[(y + r) % s.size()]) return false;
++x;
--y;
}
return ok;
}
int main() {
ios_base::sync_with_stdio(false);
string s;
cin >> s;
int c = 0;
for (int i = 1; i < s.size(); ++i) {
if (s[i] != s[0]) ++c;
}
if (c < 2) {
cout << "Impossible";
return 0;
}
int i = 1;
while (i <= s.size() / 2) {
if (test(s, i)) {
cout << 1;
return 0;
}
++i;
}
cout << 2;
}
| 2 |
#include <iostream>
#include <string>
using namespace std;
int main()
{
int n, ans=0, len, c;
string s, name[110], t;
cin>>n>>s;
for (int i=0; i<n; i++) cin>>name[i];
for (int i=0; i<n; i++)
{
len=name[i].size();
for (int j=1; j<51; j++)
{
for (int k=0; k<len; k++)
{
t=""; c=0;
for (int l=k; l<len && c<s.size(); l+=j)
{
if (l<len) { t+=name[i][l]; c++; }
}
if (t==s) { ans++; k=200; j=60; }
}
}
}
cout<<ans<<'\n';
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, k;
int n, m;
string s, ans;
cin >> n;
cin >> s;
set<int> room;
for (i = 0; i < 10; i++) ans.push_back('0'), room.insert(i);
for (i = 0; i < n; i++) {
if (s[i] == 'L')
k = *room.begin(), room.erase(k), ans[k] = '1';
else if (s[i] == 'R')
k = *room.rbegin(), room.erase(k), ans[k] = '1';
else {
k = s[i] - 48;
ans[k] = '0';
room.insert(k);
}
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000003;
const int V = 501000;
int n, m;
vector<string> str;
string tmp;
int row[V], col[V];
int main() {
scanf("%d%d", &n, &m);
str.resize(n);
for (int i = 0; i < n; i++) cin >> str[i];
memset(row, -1, sizeof(row));
memset(col, -1, sizeof(col));
bool ok = true;
int r = n, c = m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
if (str[i][j] != '.') {
str[i][j] -= '1';
int row1 = (j & 1) ? !(str[i][j] / 2) : str[i][j] / 2;
int c1 = (str[i][j] < 3 && str[i][j] > 0) ? 0 : 1;
int col1 = (i & 1) ? !c1 : c1;
if (row[i] == -1) {
row[i] = row1;
r--;
} else if (row[i] != row1) {
ok = false;
break;
}
if (col[j] == -1) {
col[j] = col1;
c--;
} else if (col[j] != col1) {
ok = false;
break;
}
}
if (!ok) break;
}
if (!ok)
printf("0\n");
else {
long long ans = 1;
for (int i = 0; i < c + r; i++) ans = ans * 2 % MOD;
printf("%I64d\n", ans);
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int N, K, ans;
int p[205];
int main() {
int i;
scanf("%d", &N);
for (i = 1; i <= 2 * N - 1; i++) {
scanf("%d", &p[i]);
if (p[i] >= 0)
K++;
else
p[i] = -p[i];
ans += p[i];
}
sort(p + 1, p + 2 * N);
if ((2 * N - 1 - K) % 2 == 1)
if (N % 2 == 0) ans -= p[1] * 2;
printf("%d\n", ans);
return 0;
}
| 1 |
#include <iostream>
using namespace std;
int main()
{
int a[100],n,i,j,t,c;
for(;;){
cin >> n;
if(n==0)break;
for(i=0;i<n;i++){
cin >> a[i];
}
c = 0;
for(i=n-1;i>0;i--){
for(j=0;j<i;j++){
if(a[j] > a[j+1]){
t = a[j];
a[j] = a[j+1];
a[j+1] = t;
c++;
}
}
}
cout << c << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 5;
const long long MOD = 1e9 + 7;
const double eps = 1e-7;
int N, M, K, Q, T;
long long gcd(long long a, long long b) {
if (b == 0LL) return a;
return gcd(b, a % b);
}
int tree[MAXN];
int nmx;
void update(int i, int x) {
while (i <= nmx) {
tree[i] += x;
i += i & -i;
}
}
long long query(int i) {
long long sum = 0ll;
while (i > 0) {
sum += (long long)tree[i];
i -= i & -i;
}
return sum;
}
int main() {
int i, j, x;
scanf("%d%d", &N, &Q);
nmx = N + 5;
for (i = 1; i <= N; ++i) {
scanf("%d", &x);
update(x, 1);
}
for (i = 1; i <= Q; ++i) {
scanf("%d", &x);
if (x > 0)
update(x, 1);
else {
x = -x;
int l = 1;
int r = N;
int ans = -1;
while (l <= r) {
int m = (l + r) >> 1;
int num = query(m);
if (num >= x) {
ans = m;
r = m - 1;
} else {
l = m + 1;
}
}
update(ans, -1);
}
}
for (i = 1; i <= N; ++i) {
if (query(i)) {
printf("%d", i);
return 0;
}
}
printf("0");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long dx[] = {1, 0, -1, 0};
long long dy[] = {0, 1, 0, -1};
void solve() {
long long n, m;
string s, t;
cin >> s >> t;
n = stoi(s);
m = stoi(t);
if (s.size() != t.size()) {
cout << "WRONG_ANSWER"
<< "\n";
return;
}
if (n == 0 && m == 0) {
cout << "OK"
<< "\n";
return;
}
if (n == 0) {
cout << "WRONG_ANSWER"
<< "\n";
return;
}
char mn = ';';
for (long long i = 0; i < s.size(); i++)
if (s[i] != '0') mn = min(mn, s[i]);
string ans;
ans.push_back(mn);
multiset<char> mul;
for (long long i = 0; i < s.size(); i++) mul.insert(s[i]);
mul.erase(mul.find(mn));
for (char x : mul) ans.push_back(x);
if (ans != t) {
cout << "WRONG_ANSWER"
<< "\n";
return;
} else
cout << "OK"
<< "\n";
return;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int N = 100000 + 10;
int n;
vector<int> G[N];
int son_size[N];
double ans[N];
void init() {
for (int i = 1; i <= n; ++i) G[i].clear();
for (int i = 2; i <= n; ++i) {
int x;
scanf("%d", &x);
G[x].push_back(i);
}
memset(ans, 0, sizeof(ans));
}
void get_son(int u) {
son_size[u] = 1;
int siz = G[u].size();
for (int i = 0; i < siz; ++i) {
int v = G[u][i];
get_son(v);
son_size[u] += son_size[v];
}
}
void get_ans(int u) {
int siz = G[u].size();
for (int i = 0; i < siz; ++i) {
int v = G[u][i];
double d = siz > 1 ? 1.0 * (son_size[u] - son_size[v] - 1) / (siz - 1) : 0;
ans[v] = ans[u] + 1.0 / siz * (siz + 1.0 * siz * (siz - 1) / 2 * d);
get_ans(v);
}
}
void deal() {
get_son(1);
ans[1] = 1;
get_ans(1);
}
int main() {
scanf("%d", &n);
init();
deal();
for (int i = 1; i <= n; ++i) {
if (i != 1) printf(" ");
printf("%.20f", ans[i]);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 550;
int n, root, bo[N], ans[N], a[N * 3];
char ss[N][N];
struct node {
vector<int> ch;
int tag, col, leaf;
} d[N * 3];
int dn = 0;
bool chk(node &it) {
int o = 0;
for (int j = 0; j < it.ch.size(); ++j) {
a[j] = d[it.ch[j]].col;
if (a[j] > a[o]) o = j;
}
for (int j = 0; j < o; ++j)
if (a[j] > a[j + 1]) return 0;
for (int j = o; j < it.ch.size() - 1; ++j)
if (a[j] < a[j + 1]) return 0;
return 1;
}
bool srt(node &it) {
int o = 0, z0 = 1, z1 = 1;
for (int j = 0; j < it.ch.size(); ++j) {
a[j] = d[it.ch[j]].col;
if (j && a[j] < a[j - 1]) z0 = 0;
if (j && a[j] > a[j - 1]) z1 = 0;
}
if (z0) return 1;
if (z1) {
reverse(it.ch.begin(), it.ch.end());
return 1;
}
return 0;
}
void gameover() {
puts("NO");
exit(0);
}
void link(int u, int v) {
if (v) d[u].ch.push_back(v);
}
void link(int u, vector<int> &v) {
for (int j = 0; j < v.size(); ++j) link(u, v[j]);
}
void merge(vector<int> &u, vector<int> v) {
for (int j = 0; j < v.size(); ++j)
if (v[j]) u.push_back(v[j]);
}
void build() {
root = ++dn;
for (int i = 1; i <= n; ++i) {
int nd = ++dn;
link(root, nd);
d[nd].leaf = i;
}
}
void paint(int u) {
if (d[u].leaf) {
int id = d[u].leaf;
if (bo[id])
d[u].col = 2;
else
d[u].col = 0;
return;
}
int cnt[3] = {0};
for (int j = 0; j < d[u].ch.size(); ++j) {
int v = d[u].ch[j];
paint(v);
++cnt[d[v].col];
}
d[u].col = 1;
if (!cnt[0] && !cnt[1]) d[u].col = 2;
if (!cnt[1] && !cnt[2]) d[u].col = 0;
}
int bud(vector<int> &v) {
if (v.size() == 0) return 0;
if (v.size() == 1) return v[0];
int nd = ++dn;
link(nd, v);
return nd;
}
vector<int> pushrig(int u) {
vector<int> res;
if (!u) return res;
if (d[u].tag && !srt(d[u])) gameover();
int cnt[3] = {0};
vector<int> ls[3];
for (int j = 0; j < d[u].ch.size(); ++j) {
int v = d[u].ch[j];
int c = d[v].col;
++cnt[c];
ls[c].push_back(v);
}
if (cnt[1] > 1) gameover();
if (!d[u].tag) {
res.push_back(bud(ls[0]));
if (cnt[1]) merge(res, pushrig(ls[1][0]));
res.push_back(bud(ls[2]));
} else {
merge(res, ls[0]);
if (cnt[1]) merge(res, pushrig(ls[1][0]));
merge(res, ls[2]);
}
return res;
}
void setcond(int u) {
if (d[u].col != 1) return;
int sc = 0, scn = 0;
int cnt[3] = {0};
for (int j = 0; j < d[u].ch.size(); ++j) {
int v = d[u].ch[j];
int c = d[v].col;
++cnt[c];
if (c) sc = v, ++scn;
}
if (scn == 1) return setcond(sc);
if (cnt[1] > 2) gameover();
vector<int> ls[3];
for (int j = 0; j < d[u].ch.size(); ++j) {
int v = d[u].ch[j];
ls[d[v].col].push_back(v);
}
ls[1].push_back(0);
ls[1].push_back(0);
if (d[u].tag) {
if (!chk(d[u])) gameover();
} else {
d[u].ch.clear();
int a = bud(ls[2]);
d[a].col = 2;
if (ls[1].size() > 2) {
int b = ++dn;
link(b, ls[1][0]);
link(b, a);
link(b, ls[1][1]);
d[b].col = 1;
d[b].tag = 1;
link(u, b);
link(u, ls[0]);
return setcond(b);
} else {
link(u, a);
link(u, ls[0]);
return;
}
}
vector<int> newch;
int flag = 0;
for (int j = 0; j < d[u].ch.size(); ++j) {
int v = d[u].ch[j];
int c = d[v].col;
if (c == 1) {
vector<int> res = pushrig(v);
if (flag) reverse(res.begin(), res.end());
merge(newch, res);
flag = 1;
} else {
flag |= (c == 2);
newch.push_back(v);
}
}
d[u].ch = newch;
}
void workans(int u) {
if (d[u].leaf) {
ans[++ans[0]] = d[u].leaf;
return;
}
for (int j = 0; j < d[u].ch.size(); ++j) workans(d[u].ch[j]);
}
void showtree(int u) {
printf("%d tag=%d ", u, d[u].tag);
putchar('(');
for (int j = 0; j < d[u].ch.size(); ++j) printf("%d,", d[u].ch[j]);
printf(")\n");
for (int j = 0; j < d[u].ch.size(); ++j) showtree(d[u].ch[j]);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%s", ss[i] + 1);
build();
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) bo[j] = (ss[i][j] == '1');
paint(root);
setcond(root);
}
workans(root);
puts("YES");
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) putchar(ss[i][ans[j]]);
puts("");
}
}
| 5 |
#include<algorithm>
#include<iostream>
#include<cstdlib>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<set>
#include<map>
#define LL long long
using namespace std;
inline int read( )
{
int sum=0;char c=getchar( );bool f=0;
while(c<'0'||c>'9') {if(c=='-') f=1;c=getchar( );}
while(c>='0'&&c<='9') {sum=sum*10+c-'0';c=getchar( );}
if(f) return -sum;
return sum;
}
const int mod=1000000007;
inline LL quick(LL a,LL b)
{
LL r=1,base=a;
while(b)
{
if(b&1) r=r*base%mod;
base=base*base%mod;
b>>=1;
}
return r;
}
int p[10005],f[10005];
inline void up(int &x,int y) {x+=y;if(x>=mod) x-=mod;}
int main( )
{
int n,k,i,j,x,ans=0,len=0;
n=read( );k=read( );
for(i=1;i*i<=n;i++)
if(n%i==0) p[++len]=i,p[++len]=n/i;
sort(p+1,p+len+1);
len=unique(p+1,p+len+1)-p-1;
for(i=1;i<=len;i++)
{
x=p[i];
f[i]=quick(k,(x+1)>>1);
for(j=1;j<i;j++)
if(x%p[j]==0) up(f[i],mod-f[j]);
if(!(x&1)) x>>=1;
up(ans,(LL)f[i]*x%mod);
}
printf("%d",ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace ::std;
const int INF = int(1e9);
const long long INF64 = (long long)(1e18);
vector<vector<pair<long long, long long> > > g;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long n, m;
cin >> n >> m;
g = vector<vector<pair<long long, long long> > >(n + 1);
for (int i = 0; i < m; i++) {
long long a, b, w;
cin >> a >> b >> w;
g[a].push_back(make_pair(b, w));
g[b].push_back(make_pair(a, w));
}
long long start = 1;
long long finish = n;
vector<long long> dist(n + 1, INF64);
dist[start] = 0;
vector<long long> prev(n + 1);
prev[start] = -1;
set<pair<long long, long long> > unused;
unused.insert(make_pair(0, start));
while (!unused.empty()) {
long long next = unused.begin()->second;
unused.erase(unused.begin());
for (auto edge : g[next]) {
long long to = edge.first;
long long wt = edge.second;
if (dist[to] > dist[next] + wt) {
prev[to] = next;
unused.erase(make_pair(dist[to], to));
dist[to] = dist[next] + wt;
unused.insert(make_pair(dist[to], to));
}
}
}
if (dist[finish] == INF64) return cout << -1, 0;
long long curr = finish;
vector<long long> ans;
while (curr != -1) {
ans.push_back(curr);
curr = prev[curr];
}
reverse(ans.begin(), ans.end());
for (int i = 0; i < ans.size(); i++) {
cout << ans[i] << ' ';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const pair<long long, long long> M = make_pair(1e9 + 7, 1e9 + 9);
const long long base = 347;
const int N = 1e6 + 7;
ostream& operator<<(ostream& os, pair<long long, long long> hash) {
return os << "(" << hash.first << ", " << hash.second << ")";
}
pair<long long, long long> operator+(pair<long long, long long> a,
long long x) {
return make_pair(a.first + x, a.second + x);
}
pair<long long, long long> operator-(pair<long long, long long> a,
long long x) {
return make_pair(a.first - x, a.second - x);
}
pair<long long, long long> operator*(pair<long long, long long> a,
long long x) {
return make_pair(a.first * x, a.second * x);
}
pair<long long, long long> operator+(pair<long long, long long> a,
pair<long long, long long> x) {
return make_pair(a.first + x.first, a.second + x.second);
}
pair<long long, long long> operator-(pair<long long, long long> a,
pair<long long, long long> x) {
return make_pair(a.first - x.first, a.second - x.second);
}
pair<long long, long long> operator*(pair<long long, long long> a,
pair<long long, long long> x) {
return make_pair(a.first * x.first, a.second * x.second);
}
pair<long long, long long> operator%(pair<long long, long long> a,
pair<long long, long long> m) {
return make_pair(a.first % m.first, a.second % m.second);
}
pair<long long, long long> pb[N];
void hashPre() {
pb[0] = make_pair(1, 1);
for (int i = 1; i < N; i++) pb[i] = (pb[i - 1] * base) % M;
}
vector<pair<long long, long long> > hashList(string s) {
int n = s.size();
vector<pair<long long, long long> > ans(n + 1);
ans[0] = make_pair(0, 0);
for (int i = 1; i <= n; i++) ans[i] = (ans[i - 1] * base + s[i - 1]) % M;
return ans;
}
pair<long long, long long> substringHash(
const vector<pair<long long, long long> >& hashlist, int l, int r) {
int len = (r - l + 1);
return ((hashlist[r] - hashlist[l - 1] * pb[len]) % M + M) % M;
}
vector<int> prefix_function(string s) {
int n = s.size();
vector<int> pi(n);
for (int i = 1; i < n; i++) {
int j = pi[i - 1];
while (j > 0 and s[i] != s[j]) j = pi[j - 1];
if (s[i] == s[j]) ++j;
pi[i] = j;
}
return pi;
}
int main() {
hashPre();
string a;
vector<pair<long long, long long> > ha;
int n;
cin >> a;
ha = hashList(a);
n = a.size();
vector<long long> vv;
for (int i = 1; i < n; i++) {
if (substringHash(ha, 1, i) == substringHash(ha, n - i + 1, n))
vv.emplace_back(i);
}
sort(vv.begin(), vv.end());
vector<int> vv1 = prefix_function(a);
int ans = 0;
for (int i = 1; i < n - 1; i++)
if (binary_search(vv.begin(), vv.end(), vv1[i])) ans = max(ans, vv1[i]);
if (ans) {
for (int i = 0; i < ans; i++) cout << a[i];
} else
cout << "Just a legend";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool good(int a) {
while (a > 0) {
if (a % 10 != 4 && a % 10 != 7) {
return false;
}
a /= 10;
}
return true;
}
int main() {
int n;
scanf("%d", &n);
int i = 0;
int l = 0;
multiset<pair<int, int>> m;
vector<int> v(n);
for (int j = 0; j < n; ++j) {
int a;
scanf("%d", &a);
v[j] = a;
m.insert(make_pair(a, j + 1));
if (good(a)) {
i = a;
l = j + 1;
}
}
vector<pair<int, int>> ans;
if (i == 0) {
auto it = m.begin();
++i;
while (it != m.end()) {
if (it->second != i) {
printf("-1\n");
return 0;
}
++i;
++it;
}
printf("0\n");
return 0;
}
m.erase(m.find(make_pair(i, l)));
bool ok = false;
auto it = m.begin();
int u = 1;
while (!m.empty()) {
auto temp2 = *it;
m.erase(it);
if (temp2.first > i && !ok) {
++u;
ok = true;
}
if (temp2.second != u) {
if (l != u) {
ans.push_back(make_pair(l, u));
auto temp = *m.find(make_pair(v[u - 1], u));
m.erase(m.find(temp));
v[u - 1] = i;
v[l - 1] = temp.first;
temp.second = l;
m.insert(temp);
l = u;
}
ans.push_back(make_pair(l, temp2.second));
v[temp2.second - 1] = i;
v[l - 1] = temp2.first;
l = temp2.second;
}
it = m.begin();
++u;
}
printf("%d\n", (int)ans.size());
for (auto i : ans) {
printf("%d %d\n", i.first, i.second);
}
}
| 4 |
#include <iostream>
using namespace std;
int main() {
int N, p[50], count=0;
cin >> N;
for(int i=0; i<N; ++i) cin >> p[i];
for(int i=0; i<N; ++i)
if(p[i]!=i+1) ++count;
cout << ((count<=2)?"YES":"NO") << endl;
return 0;
} | 0 |
#include<iostream>
#include<algorithm>
#include<iomanip>
using namespace std;
double dp[200][555];
int n;
int main()
{
cin>>n;
for(int i=0;i<555;i++)dp[0][i]=1e150;
dp[0][1]=0;
for(int i=0;i<n;i++)
{
int h;
cin>>h;
for(int j=0;j<555;j++)dp[i+1][j]=1e150;
for(int j=1;j<500;j++)
{
for(int k=1;k<500;k++)
{
double cost;
if(j<=h)
{
if(k<=h)
{
cost=(2*h-j-k)/2.0;
}
else
{
cost=(h-j+k-h)/2.0-(h-j)*(k-h)/(double)(h-j+k-h);
}
}
else
{
if(k<=h)
{
cost=(j-h+h-k)/2.0-(j-h)*(h-k)/(double)(j-h+h-k);
}
else
{
cost=(j+k-2*h)/2.0;
}
}
dp[i+1][k]=min(dp[i+1][k],dp[i][j]+cost);
}
}
}
double ans=1e150;
for(int i=0;i<555;i++)ans=min(ans,dp[n][i]);
cout<<fixed<<setprecision(9)<<ans<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
long long p, h[100005], a[100005], now[100005];
struct node {
long long d;
int id;
friend bool operator<(node x, node y) { return x.d > y.d; }
};
priority_queue<node> q;
bool check(long long x) {
while (!q.empty()) q.pop();
for (int i = 1; i <= n; i++) {
now[i] = x;
if (now[i] - a[i] * m < h[i]) q.push(node{now[i] / a[i] + 1, i});
}
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= k; j++) {
if (q.empty()) return 1;
int t = q.top().id;
if (q.top().d <= i) return 0;
q.pop();
now[t] += p;
if (now[t] - a[t] * m < h[t]) q.push(node{now[t] / a[t] + 1, t});
}
}
return q.empty();
}
int main() {
scanf("%d%d%d%lld", &n, &m, &k, &p);
for (int i = 1; i <= n; i++) scanf("%lld%lld", &h[i], &a[i]);
long long l = 0, r = 1e15;
while (l < r) {
long long mid = (l + r) >> 1;
if (check(mid))
r = mid;
else
l = mid + 1;
}
printf("%lld", l);
return 0;
}
| 3 |
#include<iostream>
#include<string>
using namespace std;
int main(){
string s;
cin>>s;
string strs[]={
"dream",
"dreamer",
"erase",
"eraser"
};
bool dp[100001]={true};
for(int i=0;i<s.size();i++){
for(auto e:strs){
int n=i+e.size();
if(n<=s.size()&&!s.compare(i,e.size(),e)){
dp[n]|=dp[i];
}
}
}
cout<<(dp[s.size()]?"YES":"NO")<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void debug(T a, T b) {
;
}
template <class T>
void chmin(T& a, const T& b) {
if (a > b) a = b;
}
template <class T>
void chmax(T& a, const T& b) {
if (a < b) a = b;
}
namespace std {
template <class S, class T>
ostream& operator<<(ostream& out, const pair<S, T>& a) {
out << '(' << a.first << ',' << a.second << ')';
return out;
}
} // namespace std
int n, m, k;
char buf[2005][2005];
int res[2005];
int main() {
cin >> n >> m >> k;
for (int i = 0; i < (n); ++i) scanf("%s", buf[i]);
for (int i = 0; i < (m); ++i) {
int cnt = 0;
for (int j = 1; i - j >= 0 && j < n; ++j)
if (buf[j][i - j] == 'R') ++cnt;
for (int j = 1; i + j < m && j < n; ++j)
if (buf[j][i + j] == 'L') ++cnt;
for (int j = 2; j < n; j += 2)
if (buf[j][i] == 'U') ++cnt;
res[i] = cnt;
}
for (int i = 0; i < (m); ++i) printf("%d%c", res[i], i == m - 1 ? '\n' : ' ');
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long int a, b, mini = 0;
while (n--) {
cin >> a >> b;
mini = max(mini, a + b);
}
cout << mini << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 100, M = 52 + 10, LG = 30, base = 2;
const int MOD = 1e9 + 7, mod = 1e9 + 9;
const long long INF = 1e9, inf = 1e18;
long long a[3], m;
long double x;
bool b[N];
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
;
cin >> a[0] >> a[1] >> a[2];
x = 1.0 / a[0] + 1.0 / a[1] + 1.0 / a[2];
if (x < 1) return cout << "NO", 0;
sort(a, a + 3);
if (a[0] == 1) return cout << "YES", 0;
for (int i = 0; i < N; i++) {
if (!b[i]) {
for (int j = i; j < N; j += a[m]) b[j] = 1;
m++;
if (m == 3) break;
}
}
for (int i = 0; i < N; i++)
if (!b[i]) return cout << "NO", 0;
return cout << "YES", 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int dp[35][15][5];
int month[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
char s[100005];
int main() {
int d, m, y;
int ad, am, ay, mx = 0;
scanf("%s", s);
int len = strlen(s);
for (int i = 0; i + 9 < len; i++) {
if (s[i + 2] != '-' || s[i + 5] != '-') continue;
if (s[i + 6] != '2' || s[i + 7] != '0' || s[i + 8] != '1') continue;
bool flag = true;
for (int j = 0; j <= 9; j++) {
if (j == 2 || j == 5) continue;
if (s[i + j] < '0' || s[i + j] > '9') {
flag = false;
break;
}
}
if (flag == false) continue;
d = (s[i] - '0') * 10 + s[i + 1] - '0';
m = (s[i + 3] - '0') * 10 + s[i + 4] - '0';
if (m < 1 || m > 12 || d < 1 || d > month[m]) continue;
y = s[i + 9] - '0';
if (y < 3 || y > 5) continue;
dp[d][m][y]++;
if (dp[d][m][y] > mx) {
mx = dp[d][m][y];
ad = d, am = m, ay = y;
}
}
printf("%02d-%02d-201%d\n", ad, am, ay);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, sum = 0, ans = 0;
int day1[7] = {1, 1, 0, 0, 0, 0, 0}, day2[7] = {0, 0, 0, 0, 0, 1, 1};
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
sum += day1[i % 7];
ans += day2[i % 7];
}
cout << ans << " " << sum << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int x, y, n, m, k, ind, mx = 0, t = 1, sum = 0, flag = 0;
string str, strin;
char ch;
const int MAX_N = 1e5 + 10;
void solve() {
cin >> n >> m;
for (long long int i = 0; i < n; i++) {
for (long long int j = 0; j < m; j++) {
if (i == n - 1 && j == m - 1)
cout << 'W';
else
cout << 'B';
}
cout << endl;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> t;
while (t--) solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
int main(void) {
long long int n, k;
scanf("%lld %lld", &n, &k);
long long ans = -1, res;
long long lo = 2, hi = k;
while (lo <= hi) {
long long mid = (lo + hi) / 2;
long long left = mid * (mid + 1) / 2 - 1, right = k * (k + 1) / 2 - 1;
long long ret = (right - left) - (k - mid - 1);
if (ret <= n) {
ans = mid;
res = ret;
hi = mid - 1;
} else
lo = mid + 1;
}
if (ans != -1) {
long long rem = n - res;
if (rem) rem++;
if (!rem || (rem <= ans && rem > 1)) {
long long needed = k - ans;
if (rem) needed++;
printf("%lld\n", needed);
return 0;
}
}
puts("-1");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
pq;
int a[600005], ans;
int n, k, pre[600005], nxt[600005];
int main() {
scanf("%d%d", &k, &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
sort(a + 1, a + n + 1);
for (int i = 1; i < n; ++i)
a[i] = a[i + 1] - a[i], pq.push(pair<int, int>(a[i], i));
for (int i = 0; i <= n; ++i) pre[i] = i - 1, nxt[i] = i + 1;
a[0] = a[n] = (1 << 30), pre[0] = 0, nxt[n] = 0;
for (int i = 1; i <= k; ++i) {
while (pq.size() && a[pq.top().second] != pq.top().first) pq.pop();
if (pq.empty()) break;
pair<int, int> s = pq.top();
pq.pop();
ans += s.first;
int x = s.second;
int l = pre[x], r = nxt[x];
a[x] = l && r ? min((1 << 30), a[l] + a[r] - a[x]) : (1 << 30);
pq.push(pair<int, int>(a[x], x));
a[l] = a[r] = (1 << 30);
nxt[pre[x] = pre[l]] = x;
pre[nxt[x] = nxt[r]] = x;
}
printf("%d", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1010;
const long long mod = 998244353;
inline long long sum(long long a, long long b) { return (a + b) % mod; }
long long n, k;
long long a[maxn];
long long dp[maxn][maxn], pref[maxn][maxn];
long long le[maxn];
long long solve(long long val) {
for (long long i = 0; i <= k; i++)
for (long long j = 0; j <= n; j++) dp[i][j] = 0, pref[i][j] = 0;
le[0] = 0;
for (long long i = 1; i <= n; i++) {
le[i] = le[i - 1];
while (a[i] - a[le[i] + 1] >= val) le[i]++;
}
dp[0][0] = 1;
for (long long i = 0; i + 1 <= k; i++) {
pref[i][0] = dp[i][0];
for (long long j = 1; j <= n; j++) {
pref[i][j] = sum(pref[i][j - 1], dp[i][j]);
}
for (long long j = 1; j <= n; j++) {
dp[i + 1][j] = pref[i][le[j]];
}
}
long long ans = 0;
for (long long i = 1; i <= n; i++) ans = sum(ans, dp[k][i]);
return ans;
}
signed main() {
cin >> n >> k;
for (long long i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
long long ans = 0;
for (long long i = 1; i * (k - 1) <= 100000 + 10; i++)
ans = sum(ans, solve(i));
cout << ans;
}
| 6 |
#include<cstdio>
#include<deque>
#include<iostream>
using namespace std;
deque<int>_deq;
int main(){
int Q,q,d,x;
scanf("%d",&Q);
while(Q--){
scanf("%d",&q);
if(q==0){
scanf("%d%d",&d,&x);
if(d==0) _deq.push_front(x);
else _deq.push_back(x);
}
else if(q==1){
scanf("%d",&d);
printf("%d\n",_deq[d]);
}
else{
scanf("%d",&d);
if(d==0) _deq.pop_front();
else _deq.pop_back();
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5000005;
pair<int, int> pa[N];
int vis[N];
int main() {
int n, x, y;
scanf("%d", &n), scanf("%d", &x), scanf("%d", &y);
for (int i = 0; i < n; i++) {
scanf("%d", &pa[i].first), scanf("%d", &pa[i].second);
}
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (((pa[i].second - y) * (pa[j].first - x)) ==
((pa[j].second - y) * (pa[i].first - x)) &&
!vis[j]) {
ans++;
vis[j] = 1;
}
}
}
printf("%d\n", n - ans);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char str[100];
int a[4], result;
for (int j = 0; j <= 3; j++) a[j] = 0;
gets(str);
for (int j = 0; str[j] != '\0'; j++) {
if (str[j] == 'n') a[0]++;
if (str[j] == 'i') a[1]++;
if (str[j] == 'e') a[2]++;
if (str[j] == 't') a[3]++;
}
a[2] = a[2] / 3;
result = a[1];
for (int j = 2; j <= 3; j++) {
if (a[j] < result) result = a[j];
}
while (result > 0) {
if (a[0] < 2 * result + 1) {
result--;
} else
break;
}
cout << result;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long a[505], ans = -1;
void check(int k) {
long long temp = 0;
for (int i = 1; i <= n; i++) {
int x = a[i] / k, y = a[i] % k;
if (x < y) return;
x -= y;
temp += (x + y - x / (k + 1));
}
if (ans == -1 || ans > temp) ans = temp;
}
int main() {
while (cin >> n) {
ans = -1;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int k = 1; (long long)k * k <= a[1]; k++) {
check(k);
check(a[1] / k);
if (a[1] % k == 0 && a[1] > k) check(a[1] / k - 1);
}
cout << ans << endl;
}
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int N, D[1000];
cin >> N;
bool sss[1000] = {};
for(int i = 0; i < N; i++) {
cin >> D[i];
sss[D[i]] = true;
if(i > 0) sss[D[i - 1] * 10 + D[i]] = true;
if(i > 1) sss[D[i - 2] * 100 + D[i - 1] * 10 + D[i]] = true;
}
for(int i = 0; true; i++) {
if(!sss[i]) {
cout << i << endl;
exit(0);
}
}
} | 0 |
#include <iostream>
using namespace std;
int gcd(int a, int b) {
if (b == 0) return a;
else return gcd(b, a % b);
}
int lcm(int a, int b) {
return a * b / gcd(a, b);
}
const int MAX_N = 1010;
const int INF = (1 << 28);
int a[MAX_N];
int main() {
int n, m;
cin >> n >> m;
int group = lcm(n, m) / m;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int ans = 0;
for (int id = 0; id < group; id++) {
int start = (id * m) % n,
min_w = INF,
max_w = -INF;
for (int b_i = 0; b_i < m; b_i++) {
int ball = (start + b_i) % n;
min_w = min(min_w, a[ball]);
max_w = max(max_w, a[ball]);
}
ans += max_w - min_w;
}
cout << ans << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 1000000000 + 7;
const long long int MOD1 = 998244353;
const long long int Val9 = 1000000000;
const long long int Val6 = 1000000;
vector<long long int> vd;
void no_of_divisors(long long int n) {
for (long long int i = 1; i <= sqrt(n); i++) {
if (n % i == 0) {
if (n / i == i) {
vd.push_back(i);
} else {
vd.push_back(i);
vd.push_back(n / i);
}
}
}
}
long long int pwr(long long int x, long long int y) {
long long int r = 1;
while (y > 0) {
if (y & 1) r = r * x;
x *= x;
y >>= 1;
}
return r;
}
long long int pwrm(long long int x, long long int y, long long int m) {
x %= m;
long long int r = 1;
while (y > 0) {
if (y & 1) r = r * x % m;
x = x * x % m;
y >>= 1;
}
return r;
}
int isPrime(long long int n) {
if (n <= 1) return 0;
if (n <= 3) return 1;
if (n % 2 == 0 || n % 3 == 0) return 0;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return 0;
return 1;
}
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
vector<long long int> vprime;
vector<long long int> vsqr;
void SieveOfEratosthenes(long long int n) {
bool prime[n + 1];
memset(prime, true, sizeof(prime));
for (long long int p = 2; p * p <= n; p++) {
if (prime[p] == true) {
for (long long int i = p * p; i <= n; i += p) prime[i] = false;
}
}
for (long long int p = 2; p <= n; p++) {
if (prime[p]) {
vprime.push_back(p);
vsqr.push_back(p * p);
}
}
}
bool vis[Val6] = {false};
vector<long long int> v[Val6];
vector<long long int> ans;
long long int dfs(long long int s) {
long long int p = v[s].size();
vis[s] = true;
for (long long int i = (long long int)0; i < (long long int)v[s].size();
i++) {
if (vis[v[s][i]] == false) {
dfs(v[s][i]);
}
}
return 1;
}
void bfs(vector<long long int> v[], long long int n) {
queue<long long int> q;
q.push(n);
vis[n] = true;
long long int dist = 0;
while (!q.empty()) {
long long int p = q.front();
q.pop();
dist++;
for (long long int i = (long long int)0; i < (long long int)v[p].size();
i++) {
if (vis[v[p][i]] == false) {
q.push(v[p][i]);
vis[v[p][i]] = true;
}
}
}
}
long long int nCr(long long int n, long long int r) {
long long int ans = 1;
for (long long int i = (long long int)0; i < (long long int)r; i++) {
ans *= n - i;
ans /= i + 1;
}
return ans;
}
long long int n;
long long int a[Val6], b[Val6];
long long int y, q;
long long int dp[100005][2];
long long int fun(long long int sum, long long int i) {
if (sum < 0) return -Val6;
if (sum == 0 || i == q) return 0;
if (dp[sum][i] != -1) return dp[sum][i];
return dp[sum][i] = max(b[i] + fun(sum - a[i], i), fun(sum, i + 1));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
{
cin >> n >> q;
vector<long long int> w;
long long int ans = 0, z = 0;
for (long long int i = (long long int)0; i < (long long int)n; i++) {
long long int a;
cin >> a;
if (a == 0)
z++;
else {
vector<long long int> p;
for (long long int i = (long long int)0; i < (long long int)a; i++) {
long long int x;
cin >> x;
p.push_back(x);
w.push_back(x);
}
if (a == 1) {
v[p[0]].push_back(p[0]);
} else {
for (long long int i = (long long int)0;
i < (long long int)p.size() - 1; i++) {
long long int x1 = p[i], x2 = p[i + 1];
v[x1].push_back(x2);
v[x2].push_back(x1);
}
}
}
}
for (long long int i = (long long int)0; i < (long long int)w.size(); i++) {
if (!vis[w[i]]) {
dfs(w[i]);
ans++;
}
}
if (z == 0)
cout << ans - 1;
else if (ans == 0)
cout << ans + z;
else
cout << ans + z - 1;
}
cerr << "Time : " << 1000 * ((double)clock()) / (double)CLOCKS_PER_SEC
<< "ms\n";
return 0;
}
| 1 |
#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<map>
#include<set>
#include<utility>
#include<cmath>
#include<cstring>
#include<queue>
#include<stack>
#include<cstdio>
#include<sstream>
#include<iomanip>
#include<assert.h>
#define loop(i,a,b) for(int i=a;i<b;i++)
#define rep(i,a) loop(i,0,a)
#define pb push_back
#define all(in) in.begin(),in.end()
#define shosu(x) fixed<<setprecision(x)
using namespace std;
//kaewasuretyuui
typedef long long ll;
typedef int Def;
typedef pair<Def,Def> pii;
typedef vector<Def> vi;
typedef vector<vi> vvi;
typedef vector<pii> vp;
typedef vector<vp> vvp;
typedef vector<string> vs;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef pair<Def,pii> pip;
typedef vector<pip>vip;
//#define mt make_tuple
//typedef tuple<double,int,double> tp;
//typedef vector<tp> vt;
template<typename A,typename B>bool cmin(A &a,const B &b){return a>b?(a=b,true):false;}
template<typename A,typename B>bool cmax(A &a,const B &b){return a<b?(a=b,true):false;}
const double PI=acos(-1);
const double EPS=1e-7;
Def inf = sizeof(Def) == sizeof(long long) ? 2e18 : 1e9;
int dx[]={0,1,0,-1};
int dy[]={1,0,-1,0};
int main(){
int n,m,MOD=1000000007;
cin>>n>>m;
vi in(n);
rep(i,n)cin>>in[i];
sort(all(in),[](int a,int b){return a>b;});
vvi dp(n+1,vi(m+1));
dp[0][0]=1;
rep(i,n){
vvi ndp(n+1,vi(m+1));
rep(j,n+1)rep(k,m+1){
if(k+in[i]<=m)(ndp[j][k+in[i]]+=dp[j][k])%=MOD;
(ndp[i+1][k]+=dp[j][k])%=MOD;
}
dp=ndp;
}
int out=0;
rep(i,m+1)out+=dp[0][i];
rep(i,n)rep(j,m+1)if(j+in[i]>m)(out+=dp[i+1][j])%=MOD;
cout<<out<<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 101010;
int n, ans;
int pa[N << 1], ns[N], nt[N], ma[N], pos[N];
vector<pair<int, int> > res;
char s[N], sr[N];
void Manacher(char *s, int n, int *pa) {
pa[0] = 1;
for (int i = 1, j = 0; i < (n << 1) - 1; ++i) {
int p = i >> 1, q = i - p, r = ((j + 1) >> 1) + pa[j] - 1;
pa[i] = r < q ? 0 : min(r - q + 1, pa[(j << 1) - i]);
while (0 <= p - pa[i] && q + pa[i] < n && s[p - pa[i]] == s[q + pa[i]])
pa[i]++;
if (q + pa[i] - 1 > r) j = i;
}
for (int i = (0); i < (n); ++i) pa[i] = pa[i << 1];
}
void kmp(char *s, int *ns, char *t, int *nt) {
int lens = strlen(s);
int lent = strlen(t);
nt[0] = -1;
for (int i = 0, j = -1; i < lens; ++i) {
while (j >= 0 && s[i] != t[j + 1]) j = nt[j];
if (s[i] == t[j + 1]) ++j;
ns[i] = j;
if (j + 1 == lent) j = nt[j];
}
}
int main() {
std::ios::sync_with_stdio(0);
std::cin.tie(0);
cin >> s;
n = strlen(s);
Manacher(s, n, pa);
for (int i = (0); i < (n); ++i) sr[i] = s[n - 1 - i];
sr[n] = '\0';
kmp(sr + 1, nt + 1, sr, nt);
kmp(s, ns, sr, nt);
for (int i = (0); i < (n); ++i)
if (~ns[i]) ++ns[i];
ma[0] = ns[0];
pos[0] = 0;
for (int i = (1); i < (n); ++i) {
ma[i] = ma[i - 1];
pos[i] = pos[i - 1];
if (ma[i] < ns[i]) {
ma[i] = ns[i];
pos[i] = i;
}
}
for (int i = (0); i < (n); ++i) {
int k = i - pa[i];
int t = max(0, min(k < 0 ? 0 : ma[k], n - i - pa[i]));
int c = pa[i] * 2 - 1 + t * 2;
if (ans < c) {
ans = c;
res.clear();
res.push_back(make_pair(i - pa[i] + 1, pa[i] * 2 - 1));
if (t) {
res.push_back(make_pair(n - t, t));
int o = pos[k] - 2 * ns[pos[k]] + t + 1;
res.push_back(make_pair(o, t));
}
}
}
sort(res.begin(), res.end());
cout << (int)res.size() << "\n";
for (auto u : res) cout << u.first + 1 << " " << u.second << "\n";
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll n,cnt,ans;
string s,t;
int main(void){
cin>>n>>s;
for(int i=0;i<=9;i++){
for(int j=0;j<=9;j++){
for(int k=0;k<=9;k++){
cnt=0;
ll L[]={i,j,k};
for(int i=0;i<n;i++){
if(L[cnt]==s[i]-'0'){
cnt++;
}
if(cnt==3){
ans++;
break;
}
}
}
}
}
cout<<ans<<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
for (int i = 1, x; cin >> x && x; ++i) {
cout << "Case " << i << ": " << x << '\n';
}
}
| 0 |
#include<iostream>
#include<cstring>
#include<cstdio>
#include<cstring>
#include<vector>
#include<queue>
#include<algorithm>
#include<climits>
#include<bitset>
#define pii pair<int,int>
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define int long long
#define mod 1000000007
using namespace std;
inline int read(){
int f=1,ans=0;char c=getchar();
while(c<'0'||c>'9'){if(c=='-')f=-1;c=getchar();}
while(c>='0'&&c<='9'){ans=ans*10+c-'0';c=getchar();}
return f*ans;
}
const int MAXN=17;
int f[MAXN][1<<MAXN],fac[1<<MAXN],N,M,A[MAXN],Lim,ifac[1<<MAXN],inv[1<<MAXN],Ans;
bool cmp(int a,int b){return a>b;}
int C(int a,int b){return a<b?0:fac[a]*ifac[a-b]%mod*ifac[b]%mod;}
int lowbit(int x){return x&-x;}
int cont(int x){int c=0;while(x){x-=lowbit(x);c++;}return c;}
signed main(){
//freopen("1.in","r",stdin);
N=read(),M=read();for(int i=1;i<=M;i++) A[i]=read();sort(A+1,A+M+1,cmp);Lim=(1<<N);
fac[0]=fac[1]=inv[1]=ifac[0]=ifac[1]=1;for(int i=2;i<=Lim;i++) fac[i]=fac[i-1]*i%mod,inv[i]=(mod-mod/i)*inv[mod%i]%mod,ifac[i]=ifac[i-1]*inv[i]%mod;f[0][0]=1;
for(int i=1;i<=M;i++){
for(int j=0;j<Lim;j++){
f[i][j]+=f[i-1][j];
for(int k=0;k<N;k++){
if((j&(1<<k))) continue;
f[i][j|(1<<k)]+=f[i-1][j]*C((1<<N)-A[i]-j,(1<<k)-1)%mod*fac[(1<<k)]%mod,f[i][j]%=mod;
}
}
}
for(int i=0;i<Lim;i++){
int pw=(cont(i)&1)?-1:1;
Ans=(Ans+pw*f[M][i]*fac[Lim-1-i]+mod)%mod;
}printf("%lld\n",Ans*(1<<N)%mod);return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long n, k;
scanf("%ld %ld", &n, &k);
for (long i = k + 2 - 1; i >= 1; --i) printf("%ld ", i);
;
for (long i = k + 2; i < n + 1; ++i) printf("%ld ", i);
;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, k, n, d, x, mx, a, b;
vector<int> v;
while (cin >> n) {
for (i = 0; i < n; i++) {
cin >> k;
v.push_back(k);
}
mx = 99999;
for (i = 0; i < v.size(); i++) {
if (i != v.size() - 1) {
x = v[i] - v[i + 1];
if (x < 0) {
x = x * -1;
}
if (x < mx) {
mx = x;
a = i + 1;
b = i + 2;
}
} else {
x = v[v.size() - 1] - v[0];
if (x < 0) {
x = x * -1;
}
if (x < mx) {
mx = x;
a = v.size();
b = 1;
}
}
}
cout << a << " " << b << endl;
v.clear();
}
return 0;
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.