solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3003;
const int maxm = 3003;
const int maxq = 4e5 + 18;
int n, m, q;
int16_t F[maxn][maxn][13];
bool vs[maxn];
bool can_reach[maxn][maxn];
vector<int> adj[maxn];
vector<int> radj[maxn];
void Input() {
cin >> n >> m >> q;
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
radj[v].push_back(u);
}
for (int u = 1; u <= n; u++) {
sort(adj[u].begin(), adj[u].end());
}
}
void Init() {
for (int u = 1; u <= n; u++) {
can_reach[u][u] = true;
queue<int> Q;
Q.push(u);
while (Q.size()) {
int vu = Q.front();
Q.pop();
can_reach[u][vu] = true;
for (int v : radj[vu]) {
if (!can_reach[u][v]) {
can_reach[u][v] = true;
Q.push(v);
}
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (i == j) {
F[i][j][0] = i;
continue;
}
for (int z : adj[i]) {
if (can_reach[j][z]) {
F[i][j][0] = z;
break;
}
}
}
}
for (int k = 1; k <= 12; k++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
F[i][j][k] = F[F[i][j][k - 1]][j][k - 1];
}
}
}
}
int getbit(int x, int i) { return (x >> i) & 1; }
int answer(int u, int v, int x) {
int cur = u;
for (int j = 0; j <= 12; j++) {
if (getbit(x, j)) cur = F[cur][v][j];
}
return cur;
}
void Output() {
Init();
while (q--) {
int u, v, x;
cin >> u >> v >> x;
x--;
if (F[u][v][12] != v) {
cout << -1 << "\n";
continue;
}
int X = answer(u, v, x);
int Y = answer(u, v, x - 1);
if (X == v && Y == v)
cout << "-1\n";
else
cout << X << "\n";
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
Input();
Output();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int maxLength = 5;
char prev = 'A';
int ans = 0;
for (int i = 0; i < s.length(); i++) {
if (s[i] != prev) {
maxLength = 5;
ans++;
prev = s[i];
} else {
maxLength--;
prev = s[i];
if (maxLength < 1) {
ans++;
maxLength = 5;
}
}
}
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename Tp>
inline void read(Tp &x) {
static char c;
static bool neg;
x = 0, c = getchar(), neg = false;
for (; !isdigit(c); c = getchar()) {
if (c == '-') {
neg = true;
}
}
for (; isdigit(c); c = getchar()) {
x = x * 10 + c - '0';
}
if (neg) {
x = -x;
}
}
namespace Solve {
const int N = 500 + 5;
const int Q = 6e5 + 5;
int n, m, q;
bool ans[Q];
char mp[N][N];
struct Query {
int x1, y1, x2, y2;
};
Query que[Q];
bitset<N> f[N][N], g[N][N];
void solve(int l, int r, vector<int> &id) {
if (l > r || id.empty()) {
return;
}
int mid = (l + r) >> 1;
for (int i = 1; i <= m; ++i) {
f[mid][i].reset();
g[mid][i].reset();
}
for (int i = 1; i <= m; ++i) {
if (mp[mid][i] == '.') {
f[mid][i].set(i);
f[mid][i] |= f[mid][i + 1];
g[mid][i].set(i);
g[mid][i] |= g[mid][i - 1];
}
}
for (int i = mid - 1; i >= l; --i) {
for (int j = m; j >= 1; --j) {
if (mp[i][j] == '.') {
f[i][j] = f[i + 1][j] | f[i][j + 1];
} else {
f[i][j].reset();
}
}
}
for (int i = mid + 1; i <= r; ++i) {
for (int j = 1; j <= m; ++j) {
if (mp[i][j] == '.') {
g[i][j] = g[i - 1][j] | g[i][j - 1];
} else {
g[i][j].reset();
}
}
}
vector<int> left, right;
for (const auto &i : id) {
if (que[i].x2 < mid) {
left.emplace_back(i);
} else if (que[i].x1 > mid) {
right.emplace_back(i);
} else {
ans[i] = (f[que[i].x1][que[i].y1] & g[que[i].x2][que[i].y2]).any();
}
}
solve(l, mid, left);
solve(mid + 1, r, right);
}
inline void main() {
read(n), read(m);
for (int i = 1; i <= n; ++i) {
scanf("%s", mp[i] + 1);
}
read(q);
vector<int> id;
for (int i = 1; i <= q; ++i) {
read(que[i].x1), read(que[i].y1), read(que[i].x2), read(que[i].y2);
id.emplace_back(i);
}
solve(1, n, id);
for (int i = 1; i <= q; ++i) {
puts(ans[i] ? "Yes" : "No");
}
}
} // namespace Solve
int main() {
Solve::main();
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long mod_pow(long long x, long long n, long long modd) {
long long res = 1;
while (n > 0) {
if (n & 1) res = res * x % modd;
x = x * x % modd;
n >>= 1;
}
return res;
}
long long inv2, inv22;
template <typename T>
void fwt(vector<T>& f) {
int n = f.size();
for (int i = 1; i < n; i <<= 1) {
for (int j = 0; j < n; j++) {
if ((j & i) == 0) {
T x = f[j];
T y = f[j | i];
f[j] = (x + y) % 1000000007;
f[j | i] = (x - y + 1000000007) % 1000000007;
}
}
}
}
template <typename T>
void ifwt(vector<T>& f) {
int n = f.size();
for (int i = 1; i < n; i <<= 1) {
for (int j = 0; j < n; j++) {
if ((j & i) == 0) {
T x = f[j];
T y = f[j | i];
f[j] = (((x + y) % 1000000007) * inv2) % 1000000007;
f[j | i] = (((x - y + 1000000007) % 1000000007) * inv2) % 1000000007;
}
}
}
}
template <typename T>
void fwt2(vector<T>& f) {
int n = f.size();
for (int i = 1; i < n; i <<= 1) {
for (int j = 0; j < n; j++) {
if ((j & i) == 0) {
T x = f[j];
T y = f[j | i];
f[j] = (x + y) % 1000000033;
f[j | i] = (x - y + 1000000033) % 1000000033;
}
}
}
}
template <typename T>
void ifwt2(vector<T>& f) {
int n = f.size();
for (int i = 1; i < n; i <<= 1) {
for (int j = 0; j < n; j++) {
if ((j & i) == 0) {
T x = f[j];
T y = f[j | i];
f[j] = (((x + y) % 1000000033) * inv22) % 1000000033;
f[j | i] = (((x - y + 1000000033) % 1000000033) * inv22) % 1000000033;
}
}
}
}
vector<pair<long long, long long>> g[100010];
int col[100010];
vector<pair<long long, long long>> tour;
vector<vector<int>> wss;
void dfs(int v, int pre) {
col[v] = 1;
for (pair<long long, long long> e : g[v]) {
int nv = e.first;
int w = e.second;
if (nv == pre) continue;
if (col[nv] == 1) {
vector<int> tmp;
tmp.push_back(w);
for (int i = tour.size() - 1; i >= 0; i--) {
tmp.push_back(tour[i].second);
if (tour[i].first == nv) break;
}
wss.push_back(tmp);
} else if (col[nv] == 0) {
tour.push_back(pair<long long, long long>(v, w));
dfs(nv, v);
tour.pop_back();
}
}
col[v] = 2;
}
int main() {
inv2 = mod_pow(2, 1000000007 - 2, 1000000007);
inv22 = mod_pow(2, 1000000033 - 2, 1000000033);
long long S = 0;
int N, M;
scanf("%d%d", &N, &M);
for (long long i = (long long)(0); i < (long long)(M); i++) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
a--;
b--;
g[a].push_back(pair<long long, long long>(b, c));
g[b].push_back(pair<long long, long long>(a, c));
S ^= c;
}
dfs(0, -1);
int K = wss.size();
int L = 1 << 17;
vector<long long> res(L, 0), res2(L, 0);
res[0] = 1;
res2[0] = 1;
fwt(res);
fwt2(res2);
for (long long i = (long long)(0); i < (long long)(K); i++) {
vector<long long> tmp(L, 0), tmp2(L, 0);
for (long long j = (long long)(0); j < (long long)(wss[i].size()); j++) {
tmp[wss[i][j]] += 1;
tmp2[wss[i][j]] += 1;
}
fwt(tmp);
for (long long j = (long long)(0); j < (long long)(L); j++) {
res[j] = res[j] * tmp[j] % 1000000007;
}
fwt2(tmp2);
for (long long j = (long long)(0); j < (long long)(L); j++) {
res2[j] = res2[j] * tmp2[j] % 1000000033;
}
}
ifwt(res);
ifwt2(res2);
long long resa = 1e16, resb = 0;
for (long long i = (long long)(0); i < (long long)(L); i++) {
if ((res[i] > 0 || res2[i] > 0) && (i ^ S) < resa) {
resa = (i ^ S);
resb = res[i];
}
}
cout << resa << " " << resb << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
char s[500009];
int n, k;
char f(int x, int y) {
char cc = 'A' + (k - 1);
for (char c = 'A'; c <= cc; c++) {
if (c != s[x] && c != s[y]) return c;
}
return '0';
}
int main() {
int i, j, m, d, test, t = 0;
while (scanf("%d%d", &n, &k) == 2) {
scanf("%s", s + 1);
s[0] = '0';
int cnt = 0;
if (k == 2) {
int cnt1 = 0, cnt2 = 0;
for (i = 1; i <= n; i++) {
if (i % 2 == 1 && s[i] == 'B') cnt1++;
if (i % 2 == 0 && s[i] == 'A') cnt1++;
}
for (i = 1; i <= n; i++) {
if (i % 2 == 0 && s[i] == 'B') cnt2++;
if (i % 2 == 1 && s[i] == 'A') cnt2++;
}
if (cnt1 <= cnt2) {
for (i = 1; i <= n; i++) {
if (i % 2 == 1)
s[i] = 'A';
else
s[i] = 'B';
}
} else {
for (i = 1; i <= n; i++) {
if (i % 2 == 1)
s[i] = 'B';
else
s[i] = 'A';
}
}
printf("%d\n%s\n", min(cnt1, cnt2), s + 1);
continue;
}
for (i = 1; i < n; i++) {
if (s[i] == s[i + 1]) {
cnt++;
if (i != n - 1 && s[i] == s[i + 2]) {
s[i + 1] = f(i, i + 2);
i++;
} else
s[i] = f(i - 1, i + 1);
}
}
printf("%d\n%s\n", cnt, s + 1);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, i, j, a[307];
int main() {
cin >> n;
for (i = 0; i < n; i++) cin >> a[i];
if (a[0] > 0) cout << "P";
for (i = 1; i < a[0]; i++) cout << "RLP";
cout << "R";
for (i = 1; i < n; i++) {
if (a[i] > 0) cout << "P";
for (j = 1; j < a[i]; j++) cout << "LRP";
if (i != n - 1) cout << "R";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int base = 131;
const int MOD = 1e9 + 7;
const long long MM = 1ll * MOD * MOD;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
void AddMOD(int &x, int y) {
x += y;
if (x >= MOD) x -= MOD;
}
int Gcd(int x, int y) {
if (y == 0) return x;
return Gcd(y, x % y);
}
template <class T>
inline void Gmax(T &x, T y) {
x = max((x), (y));
}
template <class T>
inline void Gmin(T &x, T y) {
x = min((x), (y));
}
const int maxn = 2e5 + 5;
bool comp(int a, int b) { return a > b; }
void Solve() {
int n, p[maxn];
int x, y, a, b;
long long k;
cin >> n;
for (int i = (1); i <= (n); i++) cin >> p[i], p[i] /= 100;
cin >> x >> a >> y >> b >> k;
if (x < y) {
swap(x, y);
swap(a, b);
}
sort(p + 1, p + 1 + n, comp);
int l = 0, r = n + 1;
long long c = 1ll * a * b / Gcd(a, b);
while (r - l > 1) {
int mid = (l + r) >> 1;
int sl1 = mid / a;
int sl2 = mid / b;
int sl3 = mid / c;
long long pr = 0;
sl2 -= sl3;
sl1 -= sl3;
for (int i = 1; i <= sl3; i++) pr += p[i] * (x + y);
for (int i = 1; i <= sl1; i++) pr += p[sl3 + i] * x;
for (int i = 1; i <= sl2; i++) pr += p[sl3 + sl1 + i] * y;
if (pr < k)
l = mid;
else
r = mid;
}
if (r == n + 1)
cout << -1 << "\n";
else
cout << r << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int test = 1;
cin >> test;
while (test--) Solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[100005];
int main() {
int n, x, i, zz, zzz;
scanf("%d%d", &n, &x);
int z = 0;
if (n > 2) {
int k = 0;
while (1) {
z = 0;
for (i = 0; i < n - 2; i++) {
z ^= (i + k);
}
zz = 1 << 18;
i = 0;
while (1) {
int j = 1 << i;
if (z >= j) {
if (z & j) {
zz |= j;
}
} else
break;
i++;
}
zzz = x | (1 << 18);
if (zz == zzz) {
k++;
} else {
printf("YES\n");
for (i = 0; i < n - 2; i++) {
printf("%d ", i + k);
}
if (zz < zzz)
printf("%d %d\n", zz, zzz);
else
printf("%d %d\n", zzz, zz);
break;
}
}
} else {
if (n == 2) {
if (x != 0) {
printf("YES\n0 %d\n", x);
} else {
printf("NO\n");
}
} else {
printf("YES\n%d\n", x);
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void show(const vector<T> &a) {
for (T x : a) cout << x << " ";
cout << '\n';
}
vector<long long> xx = {1, 0, -1, 0};
vector<long long> yy = {0, 1, 0, -1};
string dir = "LRUD";
const long long N = 2e5 + 50, oo = 3e18 + 500;
const long long mod = 1e9 + 7;
const long double eps = 1e-7, PI = 2 * acos(0.0);
long long n, m, k;
long long cnt = 0;
long long lg = 18;
vector<long long> g[N];
vector<long long> rg[N];
vector<long long> visit(N, 0);
signed main() {
ios::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
cin >> n >> m >> k;
vector<vector<long long> > t(n, vector<long long>(m));
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
cin >> t[i][j];
}
}
vector<vector<long long> > del(m);
for (long long j = 0; j < m; j++) {
long long num = 0;
for (long long i = 0; i < n; i++) {
if (t[i][j] == 1) {
cnt = 0;
long long score = 0;
for (long long z = i; z < n && cnt < k; z++) {
score += t[z][j];
cnt++;
}
del[j].push_back(score);
}
}
}
vector<long long> dp(n * m + 1, 0);
for (long long j = 0; j < m; j++) {
vector<long long> ndp(n * m + 1, 0);
for (long long w = 0; w <= n * m; w++) {
ndp[w] = max(ndp[w], dp[w]);
;
for (long long d = 0; d < ((long long)(del[j].size())) && d <= w; d++) {
ndp[w] = max(ndp[w], dp[w - d] + del[j][d]);
;
}
}
dp = ndp;
}
cnt = 0;
for (long long w = 0; w <= n * m; w++) {
cnt = max(cnt, dp[w]);
;
}
for (long long w = 0; w <= n * m; w++) {
if (dp[w] == cnt) {
return cout << cnt << " " << w, 0;
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int f[100][100];
int main() {
f[0][0] = 1;
f[0][1] = 1;
f[0][2] = 1;
f[0][3] = 1;
f[0][4] = 1;
f[0][5] = 1;
f[0][6] = 1;
f[0][7] = 0;
f[0][8] = 1;
f[0][9] = 0;
f[0][10] = 1;
f[0][11] = 0;
f[0][12] = 1;
f[0][13] = 0;
f[0][14] = 1;
f[0][15] = 1;
f[0][16] = 1;
f[0][17] = 1;
f[0][18] = 1;
f[0][19] = 0;
f[0][20] = 0;
f[0][21] = 1;
f[0][22] = 0;
f[0][23] = 1;
f[0][24] = 0;
f[0][25] = 0;
f[0][26] = 1;
f[0][27] = 1;
f[0][28] = 1;
f[0][29] = 1;
f[0][30] = 1;
f[0][31] = 1;
f[0][32] = 1;
f[1][0] = 1;
f[1][1] = 0;
f[1][2] = 0;
f[1][3] = 0;
f[1][4] = 0;
f[1][5] = 0;
f[1][6] = 1;
f[1][7] = 0;
f[1][8] = 0;
f[1][9] = 0;
f[1][10] = 0;
f[1][11] = 0;
f[1][12] = 0;
f[1][13] = 0;
f[1][14] = 0;
f[1][15] = 0;
f[1][16] = 0;
f[1][17] = 1;
f[1][18] = 0;
f[1][19] = 1;
f[1][20] = 0;
f[1][21] = 1;
f[1][22] = 1;
f[1][23] = 0;
f[1][24] = 0;
f[1][25] = 0;
f[1][26] = 1;
f[1][27] = 0;
f[1][28] = 0;
f[1][29] = 0;
f[1][30] = 0;
f[1][31] = 0;
f[1][32] = 1;
f[2][0] = 1;
f[2][1] = 0;
f[2][2] = 1;
f[2][3] = 1;
f[2][4] = 1;
f[2][5] = 0;
f[2][6] = 1;
f[2][7] = 0;
f[2][8] = 0;
f[2][9] = 1;
f[2][10] = 1;
f[2][11] = 0;
f[2][12] = 1;
f[2][13] = 1;
f[2][14] = 0;
f[2][15] = 0;
f[2][16] = 0;
f[2][17] = 0;
f[2][18] = 0;
f[2][19] = 1;
f[2][20] = 1;
f[2][21] = 0;
f[2][22] = 1;
f[2][23] = 0;
f[2][24] = 0;
f[2][25] = 0;
f[2][26] = 1;
f[2][27] = 0;
f[2][28] = 1;
f[2][29] = 1;
f[2][30] = 1;
f[2][31] = 0;
f[2][32] = 1;
f[3][0] = 1;
f[3][1] = 0;
f[3][2] = 1;
f[3][3] = 1;
f[3][4] = 1;
f[3][5] = 0;
f[3][6] = 1;
f[3][7] = 0;
f[3][8] = 1;
f[3][9] = 0;
f[3][10] = 1;
f[3][11] = 1;
f[3][12] = 0;
f[3][13] = 0;
f[3][14] = 1;
f[3][15] = 0;
f[3][16] = 0;
f[3][17] = 1;
f[3][18] = 1;
f[3][19] = 1;
f[3][20] = 1;
f[3][21] = 1;
f[3][22] = 0;
f[3][23] = 1;
f[3][24] = 0;
f[3][25] = 0;
f[3][26] = 1;
f[3][27] = 0;
f[3][28] = 1;
f[3][29] = 1;
f[3][30] = 1;
f[3][31] = 0;
f[3][32] = 1;
f[4][0] = 1;
f[4][1] = 0;
f[4][2] = 1;
f[4][3] = 1;
f[4][4] = 1;
f[4][5] = 0;
f[4][6] = 1;
f[4][7] = 0;
f[4][8] = 1;
f[4][9] = 1;
f[4][10] = 0;
f[4][11] = 0;
f[4][12] = 0;
f[4][13] = 1;
f[4][14] = 1;
f[4][15] = 0;
f[4][16] = 0;
f[4][17] = 0;
f[4][18] = 1;
f[4][19] = 1;
f[4][20] = 1;
f[4][21] = 1;
f[4][22] = 0;
f[4][23] = 0;
f[4][24] = 1;
f[4][25] = 0;
f[4][26] = 1;
f[4][27] = 0;
f[4][28] = 1;
f[4][29] = 1;
f[4][30] = 1;
f[4][31] = 0;
f[4][32] = 1;
f[5][0] = 1;
f[5][1] = 0;
f[5][2] = 0;
f[5][3] = 0;
f[5][4] = 0;
f[5][5] = 0;
f[5][6] = 1;
f[5][7] = 0;
f[5][8] = 1;
f[5][9] = 0;
f[5][10] = 1;
f[5][11] = 0;
f[5][12] = 1;
f[5][13] = 0;
f[5][14] = 1;
f[5][15] = 0;
f[5][16] = 1;
f[5][17] = 1;
f[5][18] = 0;
f[5][19] = 1;
f[5][20] = 0;
f[5][21] = 0;
f[5][22] = 0;
f[5][23] = 0;
f[5][24] = 1;
f[5][25] = 0;
f[5][26] = 1;
f[5][27] = 0;
f[5][28] = 0;
f[5][29] = 0;
f[5][30] = 0;
f[5][31] = 0;
f[5][32] = 1;
f[6][0] = 1;
f[6][1] = 1;
f[6][2] = 1;
f[6][3] = 1;
f[6][4] = 1;
f[6][5] = 1;
f[6][6] = 1;
f[6][7] = 0;
f[6][8] = 1;
f[6][9] = 0;
f[6][10] = 1;
f[6][11] = 0;
f[6][12] = 1;
f[6][13] = 0;
f[6][14] = 1;
f[6][15] = 0;
f[6][16] = 1;
f[6][17] = 0;
f[6][18] = 1;
f[6][19] = 0;
f[6][20] = 1;
f[6][21] = 0;
f[6][22] = 1;
f[6][23] = 0;
f[6][24] = 1;
f[6][25] = 0;
f[6][26] = 1;
f[6][27] = 1;
f[6][28] = 1;
f[6][29] = 1;
f[6][30] = 1;
f[6][31] = 1;
f[6][32] = 1;
f[7][0] = 0;
f[7][1] = 0;
f[7][2] = 0;
f[7][3] = 0;
f[7][4] = 0;
f[7][5] = 0;
f[7][6] = 0;
f[7][7] = 0;
f[7][8] = 1;
f[7][9] = 1;
f[7][10] = 1;
f[7][11] = 1;
f[7][12] = 1;
f[7][13] = 0;
f[7][14] = 1;
f[7][15] = 1;
f[7][16] = 1;
f[7][17] = 1;
f[7][18] = 1;
f[7][19] = 0;
f[7][20] = 0;
f[7][21] = 1;
f[7][22] = 1;
f[7][23] = 1;
f[7][24] = 1;
f[7][25] = 0;
f[7][26] = 0;
f[7][27] = 0;
f[7][28] = 0;
f[7][29] = 0;
f[7][30] = 0;
f[7][31] = 0;
f[7][32] = 0;
f[8][0] = 1;
f[8][1] = 0;
f[8][2] = 0;
f[8][3] = 0;
f[8][4] = 1;
f[8][5] = 0;
f[8][6] = 1;
f[8][7] = 1;
f[8][8] = 1;
f[8][9] = 1;
f[8][10] = 0;
f[8][11] = 0;
f[8][12] = 1;
f[8][13] = 0;
f[8][14] = 0;
f[8][15] = 0;
f[8][16] = 0;
f[8][17] = 1;
f[8][18] = 0;
f[8][19] = 1;
f[8][20] = 1;
f[8][21] = 1;
f[8][22] = 1;
f[8][23] = 0;
f[8][24] = 1;
f[8][25] = 1;
f[8][26] = 1;
f[8][27] = 1;
f[8][28] = 1;
f[8][29] = 1;
f[8][30] = 0;
f[8][31] = 0;
f[8][32] = 1;
f[9][0] = 1;
f[9][1] = 1;
f[9][2] = 0;
f[9][3] = 1;
f[9][4] = 1;
f[9][5] = 1;
f[9][6] = 0;
f[9][7] = 0;
f[9][8] = 1;
f[9][9] = 1;
f[9][10] = 1;
f[9][11] = 1;
f[9][12] = 1;
f[9][13] = 1;
f[9][14] = 1;
f[9][15] = 1;
f[9][16] = 0;
f[9][17] = 0;
f[9][18] = 1;
f[9][19] = 0;
f[9][20] = 0;
f[9][21] = 0;
f[9][22] = 0;
f[9][23] = 1;
f[9][24] = 0;
f[9][25] = 0;
f[9][26] = 0;
f[9][27] = 1;
f[9][28] = 0;
f[9][29] = 1;
f[9][30] = 1;
f[9][31] = 0;
f[9][32] = 0;
f[10][0] = 0;
f[10][1] = 1;
f[10][2] = 1;
f[10][3] = 1;
f[10][4] = 0;
f[10][5] = 0;
f[10][6] = 1;
f[10][7] = 1;
f[10][8] = 1;
f[10][9] = 0;
f[10][10] = 1;
f[10][11] = 0;
f[10][12] = 0;
f[10][13] = 0;
f[10][14] = 0;
f[10][15] = 1;
f[10][16] = 0;
f[10][17] = 1;
f[10][18] = 0;
f[10][19] = 0;
f[10][20] = 0;
f[10][21] = 1;
f[10][22] = 1;
f[10][23] = 1;
f[10][24] = 0;
f[10][25] = 1;
f[10][26] = 0;
f[10][27] = 0;
f[10][28] = 0;
f[10][29] = 1;
f[10][30] = 0;
f[10][31] = 1;
f[10][32] = 0;
f[11][0] = 0;
f[11][1] = 1;
f[11][2] = 1;
f[11][3] = 1;
f[11][4] = 1;
f[11][5] = 0;
f[11][6] = 0;
f[11][7] = 0;
f[11][8] = 0;
f[11][9] = 1;
f[11][10] = 1;
f[11][11] = 0;
f[11][12] = 0;
f[11][13] = 0;
f[11][14] = 1;
f[11][15] = 1;
f[11][16] = 1;
f[11][17] = 1;
f[11][18] = 1;
f[11][19] = 1;
f[11][20] = 0;
f[11][21] = 1;
f[11][22] = 0;
f[11][23] = 1;
f[11][24] = 1;
f[11][25] = 0;
f[11][26] = 0;
f[11][27] = 0;
f[11][28] = 0;
f[11][29] = 0;
f[11][30] = 0;
f[11][31] = 1;
f[11][32] = 1;
f[12][0] = 1;
f[12][1] = 1;
f[12][2] = 1;
f[12][3] = 1;
f[12][4] = 1;
f[12][5] = 1;
f[12][6] = 1;
f[12][7] = 1;
f[12][8] = 1;
f[12][9] = 1;
f[12][10] = 1;
f[12][11] = 1;
f[12][12] = 1;
f[12][13] = 1;
f[12][14] = 1;
f[12][15] = 0;
f[12][16] = 0;
f[12][17] = 0;
f[12][18] = 1;
f[12][19] = 1;
f[12][20] = 1;
f[12][21] = 0;
f[12][22] = 0;
f[12][23] = 1;
f[12][24] = 0;
f[12][25] = 0;
f[12][26] = 1;
f[12][27] = 0;
f[12][28] = 1;
f[12][29] = 1;
f[12][30] = 0;
f[12][31] = 0;
f[12][32] = 0;
f[13][0] = 1;
f[13][1] = 1;
f[13][2] = 1;
f[13][3] = 0;
f[13][4] = 0;
f[13][5] = 0;
f[13][6] = 0;
f[13][7] = 1;
f[13][8] = 0;
f[13][9] = 1;
f[13][10] = 1;
f[13][11] = 1;
f[13][12] = 0;
f[13][13] = 1;
f[13][14] = 0;
f[13][15] = 0;
f[13][16] = 1;
f[13][17] = 1;
f[13][18] = 0;
f[13][19] = 1;
f[13][20] = 0;
f[13][21] = 0;
f[13][22] = 1;
f[13][23] = 1;
f[13][24] = 0;
f[13][25] = 1;
f[13][26] = 0;
f[13][27] = 1;
f[13][28] = 0;
f[13][29] = 0;
f[13][30] = 1;
f[13][31] = 0;
f[13][32] = 0;
f[14][0] = 1;
f[14][1] = 0;
f[14][2] = 1;
f[14][3] = 0;
f[14][4] = 1;
f[14][5] = 0;
f[14][6] = 1;
f[14][7] = 0;
f[14][8] = 0;
f[14][9] = 0;
f[14][10] = 1;
f[14][11] = 0;
f[14][12] = 1;
f[14][13] = 1;
f[14][14] = 0;
f[14][15] = 0;
f[14][16] = 1;
f[14][17] = 0;
f[14][18] = 1;
f[14][19] = 1;
f[14][20] = 0;
f[14][21] = 1;
f[14][22] = 0;
f[14][23] = 1;
f[14][24] = 0;
f[14][25] = 1;
f[14][26] = 0;
f[14][27] = 0;
f[14][28] = 0;
f[14][29] = 0;
f[14][30] = 0;
f[14][31] = 1;
f[14][32] = 0;
f[15][0] = 1;
f[15][1] = 0;
f[15][2] = 1;
f[15][3] = 1;
f[15][4] = 0;
f[15][5] = 0;
f[15][6] = 0;
f[15][7] = 0;
f[15][8] = 0;
f[15][9] = 1;
f[15][10] = 0;
f[15][11] = 1;
f[15][12] = 0;
f[15][13] = 1;
f[15][14] = 0;
f[15][15] = 0;
f[15][16] = 0;
f[15][17] = 1;
f[15][18] = 1;
f[15][19] = 1;
f[15][20] = 1;
f[15][21] = 1;
f[15][22] = 0;
f[15][23] = 1;
f[15][24] = 0;
f[15][25] = 0;
f[15][26] = 0;
f[15][27] = 0;
f[15][28] = 0;
f[15][29] = 0;
f[15][30] = 0;
f[15][31] = 0;
f[15][32] = 0;
f[16][0] = 0;
f[16][1] = 0;
f[16][2] = 0;
f[16][3] = 0;
f[16][4] = 1;
f[16][5] = 0;
f[16][6] = 1;
f[16][7] = 0;
f[16][8] = 0;
f[16][9] = 0;
f[16][10] = 1;
f[16][11] = 1;
f[16][12] = 0;
f[16][13] = 0;
f[16][14] = 1;
f[16][15] = 1;
f[16][16] = 0;
f[16][17] = 1;
f[16][18] = 0;
f[16][19] = 0;
f[16][20] = 0;
f[16][21] = 1;
f[16][22] = 1;
f[16][23] = 1;
f[16][24] = 1;
f[16][25] = 0;
f[16][26] = 1;
f[16][27] = 0;
f[16][28] = 1;
f[16][29] = 1;
f[16][30] = 0;
f[16][31] = 1;
f[16][32] = 0;
f[17][0] = 1;
f[17][1] = 0;
f[17][2] = 1;
f[17][3] = 0;
f[17][4] = 0;
f[17][5] = 1;
f[17][6] = 0;
f[17][7] = 0;
f[17][8] = 1;
f[17][9] = 1;
f[17][10] = 1;
f[17][11] = 1;
f[17][12] = 1;
f[17][13] = 0;
f[17][14] = 1;
f[17][15] = 1;
f[17][16] = 1;
f[17][17] = 1;
f[17][18] = 0;
f[17][19] = 0;
f[17][20] = 0;
f[17][21] = 1;
f[17][22] = 0;
f[17][23] = 1;
f[17][24] = 0;
f[17][25] = 1;
f[17][26] = 0;
f[17][27] = 0;
f[17][28] = 0;
f[17][29] = 1;
f[17][30] = 1;
f[17][31] = 1;
f[17][32] = 0;
f[18][0] = 1;
f[18][1] = 0;
f[18][2] = 1;
f[18][3] = 1;
f[18][4] = 0;
f[18][5] = 1;
f[18][6] = 1;
f[18][7] = 1;
f[18][8] = 1;
f[18][9] = 1;
f[18][10] = 1;
f[18][11] = 1;
f[18][12] = 0;
f[18][13] = 0;
f[18][14] = 0;
f[18][15] = 1;
f[18][16] = 0;
f[18][17] = 0;
f[18][18] = 1;
f[18][19] = 0;
f[18][20] = 0;
f[18][21] = 0;
f[18][22] = 0;
f[18][23] = 1;
f[18][24] = 1;
f[18][25] = 1;
f[18][26] = 0;
f[18][27] = 0;
f[18][28] = 0;
f[18][29] = 1;
f[18][30] = 0;
f[18][31] = 0;
f[18][32] = 0;
f[19][0] = 0;
f[19][1] = 0;
f[19][2] = 0;
f[19][3] = 0;
f[19][4] = 1;
f[19][5] = 0;
f[19][6] = 0;
f[19][7] = 1;
f[19][8] = 1;
f[19][9] = 0;
f[19][10] = 0;
f[19][11] = 0;
f[19][12] = 1;
f[19][13] = 0;
f[19][14] = 0;
f[19][15] = 1;
f[19][16] = 1;
f[19][17] = 0;
f[19][18] = 0;
f[19][19] = 0;
f[19][20] = 0;
f[19][21] = 0;
f[19][22] = 1;
f[19][23] = 1;
f[19][24] = 0;
f[19][25] = 1;
f[19][26] = 0;
f[19][27] = 0;
f[19][28] = 0;
f[19][29] = 0;
f[19][30] = 0;
f[19][31] = 1;
f[19][32] = 0;
f[20][0] = 0;
f[20][1] = 0;
f[20][2] = 1;
f[20][3] = 1;
f[20][4] = 0;
f[20][5] = 1;
f[20][6] = 1;
f[20][7] = 0;
f[20][8] = 1;
f[20][9] = 0;
f[20][10] = 0;
f[20][11] = 1;
f[20][12] = 1;
f[20][13] = 0;
f[20][14] = 1;
f[20][15] = 1;
f[20][16] = 1;
f[20][17] = 0;
f[20][18] = 0;
f[20][19] = 1;
f[20][20] = 0;
f[20][21] = 0;
f[20][22] = 1;
f[20][23] = 0;
f[20][24] = 0;
f[20][25] = 1;
f[20][26] = 1;
f[20][27] = 0;
f[20][28] = 1;
f[20][29] = 1;
f[20][30] = 0;
f[20][31] = 0;
f[20][32] = 0;
f[21][0] = 0;
f[21][1] = 1;
f[21][2] = 1;
f[21][3] = 1;
f[21][4] = 0;
f[21][5] = 1;
f[21][6] = 0;
f[21][7] = 1;
f[21][8] = 1;
f[21][9] = 0;
f[21][10] = 1;
f[21][11] = 0;
f[21][12] = 0;
f[21][13] = 0;
f[21][14] = 1;
f[21][15] = 0;
f[21][16] = 0;
f[21][17] = 0;
f[21][18] = 1;
f[21][19] = 1;
f[21][20] = 1;
f[21][21] = 1;
f[21][22] = 0;
f[21][23] = 1;
f[21][24] = 0;
f[21][25] = 1;
f[21][26] = 0;
f[21][27] = 1;
f[21][28] = 0;
f[21][29] = 0;
f[21][30] = 1;
f[21][31] = 1;
f[21][32] = 0;
f[22][0] = 1;
f[22][1] = 1;
f[22][2] = 1;
f[22][3] = 0;
f[22][4] = 1;
f[22][5] = 0;
f[22][6] = 1;
f[22][7] = 0;
f[22][8] = 0;
f[22][9] = 1;
f[22][10] = 1;
f[22][11] = 0;
f[22][12] = 0;
f[22][13] = 1;
f[22][14] = 1;
f[22][15] = 1;
f[22][16] = 0;
f[22][17] = 1;
f[22][18] = 0;
f[22][19] = 0;
f[22][20] = 1;
f[22][21] = 1;
f[22][22] = 0;
f[22][23] = 1;
f[22][24] = 0;
f[22][25] = 0;
f[22][26] = 0;
f[22][27] = 0;
f[22][28] = 0;
f[22][29] = 1;
f[22][30] = 1;
f[22][31] = 1;
f[22][32] = 0;
f[23][0] = 1;
f[23][1] = 1;
f[23][2] = 0;
f[23][3] = 0;
f[23][4] = 0;
f[23][5] = 1;
f[23][6] = 0;
f[23][7] = 1;
f[23][8] = 0;
f[23][9] = 0;
f[23][10] = 1;
f[23][11] = 0;
f[23][12] = 1;
f[23][13] = 0;
f[23][14] = 1;
f[23][15] = 1;
f[23][16] = 1;
f[23][17] = 1;
f[23][18] = 0;
f[23][19] = 0;
f[23][20] = 0;
f[23][21] = 1;
f[23][22] = 0;
f[23][23] = 1;
f[23][24] = 1;
f[23][25] = 1;
f[23][26] = 1;
f[23][27] = 1;
f[23][28] = 1;
f[23][29] = 1;
f[23][30] = 0;
f[23][31] = 0;
f[23][32] = 0;
f[24][0] = 0;
f[24][1] = 0;
f[24][2] = 1;
f[24][3] = 0;
f[24][4] = 0;
f[24][5] = 0;
f[24][6] = 1;
f[24][7] = 1;
f[24][8] = 1;
f[24][9] = 0;
f[24][10] = 1;
f[24][11] = 1;
f[24][12] = 1;
f[24][13] = 0;
f[24][14] = 0;
f[24][15] = 0;
f[24][16] = 0;
f[24][17] = 1;
f[24][18] = 0;
f[24][19] = 1;
f[24][20] = 0;
f[24][21] = 1;
f[24][22] = 1;
f[24][23] = 0;
f[24][24] = 1;
f[24][25] = 1;
f[24][26] = 1;
f[24][27] = 1;
f[24][28] = 1;
f[24][29] = 0;
f[24][30] = 0;
f[24][31] = 0;
f[24][32] = 0;
f[25][0] = 0;
f[25][1] = 0;
f[25][2] = 0;
f[25][3] = 0;
f[25][4] = 0;
f[25][5] = 0;
f[25][6] = 0;
f[25][7] = 0;
f[25][8] = 1;
f[25][9] = 1;
f[25][10] = 1;
f[25][11] = 0;
f[25][12] = 0;
f[25][13] = 1;
f[25][14] = 0;
f[25][15] = 1;
f[25][16] = 1;
f[25][17] = 0;
f[25][18] = 1;
f[25][19] = 0;
f[25][20] = 0;
f[25][21] = 0;
f[25][22] = 1;
f[25][23] = 0;
f[25][24] = 1;
f[25][25] = 0;
f[25][26] = 0;
f[25][27] = 0;
f[25][28] = 1;
f[25][29] = 0;
f[25][30] = 1;
f[25][31] = 1;
f[25][32] = 0;
f[26][0] = 1;
f[26][1] = 1;
f[26][2] = 1;
f[26][3] = 1;
f[26][4] = 1;
f[26][5] = 1;
f[26][6] = 1;
f[26][7] = 0;
f[26][8] = 1;
f[26][9] = 0;
f[26][10] = 0;
f[26][11] = 0;
f[26][12] = 1;
f[26][13] = 0;
f[26][14] = 1;
f[26][15] = 1;
f[26][16] = 1;
f[26][17] = 1;
f[26][18] = 0;
f[26][19] = 0;
f[26][20] = 0;
f[26][21] = 1;
f[26][22] = 1;
f[26][23] = 0;
f[26][24] = 1;
f[26][25] = 0;
f[26][26] = 1;
f[26][27] = 0;
f[26][28] = 1;
f[26][29] = 1;
f[26][30] = 0;
f[26][31] = 1;
f[26][32] = 0;
f[27][0] = 1;
f[27][1] = 0;
f[27][2] = 0;
f[27][3] = 0;
f[27][4] = 0;
f[27][5] = 0;
f[27][6] = 1;
f[27][7] = 0;
f[27][8] = 0;
f[27][9] = 1;
f[27][10] = 1;
f[27][11] = 1;
f[27][12] = 0;
f[27][13] = 1;
f[27][14] = 0;
f[27][15] = 1;
f[27][16] = 0;
f[27][17] = 1;
f[27][18] = 1;
f[27][19] = 1;
f[27][20] = 1;
f[27][21] = 1;
f[27][22] = 0;
f[27][23] = 0;
f[27][24] = 1;
f[27][25] = 0;
f[27][26] = 0;
f[27][27] = 0;
f[27][28] = 1;
f[27][29] = 1;
f[27][30] = 0;
f[27][31] = 1;
f[27][32] = 1;
f[28][0] = 1;
f[28][1] = 0;
f[28][2] = 1;
f[28][3] = 1;
f[28][4] = 1;
f[28][5] = 0;
f[28][6] = 1;
f[28][7] = 0;
f[28][8] = 1;
f[28][9] = 0;
f[28][10] = 0;
f[28][11] = 1;
f[28][12] = 0;
f[28][13] = 1;
f[28][14] = 0;
f[28][15] = 0;
f[28][16] = 0;
f[28][17] = 0;
f[28][18] = 1;
f[28][19] = 0;
f[28][20] = 1;
f[28][21] = 0;
f[28][22] = 0;
f[28][23] = 0;
f[28][24] = 1;
f[28][25] = 1;
f[28][26] = 1;
f[28][27] = 1;
f[28][28] = 1;
f[28][29] = 1;
f[28][30] = 0;
f[28][31] = 0;
f[28][32] = 0;
f[29][0] = 1;
f[29][1] = 0;
f[29][2] = 1;
f[29][3] = 1;
f[29][4] = 1;
f[29][5] = 0;
f[29][6] = 1;
f[29][7] = 0;
f[29][8] = 0;
f[29][9] = 0;
f[29][10] = 1;
f[29][11] = 1;
f[29][12] = 0;
f[29][13] = 1;
f[29][14] = 0;
f[29][15] = 0;
f[29][16] = 1;
f[29][17] = 0;
f[29][18] = 0;
f[29][19] = 1;
f[29][20] = 0;
f[29][21] = 1;
f[29][22] = 1;
f[29][23] = 1;
f[29][24] = 1;
f[29][25] = 1;
f[29][26] = 1;
f[29][27] = 0;
f[29][28] = 1;
f[29][29] = 1;
f[29][30] = 0;
f[29][31] = 1;
f[29][32] = 0;
f[30][0] = 1;
f[30][1] = 0;
f[30][2] = 1;
f[30][3] = 1;
f[30][4] = 1;
f[30][5] = 0;
f[30][6] = 1;
f[30][7] = 0;
f[30][8] = 0;
f[30][9] = 1;
f[30][10] = 0;
f[30][11] = 0;
f[30][12] = 0;
f[30][13] = 1;
f[30][14] = 1;
f[30][15] = 0;
f[30][16] = 1;
f[30][17] = 1;
f[30][18] = 1;
f[30][19] = 1;
f[30][20] = 0;
f[30][21] = 1;
f[30][22] = 1;
f[30][23] = 0;
f[30][24] = 1;
f[30][25] = 0;
f[30][26] = 1;
f[30][27] = 1;
f[30][28] = 1;
f[30][29] = 0;
f[30][30] = 0;
f[30][31] = 0;
f[30][32] = 0;
f[31][0] = 1;
f[31][1] = 0;
f[31][2] = 0;
f[31][3] = 0;
f[31][4] = 0;
f[31][5] = 0;
f[31][6] = 1;
f[31][7] = 0;
f[31][8] = 0;
f[31][9] = 1;
f[31][10] = 1;
f[31][11] = 0;
f[31][12] = 0;
f[31][13] = 1;
f[31][14] = 1;
f[31][15] = 0;
f[31][16] = 0;
f[31][17] = 1;
f[31][18] = 1;
f[31][19] = 1;
f[31][20] = 1;
f[31][21] = 1;
f[31][22] = 0;
f[31][23] = 0;
f[31][24] = 1;
f[31][25] = 1;
f[31][26] = 1;
f[31][27] = 1;
f[31][28] = 0;
f[31][29] = 0;
f[31][30] = 0;
f[31][31] = 0;
f[31][32] = 0;
f[32][0] = 1;
f[32][1] = 1;
f[32][2] = 1;
f[32][3] = 1;
f[32][4] = 1;
f[32][5] = 1;
f[32][6] = 1;
f[32][7] = 0;
f[32][8] = 1;
f[32][9] = 1;
f[32][10] = 0;
f[32][11] = 1;
f[32][12] = 0;
f[32][13] = 0;
f[32][14] = 0;
f[32][15] = 1;
f[32][16] = 0;
f[32][17] = 1;
f[32][18] = 0;
f[32][19] = 0;
f[32][20] = 1;
f[32][21] = 1;
f[32][22] = 0;
f[32][23] = 1;
f[32][24] = 1;
f[32][25] = 1;
f[32][26] = 0;
f[32][27] = 0;
f[32][28] = 1;
f[32][29] = 0;
f[32][30] = 0;
f[32][31] = 0;
f[32][32] = 1;
int a, b;
cin >> a >> b;
cout << f[a][b];
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1000000000ll;
const long long inf64 = inf * inf;
const long long base = inf + 7;
bool solve() {
int n;
scanf("%d", &n);
vector<int> x(n + 1);
for (int i = 1; i <= n; i++) {
scanf("%d", &x[i]);
}
sort(x.begin() + 1, x.end());
int ans = inf + 10;
for (int i = 1; i <= n / 2; i++) ans = min(ans, x[i + n / 2] - x[i]);
printf("%d\n", ans);
return true;
}
int main() {
solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int mn = 210;
const long double zero = 1e-7;
int hp1, dt1, l1, r1, p1, L;
int hp2, dt2, l2, r2, p2, t1, t2;
double f1[mn], f2[mn], ans;
bool atk(double* f, int l, int r, int p) {
int i, j;
double w;
bool res = 0;
for (i = 1; i <= L; ++i) {
if (f[i] < zero) continue;
res = 1;
w = f[i] * (1 - p * 0.01) / (r - l + 1);
f[i] = f[i] * p * 0.01;
for (j = l; j <= r; ++j) f[max(i - j, 0)] += w;
}
return res;
}
int main() {
scanf("%d%d%d%d%d", &hp1, &dt1, &l1, &r1, &p1);
scanf("%d%d%d%d%d", &hp2, &dt2, &l2, &r2, &p2);
if (p1 == 100) {
printf("0\n");
return 0;
}
if (p2 == 100) {
printf("1\n");
return 0;
}
t1 = t2 = 0;
L = max(hp1, hp2);
f1[hp1] = f2[hp2] = 1;
for (;;) {
if (t1 <= t2) {
t1 += dt1;
f2[0] = 0;
atk(f2, l1, r1, p1);
ans += (1 - f1[0]) * f2[0];
} else {
t2 += dt2;
if (!atk(f1, l2, r2, p2)) break;
}
}
printf("%.7lf\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-10;
struct Point {
double x, y;
Point() {}
Point(double _x, double _y) : x(_x), y(_y) {}
Point operator+(const Point &p) { return Point(x + p.x, y + p.y); }
Point operator-(const Point &p) { return Point(x - p.x, y - p.y); }
Point operator*(const double k) { return Point(x * k, y * k); }
double abs() { return sqrt(norm()); }
double norm() { return x * x + y * y; }
bool operator<(const Point &p) const {
return !(fabs((x) - (p.x)) < EPS) ? x < p.x : y < p.y;
}
bool operator==(const Point &p) const {
return (fabs((x) - (p.x)) < EPS) && (fabs((y) - (p.y)) < EPS);
}
};
struct Segment {
Point p1, p2;
Segment() {}
Segment(Point _p1, Point _p2) : p1(_p1), p2(_p2) {}
};
double norm(Point a) { return a.x * a.x + a.y * a.y; }
double abs(Point a) { return sqrt(norm(a)); }
double dot(Point a, Point b) { return a.x * b.x + a.y * b.y; }
double cross(Point a, Point b) { return a.x * b.y - a.y * b.x; }
bool isOrthogonal(Point a, Point b) {
return (fabs((dot(a, b)) - (0.0)) < EPS);
}
bool isOrthogonal(Point a1, Point a2, Point b1, Point b2) {
return isOrthogonal(a1 - a2, b1 - b2);
}
bool isOrthogonal(Segment s1, Segment s2) {
return (fabs((dot(s1.p2 - s1.p1, s2.p2 - s2.p1)) - (0.0)) < EPS);
}
bool isParallel(Point a, Point b) {
return (fabs((cross(a, b)) - (0.0)) < EPS);
}
bool isParallel(Point a1, Point a2, Point b1, Point b2) {
return isParallel(a1 - a2, b1 - b2);
}
bool isParallel(Segment s1, Segment s2) {
return (fabs((cross(s1.p2 - s1.p1, s2.p2 - s2.p1)) - (0.0)) < EPS);
}
Point project(Segment s, Point p) {
Point base = s.p2 - s.p1;
double r = dot(p - s.p1, base) / norm(base);
return s.p1 + base * r;
}
Point reflect(Segment s, Point p) { return p + (project(s, p) - p) * 2.0; }
double getDistance(Point a, Point b) { return abs(a - b); }
double getDistanceLP(Segment l, Point p) {
return abs(cross(l.p2 - l.p1, p - l.p1) / abs(l.p2 - l.p1));
}
double getDistanceSP(Segment s, Point p) {
if (dot(s.p2 - s.p1, p - s.p1) < 0.0) return abs(p - s.p1);
if (dot(s.p1 - s.p1, p - s.p2) < 0.0) return abs(p - s.p2);
return getDistanceLP(s, p);
}
int n;
double x, y;
vector<Point> v;
void solve() {
if (v.size() <= 3) {
printf("YES\n");
return;
}
Point v1 = v[0];
Point v2 = v[1];
Point v3 = v[2];
Segment l1 = Segment(v1, v2);
Segment l2 = Segment(v1, v3);
Segment l3 = Segment(v2, v3);
if ((fabs((getDistanceLP(l1, v3)) - (0.0)) < EPS)) {
bool flag = true;
for (int i = 3; i < v.size(); i++) {
if (!(fabs((getDistanceLP(l1, v[i])) - (0.0)) < EPS)) {
flag = false;
break;
}
}
if (flag) {
printf("YES\n");
return;
}
}
vector<Point> tmp;
for (int i = 0; i < v.size(); i++) {
if (!(fabs((getDistanceLP(l1, v[i])) - (0.0)) < EPS)) {
tmp.push_back(v[i]);
}
}
if (tmp.size() <= 2) {
printf("YES\n");
return;
} else {
Point p1 = tmp[0];
Point p2 = tmp[1];
Segment l2 = Segment(p1, p2);
bool flag = true;
for (int i = 0; i < tmp.size(); i++) {
if (!(fabs((getDistanceLP(l2, tmp[i])) - (0.0)) < EPS)) {
flag = false;
break;
}
}
if (flag) {
printf("YES\n");
return;
}
}
tmp.clear();
for (int i = 0; i < v.size(); i++) {
if (!(fabs((getDistanceLP(l2, v[i])) - (0.0)) < EPS)) {
tmp.push_back(v[i]);
}
}
if (tmp.size() <= 2) {
printf("YES\n");
return;
} else {
Point p1 = tmp[0];
Point p2 = tmp[1];
Segment l2 = Segment(p1, p2);
bool flag = true;
for (int i = 0; i < tmp.size(); i++) {
if (!(fabs((getDistanceLP(l2, tmp[i])) - (0.0)) < EPS)) {
flag = false;
break;
}
}
if (flag) {
printf("YES\n");
return;
}
}
tmp.clear();
for (int i = 0; i < v.size(); i++) {
if (!(fabs((getDistanceLP(l3, v[i])) - (0.0)) < EPS)) {
tmp.push_back(v[i]);
}
}
if (tmp.size() <= 2) {
printf("YES\n");
return;
} else {
Point p1 = tmp[0];
Point p2 = tmp[1];
Segment l2 = Segment(p1, p2);
bool flag = true;
for (int i = 0; i < tmp.size(); i++) {
if (!(fabs((getDistanceLP(l2, tmp[i])) - (0.0)) < EPS)) {
flag = false;
break;
}
}
if (flag) {
printf("YES\n");
return;
}
}
printf("NO\n");
}
int main() {
while (~scanf("%d", &n)) {
v.clear();
for (int i = 0; i < n; i++) {
scanf("%lf %lf", &x, &y);
v.push_back(Point(x, y));
}
solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1111;
const int INF = 1000 * 1000 * 1000;
int dx[] = {0, 0, -1, 1};
int dy[] = {-1, 1, 0, 0};
string s[N];
int d[N][N];
queue<pair<int, int> > q;
int n, m;
bool good(int i, int j) {
if (i < 0 || i >= n || j < 0 || j >= m) return false;
return s[i][j] != 'T';
}
int func(int i, int j) {
if (s[i][j] <= '9' && s[i][j] >= '0')
return s[i][j] - '0';
else
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> s[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) d[i][j] = INF;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (s[i][j] == 'E') {
d[i][j] = 0;
q.push(pair<int, int>(i, j));
}
while (!q.empty()) {
int x = q.front().first;
int y = q.front().second;
q.pop();
for (int rep = 0; rep < 4; rep++) {
int xx = x + dx[rep];
int yy = y + dy[rep];
if (good(xx, yy) && d[xx][yy] > d[x][y] + 1) {
d[xx][yy] = d[x][y] + 1;
q.push(pair<int, int>(xx, yy));
}
}
}
int dist = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (s[i][j] == 'S') dist = d[i][j];
int res = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (d[i][j] <= dist) res += func(i, j);
cout << res;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int p[105];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b, c;
cin >> a >> b >> c;
p[a] += c;
p[b] -= c;
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (p[i] > 0) ans += p[i];
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
char s[4000006];
cin >> (s);
int l = strlen(s);
int inc = (l - 1) / n;
for (int i = 0; i < l; i++) {
if (i + 2 < l - 1) {
if (i % n == n - 3) {
if (s[i] != s[i + 1] || s[i + 1] != s[i + 2]) {
inc--;
}
}
}
}
cout << inc << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
signed main(void) {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
long long int t = 1;
cin >> t;
while (t--) {
long long int n;
cin >> n;
vector<long long int> h(n);
long long int cnt = 0;
for (long long int i = 0; i < n; i++) {
cin >> h[i];
}
long long int mx = h[0];
for (long long int i = 1; i < n; i++) {
if (h[i] < h[i - 1]) cnt += h[i - 1] - h[i];
}
cout << cnt << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long x, y, z, t1, t2, t3;
cin >> x >> y >> z >> t1 >> t2 >> t3;
long long d1 = abs(x - y);
long long ans1 = d1 * t1;
long long ans2 = abs(x - z) * t2 + 2 * t3 + abs(x - y) * t2 + t3;
if (ans1 >= ans2) {
cout << "YES\n";
} else {
cout << "NO\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 100;
struct node {
int id;
long long x, y;
} data[maxn];
int ans[maxn];
int main() {
srand(time(NULL));
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
cin >> data[i].x >> data[i].y;
data[i].id = i;
}
while (true) {
long long tmp = 0, t1, t2;
long long prex = data[1].x, prey = data[1].y;
ans[data[1].id] = 1;
for (int i = 2; i <= n; i++) {
long long tx1 = prex - data[i].x;
long long ty1 = prey - data[i].y;
t1 = tx1 * tx1 + ty1 * ty1;
long long tx2 = data[i].x + prex;
long long ty2 = data[i].y + prey;
t2 = tx2 * tx2 + ty2 * ty2;
if (t1 < t2) {
ans[data[i].id] = -1;
prex = tx1;
prey = ty1;
} else {
ans[data[i].id] = 1;
prex = tx2;
prey = ty2;
}
}
if (min(t1, t2) <= 2250000000000LL) {
break;
} else {
random_shuffle(data + 1, data + n + 1);
}
}
for (int i = 1; i <= n; i++) printf("%d%c", ans[i], i == n ? '\n' : ' ');
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long int countSetBits(long long int n) {
if (n == 0)
return 0;
else
return (n & 1) + countSetBits(n >> 1);
}
int main() {
long long int s, x;
cin >> s >> x;
if (x > s || (s - x) % 2) {
cout << 0 << "\n";
return 0;
}
if ((s - x) / 2 & x) {
cout << 0 << "\n";
return 0;
}
long long int one = countSetBits(x);
long long int way = pow(2, one);
if (s == x) way -= 2;
cout << way << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, f;
string a;
cin >> n >> k;
vector<string> names(n);
for (int i = 0; i < n; ++i) {
names[i].push_back(rand() % 25 + 65);
f = rand() % 9 + 1;
for (int j = 0; j < f; ++j) names[i].push_back(rand() % 25 + 97);
}
for (int i = 0; i < n - k + 1; ++i) {
cin >> a;
if (a == "NO") names[i + k - 1] = names[i];
}
for (int i = 0; i < n; ++i) cout << names[i] << " ";
return 0;
}
| 3 |
#include <bits/stdc++.h>
bool local = false;
using namespace std;
template <class T>
void print(T v) {
cout << ((int)(v).size()) << "\n";
for (auto x : v) cout << x << ' ';
cout << "\n";
};
template <class T>
void print1(T v) {
cout << ((int)(v).size()) << "\n";
for (auto x : v) cout << x + 1 << ' ';
cout << "\n";
};
template <class T1, class T2>
ostream &operator<<(ostream &o, pair<T1, T2> x) {
return o << x.first << ' ' << x.second;
}
template <class T1, class T2>
istream &operator>>(istream &o, pair<T1, T2> &x) {
return o >> x.first >> x.second;
}
template <class T>
ostream &operator<<(ostream &o, vector<T> &x) {
for (auto &el : x) o << el << ' ';
return o;
}
template <class T>
istream &operator>>(istream &o, vector<T> &x) {
for (auto &el : x) o >> el;
return o;
}
template <class T1, class T2>
pair<T1, T2> operator+(pair<T1, T2> a, pair<T1, T2> b) {
a.first += b.first;
a.second += b.second;
return a;
}
template <class T1, class T2>
pair<T1, T2> operator-(pair<T1, T2> a, pair<T1, T2> b) {
a.first -= b.first;
a.second -= b.second;
return a;
}
template <class T1, class T2>
void operator+=(pair<T1, T2> &a, pair<T1, T2> b) {
a.first += b.first;
a.second += b.second;
}
template <class T1, class T2>
void operator-=(pair<T1, T2> &a, pair<T1, T2> b) {
a.first -= b.first;
a.second -= b.second;
}
int nint() {
int x;
cin >> x;
return x;
}
double getTime() { return clock() / (double)CLOCKS_PER_SEC; };
mt19937 rnd(0);
int rand(int n) { return rnd() % n; }
int rand(int l, int r) { return rnd() % (r - l + 1) + l; }
const int mod = 1000000000 + 7;
void initIO() {
if (local) {
freopen("input.txt", "r", stdin);
srand((int)time(0));
rnd.seed((int)time(0));
} else {
{
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
};
}
}
void solve();
void precalc();
int TID;
signed main() {
initIO();
int tc = 1;
precalc();
for (int tt = 0; tt < (tc); tt++) {
TID = tt;
solve();
}
if (local)
cout << "\n"
<< "time = " << getTime() << "\n";
}
void precalc() {}
int n;
int m;
int a[200500];
int last[200500];
int getans(int l, int r) {
map<int, int> m;
for (int i = l; i <= r; i++) m[a[i]]++;
int ans = 0;
for (pair<int, int> o : m) ans = max(ans, o.second);
return r - l + 1 - ans;
}
void solve() {
cin >> n >> m;
for (int i = 0; i < (n); i++) {
cin >> a[i];
last[a[i]] = i;
}
int l = 0, r = last[a[0]];
int ans = 0;
for (int i = 0; i < (n); i++) {
r = max(r, last[a[i]]);
if (r == i) {
ans += getans(l, r);
l = i + 1;
}
}
cout << ans << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long t, n, x, y, l, r;
char a[200000 + 5];
map<long long, long long> Map;
long long read() {
char c;
long long x = 0, f = 1;
c = getchar();
while (c > '9' || c < '0') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 3) + (x << 1) + c - '0';
c = getchar();
}
return x * f;
}
long long Mul(long long a, long long b) { return 1ll * a * b % 1000000007; }
long long Inc(long long a, long long b) {
return (a += b) >= 1000000007 ? a - 1000000007 : a;
}
long long Dec(long long a, long long b) {
return (a -= b) < 0 ? a + 1000000007 : a;
}
long long c(long long a, long long b) { return a * 2000000 + b; }
signed main() {
t = read();
while (t--) {
n = read();
scanf("%s", a + 1);
x = 0, y = 0;
l = 0, r = n + 1;
Map.clear();
Map[c(0, 0)] = 1;
for (register long long i = 1; i <= n; ++i) {
if (a[i] == 'L') x--;
if (a[i] == 'R') x++;
if (a[i] == 'U') y++;
if (a[i] == 'D') y--;
if (Map[c(x, y)] && i - Map[c(x, y)] + 1 < r - l + 1)
l = Map[c(x, y)], r = i;
Map[c(x, y)] = i + 1;
}
if (l == 0)
puts("-1");
else
printf("%lld %lld\n", l, r);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int ans;
int val;
int operate = 1;
string s;
int main() {
cin >> s;
for (char c : s) {
if (c == '+' || c == '-') {
ans += val * operate;
operate = (c == '+') ? 1 : -1;
val = 0;
}
val = val * 10 + (c - '0');
}
ans += val * operate;
printf("%d", ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
srand(time(NULL));
int n, i, j;
cin >> n;
vector<int> v(n);
for (i = 0; i < n; i++) {
cin >> v[i];
}
for (i = 0; i < n; i++) {
long long sum = 0;
for (j = 0; j < v[i]; j++) {
int a;
cin >> a;
sum += 15 + (a * 5);
}
v[i] = sum;
}
sort(v.begin(), v.end());
cout << v.front() << "\n";
}
| 0 |
#include <bits/stdc++.h>
using std::cerr;
using std::cin;
using std::cout;
bool MEMST;
const long long N = 5e6 + 5;
long long n, P, f[N], g[N], sum[N];
bool MEMED;
signed main() {
std::ios::sync_with_stdio(false), std::cin.tie(nullptr);
cin >> n >> P;
f[1] = 1;
for (long long i = 1; i <= n; ++i) {
g[i] = (g[i] + g[i - 1]) % P;
f[i] = (f[i] + g[i] + sum[i - 1]) % P;
for (long long j = 2; i * j <= n; ++j) {
g[i * j] = (g[i * j] + f[i]) % P;
if (1ll * i * j + j <= n) g[i * j + j] = (g[i * j + j] - f[i] + P) % P;
}
sum[i] = (sum[i - 1] + f[i]) % P;
}
cout << f[n] << '\n';
cout.flush();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, k;
int main() {
cin >> n >> k;
long long a[n + 1], dp[n + 1], ans;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
sort(a + 1, a + n + 1);
long long l = 0, r = 1e9, mid;
while (r - l >= 0) {
memset(dp, 0, sizeof(dp));
for (int i = 0; i < k; i++) {
dp[i] = 1;
}
mid = (r + l) / 2;
if (a[k] - a[1] <= mid)
dp[k] = 2;
else
dp[k] = 1;
for (int i = k + 1; i <= n; i++) {
if (a[i] - a[i - k + 1] <= mid) {
long long le = 1, ri = i - k + 1, t, mi;
while (ri - le >= 0) {
t = (ri + le) / 2;
if (a[i] - a[t] <= mid) {
mi = t;
ri = t - 1;
} else
le = t + 1;
}
if (dp[i - k] - (mi > 1 ? dp[mi - 2] : 0) >= 1)
dp[i] = dp[i - 1] + 1;
else
dp[i] = dp[i - 1];
} else
dp[i] = dp[i - 1];
}
if (dp[n] - dp[n - 1] >= 1) {
ans = mid;
r = mid - 1;
} else
l = mid + 1;
}
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int t[3000050], len, st, n, m, p, a[3000050], ans, f[3000050];
bool b[3000050];
bool Is_Prime(int x) {
for (int i = 2; i * i <= x; i++)
if (x % i == 0) return 0;
return 1;
}
void DFS(int x, int y) {
if (!y) {
t[++len] = x;
return;
}
DFS(x, y - 1);
for (int i = x; i <= m / a[y]; i *= a[y]) DFS(i * a[y], y - 1);
}
int main() {
cin >> n >> m >> p;
for (int i = 2; i <= p; i++)
if (Is_Prime(i)) a[++st] = i;
DFS(1, st);
sort(t + 1, t + len + 1);
memset(f, 127, sizeof(f));
f[1] = 0;
b[1] = 1;
for (int i = 2; i <= p; i++) {
for (int j = i, k = 1; j <= len; j++) {
while (t[k] * i < t[j]) k++;
if (t[k] * i == t[j] && f[j] > f[k] + 1 && i + f[k] + 1 <= p)
f[j] = f[k] + 1, b[j] = 1;
}
}
for (int i = 2; i <= len; i++)
if (t[i] >= n && t[i] <= m && b[i]) ans++;
cout << ans << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<pair<double, double> > V;
set<pair<double, double> > S;
for (int i = 0; i < n; i++) {
double x, y;
cin >> x >> y;
V.push_back(make_pair(x, y));
S.insert(make_pair(x, y));
}
int f = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (S.count(make_pair((V[i].first + V[j].first) / 2,
(V[i].second + V[j].second) / 2))) {
f++;
}
}
}
cout << f;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int cnt = 0;
int r = 0;
int n;
int k;
cin >> n >> k;
string sr;
int r1 = 0;
for (; n != 0; n--) {
vector<int> arr(k + 1);
r1++;
cin >> sr;
int i = 0;
for (i = 0; sr[i] != '\0'; i++) {
if (sr[i] - '0' <= k) {
arr[sr[i] - '0']++;
}
}
for (i = 0; i <= k; i++) {
if (arr[i] == 0) {
r++;
break;
}
}
if (r == 0) {
cnt++;
}
r = 0;
}
cout << cnt << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[1000006];
int n, m;
bool used[1000006];
map<pair<int, int>, int> got;
void go(int x) {
if (used[x]) return;
used[x] = 1;
int i;
for (i = 0; i < adj[x].size(); i++) go(adj[x][i]);
}
int main() {
cin >> n >> m;
int i, j;
for (i = 0; i < m; i++) {
int x, y;
scanf("%d %d", &x, &y);
adj[x].push_back(y);
if (x != y) adj[y].push_back(x);
}
bool ok2 = 1;
for (i = 1; i <= n; i++) {
if (adj[i].size() && ok2) {
go(i);
ok2 = 0;
} else if (adj[i].size() && !used[i]) {
cout << 0 << endl;
return 0;
}
}
long long ans = 0;
long long sl = 0;
for (i = 1; i <= n; i++) {
long long okk = 0, nonok = 0;
for (j = 0; j < adj[i].size(); j++) {
if (adj[i][j] == i)
nonok++;
else
okk++;
}
ans += (okk * (okk - 1) / 2);
sl += nonok;
}
ans += sl * (sl - 1) / 2;
ans += sl * (m - sl);
cout << ans << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long s, x;
cin >> s >> x;
if ((s - x) & 1 || s - x < 0) {
cout << "0" << endl;
return 0;
}
long long k = (s - x) >> 1;
long long tmp = x;
long long cnt = 0;
while (tmp) {
cnt++;
tmp = tmp >> 1;
}
long long ans = 1;
for (long long i = 0; i < cnt; i++) {
long long a = (x >> i) & 1;
long long b = (k >> i) & 1;
if (a == 1) {
if (b == 0)
ans *= 2;
else {
ans = 0;
break;
}
}
}
if (!k) ans -= 2;
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
constexpr int N = 200003;
int n, m, len, num[N << 1], nxt[N << 1];
char s1[N], s2[N], S[N << 1];
void mg() {
memcpy(S + 1, s2 + 1, m), S[m + 1] = '$';
memcpy(S + 2 + m, s1 + 1, n);
len = n + m + 1;
}
void getnxt(char s[], int n) {
nxt[1] = 0;
for (int i = 2; i <= n; i++) {
int j = nxt[i - 1];
while (j && s[j + 1] != s[i]) j = nxt[j];
if (s[j + 1] == s[i])
nxt[i] = j + 1;
else
nxt[i] = 0;
}
}
std::vector<int> G[N << 1];
void dfs(int u) {
if (u >= m + 2) num[u] = 1;
for (int i = 0; i < G[u].size(); ++i) {
int v = G[u][i];
dfs(v);
num[u] += num[v];
}
}
void getnum() {
for (int i = 1; i <= len; ++i) G[nxt[i]].push_back(i);
dfs(0);
}
long long cal() {
long long ans = 1ll * n * m;
for (int i = 1; i <= m; ++i) {
if (S[i] == S[i + m + 1])
--num[i];
else
break;
}
for (int p, i = 1; i <= m; ++i)
if (nxt[i]) {
p = i - nxt[i];
ans -= num[p];
}
return ans;
}
int main() {
scanf(" %s", s1 + 1);
n = strlen(s1 + 1);
scanf(" %s", s2 + 1);
m = strlen(s2 + 1);
mg();
getnxt(S, len);
getnum();
printf("%lld\n", cal());
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::duration_cast<chrono::nanoseconds>(
chrono::high_resolution_clock::now().time_since_epoch())
.count());
const long int N = 1000005;
const long int LG = 22;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long int n, m;
cin >> n >> m;
long int a[n];
for (long int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
multiset<long int> s;
for (long int i = 0; i < n; i++) s.insert(a[i]);
long int x = m;
while (x--) {
auto it = s.begin();
long int val = *it;
val++;
s.erase(it);
s.insert(val);
}
cout << *s.rbegin() << ' ' << a[n - 1] + m << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
const long long mod = 1e6 + 3;
long long qpow(long long x, long long y) {
long long ret = 1;
while (y) {
if (y & 1) ret = ret * x % mod;
x = x * x % mod;
y >>= 1;
}
return ret;
}
int main() {
long long n, k;
scanf("%I64d%I64d", &n, &k);
if (n <= 62 && k > 1ll << n) {
printf("1 1\n");
return 0;
}
long long num = 0;
for (long long i = k - 1; i; i >>= 1) {
num += i / 2;
}
long long b = 1, a = qpow(2, n);
for (long long i = 1; i <= k - 1; ++i) {
long long tmp = (a - i + mod) % mod;
b = b * tmp % mod;
if (tmp == 0) break;
}
long long inv = qpow(qpow(2, num), mod - 2);
a = qpow(a, k - 1);
a = a * inv % mod;
b = b * inv % mod;
b = (a - b + mod) % mod;
printf("%I64d %I64d\n", b, a);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long modn = 1000000007;
inline long long mod(long long x) { return x % modn; }
template <class num>
inline void rd(num &x) {
char c;
while (isspace(c = getchar()))
;
bool neg = false;
if (!isdigit(c))
neg = (c == '-'), x = 0;
else
x = c - '0';
while (isdigit(c = getchar())) x = (x << 3) + (x << 1) + c - '0';
if (neg) x = -x;
}
int n;
const int N = 212345;
int S[N], sz[N], mrk[N];
int find(int i) {
if (S[S[i]] != S[i]) S[i] = find(S[i]);
return S[i];
}
void join(int a, int b) {
if ((a = find(a)) == (b = find(b))) return;
if (sz[a] < sz[b]) swap(a, b);
S[b] = a;
sz[a] += sz[b];
mrk[a] |= mrk[b];
}
int a[N], b[N], w[N], p[N];
int main() {
int i, j, m;
rd(n);
rd(m);
for (i = 0; i < m; i++) {
scanf("%d %d %d", &a[i], &b[i], &w[i]);
a[i]--;
b[i]--;
p[i] = i;
}
for (i = 0; i < n; i++) S[i] = i, sz[i] = 1;
sort(p, p + m, [](int i, int j) { return w[i] > w[j]; });
int tot = 0;
for (i = 0; i < m; i++) {
int a = ::a[p[i]], b = ::b[p[i]];
a = find(a);
b = find(b);
if (a == b && mrk[a]) continue;
if (a == b) {
mrk[a] = 1;
tot += w[p[i]];
continue;
}
if (mrk[a] && mrk[b]) continue;
tot += w[p[i]];
join(a, b);
}
printf("%d\n", tot);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500003;
int n, a[maxn], f[20][maxn], g[20][maxn], Log[maxn];
long long ans = 0;
int get() {
int f = 0, v = 0;
char ch;
while (!isdigit(ch = getchar()))
if (ch == '-') break;
if (ch == '-')
f = 1;
else
v = ch - 48;
while (isdigit(ch = getchar())) v = v * 10 + ch - 48;
if (f == 1)
return -v;
else
return v;
}
int main() {
n = get();
Log[0] = -1;
for (int i = 1; i <= n; i++) a[i] = a[i + n] = -get();
for (int i = 1; i <= 2 * n; i++)
a[i] += i, f[0][i] = i, Log[i] = Log[i / 2] + 1;
f[0][2 * n] = 0;
a[2 * n] = n * 2;
for (int i = 1; i <= Log[2 * n]; i++)
for (int j = 1; j + (1 << i) <= 2 * n; j++) {
int x = f[i - 1][j], y = f[i - 1][j + (1 << i - 1)];
if (a[x] < a[y])
f[i][j] = x;
else
f[i][j] = y;
}
for (int i = 1; i < 2 * n; i++) {
if (a[i] <= 0) {
g[0][i] = 0;
continue;
}
int x = a[i], y = i - 1, tp = Log[y - x + 1];
x = f[tp][x], y = f[tp][y - (1 << tp) + 1];
if (a[x] < a[y])
g[0][i] = x;
else
g[0][i] = y;
}
for (int i = 1; i <= Log[2 * n]; i++)
for (int j = 1; j < 2 * n; j++) g[i][j] = g[i - 1][g[i - 1][j]];
for (int i = n; i < 2 * n; i++) {
ans += 1 + (a[i] > i - n + 1);
for (int x = i, j = Log[2 * n]; j >= 0; j--)
if (a[g[j][x]] > i - n + 1) x = g[j][x], ans += 1 << j;
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
scanf("%d", &t);
while (t-- > 0) {
string a;
cin >> a;
string b = "";
if (a.length() <= 2) {
cout << a << endl;
continue;
}
for (int i = 0; i < a.length(); i = i + 2) b += a[i];
b = b + a[a.length() - 1];
cout << b << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> v[3005];
long long par[3005];
long long n;
long long dp[3005][3005];
long long M = 1e9 + 7;
long long power(long long a, long long b, long long mod) {
long long x = 1, y = a;
while (b > 0) {
if (b % 2) {
x = (x * y) % mod;
}
y = (y * y) % mod;
b /= 2;
}
return x % mod;
}
long long modular_inverse(long long n, long long mod) {
return power(n, mod - 2, mod);
}
void dfs(long long x) {
long long a, b, c, d, i, j, k;
for (i = 1; i <= n + 1; i++) dp[x][i] = 1;
for (i = 0; i < v[x].size(); i++) {
a = v[x][i];
dfs(a);
for (j = 1; j <= n + 1; j++) {
dp[x][j] *= dp[a][j];
dp[x][j] %= M;
}
}
for (i = 2; i <= n + 1; i++) dp[x][i] += dp[x][i - 1], dp[x][i] %= M;
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout << setprecision(25);
long long a, b, c, d, e, f, i, j, k;
long long D;
cin >> n >> D;
for (i = 2; i <= n; i++) {
cin >> par[i];
v[par[i]].push_back(i);
}
dfs(1);
dp[1][0] = 0;
long long ans = 0;
for (i = 0; i <= n + 1; i++) {
long long num = 1, den = 1;
for (j = 0; j <= n + 1; j++) {
if (i == j) continue;
num = (num * (D - j + M)) % M;
den = (den * (M + i - j)) % M;
}
num = (num * dp[1][i]) % M;
num = (num * modular_inverse(den, M)) % M;
ans = (ans + num) % M;
}
cout << ans << "\n";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <typename... T>
void scan(T &...args) {
((cin >> args), ...);
}
template <typename... T>
void print(T... args) {
((cout << args), ...);
}
class Solution_To_Problem {
int r, g, b, m, ans;
array<int, 3> count;
public:
void solution_function() {
scan(r, g, b);
count[0] = ceil(b / 2.0);
count[1] = ceil(g / 2.0);
count[2] = ceil(r / 2.0);
m = INT_MIN;
for (int i = 0; i < 3; i++) {
if (count[i] > m) {
m = count[i];
ans = 30 + (3 - i - 1) + (m - 1) * 3;
}
}
print(ans, '\n');
}
} Solution;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
Solution.solution_function();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
void Max(T1 &a, T2 b) {
a = max(a, (T1)b);
}
template <typename T1, typename T2>
void Min(T1 &a, T2 b) {
a = min(a, (T1)b);
}
template <int MOD>
struct ModInt {
unsigned x;
ModInt() : x(0) {}
ModInt(signed sig) : x(sig) {}
ModInt(signed long long sig) : x(sig % MOD) {}
int get() const { return (int)x; }
ModInt power(unsigned p) {
ModInt res = 1, a = *this;
while (p) {
if (p & 1) res *= a;
a *= a;
p >>= 1;
}
return res;
}
ModInt &operator+=(ModInt that) {
if ((x += that.x) >= MOD) x -= MOD;
return *this;
}
ModInt &operator-=(ModInt that) {
if ((x += MOD - that.x) >= MOD) x -= MOD;
return *this;
}
ModInt &operator*=(ModInt that) {
x = (unsigned long long)x * that.x % MOD;
return *this;
}
ModInt &operator/=(ModInt that) { return (*this) *= that.power(MOD - 2); }
ModInt operator+(ModInt that) const { return ModInt(*this) += that; }
ModInt operator-(ModInt that) const { return ModInt(*this) -= that; }
ModInt operator*(ModInt that) const { return ModInt(*this) *= that; }
ModInt operator/(ModInt that) const { return ModInt(*this) /= that; }
};
const int N = 200;
void solve() {
long long n, x;
cin >> n;
priority_queue<long long, vector<long long>, greater<long long>> q;
n <<= 1;
long long ans = 0;
long long last_change = 0;
while (n--) {
string op;
cin >> op;
if (op == "add") {
cin >> x;
if (!q.empty() && q.top() <= x) last_change = q.size() + 1;
q.push(x);
} else {
if (q.size() == last_change) {
ans++;
last_change = 0;
}
q.pop();
}
}
cout << ans << '\n';
}
void init() {}
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.setf(ios::fixed);
cout.precision(20);
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, sx, sy, x, y;
cin >> n >> sx >> sy;
vector<pair<long long int, long long int> > vp;
for (int i = 0; i < n; i++) {
cin >> x >> y;
vp.push_back(make_pair(x, y));
}
long long int r1 = 0, r2 = 0, r3 = 0, r4 = 0;
for (int i = 0; i < n; i++) {
if (vp[i].first < sx && vp[i].second < sy) r1++;
if (vp[i].first < sx && vp[i].second > sy) r2++;
if (vp[i].first > sx && vp[i].second < sy) r3++;
if (vp[i].first > sx && vp[i].second > sy) r4++;
}
long long int x1 = 0, x2 = 0, y1 = 0, y2 = 0;
for (int i = 0; i < n; i++) {
if (vp[i].first < sx && vp[i].second == sy) x1++;
if (vp[i].first > sx && vp[i].second == sy) x2++;
if (vp[i].second < sy && vp[i].first == sx) y1++;
if (vp[i].second > sy && vp[i].first == sx) y2++;
}
if (r1 + r2 + x1 >= max(max(r2 + r4 + y2, r3 + r4 + x2), r3 + r1 + y1)) {
cout << r1 + r2 + x1 << endl;
cout << sx - 1 << " " << sy << endl;
} else if (r4 + r2 + y2 >=
max(max(r2 + r1 + x1, r3 + r4 + x2), r3 + r1 + y1)) {
cout << r4 + r2 + y2 << endl;
cout << sx << " " << sy + 1 << endl;
} else if (r3 + r4 + x2 >=
max(max(r2 + r4 + y2, r1 + r2 + x1), r3 + r1 + y1)) {
cout << r3 + r4 + x2 << endl;
cout << sx + 1 << " " << sy << endl;
} else if (r1 + r3 + y1 >=
max(max(r2 + r1 + x1, r2 + r4 + y2), r3 + r4 + x2)) {
cout << r1 + r3 + y1 << endl;
cout << sx << " " << sy - 1 << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<pair<int, int> > G[100010];
int d[100010];
vector<int> t[100010];
inline int read_int() {
int t = 1, x = 0;
char ch = getchar();
while (!isdigit(ch) && ch != '-') ch = getchar();
if (ch == '-') t = -1, ch = getchar();
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return x * t;
}
int getTim(int v, int d) {
for (int i = 0; i < t[v].size(); i++) {
if (t[v][i] > d) return d;
if (t[v][i] == d) d++;
}
return d;
}
void dijkstra(int s, vector<pair<int, int> > G[]) {
set<pair<int, int> > pq;
fill(d + 1, d + n + 1, INT_MAX);
d[s] = 0;
pq.insert(make_pair(0, s));
while (!pq.empty()) {
int v = pq.begin()->second;
int q = pq.begin()->first;
pq.erase(pq.begin());
q = getTim(v, q);
for (int i = 0; i < G[v].size(); i++) {
pair<int, int> e = G[v][i];
int to = e.first, p = e.second;
if (d[to] > q + p) {
d[to] = q + p;
pq.insert(make_pair(d[to], to));
}
}
}
}
int main() {
n = read_int(), m = read_int();
for (int i = 1; i <= m; i++) {
int x = read_int(), y = read_int(), z = read_int();
G[x].push_back(make_pair(y, z));
G[y].push_back(make_pair(x, z));
}
for (int i = 1; i <= n; i++) {
int x = read_int();
while (x--) {
int y;
cin >> y;
t[i].push_back(y);
}
}
dijkstra(1, G);
if (d[n] == INT_MAX)
puts("-1");
else
cout << d[n] << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = (1 << 15) + 100;
int n, m;
string cur, prv;
int d[maxn], c[maxn], head[maxn];
int ans;
string num(char c) {
string ret = "";
int x;
x = c >= 'A' ? c - 'A' + 10 : c - '0';
for (int i = 8; i; i /= 2)
if (x & i)
ret += '1';
else
ret += '0';
return ret;
}
string cng(string s) {
string ret = "";
for (int i = 0; i < s.size(); i++) {
ret += num(s[i]);
}
return ret;
}
int get(int v) { return d[v] == v ? v : d[v] = get(d[v]); }
int mrg(int v, int u) {
v = get(v), u = get(u);
if (v == u) return 0;
return d[u] = v, 1;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = m; i--; prv += '0')
;
for (int i = m * 2; i--; d[i] = i)
;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
cur = cng(s);
{
int x = i & 1;
int y = 1 - x;
for (int j = 0; j < m; j++) {
if (cur[j] - '0') {
ans++;
if (prv[j] - '0') ans -= mrg(2 * j + x, 2 * j + y);
if (j and cur[j - 1] - '0') ans -= mrg(2 * j + x, 2 * j + x - 2);
}
}
for (int j = 0; j < m; j++) d[2 * j + y] = 2 * j + y;
}
prv = cur;
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, p, q;
scanf("%d%d%d%d", &n, &m, &p, &q);
if (q < 0) {
if (n < m) {
puts("DRAW");
return 0;
}
p *= -1;
q *= -1;
swap(p, q);
int d = n - m;
if (d % (p + q) >= p && d % (p + q) <= q) {
printf("FIRST\n%d\n", n - d % (p + q));
} else {
if (d % (p + q) == 0)
puts("SECOND");
else
puts("DRAW");
}
} else if (p <= 0) {
if (n < m) {
if (m - n <= q) {
printf("FIRST\n%d\n", m);
} else {
puts("DRAW");
}
} else {
if (n - m <= -p) {
printf("FIRST\n%d\n", m);
} else {
puts("DRAW");
}
}
} else {
if (n > m) {
puts("DRAW");
return 0;
}
int d = m - n;
if (d % (p + q) >= p && d % (p + q) <= q) {
printf("FIRST\n%d\n", n + d % (p + q));
} else {
if (d % (p + q) == 0)
puts("SECOND");
else
puts("DRAW");
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void r1(T &x) {
x = 0;
char c(getchar());
int f(1);
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48);
x *= f;
}
const int maxn = 1000 + 5;
const int maxm = 25;
bool begin;
long long n, d, mod;
long long inv[maxm];
long long f[maxn][maxm][maxn >> 1];
bool end;
long long ksm(long long mi, long long x) {
long long res(1);
while (mi) {
if (mi & 1) res = res * x % mod;
mi >>= 1;
x = x * x % mod;
}
return res;
}
long long C(long long a, long long b) {
if (a < b) return 0;
long long res(a);
for (long long i = a - 1; i > a - b; --i) res = res * i % mod;
return res * inv[b] % mod;
}
signed main() {
long long i, j, k;
r1(n), r1(d), r1(mod);
if (n <= 2) return puts("1"), 0;
inv[10] = ksm(mod - 2, 3628800 % mod);
for (i = 9; i; --i) inv[i] = inv[i + 1] * (i + 1) % mod;
for (i = 0; i <= (n >> 1); ++i) f[1][0][i] = 1;
for (i = 2; i <= n; ++i) {
for (j = 1; j <= min(d, i - 1); ++j) {
for (k = 1; k <= (n / 2); ++k) {
f[i][j][k] = f[i][j][k - 1];
for (long long t = 1; i - t * k > 0 && j - t >= 0; ++t) {
if (k == 1)
f[i][j][k] = (f[i][j][k] + f[i - t * k][j - t][k - 1] *
C(f[k][0][k - 1] + t - 1, t) % mod) %
mod;
else
f[i][j][k] =
(f[i][j][k] + f[i - t * k][j - t][k - 1] *
C(f[k][d - 1][k - 1] + t - 1, t) % mod) %
mod;
}
}
}
}
long long ans(0);
if (n & 1)
ans = f[n][d][n / 2];
else {
ans = f[n][d][n / 2] - C(f[n / 2][d - 1][n / 2 - 1], 2);
ans = (ans + mod) % mod;
}
printf("%lld\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
cout << max(m, n) - 1 << " " << min(m, n);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<int> Ans;
const int N = 111;
int n, m, Memo[N][N];
map<int, string> Msg;
map<int, string> idUser;
map<string, int> userId;
inline bool isAc(char c) {
return (c == '.' || c == ',' || c == '!' || c == '?' || c == ' ');
}
inline bool isValid(int msg, int id) {
string s = Msg[msg];
string name = idUser[id];
string cur = "";
for (auto x : s) {
if (isAc(x)) {
if (cur == name) return 0;
cur = "";
} else {
cur += x;
}
}
if (cur == name) return 0;
return 1;
}
int match(int i) {
if (i == m) return 1;
if (Ans[i] != 0) {
if (i && Ans[i] == Ans[i - 1]) return -1;
if (Memo[i][Ans[i] - 1] != 0) return Memo[i][Ans[i] - 1];
Memo[i][Ans[i] - 1] = match(i + 1);
return Memo[i][Ans[i] - 1];
}
for (int name = 1; name <= n; name++) {
if ((!i && isValid(i, name)) ||
(i && isValid(i, name) && name != Ans[i - 1])) {
Ans[i] = name;
if (Memo[i][Ans[i] - 1] == 0) Memo[i][Ans[i] - 1] = match(i + 1);
if (Memo[i][Ans[i] - 1] == 1) return 1;
}
}
Ans[i] = 0;
return -1;
}
void Solve() {
bool flag = true;
{
string tmp;
userId.insert(make_pair("?", 0));
idUser.insert(make_pair(0, "?"));
cin >> n;
cin.ignore();
getline(cin, tmp);
stringstream names(tmp);
for (int Cnt = 1; names >> tmp; Cnt++) {
userId[tmp] = Cnt;
idUser[Cnt] = tmp;
if (isdigit(tmp[0])) flag = false;
}
}
cin >> m;
cin.ignore();
Ans.assign(m, 0);
for (int i = 0; i < m; i++) {
unsigned int id, sz;
string tmp, user, msg = "";
getline(cin, tmp);
stringstream inputMsg(tmp);
inputMsg >> tmp;
for (sz = 0; sz < tmp.size(); sz++)
if (tmp[sz] == ':') break;
user = tmp.substr(0, sz);
id = userId[user];
tmp = tmp.substr(sz + 1);
msg = msg + tmp;
while (inputMsg >> tmp) msg = msg + " " + tmp;
Ans[i] = id;
Msg[i] = msg;
}
if (flag) {
for (int i = 0; i < m; i++)
for (int j = 0; j < n; j++) Memo[i][j] = 0;
if (match(0) == -1)
cout << "Impossible" << endl;
else
for (int i = 0; i < m; i++)
cout << idUser[Ans[i]] << ':' << Msg[i] << endl;
} else {
cout << "Impossible" << endl;
}
userId.clear();
idUser.clear();
Msg.clear();
Ans.clear();
return;
}
int main() {
int Tc;
cin >> Tc;
while (Tc--) Solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
double b;
cin >> n >> b;
vector<int> array(n);
vector<double> ans(n);
for (int i = 0; i < n; ++i) {
cin >> array[i];
}
int _max = *max_element(array.begin(), array.end());
int _min = 0;
for (int i = 0; i < n; ++i) {
if (array[i] != _max) {
_min += _max - array[i];
}
}
if (_min > b) {
cout << -1;
return 0;
} else {
for (int i = 0; i < n; ++i) {
ans[i] = _max - array[i];
b -= (_max - array[i]);
}
if (b > 0) {
double _else = b / n;
for (int i = 0; i < n; ++i) {
ans[i] += _else;
}
}
cout.precision(6);
for (int i = 0; i < n; ++i) {
cout << fixed << ans[i] << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
;
cin.tie(nullptr);
char ch;
bool flag1, flag2, flag, flag3, flag4;
flag3 = flag4 = false;
int i, len, cnt = 0, tmp, j;
string s, tmps, num, str;
cin >> s;
len = s.size();
s += ';', len++;
num = str = tmps = "";
flag1 = flag2 = true;
for (i = 0; i < len; i++) {
if (s[i] == ';' || s[i] == ',') {
tmp = tmps.size();
flag = (tmp) ? true : false;
if (tmps[0] == '0' && tmp > 1) flag = false;
if (flag) {
for (j = 0; j < tmp; j++) {
ch = tmps[j];
if ((ch >= 'a' && ch <= 'z') || ch == '.' ||
(ch >= 'A' && ch <= 'Z')) {
flag = false;
break;
}
}
}
if (flag) {
if (flag1)
num += tmps, flag1 = false;
else
num += ',', num += tmps;
flag3 = true;
} else {
if (flag2)
str += tmps, flag2 = false;
else
str += ',', str += tmps;
flag4 = true;
}
tmps = "";
continue;
}
tmps += s[i];
}
if (flag3)
cout << '"' << num << '"' << '\n';
else
cout << '-' << '\n';
if (flag4)
cout << '"' << str << '"' << '\n';
else
cout << '-' << '\n';
return 0;
}
| 4 |
//#pragma GCC optimize("Ofast")
//#pragma GCC target("avx,avx2,fma")
#include <bits/stdc++.h>
using namespace std;
void __print(int x) {cerr << x;}
void __print(long x) {cerr << x;}
void __print(long long x) {cerr << x;}
void __print(unsigned x) {cerr << x;}
void __print(unsigned long x) {cerr << x;}
void __print(unsigned long long x) {cerr << x;}
void __print(float x) {cerr << x;}
void __print(double x) {cerr << x;}
void __print(long double x) {cerr << x;}
void __print(char x) {cerr << '\'' << x << '\'';}
void __print(const char *x) {cerr << '\"' << x << '\"';}
void __print(const string &x) {cerr << '\"' << x << '\"';}
void __print(bool x) {cerr << (x ? "true" : "false");}
template<typename T, typename V>
void __print(const pair<T, V> &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';}
template<typename T>
void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i: x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";}
void _print() {cerr << "]\n";}
template <typename T, typename... V>
void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);}
void debug3(int *t,int st,int n) {cerr << '{' << t[st];for(int i=st+1;i<=n;i++) cerr<<",",__print(t[i]);cerr <<"}"<<'\n';}
#ifndef ONLINE_JUDGE
#define debug(x...) cerr << "[" << #x << "] = ["; _print(x)
#define debug2(x...) cerr<<"[" << #x << "] = "; debug3(x)
#endif
#define N 200005
#define ll long long
#define ull unsigned long long
#define pii pair<int,int>
#define sf second.first
#define ss second.second
#define INF 1e9
int v[N];
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
//freopen("test.in", "r", stdin);
int t,n,m,i,j,x;
double pr,pb,sol;
cin >> t ;
while ( t-- )
{
pr = 1 ;
sol = 0 ;
cin >> n >> m ;
for ( i = 1; i <= n ; i++ )
cin >> v[i] ;
for ( j=n ; v[j]==j&&j; j-- ) ;
while ( m-- )
{
cin >> x >> pb ;
if ( x < j )
continue ;
sol = sol + pr*pb ;
pr = pr*(1-pb) ;
}
if ( j == 0 )
sol = 1 ;
cout << sol << '\n';
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 2e9;
int daq(string& s, char c, int l, int r, vector<int>& amount) {
if (l == r) {
amount[s[l] - 'a'] = 1;
return s[l] == c ? 0 : 1;
}
vector<int> la(26, 0), ra(26, 0);
int mid = (l + r) / 2;
int ans, lmin = daq(s, c + 1, l, mid, la),
rmin = daq(s, c + 1, mid + 1, r, ra);
ans = min(lmin + mid - l + 1 - ra[c - 'a'], rmin + mid - l + 1 - la[c - 'a']);
for (int i = 0; i < 26; i++) amount[i] = la[i] + ra[i];
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int T;
cin >> T;
while (T--) {
vector<int> haha(26, 0);
int n;
cin >> n;
string s;
cin >> s;
cout << daq(s, 'a', 0, n - 1, haha) << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[20], b[5][5], s, dif[20], cnt[20], n, t;
void dfs(int x, int y) {
if (y == n + 1) {
cout << s << endl;
for (int i = 1; i <= n; i++, cout << endl)
for (int j = 1; j <= n; j++) cout << b[i][j] << " ";
exit(0);
}
int nx = x + 1, ny = y;
if (nx == n + 1) nx = 1, ny++;
for (int i = 0; i <= t; i++) {
if (cnt[i]) {
cnt[i]--;
b[x][y] = dif[i];
bool ok = true;
if (x == n) {
int sum = 0;
for (int i = 1; i <= n; i++) sum += b[i][y];
if (sum != s) ok = false;
}
if (y == n) {
int sum = 0;
for (int i = 1; i <= n; i++) sum += b[x][i];
if (sum != s) ok = false;
}
if (x == n && y == n) {
int sum = 0;
for (int i = 1; i <= n; i++) sum += b[i][i];
if (sum != s) ok = false;
}
if (x == 1 && y == n) {
int sum = 0;
for (int i = 1; i <= n; i++) sum += b[i][n - i + 1];
if (sum != s) ok = false;
}
if (ok) dfs(nx, ny);
cnt[i]++;
}
}
}
int main() {
cin >> n;
for (int i = 0; i < n * n; i++) cin >> a[i], s += a[i];
sort(a, a + n * n);
dif[0] = a[0];
cnt[0] = 1;
for (int i = 1; i < n * n; i++)
if (a[i] != a[i - 1])
dif[++t] = a[i], cnt[t] = 1;
else
cnt[t]++;
s /= n;
dfs(1, 1);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
const long long mod = 1000000007;
int basis[N][20], basis_sz[N];
long long pw2[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout << setprecision(32);
int n, q, l, x;
cin >> n >> q;
memset(basis, -1, sizeof(basis));
basis_sz[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> x;
for (int j = 0; j < 20; j++) {
basis[i][j] = basis[i - 1][j];
if (basis[i][j] != -1) {
if (x & (1 << j)) {
x ^= basis[i][j];
}
}
}
basis_sz[i] = basis_sz[i - 1];
for (int j = 0; j < 20; j++) {
if (x & (1 << j)) {
assert(basis[i][j] == -1);
basis[i][j] = x;
basis_sz[i]++;
break;
}
}
}
pw2[0] = 1;
for (int i = 1; i < N; i++) {
pw2[i] = (pw2[i - 1] << 1);
if (pw2[i] >= mod) pw2[i] -= mod;
}
while (q--) {
cin >> l >> x;
for (int i = 0; i < 20; i++) {
if (x & (1 << i)) {
if (basis[l][i] != -1) x ^= basis[l][i];
}
}
if (x == 0) {
cout << pw2[l - basis_sz[l]] << '\n';
} else {
cout << 0 << '\n';
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 6001;
long long b[N], a[N];
int vis[N];
char str[N];
int s[N];
long long sum(int l, int r) {
if (l > r) return 0;
long long ans = 0;
for (int k = l; k <= r; k += 2) b[k] = 0, vis[k] = 0;
for (int k = l; k <= r; k += 2) {
if (b[k] == 0) {
b[k] = a[k];
}
if (str[k + 1] == '*' && k + 1 <= r) {
vis[k] = 1;
b[k + 2] = b[k] * a[k + 2];
}
}
for (int k = l; k <= r; k += 2) {
if (vis[k] == 1) continue;
ans += b[k];
}
return ans;
}
int main() {
scanf("%s", str);
int n = strlen(str);
for (int i = 0; i < n; i += 2) {
a[i] = str[i] - '0';
}
long long maxn = 0;
maxn = sum(0, n - 1);
memset(vis, 0, sizeof(vis));
int cnt = 0;
for (int i = 0; i < n; i++) {
if (str[i] == '*') s[++cnt] = i;
}
s[++cnt] = -1;
s[++cnt] = n;
sort(s + 1, s + 1 + cnt);
for (int i = 1; i <= cnt; i++) {
for (int j = i + 1; j <= cnt; j++) {
memset(vis, 0, sizeof(vis));
memset(b, 0, sizeof(b));
long long ans = 0;
int flag = 0;
for (int k = 0; k < n; k += 2) {
if (s[i] - 1 == -2 && flag == 0) {
b[s[j] - 1] = sum(s[i] + 1, s[j] - 1);
k = s[j] - 1;
flag = 1;
}
if (b[k] == 0) b[k] = a[k];
if (k == s[i] - 1)
b[s[j] - 1] = b[k] * sum(s[i] + 1, s[j] - 1), vis[k] = 1,
k = s[j] - 1;
if (str[k + 1] == '*') vis[k] = 1, b[k + 2] = b[k] * a[k + 2];
}
flag = 0;
for (int k = 0; k < n; k += 2) {
if (s[i] - 1 == -2 && flag == 0) {
k = s[j] - 1;
flag = 1;
}
if (k == s[i] - 1) k = s[j] - 1;
if (vis[k] == 0) {
ans += b[k];
}
}
maxn = max(maxn, ans);
}
}
cout << maxn << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, maxx, dp[300], co[300];
char s[300];
int main() {
scanf("%d", &n);
cin >> (s + 1);
for (register int i = 1; i <= n; i++) {
dp[i] = 1;
for (register int j = 1; j <= i - 1; j++)
if (s[j] > s[i]) {
dp[i] = max(dp[i], dp[j] + 1);
maxx = max(maxx, dp[i]);
}
}
if (maxx > 2)
puts("NO");
else {
for (register int i = 1; i <= n - 1; i++) {
for (register int j = i + 1; j <= n; j++) {
if (s[j] < s[i]) co[j] = abs(1 - co[i]);
}
}
puts("YES");
for (register int i = 1; i <= n; i++) printf("%d", co[i]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j, party, total, cnt, A[110], alice, flag;
vector<int> v;
scanf("%d", &n);
total = 0;
for (i = 0; i < n; i++) {
scanf("%d", &A[i]);
total = total + A[i];
}
party = A[0];
alice = A[0];
v.push_back(1);
cnt = 1;
flag = 0;
for (i = 1; i < n; i++) {
if (alice >= (A[i] * 2)) {
party = party + A[i];
v.push_back(i + 1);
cnt += 1;
}
if (total < (party * 2)) {
printf("%d\n", cnt);
for (i = 0; i < v.size(); i++) {
printf("%d ", v[i]);
}
flag = 1;
break;
}
}
if (flag != 1) {
printf("0\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long tt(long long a) {
if (a == 1 || a == 2) {
return 0;
}
if (a == 3) {
return 1;
}
long long k = 0;
long long l = 1;
while (3 * l <= a) {
l *= 3;
k++;
}
return k;
}
string Three(long long a) {
long long x = tt(a);
string m = "";
while (x >= 0) {
long long r = pow(3, x);
long long t = a / r;
a -= r * t;
m += char(t + '0');
x--;
}
return m;
}
long long Threez(string a) {
long long ansz = 0;
for (int k = a.length() - 1; k >= 0; k--) {
ansz += (a[a.length() - k - 1] - '0') * pow(3, k);
}
return ansz;
}
int main() {
int a, b;
cin >> a >> b;
string x = Three(a);
string y = Three(b);
string ans = "";
if (x.size() < y.size()) {
long long k = y.size() - x.size();
string z = "";
for (int g = 0; g < k; g++) {
z += '0';
}
x = z + x;
} else {
long long k = x.size() - y.size();
string zz = "";
for (int g = 0; g < k; g++) {
zz += '0';
}
y = zz + y;
}
string tt = "";
for (int g = 0; g < x.size(); g++) {
if (x[g] > y[g]) {
tt = tt + char((y[g] + 3 - x[g]) + '0');
} else {
tt = tt + char((y[g] - x[g]) + '0');
}
}
cout << Threez(tt);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool inD(int x, int y, int r1, int r, int d, bool v) {
double dist = sqrt(double(x) * x + y * y);
if (v) {
printf("dist = %lf\n", dist);
printf("dist + r1 = %lf\n", dist + r1);
printf("dist - r1 = %lf\n", dist - r1);
printf("r = %lf\n", double(r));
printf("r-d = %lf\n", double(r) - d);
}
bool inR = dist + r1 <= r;
bool outOfRmD = dist - r1 >= r - d;
return inR && outOfRmD;
}
int main() {
int r, d, n;
scanf("%d%d%d", &r, &d, &n);
int res = 0;
for (int i = 0; i < n; ++i) {
int x, y, r1;
scanf("%d%d%d", &x, &y, &r1);
res += inD(x, y, r1, r, d, false);
}
printf("%d\n", res);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
while (cin >> n) {
char ben[10];
cin >> ben;
int cnt = 0;
for (int i = 0; i < n; i++) {
char t[10];
cin >> t;
bool win = true;
for (int j = 0; j < 3; j++) {
if (ben[j] != t[j]) {
win = false;
break;
}
}
if (win) cnt++;
win = true;
for (int j = 5; j < 8; j++) {
if (ben[j - 5] != t[j]) {
win = false;
break;
}
}
if (win) cnt--;
}
if (cnt)
cout << "contest" << endl;
else
cout << "home" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10, mod = 1e9 + 7;
int T, n, t, fla = -1;
int a[maxn];
vector<int> q[60];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
t = a[i];
for (int j = 1; t > 0; j++) {
if (t % 2 == 1) q[j].push_back(i);
t /= 2;
}
}
for (int i = 59; i > 0; i--) {
if (q[i].size() == 1) {
fla = q[i][0];
break;
}
}
if (fla == -1)
for (int i = 1; i <= n; i++) printf("%d ", a[i]);
else {
printf("%d ", a[fla]);
for (int i = 1; i <= n; i++)
if (i != fla) printf("%d ", a[i]);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long len(long long x, long long y) { return x * x + y * y; }
long long scal(long long x1, long long y1, long long x2, long long y2) {
if (x1 * y2 == x2 * y1) return -1;
return x1 * x2 + y1 * y2;
}
bool in(long long x1, long long y1, long long x2, long long y2, long long x,
long long y) {
long long vx = x1 - x;
long long vy = y1 - y;
long long wx = x2 - x;
long long wy = y2 - y;
if (vx * wy == vy * wx && vx * wx + vy * wy < 0) return true;
return false;
}
bool sootn(long long x1, long long y1, long long x2, long long y2, long long x,
long long y) {
long long vx = x - x1;
long long vy = y - y1;
long long wx = x - x2;
long long wy = y - y2;
long long l1 = len(vx, vy);
long long l2 = len(wx, wy);
if (l1 >= l2)
return (16 * l2 >= l1);
else
return (16 * l1 >= l2);
}
int Solution() {
int t;
scanf("%d", &t);
for (int i = 0; i < t; ++i) {
long long x[6], y[6];
for (int j = 0; j < 6; ++j) scanf("%I64d%I64d", &x[j], &y[j]);
int ind = -1;
for (int j = 0; j < 6; ++j)
for (int k = j + 1; k < 6; ++k)
if (x[j] == x[k] && y[j] == y[k]) {
ind = j;
break;
}
if (ind == -1) {
printf("NO\n");
continue;
}
int ind1 = -1, ind2;
for (int j = 0; j < 6; ++j)
if (x[j] == x[ind] && y[j] == y[ind])
if (ind1 == -1)
ind1 = j;
else
ind2 = j;
if (ind1 & 1)
ind1--;
else
ind1++;
if (ind2 & 1)
ind2--;
else
ind2++;
long long an = scal(x[ind1] - x[ind], y[ind1] - y[ind], x[ind2] - x[ind],
y[ind2] - y[ind]);
if (an < 0) {
printf("NO\n");
continue;
}
int num3 = 3 - ind1 / 2 - ind2 / 2;
if (in(x[ind], y[ind], x[ind1], y[ind1], x[num3 * 2], y[num3 * 2]) &&
in(x[ind], y[ind], x[ind2], y[ind2], x[num3 * 2 + 1],
y[num3 * 2 + 1])) {
bool soot =
sootn(x[ind], y[ind], x[ind1], y[ind1], x[num3 * 2], y[num3 * 2]);
if (!soot) {
printf("NO\n");
continue;
}
soot = sootn(x[ind], y[ind], x[ind2], y[ind2], x[num3 * 2 + 1],
y[num3 * 2 + 1]);
if (!soot) {
printf("NO\n");
continue;
}
} else if (in(x[ind], y[ind], x[ind1], y[ind1], x[num3 * 2 + 1],
y[num3 * 2 + 1]) &&
in(x[ind], y[ind], x[ind2], y[ind2], x[num3 * 2], y[num3 * 2])) {
bool soot = sootn(x[ind], y[ind], x[ind1], y[ind1], x[num3 * 2 + 1],
y[num3 * 2 + 1]);
if (!soot) {
printf("NO\n");
continue;
}
soot = sootn(x[ind], y[ind], x[ind2], y[ind2], x[num3 * 2], y[num3 * 2]);
if (!soot) {
printf("NO\n");
continue;
}
} else {
printf("NO\n");
continue;
}
printf("YES\n");
}
return 0;
}
int main() {
Solution();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, arr[60], c = 0, ans = 1e9, x = 0;
memset(arr, 0, sizeof(arr));
string s;
cin >> n >> s;
set<char> st;
for (int i = 0; i < n; ++i) {
st.insert(s[i]);
}
c = st.size();
for (int i = 0, j = 0; i < n; ++i) {
if (s[i] >= 'a' && s[i] <= 'z') {
if (!arr[(s[i] - 'a')]) {
++x;
}
++arr[(s[i] - 'a')];
}
if (s[i] >= 'A' && s[i] <= 'Z') {
if (!arr[(s[i] - 'A') + 26]) {
++x;
}
++arr[(s[i] - 'A') + 26];
}
if (x == c) {
ans = min(ans, i - j + 1);
while (j < i) {
if (s[j] >= 'a' && s[j] <= 'z') {
if (arr[(s[j] - 'a')] == 1) {
--x;
ans = min(ans, i - j + 1);
--arr[(s[j] - 'a')], ++j;
break;
} else {
--arr[(s[j] - 'a')], ++j;
}
}
if (s[j] >= 'A' && s[j] <= 'Z') {
if (arr[(s[j] - 'A') + 26] == 1) {
--x;
ans = min(ans, i - j + 1);
--arr[(s[j] - 'A') + 26], ++j;
break;
} else {
--arr[(s[j] - 'A') + 26], ++j;
}
}
}
}
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int* arr = new int[n];
int a = 0;
for (int i = 0; i < n; i++) {
char temp;
cin >> temp;
if (temp == '(') {
a++;
} else {
a--;
}
arr[i] = a;
}
if (a != 0) {
cout << 0 << endl << 1 << " " << 1 << endl;
return 0;
}
int Min = 1;
int index = 0;
for (int i = 0; i < n; i++) {
if (arr[i] < Min) {
Min = arr[i];
index = i;
}
}
int* ans = new int[n];
for (int i = index + 1; i < n; i++) {
ans[i - index - 1] = arr[i];
}
for (int i = 0; i < index + 1; i++) {
ans[n - index - 1 + i] = arr[i];
}
int temp = 0 - ans[n - 1];
for (int i = 0; i < n; i++) {
ans[i] += temp;
}
int numZeroes = 0;
for (int i = 0; i < n; i++) {
if (ans[i] == 0) {
numZeroes++;
}
}
int i1 = 0;
int i2 = 0;
int max1 = 0;
int numOnes = 0;
int last = 0;
for (int i = 0; i < n; i++) {
if (ans[i] == 0) {
if (numOnes > max1) {
max1 = numOnes;
i1 = last;
i2 = i;
}
last = i + 1;
numOnes = 0;
continue;
}
if (ans[i] == 1) {
numOnes++;
}
}
last = 0;
int j1 = 0;
int j2 = 0;
int max2 = 0;
int numTwos = 0;
for (int i = 0; i < n; i++) {
if (ans[i] == 0 || ans[i] == 1) {
if (numTwos > max2) {
max2 = numTwos;
j1 = last;
j2 = i;
}
last = i + 1;
numTwos = 0;
continue;
}
if (ans[i] == 2) {
numTwos++;
}
}
numOnes = max1;
numTwos = max2;
if (numZeroes + numTwos >= numOnes) {
if (j1 < n - index - 1) {
j1 = j1 + index + 1;
} else {
j1 = j1 - n + index + 1;
}
if (j2 < n - index - 1) {
j2 = j2 + index + 1;
} else {
j2 = j2 - n + index + 1;
}
cout << numZeroes + numTwos << endl << j1 + 1 << " " << j2 + 1 << endl;
} else {
j1 = i1;
j2 = i2;
if (j1 < n - index - 1) {
j1 = j1 + index + 1;
} else {
j1 = j1 - n + index + 1;
}
if (j2 < n - index - 1) {
j2 = j2 + index + 1;
} else {
j2 = j2 - n + index + 1;
}
cout << numOnes << endl << j1 + 1 << " " << j2 + 1 << endl;
}
delete[] arr;
delete[] ans;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct SegmentTree {
struct Op {
int h;
};
int l;
int r;
int h;
SegmentTree* lc;
SegmentTree* rc;
bool lazy;
Op op;
SegmentTree(int ll, int rr) {
lazy = false;
l = ll;
r = rr;
h = 0;
if (l == r) return;
int m = (l + r) / 2;
lc = new SegmentTree(l, m);
rc = new SegmentTree(m + 1, r);
}
int query(int xl, int xr) {
if (l == r) return h;
if (xl <= l && r <= xr) return h;
if (lazy) {
lc->update(lc->l, lc->r, op.h);
rc->update(rc->l, rc->r, op.h);
lazy = false;
}
int ret = INT_MAX;
if (xl <= lc->r) {
int temp = lc->query(xl, xr);
if (ret > temp) ret = temp;
}
if (rc->l <= xr) {
int temp = rc->query(xl, xr);
if (ret > temp) ret = temp;
}
return ret;
}
void update(int xl, int xr, int xh) {
if (l == r) {
if (h < xh) h = xh;
return;
}
if (xl <= l && r <= xr) {
if (h < xh) h = xh;
if (lazy) {
if (op.h < xh) op.h = xh;
} else {
op.h = xh;
lazy = true;
}
return;
}
if (lazy) {
lc->update(lc->l, lc->r, op.h);
rc->update(rc->l, rc->r, op.h);
lazy = false;
}
if (xl <= lc->r) lc->update(xl, xr, xh);
if (rc->l <= xr) rc->update(xl, xr, xh);
h = min(lc->h, rc->h);
}
};
struct Hall {
int h;
int proj_index[2];
int proj_x[2];
};
const int HH = 1002;
int n;
int vx;
int vy;
Hall hall[HH][HH];
long long ans;
inline double get_x(double x, double y) {
if (vx == 0) return x;
return x - y / vy * vx;
}
int init_project() {
int xx[] = {0, 1};
int yy[] = {1, 0};
double EPS = 1e-7;
struct Proj {
int i;
int j;
double x;
int k;
};
vector<Proj> projection;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
for (int k = 0; k < 2; k++)
projection.push_back((Proj){i, j, get_x(i + xx[k], j + yy[k]), k});
sort(begin(projection), end(projection),
[](const Proj& a, const Proj& b) { return a.x < b.x; });
int n_seg = 0;
hall[projection[0].i][projection[0].j].proj_index[projection[0].k] = 0;
for (int i = 1; i < projection.size(); i++) {
if (abs(projection[i].x - projection[i - 1].x) > EPS) n_seg++;
hall[projection[i].i][projection[i].j].proj_index[projection[i].k] = n_seg;
}
return n_seg;
}
int temp_h[HH][HH];
void rotate() {
if (vy < 0) {
for (int i = 0; i < n; i++) {
int l = 0;
int r = n - 1;
while (l < r) {
swap(temp_h[i][l], temp_h[i][r]);
l++;
r--;
}
}
vy = -vy;
}
if (vx < 0 || vy == 0) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < i; j++) {
swap(temp_h[i][j], temp_h[j][i]);
}
}
swap(vx, vy);
}
if (vy < 0) {
for (int i = 0; i < n; i++) {
int l = 0;
int r = n - 1;
while (l < r) {
swap(temp_h[i][l], temp_h[i][r]);
l++;
r--;
}
}
vy = -vy;
}
}
int main() {
scanf("%d %d %d", &n, &vx, &vy);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) scanf("%d", &temp_h[i][j]);
rotate();
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) hall[i][j].h = temp_h[i][j];
int len = init_project();
SegmentTree st(0, len - 1);
for (int j = 0; j < n; j++) {
for (int i = 0; i < n; i++) {
const Hall& h = hall[i][j];
int min_height = st.query(h.proj_index[0], h.proj_index[1] - 1);
ans += max(0, h.h - min_height);
st.update(h.proj_index[0], h.proj_index[1] - 1, h.h);
}
}
printf("%lld\n", ans);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
string s;
bool good[4][4], bad[4][4];
long long ab, ans, a[705], b[705], dp[705][705][3][3];
long long dfs(int l, int r, int x, int y) {
if (l >= r) return 1;
if (dp[l][r][x][y] != -1) return dp[l][r][x][y];
dp[l][r][x][y] = 0;
if (a[l] == r) {
for (int i = 0; i < 3; i++)
if (!bad[i][x])
for (int j = 0; j < 3; j++)
if (!bad[j][y] and good[i][j])
dp[l][r][x][y] = (dp[l][r][x][y] + dfs(l + 1, r - 1, i, j)) % mod;
} else {
for (int i = 0; i < 3; i++)
if (!bad[i][x])
for (int j = 0; j < 3; j++)
if (good[i][j])
dp[l][r][x][y] = (dp[l][r][x][y] + dfs(l + 1, a[l] - 1, i, j) *
dfs(a[l] + 1, r, j, y)) %
mod;
}
return dp[l][r][x][y];
}
int main() {
ios::sync_with_stdio(false);
memset(dp, -1, sizeof(dp));
good[0][1] = good[0][2] = good[1][0] = good[2][0] = bad[1][1] = bad[2][2] =
true;
cin >> s;
for (int i = 0; i < s.size(); i++)
if (s[i] == '(')
b[ab++] = i;
else
a[b[--ab]] = i;
cout << dfs(0, s.size() - 1, 3, 3);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long fact[500010], inv[500010];
long long NCR(long long N, long long r) {
if (r > N) return 0;
return (fact[N] * inv[r] % mod) * inv[N - r] % mod;
}
long long pow_mod(long long base, long long power) {
long long res = 1;
while (power) {
if (power & 1) res = res * base % mod;
base = base * base % mod;
power >>= 1;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
fact[0] = fact[1] = inv[0] = inv[1] = 1;
for (int i = 2; i < 500010; i++)
fact[i] = fact[i - 1] * i % mod, inv[i] = pow_mod(fact[i], mod - 2);
int N, K, l, r;
cin >> N >> K;
vector<pair<int, int> > ev;
for (int i = 0; i < N; i++) {
cin >> l >> r;
ev.push_back({l, 1});
ev.push_back({r + 1, -1});
}
sort(ev.begin(), ev.end());
long long last = INT_MIN;
long long cur = 0;
long long res = 0;
for (int i = 0; i < (int)ev.size();) {
long long len = ev[i].first - last;
res = (res + len * NCR(cur, K)) % mod;
int j = i;
while (j < (int)ev.size() && ev[j].first == ev[i].first) {
cur += ev[j].second;
j++;
}
last = ev[i].first;
i = j;
}
cout << res << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = (long long)1 << 62;
const long long MOD = 1e9 + 7;
const int iINF = 1 << 30;
const double PI = 3.14159265359;
vector<vector<int> > adj;
vector<int> dp[2][2];
vector<bool> vis[2][2];
void dfs(int u, int p, int gp, int par) {
dp[p][gp][u] = 1;
for (int v : adj[u]) {
if (v == par) continue;
if (!vis[1][p][v]) dfs(v, 1, p, u);
dp[p][gp][u] += dp[1][p][v];
}
if (p) {
int tmp = 0;
for (int v : adj[u]) {
if (v == par) continue;
if (!vis[0][p][v]) dfs(v, 0, p, u);
tmp += dp[0][p][v];
}
dp[p][gp][u] = min(dp[p][gp][u], tmp);
}
if (p || gp) {
int s = 0;
for (int v : adj[u]) {
if (v == par) continue;
if (!vis[0][0][v]) dfs(v, 0, 0, u);
if (!vis[0][1][v]) dfs(v, 0, 1, u);
s += min(dp[0][0][v], dp[0][1][v]);
}
int minval = iINF, minnd = -1;
for (int v : adj[u]) {
if (v == par) continue;
if (minval > s - min(dp[0][0][v], dp[0][1][v]) + dp[0][0][v]) {
minval = s - min(dp[0][0][v], dp[0][1][v]) + dp[0][0][v];
minnd = v;
}
}
if (minnd != -1) dp[p][gp][u] = min(dp[p][gp][u], minval);
}
vis[p][gp][u] = true;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
adj.resize(n);
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
dp[i][j].assign(n, -1);
vis[i][j].assign(n, false);
}
}
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
adj[u].push_back(v);
adj[v].push_back(u);
}
vector<pair<int, int> > vertices;
for (int v : adj[0]) {
for (int vd : adj[v]) {
if (vd == 0) continue;
vertices.push_back({vd, v});
}
}
int ans = 0;
for (int i = 0; i < vertices.size(); i++) {
if (!vis[1][1][vertices[i].first])
dfs(vertices[i].first, 1, 1, vertices[i].second);
ans += dp[1][1][vertices[i].first];
}
cout << ans << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline int read(int x = 0, int f = 1, char ch = '0') {
while (!isdigit(ch = getchar()))
if (ch == '-') f = -1;
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return f * x;
}
const int N = 2e6 + 5;
int n, m, tot;
int head[N], ver[N << 1], nxt[N << 1];
inline void add(int x, int y) {
ver[++tot] = y;
nxt[tot] = head[x];
head[x] = tot;
}
int len[N], son[N], ans[N];
int tmp[N], *f[N], *id = tmp;
void dfs1(int x, int ff) {
for (register int i = head[x]; i; i = nxt[i]) {
int y = ver[i];
if (y == ff) continue;
dfs1(y, x);
if (len[y] > len[son[x]]) son[x] = y;
}
len[x] = len[son[x]] + 1;
}
void dfs2(int x, int ff) {
f[x][0] = 1;
if (son[x]) f[son[x]] = f[x] + 1, dfs2(son[x], x), ans[x] = ans[son[x]] + 1;
for (int e = head[x]; e; e = nxt[e]) {
int y = ver[e];
if (y == ff || y == son[x]) continue;
f[y] = id;
id += len[y];
dfs2(y, x);
for (int j = 1; j <= len[y]; ++j) {
f[x][j] += f[y][j - 1];
if ((j < ans[x] && f[x][j] == f[x][ans[x]]) || f[x][j] > f[x][ans[x]])
ans[x] = j;
}
}
if (f[x][ans[x]] == 1) ans[x] = 0;
}
int main() {
n = read();
for (register int i = (1); i <= (n - 1); ++i) {
int x = read(), y = read();
add(x, y);
add(y, x);
}
dfs1(1, 0);
f[1] = id;
id += len[1];
dfs2(1, 0);
for (register int i = 1; i <= n; ++i) printf("%d\n", ans[i]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct student {
int st, en, id;
};
bool cmp(student a, student b) {
if (a.st == b.st)
return a.id < b.id;
else
return a.st < b.st;
}
int main() {
int n, k;
int t;
cin >> t;
for (int i = 1; i <= t; i++) {
cin >> n;
student arr[1005];
for (int j = 0; j < n; j++) {
int x, y;
cin >> x >> y;
arr[j].st = x;
arr[j].en = y;
arr[j].id = j + 1;
}
sort(arr, arr + n, cmp);
int ans[1005];
int now = 0;
for (int j = 0; j < n; j++) {
if (now <= arr[j].en) {
if (now <= arr[j].st) {
ans[arr[j].id] = arr[j].st;
now = arr[j].st + 1;
} else {
ans[arr[j].id] = now;
now = now + 1;
}
} else {
ans[arr[j].id] = 0;
}
}
for (int j = 1; j <= n; j++) {
printf("%d", ans[j]);
if (j == n)
printf("\n");
else
printf(" ");
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[100000];
int freq[8];
for (int i = 0; i <= 7; i++) freq[i] = 0;
bool failed = 0;
for (int i = 0; i < n; i++) {
cin >> arr[i];
if (arr[i] == 5 || arr[i] == 7) {
failed = 1;
break;
}
freq[arr[i]]++;
}
if (failed)
cout << -1 << endl;
else if (freq[1] != (n / 3))
cout << -1 << endl;
else if (freq[2] + freq[3] != (n / 3))
cout << -1 << endl;
else if (freq[6] < freq[3])
cout << -1 << endl;
else if (freq[6] + freq[4] != (n / 3))
cout << -1 << endl;
else {
for (int i = 0; i < n / 3; i++) {
cout << 1 << " ";
if (freq[2] > 0) {
cout << 2 << " ";
freq[2]--;
} else {
cout << 3 << " ";
freq[3]--;
}
if (freq[4] > 0) {
cout << 4 << " ";
freq[4]--;
} else {
cout << 6 << " ";
freq[6]--;
}
cout << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e3 + 7;
int n, k, a, b, c, d;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k >> a >> b >> c >> d;
if (n == 4 || k < (n + 1)) {
cout << -1 << "\n";
return 0;
}
vector<int> r1, r2;
r1.push_back(a);
r1.push_back(c);
for (int i = 1; i <= n; ++i) {
if (i != a && i != b && i != c && i != d) {
r1.push_back(i);
}
}
r1.push_back(d);
r1.push_back(b);
r2.push_back(c);
r2.push_back(a);
for (int i = 2; i < n - 2; ++i) {
r2.push_back(r1[i]);
}
r2.push_back(b);
r2.push_back(d);
for (int i = 0; i < n; ++i) {
cout << r1[i] << " ";
}
cout << "\n";
for (int i = 0; i < n; ++i) {
cout << r2[i] << " ";
}
cout << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, d, np = 0, ans = 0;
cin >> n >> d;
string s;
cin >> s;
for (int i = 0; i < n;) {
int k = -1;
for (int j = ((i + d) < n ? i + d : n - 1); j > i; j--)
if (s[j] == '1') {
k = j;
break;
}
if (k == n - 1) {
ans++;
break;
}
if (k == -1) {
np = 1;
break;
}
i = k;
ans++;
}
if (!np)
cout << ans;
else
cout << "-1";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000000 + 20;
int xor_n[maxn];
int p[maxn];
int n;
int q;
void init() {
xor_n[0] = 0;
for (int i = 1; i < maxn; i++) {
xor_n[i] = i ^ xor_n[i - 1];
}
}
int main() {
init();
while (~scanf("%d", &n)) {
q = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &p[i]);
q = q ^ p[i];
}
for (int i = 1; i <= n; i++) {
int tmp = n / i;
if (n % i == 0) {
if (tmp & 1) q = q ^ xor_n[i - 1];
} else {
if (tmp & 1)
q = q ^ xor_n[i - 1] ^ xor_n[n % i];
else
q = q ^ xor_n[n % i];
}
}
printf("%d\n", q);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXBUF = 10000;
char buf[MAXBUF], *ps = buf, *pe = buf + 1;
inline bool isdigit(const char& n) { return (n >= '0' && n <= '9'); }
inline void rnext() {
if (++ps == pe)
pe = (ps = buf) +
fread(buf, sizeof(char), sizeof(buf) / sizeof(char), stdin);
}
template <class T>
inline bool in(T& ans) {
ans = 0;
T f = 1;
if (ps == pe) return false;
do {
rnext();
if ('-' == *ps) f = -1;
} while (!isdigit(*ps) && ps != pe);
if (ps == pe) return false;
do {
ans = (ans << 1) + (ans << 3) + *ps - 48;
rnext();
} while (isdigit(*ps) && ps != pe);
ans *= f;
return true;
}
const int MAXOUT = 10000;
char bufout[MAXOUT], outtmp[50], *pout = bufout, *pend = bufout + MAXOUT;
inline void write() {
fwrite(bufout, sizeof(char), pout - bufout, stdout);
pout = bufout;
}
inline void out_char(char c) {
*(pout++) = c;
if (pout == pend) write();
}
inline void out_str(char* s) {
while (*s) {
*(pout++) = *(s++);
if (pout == pend) write();
}
}
template <class T>
inline void out_int(T x) {
if (!x) {
out_char('0');
return;
}
if (x < 0) x = -x, out_char('-');
int len = 0;
while (x) {
outtmp[len++] = x % 10 + 48;
x /= 10;
}
outtmp[len] = 0;
for (int i = 0, j = len - 1; i < j; i++, j--) swap(outtmp[i], outtmp[j]);
out_str(outtmp);
}
template <typename T, typename... T2>
inline int in(T& value, T2&... value2) {
in(value);
return in(value2...);
}
const double eps = 1e-9;
const int maxn = 5e5 + 10;
const int INF = 0x3f3f3f3f;
const int mod = 1e9 + 7;
int N, M, tmp, K, Q;
struct Edge {
int u, v, w, id;
} edge[maxn];
struct node {
int w, id, pointer;
friend bool operator<(node a, node b) { return a.w > b.w; }
};
vector<int> query[maxn];
priority_queue<node> P;
int Back[maxn][2];
int cnt;
int tree[maxn];
int Size[maxn];
int ans[maxn], ID[maxn];
void init() {
for (register int i = 1; i <= N; i++) tree[i] = i, Size[i] = 1;
}
int find(int p) {
if (p == tree[p]) return p;
return find(tree[p]);
}
bool Union(int u, int v) {
u = find(u);
v = find(v);
if (u == v) return false;
if (Size[u] > Size[v]) swap(u, v);
tree[u] = v;
Size[v] += Size[u];
Back[++cnt][0] = u;
Back[cnt][1] = v;
return true;
}
void Cancel() {
while (cnt) {
int u = Back[cnt][0];
int v = Back[cnt--][1];
tree[u] = u;
Size[v] -= Size[u];
}
}
bool cmp(Edge a, Edge b) { return a.w < b.w; }
bool cmp2(int a, int b) { return edge[a].w < edge[b].w; }
int main() {
in(N, M);
init();
for (register int i = 1; i <= M; i++)
in(edge[i].u, edge[i].v, edge[i].w), edge[i].id = i;
sort(edge + 1, edge + M + 1, cmp);
for (register int i = 1; i <= M; i++) ID[edge[i].id] = i;
in(Q);
for (register int i = 1; i <= Q; i++) {
in(tmp);
while (tmp--) {
int t;
in(t);
t = ID[t];
query[i].push_back(t);
}
sort(query[i].begin(), query[i].end());
node h;
h.id = i;
h.pointer = 0;
h.w = query[i][0];
P.push(h);
}
for (int i = 1; i <= M;) {
int W = edge[i].w;
int j = i + 1;
for (; j <= M && edge[j].w == edge[i].w; j++)
;
j--;
while (!P.empty()) {
node x = P.top();
if (x.w > j) break;
P.pop();
int v = x.id;
while (x.pointer < query[v].size() && query[v][x.pointer] <= j) {
if (!Union(edge[query[v][x.pointer]].u, edge[query[v][x.pointer]].v))
break;
x.pointer++;
}
Cancel();
if (x.pointer == query[v].size()) {
ans[x.id] = 1;
continue;
}
x.w = query[v][x.pointer];
if (x.w > j) P.push(x);
}
for (; i <= j; i++) Union(edge[i].u, edge[i].v);
cnt = 0;
}
for (register int i = 1; i <= Q; i++) {
if (ans[i] == 1)
puts("YES");
else
puts("NO");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
bool ask(vector<int> vt) {
printf("? %d ", (int)vt.size());
for (int i = 0; i < vt.size(); i++) printf("%d ", vt[i]);
printf("\n");
fflush(stdout);
int x;
scanf("%d", &x);
return x;
}
int id[3][5][7][8], ans[1005];
pair<int, int> num[11];
vector<int> vt[10];
bool vis1[10];
void dfs(int s1, int s2, int p, int d, vector<int> q) {
if (s1 == p - 1) {
if (!vis1[s2]) {
vis1[s2] = 1;
vt[s2] = q;
}
return;
}
if (d > 10) return;
dfs(s1, s2, p, d + 1, q);
q.push_back(num[d].second);
dfs(s1 + 1, (s2 + num[d].first) % p, p, d + 1, q);
}
bool vis2[1005];
int val[1005][4];
void solve_prime(int n, int p, int d) {
memset(vis1, 0, sizeof(vis1));
dfs(0, 0, p, 1, vector<int>());
memset(vis2, 0, sizeof(vis2));
int id, s = 0;
for (int i = 0; i < p; i++) {
if (s == p - 1 || !vis1[(p - i) % p]) {
id = i;
continue;
}
s++;
for (int j = 1; j <= n; j++)
if (!vis2[j] && !ans[j]) {
vector<int> cur = vt[(p - i) % p];
cur.push_back(j);
if (ask(cur)) {
vis2[j] = 1;
val[j][d] = i;
}
}
}
for (int i = 1; i <= n; i++)
if (!vis2[i] && !ans[i]) val[i][d] = id;
}
int main() {
int n;
scanf("%d", &n);
bool v = 0;
int fir = 0;
for (int i = 1; i <= n; i++) {
vector<int> cur;
for (int j = 1; j <= n; j++)
if (j != i) cur.push_back(j);
if (ask(cur)) {
ans[i] = ((!v) ? 1 : n);
if (ans[i] == 1) fir = i;
v = 1;
}
}
for (int i = 2; i <= (n >> 1) && i <= 5; i++)
for (int j = 1; j <= n; j++) {
vector<int> cur;
for (int k = 1; k <= n; k++)
if (k != j && (!ans[k] || min(ans[k], n - ans[k] + 1) >= i))
cur.push_back(k);
if (ask(cur)) {
cur.clear();
cur.push_back(fir);
cur.push_back(j);
ans[j] = ((ask(cur) ^ (i & 1)) ? n - i + 1 : i);
}
}
if (n > 10) {
int sz = 0;
for (int i = 1; i <= n; i++)
if (ans[i]) num[++sz] = pair<int, int>(ans[i], i);
sort(num + 1, num + sz + 1);
solve_prime(n, 3, 0);
solve_prime(n, 5, 1);
solve_prime(n, 7, 2);
solve_prime(n, 8, 3);
for (int i = 1; i <= n; i++) id[i % 3][i % 5][i % 7][i % 8] = i;
for (int i = 1; i <= n; i++)
if (!ans[i]) ans[i] = id[val[i][0]][val[i][1]][val[i][2]][val[i][3]];
}
if (ans[1] > (n >> 1)) {
for (int i = 1; i <= n; i++) ans[i] = n - ans[i] + 1;
}
printf("! ");
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
printf("\n");
fflush(stdout);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 1488;
string s;
long long n, k, chl = 1;
string one() {
string s2 = s;
chl = 0;
for (long long i = 0; i < n; i++) {
long long e0 = s[(i - 1 + n) % n] == 'W' ? 1 : 0;
long long e1 = s[i] == 'W' ? 1 : 0;
long long e2 = s[(i + 1) % n] == 'W' ? 1 : 0;
if (e0 + e1 + e2 >= 2)
s2[i] = 'W';
else
s2[i] = 'B';
if (s[i] != s2[i]) chl++;
}
return s2;
}
bool odin[N];
long long ps[N];
bool ban[N];
signed main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(0);
cin >> n >> k;
cin >> s;
long long oc = 0;
for (long long i = 0; i < n; i++) {
long long e0 = s[(i - 1 + n) % n] == 'W' ? 1 : 0;
long long e1 = s[i] == 'W' ? 1 : 0;
long long e2 = s[(i + 1) % n] == 'W' ? 1 : 0;
if (e1 != e0 && e1 != e2) odin[i] = 1, oc++;
}
if (oc == n) {
if (k & 1) s = one();
cout << s << '\n';
return 0;
}
long long wp = n - 1;
while (odin[wp]) --wp;
for (long long i = (wp + 1) % n, j = 0; j < n; j++, i = (i + 1) % n) {
if (odin[i])
ps[i] = ps[(i + n - 1) % n] + 1;
else
ps[i] = 0;
}
wp = 0;
while (odin[wp]) ++wp;
for (long long i = (wp - 1 + n) % n, j = 0; j < n; j++, i = (i - 1 + n) % n) {
if (odin[i]) ps[i] = min(ps[i], ps[(i + 1) % n] + 1);
}
long long p2 = wp;
ban[wp] = 1;
while (true) {
bool cd = 1;
while (!odin[p2]) {
p2 = (p2 + 1) % n;
if (ban[p2]) {
cd = 0;
break;
}
ban[p2] = 1;
}
if (!cd) break;
long long p1 = p2;
while (odin[p2]) {
p2 = (p2 + 1) % n;
if (ban[p2] && odin[p2]) {
cd = 0;
break;
}
ban[p2] = 1;
}
if (!cd) break;
long long p3 = p2;
p2 = (p2 + n - 1) % n;
long long us = (p1 <= p2 ? p2 - p1 + 1 : n - p1 + p2 + 1);
for (long long op = 0; op < k && us > 0; op++) {
odin[p1] = 0, odin[p2] = 0;
if (p1 <= p2) {
s[p1] = s[(p1 + n - 1) % n];
s[p2] = s[(p2 + 1) % n];
++p1, p2--;
us -= 2;
} else {
s[p1] = s[(p1 + n - 1) % n];
s[p2] = s[(p2 + 1) % n];
p1 = (p1 + 1) % n;
p2 = (p2 + n - 1) % n;
us -= 2;
}
}
p2 = p3;
}
for (long long i = 0; i < n; i++) {
if (odin[i] && k % 2 == 1) {
s[i] = (s[i] == 'W' ? 'B' : 'W');
}
}
cout << s;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b;
cin >> a >> b;
if (a != b) cout << 1;
if (a == b) cout << a;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, two, r, now, ans, l;
char c[1000005];
bool three;
int main() {
scanf("%d ", &n);
gets(c);
now = '1' + '0' - c[0];
for (int i = 0; i < n; i++) {
if (c[i] == now) {
r++;
} else {
now = '1' + '0' - now;
r = 1;
ans++;
}
if (r == 2) {
two++;
l = i;
}
if (r == 3) three = 1;
}
if (two > 1 || three)
ans += 2;
else if (two == 1)
ans += 1;
printf("%d", ans);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long city[1001][1001], n, m, lr, gr, lc, gc;
vector<long long> c[1001], r[1001];
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
scanf("%I64d", &city[i][j]);
r[i].push_back(city[i][j]);
c[j].push_back(city[i][j]);
}
}
for (int i = 1; i <= n; i++) {
sort(r[i].begin(), r[i].end());
auto last = unique(r[i].begin(), r[i].end());
r[i].erase(last, r[i].end());
}
for (int i = 1; i <= m; i++) {
sort(c[i].begin(), c[i].end());
auto last = unique(c[i].begin(), c[i].end());
c[i].erase(last, c[i].end());
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
lr = (lower_bound(r[i].begin(), r[i].end(), city[i][j]) - r[i].begin());
lc = (lower_bound(c[j].begin(), c[j].end(), city[i][j]) - c[j].begin());
gr = r[i].size() - lr - 1;
gc = c[j].size() - lc - 1;
cout << max(lr, lc) + max(gr, gc) + 1 << ' ';
}
cout << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct tree {
tree* l;
tree* r;
long long cnt;
tree() {
l = NULL;
r = NULL;
cnt = 0;
}
};
tree* top = new tree();
void add(long long x) {
tree* cur = top;
for (long long i = 29; i >= 0; i--) {
if (x & (1 << i)) {
if (!cur->r) cur->r = new tree();
cur = cur->r;
} else {
if (!cur->l) cur->l = new tree();
cur = cur->l;
}
}
}
long long solve(tree* cur, long long bits = 29) {
if (cur->l && cur->r) {
return min(solve(cur->l, bits - 1), solve(cur->r, bits - 1)) +
(1ll << bits);
} else if (cur->r) {
return solve(cur->r, bits - 1);
} else if (cur->l) {
return solve(cur->l, bits - 1);
} else {
return 0;
}
}
signed main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(0);
;
long long n;
cin >> n;
vector<long long> a(n);
for (auto& z : a) {
cin >> z;
add(z);
}
cout << solve(top);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long cnt[200005] = {0};
int main() {
long long n;
cin >> n;
cnt[1] = 10;
long long sum1 = 10, sum2 = 0, sum3 = 0;
for (long long i = 2ll; i <= n; i++) {
sum1 *= 10ll;
sum1 %= 998244353;
sum2 += 2ll * cnt[i - 1ll];
sum2 %= 998244353;
sum2 += sum3;
cnt[i] = (sum1 * i % 998244353 - sum2 % 998244353 + 998244353) % 998244353;
sum3 += cnt[i - 1];
sum3 %= 998244353;
}
for (int i = n; i >= 1; i--) {
if (i != n) cout << " ";
cout << cnt[i];
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int mod = 1e9 + 7;
const int inf = (1 << 30) - 1;
const ll infll = (1LL << 61) - 1;
ll r, g, b, ans;
int main() {
cin >> r >> g >> b;
if (max(r, max(g, b)) >= 2 * (r + g + b - max(r, max(g, b))))
ans = r + g + b - max(r, max(g, b));
else
ans = (r + g + b) / 3;
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m, Max, Min, d = 0;
int a[101];
int main() {
cin >> n >> m >> Min >> Max;
for (int i = 0; i < m; i++) {
cin >> a[i];
if (a[i] != Min && a[i] != Max) d++;
}
if (d > n - 2) {
cout << "Incorrect" << endl;
return 0;
}
for (int i = 0; i < m; i++) {
if (a[i] > Max || a[i] < Min) {
cout << "Incorrect" << endl;
return 0;
}
}
cout << "Correct" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 300005, OO = 1110111110111, mod = 1000000007,
mod2 = 998244353;
long long n, a[N], sol;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
long long acc = 0, prs = 0;
for (int i = 0; i < n; i++) {
long long mn = min(acc, a[i] / 2);
sol += mn;
acc -= mn;
a[i] -= mn * 2;
long long m3 = a[i] / 3;
sol += m3;
a[i] -= 3 * m3;
acc += a[i] % 3;
}
cout << sol;
return 0;
}
| 5 |
/*
Author: QAQAutoMaton
Lang: C++
Code: C1.cpp
Mail: [email protected]
Blog: https://www.qaq-am.com/
*/
#include<bits/stdc++.h>
#define debug(qaq...) fprintf(stderr,qaq)
#define DEBUG printf("Passing [%s] in LINE %d\n",__FUNCTION__,__LINE__)
#define Debug debug("Passing [%s] in LINE %d\n",__FUNCTION__,__LINE__)
#define all(x) x.begin(),x.end()
#define x first
#define y second
#define unq(a) sort(all(a)),a.erase(unique(all(a)),a.end())
using namespace std;
typedef unsigned uint;
typedef long long ll;
typedef unsigned long long ull;
typedef complex<double> cp;
typedef pair<int,int> pii;
int inf;
const double eps=1e-8;
const double pi=acos(-1.0);
template<class T,class T2>int chkmin(T &a,T2 b){return a>b?a=b,1:0;}
template<class T,class T2>int chkmax(T &a,T2 b){return a<b?a=b,1:0;}
template<class T>T sqr(T a){return a*a;}
template<class T,class T2>T mmin(T a,T2 b){return a<b?a:b;}
template<class T,class T2>T mmax(T a,T2 b){return a>b?a:b;}
template<class T>T aabs(T a){return a<0?-a:a;}
template<class T>int dcmp(T a,T b){return a>b;}
template<int *a>int cmp_a(int x,int y){return a[x]<a[y];}
template<class T>bool sort2(T &a,T &b){return a>b?swap(a,b),1:0;}
#define min mmin
#define max mmax
#define abs aabs
struct __INIT__{
__INIT__(){
fill((unsigned char*)&inf,(unsigned char*)&inf+sizeof(inf),0x3f);
}
}__INIT___;
namespace io {
const int SIZE = (1 << 21) + 1;
char ibuf[SIZE], *iS, *iT, obuf[SIZE], *oS = obuf, *oT = oS + SIZE - 1, c, qu[55]; int f, qr;
// getchar
#define gc() (iS == iT ? (iT = (iS = ibuf) + fread (ibuf, 1, SIZE, stdin), (iS == iT ? EOF : *iS ++)) : *iS ++)
// print the remaining part
inline void flush () {
fwrite (obuf, 1, oS - obuf, stdout);
oS = obuf;
}
// putchar
inline void putc (char x) {
*oS ++ = x;
if (oS == oT) flush ();
}
template<typename A>
inline bool read (A &x) {
for (f = 1, c = gc(); c < '0' || c > '9'; c = gc()) if (c == '-') f = -1;else if(c==EOF)return 0;
for (x = 0; c <= '9' && c >= '0'; c = gc()) x = x * 10 + (c & 15); x *= f;
return 1;
}
inline bool read (char &x) {
while((x=gc())==' '||x=='\n' || x=='\r');
return x!=EOF;
}
inline bool read(char *x){
while((*x=gc())=='\n' || *x==' '||*x=='\r');
if(*x==EOF)return 0;
while(!(*x=='\n'||*x==' '||*x=='\r'||*x==EOF))*(++x)=gc();
*x=0;
return 1;
}
template<typename A,typename ...B>
inline bool read(A &x,B &...y){
return read(x)&&read(y...);
}
template<typename A>
inline bool write (A x) {
if (!x) putc ('0'); if (x < 0) putc ('-'), x = -x;
while (x) qu[++ qr] = x % 10 + '0', x /= 10;
while (qr) putc (qu[qr --]);
return 0;
}
inline bool write (char x) {
putc(x);
return 0;
}
inline bool write(const char *x){
while(*x){putc(*x);++x;}
return 0;
}
inline bool write(char *x){
while(*x){putc(*x);++x;}
return 0;
}
template<typename A,typename ...B>
inline bool write(A x,B ...y){
return write(x)||write(y...);
}
//no need to call flush at the end manually!
struct Flusher_ {~Flusher_(){flush();}}io_flusher_;
}
using io :: read;
using io :: putc;
using io :: write;
const int p=1000000007;
struct Z{
uint x;
Z(){}
Z(uint a){
x=a;
}
};
inline uint modp(const uint x){
return x<p?x:x-p;
}
inline Z operator+(const Z x1, const Z x2) { return modp(x1.x+x2.x);}
inline Z operator-(const Z x1, const Z x2) { return modp(x1.x+p-x2.x);}
inline Z operator-(const Z x) {return x.x?p-x.x:0;}
inline Z operator*(const Z x1, const Z x2) { return static_cast<ull>(x1.x)*x2.x%p;}
void exgcd(int a,int b,int &x,int &y){
if(!b){x=1;y=0;return;}
exgcd(b,a%b,y,x);
y-=(a/b)*x;
}
inline Z Inv(const Z a){
int x,y;
exgcd(p,a.x,x,y);
return y<0?y+=p:y;
}
inline Z operator/(const Z x1, const Z x2) { return x1*Inv(x2);}
inline Z &operator++(Z &x1){x1.x==p-1?x1.x=0:++x1.x;return x1;}
inline Z &operator--(Z &x1){x1.x?--x1.x:x1.x=p-1;return x1;}
inline Z &operator+=(Z &x1, const Z x2) { return x1 = x1 + x2; }
inline Z &operator-=(Z &x1, const Z x2) { return x1 = x1 - x2; }
inline Z &operator*=(Z &x1, const Z x2) { return x1 = x1 * x2; }
inline Z &operator/=(Z &x1, const Z x2) { return x1 = x1 / x2; }
inline Z fpm(Z a,int b){Z c(1);for(;b;b>>=1,a*=a)if(b&1)c*=a;return c;}
int c[105],b[105];
Z f[10005],g[10005];
int w[105];
signed main(){
#ifdef QAQAutoMaton
freopen("C1.in","r",stdin);
freopen("C1.out","w",stdout);
#endif
int n;
read(n);
int l=0;
for(int i=1;i<=n;++i){
read(c[i]);
}
for(int i=l;~i;--i)f[i]+=f[i+1];
for(int i=1;i<n;++i){
read(b[i]);
}
int ss=0;
for(int i=2;i<=n;++i){
ss+=b[i-1];
w[i]=w[i-1]+ss;
}
int q;
read(q);
int x;
for(;q;--q){
read(x);
for(int i=0;i<=l;++i)f[i]=0;
f[0]=1;
l=0;
for(int i=1;i<=n;++i){
g[0]=f[0];
l+=c[i];
for(int j=1;j<=l;++j)g[j]=f[j]+g[j-1];
for(int j=0;j<=l;++j){
f[j]=g[j]-(j>c[i]?g[j-c[i]-1]:0);
}
for(int j=0;j<=l;++j){
if(x*i+w[i]>j)f[j]=0;
}
}
Z ans(0);
for(int i=0;i<=l;++i)ans+=f[i];
write(ans.x,'\n');
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int parent[100000];
bool inSet[100000];
set<int> children[100000];
bool respect[100000];
set<int> canDel;
int main() {
int N;
cin >> N;
for (int i = 0; i < N; i++) {
inSet[i] = true;
cin >> parent[i];
if (parent[i] != -1) {
parent[i]--;
children[parent[i]].insert(i);
}
cin >> respect[i];
}
for (int i = 0; i < N; i++) {
if (respect[i] == 0) continue;
bool none = false;
for (auto q : children[i]) {
if (respect[q] == 0) {
none = true;
break;
}
}
if (!none) {
canDel.insert(i);
}
}
if (canDel.size() == 0) cout << -1 << endl;
for (auto i : canDel) cout << i + 1 << ' ';
cout << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int main() {
cin >> n >> m;
if (m > 2 * (n + 1) or n > m + 1) {
cout << -1 << endl;
return 0;
}
while (n or m) {
if (m >= 2 && !(n > m - 1)) {
cout << 11;
m -= 2;
} else if (m != 0 && !(n > m)) {
cout << 1;
m -= 1;
}
if (n) {
cout << 0;
n -= 1;
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long comp(long long c) {
long long ans = c;
if (ans % 2 == 0) {
ans /= 2;
ans *= (c + 1);
} else {
ans *= ((c + 1) / 2);
}
return ans;
}
long long worker() {
int n, m;
scanf("%d%d", &n, &m);
vector<int> pid(n + 1);
int i;
for (i = 0; i < n; i++) {
int x;
scanf("%d", &x);
pid[x] = i;
}
set<pair<int, int> > foes;
for (i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
int l = min(pid[a], pid[b]);
int r = max(pid[a], pid[b]);
foes.insert(make_pair(r, l));
}
long long ans = 0;
set<pair<int, int> >::iterator it;
int last = 0;
for (it = foes.begin(); it != foes.end(); it++) {
int r = it->first;
int l = it->second;
long long c1 = r - last;
long long c2 = r - l - 1;
if (c2 >= c1) continue;
ans += (comp(c1) - comp(c2));
last = l + 1;
}
long long d = n - last;
ans += comp(d);
return ans;
}
int main() {
printf("%I64d", worker());
int xx;
cin >> xx;
return 0;
}
| 5 |
/*
Author : Prathamesh Wagh
*/
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,fma")
#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
using namespace std;
int MOD = 998244353;
#define int long long
#define dbg(x) cout<<#x<<" = "<<x<<"\n"
#define pb push_back
#define fi first
#define se second
#define fast_cin() ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL)
void solve(){
int n;
cin >> n;
vector<int> a(n);
vector<int> b(n);
for(int i=0;i<n;i++){
cin >> a[i];
}
for(int i=0;i<n;i++){
cin >> b[i];
}
vector<vector<int>> ans;
for(int i=0;i<n;i++){
if(a[i] != b[i]){
for(int j=i+1;j<n;j++){
while(a[i] < b[i] && a[j] > b[j]){
ans.push_back({j+1,i+1});
a[i]++;
a[j]--;
}
while(a[i] > b[i] && a[j] < b[j]){
ans.push_back({i+1,j+1});
a[i]--;
a[j]++;
}
}
}
}
for(int i=0;i<n;i++){
if(a[i] != b[i]){
cout << -1 << "\n";
return ;
}
}
cout << ans.size() << "\n";
for(auto it : ans){
cout << it[0] << " " << it[1] << "\n";
}
}
int32_t main()
{
fast_cin();
int t;
cin >> t;
while(t--) {
solve();
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 66;
int c[1 << 16];
void cc() {
int m = 1 << 16, i, j;
for (i = 0; i < m; i = i + 1)
for (j = 1; j < m; j = j + j)
if (i & j) c[i]++;
}
int cnt(long long x) {
if (!x) return 0;
return c[(long long)x & 65535] + cnt(x >> 16);
}
int n, m, a[N], b[N];
map<int, long long> MA, MB;
map<int, long long>::iterator it;
long long aa[N * N], bb[N * N];
int main() {
cc();
int i, j, x, ans = 0;
cin >> n >> m;
for (i = 0; i < n; i = i + 1) cin >> a[i];
for (i = 0; i < m; i = i + 1) cin >> b[i];
for (i = 0; i < n; i = i + 1)
for (j = 0; j < m; j = j + 1)
MA[a[i] + b[j]] |= ((long long)1 << i),
MB[a[i] + b[j]] |= ((long long)1 << j);
for (i = 0; i < n; i = i + 1)
for (j = 0; j < m; j = j + 1)
aa[i * m + j] = MA[a[i] + b[j]], bb[i * m + j] = MB[a[i] + b[j]];
for (i = 0; i < n * m; i = i + 1)
for (j = i; j < n * m; j = j + 1) {
x = cnt(aa[i] | aa[j]) + cnt(bb[i] | bb[j]);
if (ans < x) ans = x;
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200000 + 5;
int minst[N][27];
int maxst[N][27];
int n;
void inst() {
for (int j = 1; (1 << j) <= n; j++) {
for (int i = 1; i + (1 << j) - 1 <= n; i++) {
minst[i][j] = min(minst[i][j - 1], minst[i + (1 << (j - 1))][j - 1]);
maxst[i][j] = max(maxst[i][j - 1], maxst[i + (1 << (j - 1))][j - 1]);
}
}
return;
}
int query(int l, int r) {
int x = log(r - l + 1.0) / log(2.0);
int maxx = max(maxst[l][x], maxst[r - (1 << x) + 1][x]);
int minn = min(minst[l][x], minst[r - (1 << x) + 1][x]);
if (maxx > minn) return 1;
if (maxx == minn) return 0;
return -1;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &maxst[i][0]);
for (int i = 1; i <= n; i++) scanf("%d", &minst[i][0]);
inst();
long long ans = 0;
for (int i = 1; i <= n; i++) {
int l = i, r = n;
int fr = 0, la = 0;
while (l <= r) {
int m = (l + r) >> 1;
if (query(i, m) == 0) fr = m;
if (query(i, m) >= 0)
r = m - 1;
else
l = m + 1;
}
if (fr == 0) continue;
l = fr, r = n;
while (l <= r) {
int m = (l + r) >> 1;
if (query(i, m) > 0)
r = m - 1;
else
la = m, l = m + 1;
}
ans += 1ll * (la - fr + 1);
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
for (int i = 1000000000; i >= 1; i = i / 10) {
int temp = n / i;
if (temp > 0) {
int ans = (temp + 1) * i;
printf("%d\n", ans - n);
break;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2000;
inline long long read() {
register long long s = 0;
register bool neg = 0;
register char c = getchar();
for (; c < '0' || c > '9'; c = getchar()) neg |= (c == '-');
for (; c >= '0' && c <= '9'; s = s * 10 + (c ^ 48), c = getchar())
;
return (neg ? -s : s);
}
long long a, s[N + 10][N + 10], dis[N + 10];
bool vis[N + 10];
inline void dij(long long n) {
memset(dis, 0x3f, sizeof(dis));
for (long long i = 1; i <= a; i++) {
for (long long j = 1; j <= a; j++)
if (i != j) dis[i] = min(dis[i], s[i][j] * 2);
}
dis[n] = 0;
for (long long i = 1; i <= a; i++) {
long long mx = 0;
for (long long j = 1; j <= a; j++)
if (!vis[j] && (dis[j] < dis[mx] || mx == 0)) mx = j;
vis[mx] = 1;
for (long long j = 1; j <= a; j++) {
if (vis[j]) continue;
if (dis[j] > dis[mx] + s[mx][j]) dis[j] = dis[mx] + s[mx][j];
}
}
}
signed main() {
a = read();
long long mn = 1e18, p;
for (long long i = 1; i < a; i++) {
for (long long j = i + 1; j <= a; j++) {
s[i][j] = s[j][i] = read();
if (s[i][j] < mn) {
mn = s[i][j];
p = i;
}
}
}
for (long long i = 1; i <= a; i++)
for (long long j = i + 1; j <= a; j++) s[i][j] -= mn, s[j][i] -= mn;
dij(p);
for (long long i = 1; i <= a; i++) printf("%lld\n", dis[i] + mn * (a - 1));
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 100100;
const long long AA = 1000000;
long long n;
long long num[MAXN];
long long snum[MAXN];
long long nused[MAXN];
long long loc[MAXN];
long long l[2 * MAXN], r[2 * MAXN];
bool lucky(long long x) {
while (x > 0) {
if ((x % 10 != 4) && (x % 10 != 7)) return false;
x /= 10;
}
return true;
}
long long findloc(long long x) {
long long lo = 0, hi = n - 1;
while (lo < hi) {
long long mid = (lo + hi) / 2;
if (x > snum[mid])
lo = mid + 1;
else
hi = mid;
}
return lo;
}
int main() {
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> num[i];
num[i] *= AA;
snum[i] = num[i];
}
sort(snum, snum + n);
for (long long i = 0; i < MAXN; i++) nused[i] = 0;
for (long long i = 0; i < n; i++) {
long long lo = findloc(num[i]);
loc[lo + nused[lo]] = i;
num[i] += nused[lo];
nused[lo]++;
}
for (int i = 0; i < MAXN; i++) {
if (nused[i]) {
for (int j = i + 1; j < i + nused[i]; j++) snum[j] += j - i;
i += nused[i] - 1;
}
}
long long lnum = -1;
for (long long i = 0; i < n; i++)
if (lucky(num[loc[i]] / AA) && (nused[i] > 0)) {
lnum = i;
break;
}
if (lnum == -1) {
bool check = true;
for (long long i = 0; i < n - 1; i++)
if (num[i] > num[i + 1]) check = false;
if (check) {
cout << "0\n";
return 0;
} else {
cout << "-1\n";
return 0;
}
}
long long k = 0;
long long cur = 0;
while (cur < n) {
if (cur == lnum) {
cur++;
continue;
}
if (loc[lnum] != cur) {
l[k] = loc[lnum];
r[k] = cur;
k++;
swap(num[loc[lnum]], num[cur]);
swap(loc[lnum], loc[findloc(num[loc[lnum]])]);
}
if (loc[cur] != cur) {
l[k] = loc[cur];
r[k] = cur;
k++;
swap(num[cur], num[loc[cur]]);
swap(loc[lnum], loc[cur]);
}
cur++;
}
cout << k << "\n";
for (long long i = 0; i < k; i++) cout << l[i] + 1 << " " << r[i] + 1 << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long fact[200010];
long long fpow(long long a, int b) {
if (b == 0) return 1;
long long tmp = fpow(a, b / 2);
tmp = (tmp * tmp) % 1000000007;
if (b % 2 == 0) return tmp;
return (a * tmp) % 1000000007;
}
long long binomial(int a, int b) {
if (b > a || b < 0 || a < 0) return 0;
long long den = 1, num = 1;
num = fact[a];
den = (fact[b] * fact[a - b]) % 1000000007;
return (fpow(den, 1000000007 - 2) * num) % 1000000007;
}
int main() {
int l, t, w;
cin >> l >> t >> w;
l = t + l;
fact[0] = 1;
for (int i = 1; i <= l; i++) fact[i] = (i * fact[i - 1]) % 1000000007;
long long ans = 0;
if (w == 0) {
for (int i = 0; i < l - 1; i += 2) {
ans = ans + binomial(l - i - 1, t - 1);
ans %= 1000000007;
}
} else {
for (int i = 1; i < l - 1; i += 2) {
ans = ans + binomial(l - i - 1, t - 1);
ans %= 1000000007;
}
}
if (t == 0 && l % 2 != w) ans++;
if (t == 1 && l % 2 == w) ans++;
ans %= 1000000007;
if (l == 2) {
if (t == 1) {
if (w == 0)
ans = 2;
else
ans = 0;
} else {
if (t == 2) {
ans = (w == 0);
} else
ans = (w == 1);
}
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9;
const long long N = 3e3 + 1;
const long long mod = 1e7 + 9;
const long double eps = 1E-7;
int ans;
int n, a[N];
int x, y, mx;
void dfs(int v) {
y = max(y, a[v]);
if (v * 2 >= mx) return;
a[v * 2] += a[v];
a[v * 2 + 1] += a[v];
dfs(v * 2), dfs(v * 2 + 1);
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
mx = (1 << n + 1);
for (int i = 2; i < mx; i++) cin >> a[i];
dfs(1);
for (int i = mx / 2; i >= 1; i /= 2) {
for (int j = mx / 2; j < mx; j += i) {
x = 0;
for (int h = j; h < j + i; h++) {
x = max(x, a[h]);
}
ans += y - x;
for (int h = j; h < j + i; h++) {
a[h] += y - x;
}
}
}
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:128777216")
const long long LINF = 1000000000000000000LL;
const int INF = 1000000000;
const long double eps = 1e-9;
const long double PI = 3.1415926535897932384626433832795l;
using namespace std;
void prepare(string s) {
if (s.length() != 0) {
freopen((s + ".in").c_str(), "r", stdin);
freopen((s + ".out").c_str(), "w", stdout);
}
}
const int NMAX = 200100;
long long a[NMAX], d[NMAX];
int main() {
clock_t time = clock();
prepare("");
int n, k, v;
cin >> n >> k;
for (int i = (int)1; i <= (int)n; i++) {
cin >> a[i];
}
int l = 1, cnt = 0;
long long t;
while (l != n + 1) {
t = d[l - 1] - (n - l) * a[l] * (l - cnt - 1);
if (t < k) {
cout << l << endl;
cnt++;
d[l] = d[l - 1];
} else {
d[l] = d[l - 1] + a[l] * (l - cnt - 1);
}
l++;
}
time = clock() - time;
return 0;
}
| 4 |
#include <bits/stdc++.h>
template <typename T>
void scan(T &x) {
x = 0;
register bool _ = 0;
register T c = getchar();
_ = c == 45;
c = _ ? getchar() : c;
while (c < 48 || c > 57) c = getchar();
for (; c < 48 || c > 57; c = getchar())
;
for (; c > 47 && c < 58; c = getchar()) x = (x << 3) + (x << 1) + (c & 15);
x = _ ? -x : x;
}
template <typename T>
void printn(T n) {
register bool _ = 0;
_ = n < 0;
n = _ ? -n : n;
char snum[65];
int i = 0;
do {
snum[i++] = n % 10 + 48;
n /= 10;
} while (n);
--i;
if (_) putchar(45);
while (i >= 0) putchar(snum[i--]);
}
template <typename First, typename... Ints>
void scan(First &arg, Ints &...rest) {
scan(arg);
scan(rest...);
}
template <typename T>
void print(T n) {
printn(n);
putchar(10);
}
template <typename First, typename... Ints>
void print(First arg, Ints... rest) {
printn(arg);
putchar(32);
print(rest...);
}
using namespace std;
double h, l, x;
int main() {
cin >> h >> l;
x = (h * h + l * l) / (2 * h) - h;
printf("%.9lf\n", x);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double left, right;
double a, b;
scanf("%lf%lf", &a, &b);
left = a - b;
right = a + b;
if (left < 0) {
cout << "-1\n";
return 0;
}
if (left == 0) {
printf("%lf\n", a);
return 0;
}
if (left < 2 * b) {
printf("%lf\n", right / 2);
return 0;
}
int n1 = left / (2 * b), n2 = right / (2 * b);
printf("%.14lf\n", (left / n1 / 2) < (right / n2 / 2) ? (left / n1 / 2)
: (right / n2 / 2));
return 0;
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.