solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool mini(T &a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
bool maxi(T &a, T b) {
return a < b ? (a = b, true) : false;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.precision(10);
cout << fixed;
int n;
long long k;
cin >> n >> k;
vector<int> a(n);
for (int i = 0; i < (int)(n); i++) cin >> a[i];
sort((a).begin(), (a).end());
vector<int> val = a;
val.resize(unique((val).begin(), (val).end()) - val.begin());
map<int, int> cnt;
for (int v : a) cnt[v]++;
int l = 0, r = (int)val.size() - 1;
int cntl = cnt[val[l]], cntr = cnt[val[r]];
int ans = val[r] - val[l];
while (l < r) {
if (cntl < cntr) {
int tl = min((long long)val[l + 1], val[l] + k / cntl);
k -= (long long)(tl - val[l]) * cntl;
mini(ans, val[r] - tl);
if (k == 0 || k < cntr) break;
cntl += cnt[val[++l]];
} else {
int tr = max((long long)val[r - 1], val[r] - k / cntr);
k -= (long long)(val[r] - tr) * cntr;
mini(ans, tr - val[l]);
if (k == 0 || k < cntl) break;
cntr += cnt[val[--r]];
}
}
cout << ans << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int l, d, v, g, r;
cin >> l >> d >> v >> g >> r;
if (l <= d) {
float val = l / (float)v;
cout << setprecision(7) << val;
return 0;
}
int c = (d / v) % (g + r);
float ff = (d / float(v)) - (d / v);
if (c + 1 <= g) {
float val = l / (float)v;
cout << setprecision(7) << val;
} else {
float val = l / (float)v + (g + r) - (c + ff);
cout << setprecision(7) << val;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
cin >> n;
vector<int> s;
s.push_back(1);
for (int i = 1; i < n; i++) {
s.push_back(1);
while (s.size() > 1 && s[s.size() - 2] == s[s.size() - 1]) {
s[s.size() - 2]++;
s.pop_back();
}
}
cout << s[0];
for (int i = 1; i < s.size(); i++) {
cout << " " << s[i];
}
cout << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int dp[31][31][51], t, n, m, k;
int v(int h, int w, int c) {
if (h < w) swap(h, w);
if (c == 0 || c == h * w)
return dp[h][w][c] = 0;
else if (c > h * w)
return dp[h][w][c] = 2929292;
else if (dp[h][w][c] != -1)
return dp[h][w][c];
else {
dp[h][w][c] = 2929292;
for (int i = (1); i <= (h - 1); i++)
for (int j = (0); j <= (c); j++)
dp[h][w][c] = min(dp[h][w][c], w * w + v(i, w, j) + v(h - i, w, c - j));
for (int i = (1); i <= (w - 1); i++)
for (int j = (0); j <= (c); j++)
dp[h][w][c] = min(dp[h][w][c], h * h + v(h, i, j) + v(h, w - i, c - j));
return dp[h][w][c];
}
}
int main() {
memset(dp, -1, sizeof(dp));
scanf("%d", &t);
while (t--) {
scanf("%d %d %d", &n, &m, &k);
printf("%d\n", v(n, m, k));
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e3 + 10;
const int base = 37;
const int mod = 1e9 + 7;
int n;
string s;
int pw[maxn], hsh[maxn];
int getHash(int L, int R) {
int tmp = 0;
if (L > 0) tmp = 1ll * hsh[L - 1] * pw[R - L + 1] % mod;
return (hsh[R] - tmp + mod) % mod;
}
bool check(int L, int R) {
int len = R - L + 1;
int x = getHash(L, R);
for (int i = 0; i + len - 1 < L; i++)
if (x == getHash(i, i + len - 1)) return 1;
return 0;
}
void buildHash() {
pw[0] = 1;
for (int i = 1; i <= n; i++) pw[i] = 1ll * pw[i - 1] * base % mod;
for (int i = 0; i < n; i++) {
if (i == 0) {
hsh[i] = int(s[i] - 'a') + 1;
continue;
}
hsh[i] = (1ll * hsh[i - 1] * base % mod + int(s[i] - 'a') + 1) % mod;
}
}
int dp[maxn];
int main() {
ios_base::sync_with_stdio(false);
int a, b;
cin >> n >> a >> b;
cin >> s;
buildHash();
for (int i = 0; i < n; i++) {
if (i == 0) {
dp[i] = a;
continue;
}
int lo = 0, hi = (i + 1) / 2 + 1;
while (hi - lo > 1) {
int mid = (lo + hi) >> 1;
if (check(i - mid + 1, i))
lo = mid;
else
hi = mid;
}
dp[i] = dp[i - 1] + a;
if (lo > 0) dp[i] = min(dp[i], dp[i - lo] + b);
}
cout << dp[n - 1] << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 100;
vector<int> f[maxn];
int n, x, y;
long long g[maxn], dp[maxn], sz[maxn], dep[maxn], depx[maxn];
void dfs(int u, int fa, long long deep) {
int sum = 0;
sz[u] = 1;
dep[u] = deep;
depx[u] = deep;
for (int i = 0; i < f[u].size(); i++) {
int v = f[u][i];
if (v == fa) continue;
dfs(v, u, deep + 1);
depx[u] = max(depx[v], depx[u]);
sz[u] += sz[v];
sum++;
}
g[u] = sz[u];
if (sum == 0) {
dp[u] = 1;
return;
}
for (int i = 0; i < f[u].size(); i++) {
int v = f[u][i];
if (v == fa) continue;
g[u] += g[v];
}
}
long long ans = 0;
void dfs2(int u, int fa) {
for (int i = 0; i < f[u].size(); i++) {
int v = f[u][i];
if (v == fa) continue;
g[v] = g[u] + sz[u] - 2 * sz[v];
sz[v] = sz[u];
if (g[v] > ans) ans = g[v];
dfs2(v, u);
}
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i < n; i++) {
cin >> x >> y;
f[x].push_back(y);
f[y].push_back(x);
}
dfs(1, -1, 1);
dfs2(1, -1);
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
int n, m;
int sl[311111 << 2], sr[311111 << 2];
int pw[311111] = {1}, a[311111];
char s[311111];
int ql, qr, qd;
void bld(int x, int l, int r) {
if (l == r)
sl[x] = sr[x] = s[l] == 'L' ? 0 : 1;
else {
bld((x << 1), l, ((l + r) >> 1)),
bld(((x << 1) | 1), ((l + r) >> 1) + 1, r);
sl[x] = sl[(x << 1)] * pw[r - ((l + r) >> 1)] + sl[((x << 1) | 1)];
sr[x] = sr[((x << 1) | 1)] * pw[((l + r) >> 1) - l + 1] + sr[(x << 1)];
}
}
void update(int x, int l, int r) {
if (l == r)
sl[x] = sr[x] = s[l] == 'L' ? 0 : 1;
else {
if (qd <= ((l + r) >> 1))
update((x << 1), l, ((l + r) >> 1));
else
update(((x << 1) | 1), ((l + r) >> 1) + 1, r);
sl[x] = sl[(x << 1)] * pw[r - ((l + r) >> 1)] + sl[((x << 1) | 1)];
sr[x] = sr[((x << 1) | 1)] * pw[((l + r) >> 1) - l + 1] + sr[(x << 1)];
}
}
int query_l(int x, int l, int r) {
if (ql <= l && qr >= r)
return sl[x];
else {
int ll = 0, rr = 0;
if (ql <= ((l + r) >> 1)) ll = query_l((x << 1), l, ((l + r) >> 1));
if (qr > ((l + r) >> 1))
rr = query_l(((x << 1) | 1), ((l + r) >> 1) + 1, r);
if (ql > ((l + r) >> 1)) return rr;
if (qr <= ((l + r) >> 1)) return ll;
return ll * pw[min(r, qr) - ((l + r) >> 1)] + rr;
}
}
int query_r(int x, int l, int r) {
if (ql <= l && qr >= r)
return sr[x];
else {
int ll = 0, rr = 0;
if (ql <= ((l + r) >> 1)) ll = query_r((x << 1), l, ((l + r) >> 1));
if (qr > ((l + r) >> 1))
rr = query_r(((x << 1) | 1), ((l + r) >> 1) + 1, r);
if (qr <= ((l + r) >> 1)) return ll;
if (ql > ((l + r) >> 1)) return rr;
return rr * pw[((l + r) >> 1) - max(l, ql) + 1] + ll;
}
}
int main() {
int t, x, y, z, ca = 1;
scanf("%d", &(n));
for (int i = (int)(1); i <= (int)(n); ++i) scanf("%d", &(a[i]));
for (int i = (int)(1); i <= (int)(n); ++i) s[i] = 'R';
for (int i = (int)(1); i <= (int)(311111 - 10); ++i)
pw[i] = pw[i - 1] * 1000000007;
bld(1, 1, n);
int good = 0;
for (int i = (int)(1); i <= (int)(n); ++i) {
s[a[i]] = 'L';
qd = a[i];
update(1, 1, n);
int pa, pb, aa = 0, bb = 0;
int len = min(a[i] - 1, n - a[i]);
if (len) {
ql = a[i] - len, qr = a[i] - 1;
if (qr >= ql) aa = 1, pa = query_l(1, 1, n);
ql = a[i] + 1, qr = a[i] + len;
if (qr >= ql) bb = 1, pb = query_r(1, 1, n);
if (aa && bb && pa != pb) {
good = 1;
puts("YES");
break;
}
}
}
if (!good) puts("NO");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long a[100001];
long long b[100001];
int main() {
int n, i;
cin >> n;
for (i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
if (a[n - 1] < a[n - 2] + a[n - 3]) {
cout << "YES\n";
swap(a[n - 1], a[n - 2]);
for (i = 0; i < n; i++) cout << a[i] << " ";
} else
cout << "NO\n";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, k, ans, mk, flag[105][105];
int dx[] = {0, 0, 1, -1}, dy[] = {1, -1, 0, 0};
char maz[105][105];
int main() {
memset(flag, 0, sizeof(flag));
cin >> n >> k;
mk = (n * n + 1) / 2;
ans = k > mk ? 0 : 1;
for (int(i) = 0; (i) < (n); i++)
for (int(j) = 0; (j) < (n); j++) maz[i][j] = 'S';
if (ans) {
int cnt = k;
while (cnt) {
for (int(i) = 0; (i) < (n); i++) {
for (int(j) = 0; (j) < (n); j++) {
if (!flag[i][j]) {
flag[i][j] = 1;
maz[i][j] = 'L';
for (int(k) = 0; (k) < (4); k++) {
int nx = i + dx[k], ny = j + dy[k];
if (nx >= 0 && nx < n && ny >= 0 && ny < n) {
flag[nx][ny] = 1;
}
}
cnt--;
if (!cnt) break;
}
}
if (!cnt) break;
}
}
printf("YES\n");
for (int(i) = 0; (i) < (n); i++) printf("%s\n", maz[i]);
} else
printf("NO\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using si = set<int>;
using ii = pair<int, int>;
using vii = vector<ii>;
const int inf(0x3fffffff);
const int mod(1000000007);
const double pi(acos(-1.0));
signed main() {
{
ios::sync_with_stdio(0);
cin.tie(0);
};
ll n, m;
cin >> n >> m;
m--;
vi ret(n);
int l = 0, r = n - 1;
for (int i = 1; i <= n; i++) {
if (m >= 1ll << n - i - 1) {
m -= 1ll << n - i - 1;
ret[r--] = i;
} else
ret[l++] = i;
}
for (int i : ret) cout << i << ' ';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int arr[n];
int l[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
for (int i = 0; i < n; i++) {
cin >> l[i];
}
vector<int> temp;
for (int i = 0; i < n; i++) {
if (l[i] == 0) {
temp.push_back(arr[i]);
}
}
sort(temp.begin(), temp.end(), greater<int>());
int i = 0;
int j = 0;
int m = temp.size();
while (i < n && j < m) {
if (l[i] == 1) {
i++;
} else {
arr[i] = temp[j];
j++;
i++;
}
}
for (int i = 0; i < n; i++) {
cout << arr[i] << " ";
}
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 500;
const int INF = 1e9;
int fst[N], nxt[N], mm;
struct Edge {
int v, w;
} e[N];
void ade(int u, int v, int w) {
e[++mm] = (Edge){v, w}, nxt[mm] = fst[u], fst[u] = mm;
}
long long f[N], sum, dep[N];
int n, root, rsize;
int siz[N];
void dfs(int u, int fa) {
siz[u] = 1;
f[u] = 0;
int mx = 0;
for (int i = fst[u]; i; i = nxt[i]) {
int v = e[i].v;
if (v == fa) continue;
dfs(v, u);
siz[u] += siz[v];
mx = max(mx, siz[v]);
f[u] += f[v];
if (siz[v] & 1) f[u] += e[i].w;
}
mx = max(mx, n - siz[u]);
if (mx < rsize) rsize = mx, root = u;
}
void dfs2(int u, int fa) {
sum += dep[u];
for (int i = fst[u]; i; i = nxt[i]) {
int v = e[i].v;
if (v == fa) continue;
dep[v] = dep[u] + e[i].w;
dfs2(v, u);
}
}
int main() {
int T;
scanf("%d", &T);
while (T--) {
scanf("%d", &n);
n *= 2;
for (int i = 1; i <= n; i++) fst[i] = 0;
mm = 0;
for (int i = 1, u, v, w; i < n; i++)
scanf("%d%d%d", &u, &v, &w), ade(u, v, w), ade(v, u, w);
root = 0, rsize = INF;
dfs(1, 0);
dep[root] = 0;
sum = 0;
dfs2(root, 0);
printf("%lld ", f[1]);
printf("%lld\n", sum);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXN = 100000;
const int MAXP = 10000000;
int pw(int x, int n, int mod) {
int ret = 1;
while (true) {
if (n & 1) ret = (long long)ret * x % mod;
if ((n >>= 1) == 0) return ret;
x = (long long)x * x % mod;
}
}
int n, modlim;
char sa[MAXN + 1];
char sb[MAXN + 1];
bool isp[MAXP + 1];
vector<int> getpol(int d) {
vector<int> pol(d, 0);
for (int i = (0); i < (n); ++i) pol[i % d] += ((int)sa[i]) - ((int)sb[i]);
return pol;
}
int eval(const vector<int> &pol, int r, int mod) {
int ret = 0, x = 1;
for (int i = (0); i < (((int)(pol).size())); ++i) {
ret = (ret + (long long)pol[i] * x) % mod;
x = (long long)x * r % mod;
}
if (ret < 0) ret += mod;
return ret;
}
pair<int, int> solve() {
for (int i = (0); i <= (MAXP); ++i) isp[i] = true;
isp[0] = isp[1] = false;
for (int i = (2); i <= (MAXP); ++i)
if (isp[i])
for (int j = i + i; j <= MAXP; j += i) isp[j] = false;
for (int d = (0); d <= (MAXP); ++d)
if (d % 2 == 1 && isp[d]) {
vector<int> pol = getpol(d);
for (int p = 1; p <= MAXP; p += d)
if (isp[p] && p >= modlim) {
int r = -1;
for (int i = (2); i < (p - 2); ++i) {
int cur = pw(i, (p - 1) / d, p);
if (cur != 1) {
r = cur;
break;
}
}
assert(r != -1);
for (int i = (0); i < (d); ++i) {
int x = pw(r, i, p);
if (x < 2 || x > p - 2) continue;
assert(pw(x, d, p) == 1);
if (eval(pol, x, p) == 0) return make_pair(x, p);
}
}
}
assert(false);
return make_pair(-1, -1);
}
void run() {
scanf("%d%d", &n, &modlim);
scanf("%s", &sa);
assert(strlen(sa) == n);
scanf("%s", &sb);
assert(strlen(sb) == n);
pair<int, int> ans = solve();
printf("%d %d\n", ans.second, ans.first);
}
int main() {
run();
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const string kSuites = "JCDHS";
const string kRanks = "123456789TJQKA";
int GetSuite(char ch) { return kSuites.find_first_of(ch); }
int GetRank(char ch) { return kRanks.find_first_of(ch); }
struct Card {
int suite, rank;
Card(const string& str) {
if (isdigit(str[1])) {
suite = GetSuite(str[0]);
rank = GetRank(str[1]);
} else {
suite = GetSuite(str[1]);
rank = GetRank(str[0]);
}
}
Card(int s, int r) : suite(s), rank(r) {}
bool operator<(const Card& c) const {
if (suite != c.suite) return suite < c.suite;
return rank < c.rank;
}
bool operator==(const Card& c) const {
return suite == c.suite && rank == c.rank;
}
bool IsJoker() const { return suite == GetSuite('J'); }
string ToString() const {
string ret(1, kRanks[rank]);
ret += kSuites[suite];
return ret;
}
};
bool inside(int row, int col, int x, int y) {
return x >= row && x < row + 3 && y >= col && y < col + 3;
}
bool overlaps(int r1, int c1, int r2, int c2) {
for (int p = 0; p < 3; ++p)
for (int q = 0; q < 3; ++q)
if (inside(r1, c1, r2 + p, c2 + q) || inside(r2, c2, r1 + p, r1 + q))
return true;
return false;
}
bool good(const vector<vector<Card> >& board, int x, int y) {
vector<int> suite_counts(kSuites.length()), ranks_seen(kRanks.length());
for (int i = 0; i < 3; ++i) {
if (x + i >= board.size()) return false;
for (int j = 0; j < 3; ++j) {
if (y + j >= board[x].size()) return false;
++suite_counts[board[x + i][y + j].suite];
++ranks_seen[board[x + i][y + j].rank];
}
}
if (find(suite_counts.begin(), suite_counts.end(), 9) != suite_counts.end()) {
return true;
}
for (int i = 0; i < ranks_seen.size(); ++i)
if (ranks_seen[i] > 1) {
return false;
}
return true;
}
bool check(const vector<vector<Card> >& board, pair<int, int>& p1,
pair<int, int>& p2) {
for (int x1 = 0; x1 < board.size(); ++x1) {
for (int y1 = 0; y1 < board[x1].size(); ++y1) {
for (int x2 = 0; x2 < board.size(); ++x2) {
for (int y2 = 0; y2 < board[x2].size(); ++y2) {
if (overlaps(x1, y1, x2, y2)) continue;
if (good(board, x1, y1) && good(board, x2, y2)) {
p1 = make_pair(x1, y1);
p2 = make_pair(x2, y2);
return true;
}
}
}
}
}
return false;
}
void PrintResult(int joker_index1, const Card& rep1, int joker_index2,
const Card& rep2, const pair<int, int>& p1,
const pair<int, int>& p2) {
cout << "Solution exists." << endl;
if (joker_index1 == -1 && joker_index2 == -1) {
cout << "There are no jokers";
}
if (joker_index1 != -1) {
cout << "Replace J" << joker_index1 << " with " << rep1.ToString();
}
if (joker_index2 != -1) {
cout << " and J" << joker_index2 << " with " << rep2.ToString();
}
cout << "." << endl;
cout << "Put the first square to (" << (p1.first + 1) << ", "
<< (p1.second + 1) << ")." << endl;
cout << "Put the second square to (" << (p2.first + 1) << ", "
<< (p2.second + 1) << ")." << endl;
}
int main() {
int N, M;
cin >> N >> M;
vector<vector<Card> > board(N);
vector<pair<int, int> > joker_pos;
set<Card> used;
for (int i = 0; i < board.size(); ++i) {
for (int j = 0; j < M; ++j) {
string str;
cin >> str;
board[i].push_back(Card(str));
if (board[i][j].IsJoker()) {
joker_pos.push_back(make_pair(i, j));
} else {
used.insert(board[i][j]);
}
}
}
if (joker_pos.empty()) {
pair<int, int> p1, p2;
if (check(board, p1, p2)) {
Card c(0, 0);
PrintResult(-1, c, -1, c, p1, p2);
} else {
cout << "No solution." << endl;
}
return 0;
}
if (joker_pos.size() == 2 &&
board[joker_pos[0].first][joker_pos[0].second].rank != 0) {
swap(joker_pos[0], joker_pos[1]);
}
for (int suite1 = 1; suite1 < kSuites.length(); ++suite1) {
for (int rank1 = 1; rank1 < kRanks.length(); ++rank1) {
Card rep1(suite1, rank1);
if (used.find(rep1) != used.end()) continue;
Card joker1_backup = board[joker_pos[0].first][joker_pos[0].second];
board[joker_pos[0].first][joker_pos[0].second] = rep1;
if (joker_pos.size() == 1) {
pair<int, int> p1, p2;
if (check(board, p1, p2)) {
PrintResult(joker1_backup.rank + 1, rep1, -1, Card(0, 0), p1, p2);
return 0;
} else {
board[joker_pos[0].first][joker_pos[0].second] = joker1_backup;
continue;
}
} else {
for (int suite2 = 1; suite2 < kSuites.length(); ++suite2) {
for (int rank2 = 1; rank2 < kRanks.length(); ++rank2) {
Card rep2(suite2, rank2);
if (rep2 == rep1 || used.find(rep2) != used.end()) continue;
Card joker2_backup = board[joker_pos[1].first][joker_pos[1].second];
board[joker_pos[1].first][joker_pos[1].second] = rep2;
pair<int, int> p1, p2;
if (check(board, p1, p2)) {
PrintResult(joker1_backup.rank + 1, rep1, joker2_backup.rank + 1,
rep2, p1, p2);
return 0;
} else {
board[joker_pos[1].first][joker_pos[1].second] = joker2_backup;
continue;
}
}
}
}
board[joker_pos[0].first][joker_pos[0].second] = joker1_backup;
}
}
cout << "No solution." << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int M = 3e5 + 9;
int n, m, k;
int a[M], f[M][23], mi[M << 2], vis[M << 2];
long long sum[M << 2], ans[M];
vector<pair<int, int> > q[M];
int ask(int l, int r) {
int p = log2(r - l + 1);
return min(f[l][p], f[r - (1 << p) + 1][p]);
}
void pu(int now) {
mi[now] = min(mi[now << 1], mi[now << 1 | 1]);
sum[now] = sum[now << 1] + sum[now << 1 | 1];
}
void pd(int now, int l, int r) {
if (vis[now]) {
int &v = vis[now], mid = l + r >> 1;
vis[now << 1] = vis[now << 1 | 1] = mi[now << 1] = mi[now << 1 | 1] = v;
sum[now << 1] = 1ll * (mid - l + 1) * v;
sum[now << 1 | 1] = 1ll * (r - mid) * v;
v = 0;
}
}
void update(int now, int l, int r, int x, int y, int v) {
if (x <= l && r <= y) {
mi[now] = v;
sum[now] = 1ll * (r - l + 1) * v;
vis[now] = v;
return;
}
pd(now, l, r);
int mid = l + r >> 1;
if (x <= mid) update(now << 1, l, mid, x, y, v);
if (y > mid) update(now << 1 | 1, mid + 1, r, x, y, v);
pu(now);
}
void change(int now, int l, int r, int v) {
if (mi[now] > v) {
mi[now] = v;
sum[now] = 1ll * (r - l + 1) * v;
vis[now] = v;
return;
}
if (l == r) return;
pd(now, l, r);
int mid = l + r >> 1;
if (mi[now << 1] > v) change(now << 1 | 1, mid + 1, r, v);
change(now << 1, l, mid, v);
pu(now);
}
long long query(int now, int l, int r, int x, int y) {
if (x <= l && r <= y) return sum[now];
int mid = l + r >> 1;
long long s = 0;
pd(now, l, r);
if (x <= mid) s += query(now << 1, l, mid, x, y);
if (y > mid) s += query(now << 1 | 1, mid + 1, r, x, y);
return s;
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
f[i][0] = a[i];
}
for (int j = 1; j <= 20; ++j) {
for (int i = 1; i + (1 << j) - 1 <= n; ++i) {
f[i][j] = min(f[i][j - 1], f[i + (1 << j - 1)][j - 1]);
}
}
for (int i = 1, l, r; i <= m; ++i) {
scanf("%d%d", &l, &r);
r = (r - l) / k;
q[l].emplace_back(r, i);
}
for (int p = n; p > n - k; --p) {
int R = (p - 1) / k + 1;
update(1, 1, R, 1, R, (int)2e9);
for (int id = R, i = p; id; --id, i -= k) {
if (i + k <= n) change(1, 1, R, ask(i, i + k));
update(1, 1, R, 1, id, (int)2e9);
update(1, 1, R, id, id, a[i]);
for (auto o : q[i]) {
ans[o.second] = query(1, 1, R, id, id + o.first);
}
}
}
for (int i = 1; i <= m; ++i) printf("%lld\n", ans[i]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, p;
string s, res;
bool vis[1000][2][28][28];
bool calc(int i, bool l, int a, int b) {
if (a == b) return false;
if (i == s.size()) return l;
if (vis[i][l][a][b]) return false;
vis[i][l][a][b] = true;
if (!l) {
res[i] = s[i];
if (calc(i + 1, l, b, s[i] - 'a')) return true;
for (int j = l ? 0 : s[i] - 'a'; j < p; ++j) {
res[i] = j + 'a';
if (j != a && calc(i + 1, l || res[i] != s[i], b, j)) return true;
}
} else {
for (int j = l ? 0 : s[i] - 'a'; j < p; ++j) {
res[i] = j + 'a';
if (j != a && calc(i + 1, l || res[i] != s[i], b, j)) return true;
}
res[i] = s[i];
if (calc(i + 1, l, b, s[i] - 'a')) return true;
}
res[i] = s[i];
return false;
}
int main() {
cin >> n >> p >> s;
res = s;
if (!calc(0, false, 26, 27)) res = "NO";
cout << res << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s1, s2;
int p1 = 0, p2 = 0;
cin >> s1 >> s2;
for (int i = 0; i < (int)s1.size(); i += 2) {
if (s1[i] == '(' && s2[i] == '8') p1++;
if (s1[i] == '8' && s2[i] == '[') p1++;
if (s1[i] == '[' && s2[i] == '(') p1++;
if (s2[i] == '(' && s1[i] == '8') p2++;
if (s2[i] == '8' && s1[i] == '[') p2++;
if (s2[i] == '[' && s1[i] == '(') p2++;
}
if (p1 > p2) cout << "TEAM 1 WINS" << endl;
if (p1 == p2) cout << "TIE" << endl;
if (p2 > p1) cout << "TEAM 2 WINS" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 500000;
int s[N], t[N], type[N];
int q, qind[N];
void dfs(int n, vector<vector<int>>& adj, int root, void preVisit(int, int) = 0,
void postVisit(int, int) = 0, void traverseTreeEdge(int, int, int) = 0,
void traverseBackEdge(int, int) = 0) {
vector<int> parent(n, -2);
vector<int> stackNode(n);
vector<int> stackEdgeIndex(n);
int stackSize = 1;
stackNode[0] = root;
stackEdgeIndex[0] = 0;
parent[root] = -1;
while (stackSize > 0) {
int node = stackNode[stackSize - 1];
int edgeIndex = stackEdgeIndex[stackSize - 1];
if (edgeIndex == 0 && preVisit) {
preVisit(node, parent[node]);
}
if (edgeIndex == adj[node].size()) {
stackSize--;
if (postVisit) {
postVisit(node, parent[node]);
}
} else {
int e = adj[node][edgeIndex];
int other = s[e] == node ? t[e] : s[e];
stackEdgeIndex[stackSize - 1]++;
if (parent[other] == -2) {
parent[other] = node;
if (traverseTreeEdge) traverseTreeEdge(node, other, e);
stackNode[stackSize] = other;
stackEdgeIndex[stackSize] = 0;
stackSize++;
} else if (other != parent[node]) {
if (traverseBackEdge) traverseBackEdge(node, other);
}
}
}
}
int depth[N];
bool good[N];
int preorder[N], postorder[N];
int subtreeRoot[N];
int curorder;
void preVisit(int v, int p) {
preorder[v] = curorder++;
if (p == -1) {
depth[v] = 0;
good[v] = true;
} else {
depth[v] = depth[p] + 1;
}
}
void postVisit(int v, int p) { postorder[v] = curorder - 1; }
void traverseTreeEdge(int p, int v, int e) {
if (type[e])
good[v] = !good[p];
else
good[v] = good[p];
subtreeRoot[e] = v;
}
int getFurthest(int n, vector<vector<int>>& adj, int root) {
dfs(n, adj, root, preVisit);
int ans = 0;
for (int i = 1; i < n; i++)
if (depth[i] > depth[ans]) ans = i;
return ans;
}
int ans[N];
struct Node {
Node* left = 0;
Node* right = 0;
int leftValue;
int rightValue;
bool inverted = false;
int goodDepth = 0, badDepth = 0;
};
class SegmentTree {
public:
SegmentTree(int n) { root = buildTree(0, n - 1); }
~SegmentTree() { dispose(root); }
void dispose(Node* node) {
if (!node) return;
dispose(node->left);
dispose(node->right);
delete node;
}
Node* buildTree(int l, int r) {
Node* node = new Node();
node->leftValue = l;
node->rightValue = r;
if (l < r) {
int mid = (l + r) / 2;
node->left = buildTree(l, mid);
node->right = buildTree(mid + 1, r);
}
return node;
}
void setDepth(int ind, int depth, bool good) {
setDepth(root, ind, depth, good);
}
void setDepth(Node* node, int ind, int depth, bool good) {
if (node->rightValue == ind && node->leftValue == ind) {
if (good)
node->goodDepth = depth;
else
node->badDepth = depth;
return;
}
if (ind <= node->left->rightValue)
setDepth(node->left, ind, depth, good);
else
setDepth(node->right, ind, depth, good);
node->goodDepth = max(node->left->goodDepth, node->right->goodDepth);
node->badDepth = max(node->left->badDepth, node->right->badDepth);
}
void addSegment(int left, int right) { addSegment(root, left, right); }
void pushLazy(Node* node) {
if (node->inverted) {
swap(node->goodDepth, node->badDepth);
if (node->left) node->left->inverted = !node->left->inverted;
if (node->right) node->right->inverted = !node->right->inverted;
node->inverted = false;
}
}
void addSegment(Node* node, int left, int right) {
if (node->rightValue < left || node->leftValue > right) return;
if (left <= node->leftValue && right >= node->rightValue) {
node->inverted = !node->inverted;
return;
}
pushLazy(node);
addSegment(node->left, left, right);
addSegment(node->right, left, right);
node->goodDepth = node->badDepth = 0;
if (node->left) {
pushLazy(node->left);
node->goodDepth = node->left->goodDepth;
node->badDepth = node->left->badDepth;
}
if (node->right) {
pushLazy(node->right);
node->goodDepth = max(node->goodDepth, node->right->goodDepth);
node->badDepth = max(node->badDepth, node->right->badDepth);
}
}
int query(int left, int right) { return query(root, left, right); }
int query(Node* node, int left, int right) {
if (!node || node->rightValue < left || node->leftValue > right) return 0;
pushLazy(node);
if (left <= node->leftValue && right >= node->rightValue) {
return node->goodDepth;
}
return max(query(node->left, left, right), query(node->right, left, right));
}
Node* root;
};
void solve(int n, vector<vector<int>>& adj, int root) {
curorder = 0;
dfs(n, adj, root, preVisit, postVisit, traverseTreeEdge);
SegmentTree tree(n);
for (int i = 0; i < n; i++) tree.setDepth(preorder[i], depth[i], good[i]);
for (int i = 0; i < q; i++) {
int v = subtreeRoot[qind[i]];
tree.addSegment(preorder[v], postorder[v]);
ans[i] = max(ans[i], tree.query(0, n - 1));
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<vector<int>> adj(n);
for (int i = 0; i < n - 1; i++) {
cin >> s[i] >> t[i] >> type[i];
s[i]--;
t[i]--;
adj[s[i]].push_back(i);
adj[t[i]].push_back(i);
}
cin >> q;
for (int i = 0; i < q; i++) {
cin >> qind[i];
qind[i]--;
}
int v1 = getFurthest(n, adj, 0);
int v2 = getFurthest(n, adj, v1);
memset(ans, 0, sizeof(ans));
solve(n, adj, v1);
solve(n, adj, v2);
for (int i = 0; i < q; i++) cout << ans[i] << "\n";
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
ifstream fin("in.in");
ofstream fout("out.out");
const int N = 1e6 + 10, L = 20;
int n, m;
string str;
struct segmentTree {
int best, seq[2][2];
bool changed;
segmentTree() {
best = seq[0][0] = seq[0][1] = seq[1][1] = seq[1][0] = 0;
changed = false;
}
} node[N << 2];
inline void update(segmentTree &par, segmentTree &c1, segmentTree &c2) {
par.seq[0][0] = c1.seq[0][0] + c2.seq[0][0];
par.seq[1][1] = c1.seq[1][1] + c2.seq[1][1];
par.seq[0][1] =
max(c1.seq[0][0] + c2.seq[1][1],
max(c1.seq[0][1] + c2.seq[1][1], c1.seq[0][0] + c2.seq[0][1]));
par.seq[1][0] =
max(c1.seq[1][1] + c2.seq[0][0],
max(c1.seq[1][1] + c2.seq[1][0], c1.seq[1][0] + c2.seq[0][0]));
par.best = max(max(par.seq[0][0], par.seq[1][1]), par.seq[0][1]);
}
inline void propagate(int id, int s, int e) {
if (!node[id].changed) return;
node[id].changed = false;
node[id * 2].changed ^= 1;
node[id * 2 + 1].changed ^= 1;
swap(node[id * 2].seq[0][0], node[id * 2].seq[1][1]);
swap(node[id * 2].seq[0][1], node[id * 2].seq[1][0]);
node[id * 2].best = max(max(node[id * 2].seq[0][0], node[id * 2].seq[1][1]),
node[id * 2].seq[0][1]);
swap(node[id * 2 + 1].seq[0][0], node[id * 2 + 1].seq[1][1]);
swap(node[id * 2 + 1].seq[0][1], node[id * 2 + 1].seq[1][0]);
node[id * 2 + 1].best =
max(max(node[id * 2 + 1].seq[0][0], node[id * 2 + 1].seq[1][1]),
node[id * 2 + 1].seq[0][1]);
}
void buildTree(int s, int e, int id) {
if (s + 1 == e) {
if (str[s] == '4')
node[id].seq[0][0] = node[id].seq[0][0] = node[id].best = 1;
else
node[id].seq[1][1] = node[id].seq[1][1] = node[id].best = 1;
return;
}
int mid = (s + e) >> 1;
buildTree(s, mid, id * 2);
buildTree(mid, e, id * 2 + 1);
update(node[id], node[id * 2], node[id * 2 + 1]);
}
void modify(int s, int e, int id, int l, int r) {
if (s >= r || e <= l || l >= r) return;
if (s >= l && e <= r) {
node[id].changed ^= 1;
swap(node[id].seq[0][0], node[id].seq[1][1]);
swap(node[id].seq[0][1], node[id].seq[1][0]);
node[id].best =
max(max(node[id].seq[0][0], node[id].seq[1][1]), node[id].seq[0][1]);
return;
}
propagate(id, s, e);
int mid = (s + e) >> 1;
modify(s, mid, id * 2, l, r);
modify(mid, e, id * 2 + 1, l, r);
update(node[id], node[id * 2], node[id * 2 + 1]);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> str;
buildTree(0, n, 1);
for (; m; m--) {
string q;
cin >> q;
if (q == "switch") {
int l, r;
cin >> l >> r;
modify(0, n, 1, l - 1, r);
} else
cout << node[1].best << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
inline void proc_status() {
ifstream t("/proc/self/status");
cerr << string(istreambuf_iterator<char>(t), istreambuf_iterator<char>())
<< endl;
}
template <typename T>
inline bool chkmin(T &a, const T &b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
inline bool chkmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
template <typename T>
inline T read() {
register T sum(0), fg(1);
register char ch(getchar());
for (; !isdigit(ch); ch = getchar())
if (ch == '-') fg = -1;
for (; isdigit(ch); ch = getchar()) sum = sum * 10 - '0' + ch;
return sum * fg;
}
const int MAXN = (int)2e3, MAXM = (int)5e5;
int n, m;
bitset<MAXN + 5> A[MAXN + 5];
pair<int, int> E[MAXM + 5];
inline void input() {
n = read<int>(), m = read<int>();
for (int i = 1; i <= m; ++i) {
int u = read<int>(), v = read<int>();
A[u].set(v);
E[i] = make_pair(u, v);
}
}
inline void solve() {
static bitset<MAXN + 5> M[MAXN + 5];
for (int i = 1; i <= n; ++i) M[i].set(i);
for (int i = 1; i <= n; ++i) {
if (!A[i].test(i))
for (int j = i + 1; j <= n; ++j)
if (A[j].test(i)) {
swap(A[i], A[j]), swap(M[i], M[j]);
break;
}
for (int j = 1; j <= n; ++j)
if (i != j && A[j].test(i)) A[j] ^= A[i], M[j] ^= M[i];
}
for (int i = 1; i <= m; ++i)
puts(M[E[i].second].test(E[i].first) ? "NO" : "YES");
}
int main() {
input();
solve();
return 0;
}
| 10 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
using namespace std;
constexpr long long mod = 998244353;
const long long INF = mod * mod;
template <typename T>
void chmin(T& a, T b) {
a = min(a, b);
}
template <typename T>
void chmax(T& a, T b) {
a = max(a, b);
}
template <typename T>
void cinarray(vector<T>& v) {
for (int i = 0; i < v.size(); i++) cin >> v[i];
}
template <typename T>
void coutarray(vector<T>& v) {
for (int i = 0; i < v.size(); i++) {
if (i > 0) cout << " ";
cout << v[i];
}
cout << "\n";
}
long long mod_pow(long long x, long long n, long long m = mod) {
if (n < 0) {
long long res = mod_pow(x, -n, m);
return mod_pow(res, m - 2, m);
}
if (abs(x) >= m) x %= m;
if (x < 0) x += m;
if (x == 0) return 0;
long long res = 1;
while (n) {
if (n & 1) res = res * x % m;
x = x * x % m;
n >>= 1;
}
return res;
}
struct modint {
int n;
modint() : n(0) { ; }
modint(long long m) {
if (m < 0 || mod <= m) {
m %= mod;
if (m < 0) m += mod;
}
n = m;
}
operator int() { return n; }
};
bool operator==(modint a, modint b) { return a.n == b.n; }
modint operator+=(modint& a, modint b) {
a.n += b.n;
if (a.n >= mod) a.n -= mod;
return a;
}
modint operator-=(modint& a, modint b) {
a.n -= b.n;
if (a.n < 0) a.n += mod;
return a;
}
modint operator*=(modint& a, modint b) {
a.n = ((long long)a.n * b.n) % mod;
return a;
}
modint operator+(modint a, modint b) { return a += b; }
modint operator-(modint a, modint b) { return a -= b; }
modint operator*(modint a, modint b) { return a *= b; }
modint operator^(modint a, long long n) {
if (n == 0) return modint(1);
modint res = (a * a) ^ (n / 2);
if (n % 2) res = res * a;
return res;
}
long long inv(long long a, long long p) {
return (a == 1 ? 1 : (1 - p * inv(p % a, a)) / a + p);
}
modint operator/(modint a, modint b) { return a * modint(inv(b, mod)); }
modint operator/=(modint& a, modint b) {
a = a / b;
return a;
}
const int max_n = 1 << 20;
modint fact[max_n], factinv[max_n];
void init_f() {
fact[0] = modint(1);
for (int i = 0; i < max_n - 1; i++) {
fact[i + 1] = fact[i] * modint(i + 1);
}
factinv[max_n - 1] = modint(1) / fact[max_n - 1];
for (int i = max_n - 2; i >= 0; i--) {
factinv[i] = factinv[i + 1] * modint(i + 1);
}
}
modint comb(int a, int b) {
if (a < 0 || b < 0 || a < b) return 0;
return fact[a] * factinv[b] * factinv[a - b];
}
modint combP(int a, int b) {
if (a < 0 || b < 0 || a < b) return 0;
return fact[a] * factinv[a - b];
}
long long gcd(long long a, long long b) {
a = abs(a);
b = abs(b);
if (a < b) swap(a, b);
while (b) {
long long r = a % b;
a = b;
b = r;
}
return a;
}
mt19937 mt(time(0));
uniform_int_distribution<> ud(0, (1 << 20) - 1);
unsigned long long ranum() {
unsigned long long res = 0;
res |= ud(mt);
res |= (unsigned long long)ud(mt) << 20;
res |= (unsigned long long)ud(mt) << 40;
return res;
}
const int mn = 1 << 20;
bool isp[mn];
int chp[mn];
unsigned long long h[mn];
unsigned long long hs[mn];
unsigned long long hfact[mn];
void init() {
fill(isp + 2, isp + mn, true);
for (int i = 2; i < mn; i++) {
if (!isp[i]) continue;
h[i] = ranum();
chp[i] = i;
for (int j = 2 * i; j < mn; j += i) {
isp[j] = false;
chp[j] = i;
}
}
hs[1] = 0;
for (int i = 2; i < mn; i++) {
hs[i] = hs[i / chp[i]] ^ h[chp[i]];
hfact[i] = hfact[i - 1] ^ hs[i];
}
}
void solve() {
int n;
cin >> n;
unsigned long long z = 0;
for (int i = 1; i <= n; i++) {
z ^= hfact[i];
}
vector<int> ans;
if (z == 0) {
for (int i = 1; i <= n; i++) ans.push_back(i);
} else {
unordered_map<unsigned long long, int> mp;
for (int i = 1; i <= n; i++) mp[hfact[i]] = i;
for (int cnt = 1;; cnt++) {
vector<int> del;
unsigned long long cs = z;
function<bool(int, int)> dfs = [&](int dep, int loc) {
if (dep == cnt - 1) {
if (mp.find(cs) != mp.end()) {
del.push_back(mp[cs]);
return true;
}
return false;
}
if (loc > n) return false;
del.push_back(loc);
cs ^= hfact[loc];
if (dfs(dep + 1, loc + 1)) return true;
del.pop_back();
cs ^= hfact[loc];
if (dfs(dep, loc + 1)) return true;
return false;
};
if (dfs(0, 2)) {
vector<bool> can(n + 1, true);
for (int id : del) can[id] = false;
for (int i = 1; i <= n; i++)
if (can[i]) ans.push_back(i);
break;
}
}
}
cout << ans.size() << "\n";
coutarray(ans);
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
init();
solve();
return 0;
}
| 10 |
#include <bits/stdc++.h>
int a[10005];
int main() {
int n, k, f = 0;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) a[i] = 1;
a[n - 1] = 0;
for (int i = 0; i < k; i++) {
if (f)
for (int j = 0; j < n; j++) printf("%d%c", n, j == n - 1 ? '\n' : ' ');
else {
if (a[0] == n) {
f = 1;
for (int j = 0; j < n; j++) printf("%d%c", n, j == n - 1 ? '\n' : ' ');
continue;
}
for (int j = 0; j < n; j++) {
if (a[j] == n - j - 1) {
printf("%d%c", n, j == n - 1 ? '\n' : ' ');
continue;
}
for (int k = j; k < n; k++) {
if (a[j] + a[k] > n - j - 1)
continue;
else {
a[j] += a[k];
printf("%d%c", k + 1, j == n - 1 ? '\n' : ' ');
break;
}
}
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, k, a[101], x, t[1001], o, f, q, maxx;
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
f = 1;
while (k >= q && f == 1) {
maxx = 99999999;
f = 0;
for (int i = 1; i <= n; i++) {
if (a[i] == 0)
continue;
else
f = 1;
if (a[i] < maxx) maxx = a[i], x = i;
}
q += maxx;
a[x] = 0;
o++;
t[o] = x;
}
sort(t + 1, t + o);
cout << o - 1 << endl;
for (int i = 1; i < o; i++) {
cout << t[i] << " ";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 9;
int n, m, a[N];
long long int s;
bool ok(int mid) {
long long int ans = 0;
for (int i = 0; i < n; i++) {
long long int dif = i / mid;
ans += max((long long int)0, a[i] - dif);
}
if (ans >= m) return true;
return false;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a[i];
s += a[i];
}
if (s < m) {
cout << -1;
return 0;
}
sort(a, a + n);
reverse(a, a + n);
int l = 1, r = n, ans;
while (l <= r) {
int mid = (l + r) / 2;
if (ok(mid)) {
ans = mid;
r = mid - 1;
} else {
l = mid + 1;
}
}
cout << ans << '\n';
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline int readint() {
int a = 0;
char c = getchar(), f = 1;
for (; c < '0' || c > '9'; c = getchar())
if (c == '-') f = -f;
for (; '0' <= c && c <= '9'; c = getchar())
a = (a << 3) + (a << 1) + (c ^ 48);
return a * f;
}
const int MaxN = 3005;
vector<long long> v[MaxN];
int k;
long long dp[MaxN], tmp[13][MaxN], ans;
int zxy;
void addItem(int id) {
int t = v[id].size();
for (int i = k; i >= t; --i) dp[i] = max(dp[i], dp[i - t] + v[id].back());
}
void solve(int l, int r, int d = 0) {
if (l == r) {
int len = v[l].size();
if (len > k) len = k;
for (int i = 0; i < len; ++i) ans = max(ans, v[l][i] + dp[k - i - 1]);
return;
}
for (int i = 0; i <= k; ++i) tmp[d][i] = dp[i];
int m = (l + r) >> 1;
for (int i = m + 1; i <= r; ++i) addItem(i);
solve(l, m, d + 1);
for (int i = 0; i <= k; ++i) dp[i] = tmp[d][i];
for (int i = l; i <= m; ++i) addItem(i);
solve(m + 1, r, d + 1);
}
int main() {
int n = readint();
k = readint();
for (int i = 1; i <= n; ++i) {
int t = readint();
v[i].clear();
for (int j = 0; j < t; ++j) {
long long x = readint();
if (j) x += v[i].back();
v[i].push_back(x);
}
}
solve(1, n);
printf("%lld\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j, fl = 0;
scanf("%d", &n);
string s;
cin >> s;
for (i = 0; i < n; i++) {
if (s[i] == '*') {
for (j = 1; j <= 30; j++) {
int jump = i;
int cnt = 1;
while (s[jump + j] == '*' && jump + j <= n) {
cnt++;
jump = jump + j;
if (cnt == 5) break;
}
if (cnt == 5) {
fl = 1;
break;
}
}
}
}
if (fl)
printf("yes\n");
else
printf("no\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long getint() {
char ch = getchar();
long long f = 1, x = 0;
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
return f * x;
}
const int N = 200200;
int n;
struct dat {
long long w, h, c;
} a[N];
int bg[N], ed[N];
int cnt;
int ans;
bool operator<(const dat &a, const dat &b) {
return (a.w == b.w) ? a.h < b.h : a.w < b.w;
}
long long gcd(long long a, long long b) { return (b == 0) ? a : gcd(b, a % b); }
bool validate() {
for (int i = 2; i <= cnt; i++) {
if (ed[i] - bg[i] != ed[i - 1] - bg[i - 1]) return false;
for (int j = bg[i], k = bg[i - 1]; j <= ed[i]; j++, k++) {
if (a[j].h != a[k].h) return false;
}
long long g1, g2;
for (int j = bg[i], k = bg[i - 1]; j < ed[i]; j++, k++) {
g1 = gcd(a[j].c, a[j + 1].c);
g2 = gcd(a[k].c, a[k + 1].c);
if (a[j].c / g1 != a[k].c / g2 || a[j + 1].c / g1 != a[k + 1].c / g2)
return false;
}
}
return true;
}
void init() {
n = getint();
for (int i = 1; i <= n; i++) {
a[i].w = getint();
a[i].h = getint();
a[i].c = getint();
}
sort(a + 1, a + 1 + n);
for (int i = 1; i <= n; i++) {
++cnt;
bg[cnt] = i;
while (a[i].w == a[i + 1].w) i++;
ed[cnt] = i;
}
}
int main() {
init();
if (!validate()) {
puts("0");
return 0;
}
long long g = a[1].c;
for (int i = 2; i <= n; i++) {
g = gcd(g, a[i].c);
}
for (long long i = 1; i * i <= g; i++) {
if (g % i == 0) {
ans += (i * i == g) ? 1 : 2;
}
}
printf("%d\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T abs(T a) {
return a < 0 ? -a : a;
}
const int INF = (int)1e9;
const double PI = 3.1415926535897932384626433832795;
const int N = 0;
vector<string> v;
string tp, s;
int n;
int main() {
scanf("%d", &n);
while (n--) {
cin >> tp;
if (tp == "pwd") {
for (int i = 0; i < v.size(); i++) cout << "/" << v[i];
puts("/");
} else {
cin >> s;
s += '/';
if (s[0] == '/') {
v.clear();
string t = "";
for (int i = 1; i < s.size(); i++) {
if (s[i] == '/') {
if (t == ".." && v.size() > 0)
v.pop_back();
else
v.push_back(t);
t = "";
} else
t += s[i];
}
} else {
string t = "";
for (int i = 0; i < s.size(); i++) {
if (s[i] == '/') {
if (t == ".." && v.size() > 0)
v.pop_back();
else
v.push_back(t);
t = "";
} else
t += s[i];
}
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
const int maxn = 3e3 + 10;
int d[maxn][maxn];
int n, m, s1, t1, l1, s2, t2, l2, ans;
vector<int> adj[maxn];
void bfs(int x) {
queue<int> q;
q.push(x);
d[x][x] = 0;
while (q.size()) {
int v = q.front();
q.pop();
for (auto u : adj[v])
if (d[x][u] == -1) d[x][u] = d[x][v] + 1, q.push(u);
}
}
void task() {
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
int d1 = d[s1][i] + d[i][j] + d[j][t1];
int d2 = d[s2][j] + d[i][j] + d[i][t2];
if (d1 > l1 || d2 > l2) continue;
ans = min(ans, d1 + d2 - d[i][j]);
}
}
int main() {
cin >> n >> m;
for (int i = 0, fi, se; i < m; i++) {
cin >> fi >> se, fi--, se--;
adj[fi].push_back(se);
adj[se].push_back(fi);
}
cin >> s1 >> t1 >> l1 >> s2 >> t2 >> l2;
s1--, t1--, s2--, t2--;
memset(d, -1, sizeof d);
for (int i = 0; i < n; i++) bfs(i);
if (d[s1][t1] > l1 || d[s2][t2] > l2) return cout << -1 << endl, 0;
ans = d[s1][t1] + d[s2][t2];
task();
swap(s1, t1);
task();
cout << m - ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, mx = 0, cnt = 0;
cin >> n;
int man = 0;
int x;
for (int i = 0; i < n; i++) {
cin >> x;
if (x >= 1)
man += x;
else {
if (man == 0)
cnt++;
else
man--;
}
}
cout << cnt << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1000001;
const long long mod = 998244353;
long long pow_2[maxn];
long long a[maxn];
int n;
int main() {
ios::sync_with_stdio(false);
while (cin >> n) {
for (int i = 1; i <= n; i++) cin >> a[i];
pow_2[0] = 1;
for (int i = 1; i <= n; i++) pow_2[i] = (pow_2[i - 1] * 2) % mod;
long long ans = pow_2[n - 1] * a[1] % mod, pre = a[1];
for (int i = 2; i <= n; i++) {
ans += (pow_2[n - i] * a[i] % mod + pow_2[n - i] * pre % mod) % mod;
pre = (pre * 2 % mod + a[i] % mod) % mod;
}
cout << ans % mod << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int M = 205;
const int N = 100005;
const int L = 100000;
const int mod = 998244353;
int n, k, len, a[N], bel[N], pre[N], las[N], dp[N], fl[N], tot[N], ans[M],
s[M][N << 1];
void ad(int i, int x) {
(s[bel[i]][L + tot[i]] += mod - dp[i]) %= mod;
tot[i] += x;
(s[bel[i]][L + tot[i]] += dp[i]) %= mod;
if (x == 1 && tot[i] + fl[bel[i]] == k + 1) {
(ans[bel[i]] += mod - dp[i]) %= mod;
}
if (x == -1 && tot[i] + fl[bel[i]] == k) {
(ans[bel[i]] += dp[i]) %= mod;
}
}
void add(int l, int r, int x) {
if (bel[l] + 1 >= bel[r]) {
for (int i = l; i <= r; i++) {
ad(i, x);
}
return;
}
for (int i = l; i < (bel[l] + 1) * len; i++) {
ad(i, x);
}
for (int i = bel[r] * len; i <= r; i++) {
ad(i, x);
}
for (int i = bel[l] + 1; i < bel[r]; i++) {
if (x == 1) {
(ans[i] += mod - s[i][L + k - fl[i]]) %= mod;
}
if (x == -1) {
(ans[i] += s[i][L + k - fl[i] + 1]) %= mod;
}
fl[i] += x;
}
}
int query(int l, int r) {
int sum = 0;
if (bel[l] + 1 >= bel[r]) {
for (int i = l; i <= r; i++) {
if (tot[i] + fl[bel[i]] <= k) {
(sum += dp[i]) %= mod;
}
}
return sum;
}
for (int i = l; i < (bel[l] + 1) * len; i++) {
if (tot[i] + fl[bel[i]] <= k) {
(sum += dp[i]) %= mod;
}
}
for (int i = bel[r] * len; i <= r; i++) {
if (tot[i] + fl[bel[i]] <= k) {
(sum += dp[i]) %= mod;
}
}
for (int i = bel[l] + 1; i < bel[r]; i++) {
(sum += ans[i]) %= mod;
}
return sum;
}
signed main() {
scanf("%d%d", &n, &k);
len = 500;
for (int i = 0; i <= n; i++) {
bel[i] = i / len;
}
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
dp[0] = 1;
ans[0] += dp[0];
s[0][L] += dp[0];
for (int i = 1; i <= n; i++) {
pre[i] = las[a[i]];
las[a[i]] = i;
add(pre[i], i - 1, 1);
if (pre[i]) add(pre[pre[i]], pre[i] - 1, -1);
dp[i] = query(0, i - 1);
(ans[bel[i]] += dp[i]) %= mod;
(s[bel[i]][L - fl[bel[i]]] += dp[i]) %= mod;
}
cout << dp[n];
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int s = 0, w = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') s = s * 10 + ch - '0', ch = getchar();
return s * w;
}
const int inf = 2e9 + 7;
double eps = 1e-6;
const int mod = 1e9 + 7;
const int N = 1e6 + 10;
const double pi = acos(-1.0);
long long power(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
b >>= 1;
}
return res;
}
long long gcd(long long a, long long b) { return !b ? a : gcd(b, a % b); }
void add(long long& a, long long b) {
a += b;
((a >= mod) && (a -= mod));
((a < 0) && (a += mod));
}
long long exgcd(long long a, long long b, long long& x, long long& y) {
long long c;
return !b ? (x = 1, y = 0, a)
: (c = exgcd(b, a % b, y, x), y -= (a / b) * x, c);
}
long long INV(long long a) {
long long x, y;
exgcd(a, mod, x, y);
x %= mod;
if (x < 0) x += mod;
return x;
}
char s[N], t[N];
int dp[N], g[N];
class Pam {
public:
int sz, tot, last;
int cnt[N], ch[N][26], len[N], fail[N], dif[N], slink[N];
char s[N];
int node(int l) {
sz++;
memset(ch[sz], 0, sizeof(ch[sz]));
len[sz] = l;
fail[sz] = cnt[sz] = 0;
return sz;
}
void init() {
sz = -1;
last = 0;
s[tot = 0] = '$';
node(0);
node(-1);
fail[0] = 1;
}
int getfail(int x) {
while (s[tot - len[x] - 1] != s[tot]) x = fail[x];
return x;
}
void insert(int c) {
s[++tot] = c;
int now = getfail(last);
if (!ch[now][c]) {
int x = node(len[now] + 2);
fail[x] = ch[getfail(fail[now])][c];
ch[now][c] = x;
dif[x] = len[x] - len[fail[x]];
if (dif[x] == dif[fail[x]])
slink[x] = slink[fail[x]];
else
slink[x] = fail[x];
}
last = ch[now][c];
cnt[last]++;
}
void addtimes() {
for (int i = sz; i >= 2; --i) cnt[fail[i]] += cnt[i];
}
void work() {
dp[0] = 1;
int w = strlen(t + 1);
for (int i = 1; i <= w; ++i) {
insert(t[i] - 'a');
for (int x = last; x > 1; x = slink[x]) {
g[x] = dp[i - len[slink[x]] - dif[x]];
if (dif[x] == dif[fail[x]]) g[x] = (g[x] + g[fail[x]]) % mod;
if (i % 2 == 0) dp[i] = (dp[i] + g[x]) % mod;
}
}
cout << dp[w];
}
} pam;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> s + 1;
int w = strlen(s + 1);
for (int i = 1; i <= w; ++i)
t[i] = ((i & 1) ? s[(i + 1) / 2] : s[w + 1 - i / 2]);
pam.init();
pam.work();
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int p[10];
int n, k;
int all = 0;
int inv = 0;
void calc(int depth) {
if (depth == 0) {
all++;
int cnt = 0;
for (int(i) = (0); i < (n); ++(i))
for (int(j) = (0); j < (i); ++(j))
if (p[i] < p[j]) cnt++;
inv += cnt;
} else {
for (int(l) = (0); l < (n); ++(l))
for (int(r) = (l); r < (n); ++(r)) {
reverse(p + l, p + r + 1);
calc(depth - 1);
reverse(p + l, p + r + 1);
}
}
}
int main() {
cin >> n >> k;
for (int(i) = (0); i < (n); ++(i)) cin >> p[i];
calc(k);
cout << fixed;
cout << setprecision(11);
cout << (inv + .0) / all;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int cs[12];
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int m, d;
cin >> m >> d;
int ans = 1;
int mes = 30;
if (m == 1 or m == 3 or m == 5 or m == 7 or m == 8 or m == 10 or m == 12)
mes++;
if (m == 2) mes = 28;
for (int i = 1; i <= d; i++) cs[i]++;
for (int i = 1; i < mes; i++) {
cs[(i + d) % 7]++;
}
int ma = -10;
for (int i = 0; i < 9; i++) {
if (cs[i] > ma) ma = cs[i];
}
cout << ma << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXCOST = 300000;
vector<long long> ncost, pcost;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n, k;
cin >> n >> k;
long long maxcost = (n + 1) * (1001 - n);
ncost.resize(maxcost + 1);
pcost.resize(maxcost + 1);
vector<long long> plist, nlist;
for (long long i = 0; i < (k); ++i) {
long long x;
cin >> x;
if (x > n)
pcost[x - n] = 1;
else
ncost[n - x] = 1;
}
if (ncost[0] == 1) {
cout << 1 << endl;
return 0;
}
for (int i = 1; i <= 1000; i++) {
if (pcost[i] == 1) plist.push_back(i);
if (ncost[i] == 1) nlist.push_back(i);
}
for (long long i = 0; i < (1001); ++i) {
if (pcost[i] == ncost[i] && ncost[i] == 1) {
cout << 2 << endl;
return 0;
}
}
for (long long i = 1; i <= maxcost; i++) {
if (pcost[i] == 0) {
pcost[i] = MAXCOST;
for (long long j : plist) {
if (j > i) continue;
pcost[i] = min(pcost[i], pcost[i - j] + pcost[j]);
}
}
if (ncost[i] == 0) {
ncost[i] = MAXCOST;
for (long long j : nlist) {
if (j > i) continue;
ncost[i] = min(ncost[i], ncost[i - j] + ncost[j]);
}
}
}
long long ans = MAXCOST;
for (int i = 1; i <= maxcost; i++) {
ans = min(ans, pcost[i] + ncost[i]);
}
cout << ((MAXCOST == ans) ? (-1) : ans) << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, ans = 0, level = 1;
cin >> n;
while (n > 1) {
ans += (n / 2) * level;
level *= 2;
n = ceil(n / 2.0);
}
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
cin >> n >> m >> k;
if (n % 2 == 0) {
cout << "Marsel";
return 0;
}
bool found = false;
for (int i = 2; i * i <= m; i++)
if (m % i == 0 && m / i >= k) found = true;
if (m >= 2 && k == 1) found = true;
if (!found)
cout << "Marsel";
else
cout << "Timur";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int Len = 30;
struct BigNumber {
int X[Len];
void Set(int A) {
memset(X, 0, sizeof(X));
X[0] = A;
}
void Output() {
int P = Len - 1;
while (P && !X[P]) P--;
printf("%d", X[P]);
while (P) {
static int A[8];
P--;
for (int i = 0; i < 8; i++) {
A[i] = X[P] % 10;
X[P] /= 10;
}
for (int i = 7; i >= 0; i--) putchar(A[i] + 48);
}
putchar('\n');
}
};
bool operator<(BigNumber A, BigNumber B) {
int P = Len - 1;
while (P && A.X[P] == B.X[P]) P--;
return A.X[P] < B.X[P];
}
BigNumber operator*(BigNumber A, int P) {
BigNumber B;
for (int i = 0, G = 0; i < Len; i++) {
long long S = (long long)A.X[i] * P + G;
G = S / 100000000;
B.X[i] = S % 100000000;
}
return B;
}
BigNumber operator*(BigNumber A, BigNumber B) {
static long long S[Len];
memset(S, 0, sizeof(S));
for (int i = 0; i < Len; i++)
for (int j = 0; i + j < Len; j++) S[i + j] += (long long)A.X[i] * B.X[j];
for (int i = 1; i < Len; i++) S[i] += S[i - 1] / 100000000;
BigNumber C;
for (int i = 0; i < Len; i++) C.X[i] = S[i] % 100000000;
return C;
}
int Get() {
char c;
while (c = getchar(), c < '0' || c > '9')
;
int X = c - 48;
while (c = getchar(), c >= '0' && c <= '9') X = X * 10 + c - 48;
return X;
}
int main() {
int N = Get();
static vector<int> G[700];
for (int i = 1; i < N; i++) {
int X = Get() - 1, Y = Get() - 1;
G[X].push_back(Y);
G[Y].push_back(X);
}
int F = 0, R = 1;
static int Queue[700], Parent[700];
static vector<int> Child[700];
Queue[0] = 0;
Parent[0] = -1;
for (int F = 0, R = 1; R < N; F++)
for (int V = Queue[F], i = 0; i < G[V].size(); i++) {
int U = G[V][i];
if (U != Parent[V]) {
Parent[U] = V;
Queue[R++] = U;
Child[V].push_back(U);
}
}
static int Next[700], Right[700];
for (int i = 0; i < N; i++) Next[i] = -1;
for (int i = 0; i < N; i++) {
for (int j = 1; j < Child[i].size(); j++)
Next[Child[i][j - 1]] = Child[i][j];
for (int j = 0; j < Child[i].size(); j++)
Right[Child[i][j]] = Child[i].size() - j;
}
static BigNumber DP[700][703];
for (int T = N - 1, V = Queue[T]; T >= 0; V = Queue[--T])
if (!Child[V].size()) {
DP[V][N].Set(1);
DP[V][N + 1].Set(2);
DP[V][N + 2].Set(1);
for (int S = 0; S < N; S++)
if (S > Right[V])
DP[V][S].Set(0);
else if (Next[V] == -1)
DP[V][S].Set(1);
else if (!S)
DP[V][S] = DP[Next[V]][S];
else
DP[V][S] = max(DP[Next[V]][S], DP[Next[V]][S - 1]);
} else {
DP[V][N + 2].Set(1);
for (int i = 0; i < Child[V].size(); i++)
DP[V][N + 2] = DP[V][N + 2] * DP[Child[V][i]][N];
DP[V][N + 1] = DP[V][N + 2] * 2;
for (int i = 0; i <= Child[V].size(); i++)
DP[V][N + 1] = max(DP[V][N + 1], DP[Child[V][0]][i] * (i + 2));
DP[V][N] = DP[V][N + 2];
for (int i = 0; i <= Child[V].size(); i++)
DP[V][N] = max(DP[V][N], DP[Child[V][0]][i] * (i + 1));
int Best = 0;
BigNumber P = DP[Child[V][0]][N + 1];
BigNumber Q = DP[Child[V][0]][N];
for (int i = 1; i < Child[V].size(); i++) {
BigNumber _P = DP[Child[V][i]][N + 1];
BigNumber _Q = DP[Child[V][i]][N];
if (P * _Q < _P * Q) {
Best = i;
_P = P;
_Q = Q;
}
}
BigNumber Temp;
Temp.Set(1);
for (int i = 0; i < Child[V].size(); i++)
Temp = Temp * DP[Child[V][i]][N + (i == Best)];
DP[V][N] = max(DP[V][N], Temp);
for (int S = 0; S < N; S++)
if (S > Right[V])
DP[V][S].Set(0);
else if (Next[V] == -1)
DP[V][S] = DP[V][N + S * 2];
else if (!S)
DP[V][S] = DP[Next[V]][S] * DP[V][N];
else
DP[V][S] =
max(DP[Next[V]][S] * DP[V][N], DP[Next[V]][S - 1] * DP[V][N + 2]);
}
DP[0][N].Output();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct node {
long long int num;
long long int price;
} e[1009];
int n;
int t;
long long int p[1009];
int cmp(node x, node y) { return x.price < y.price; }
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> e[i].num >> e[i].price;
}
cin >> t;
memset(p, 0x3f3f3f3f, sizeof(p));
for (int i = 0; i < t; i++) {
cin >> p[i];
}
sort(e + 1, e + 1 + n, cmp);
long long int sum = 0;
int cnt = 0;
long long int ans = 0;
for (int i = 1; i <= n; i++) {
ans += (e[i].num * e[i].price * (cnt + 1));
while (e[i].num + sum > p[cnt]) {
ans += (e[i].price * (e[i].num - (p[cnt++] - sum)));
}
sum += e[i].num;
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
string s;
cin >> s;
int ans = 0;
int count = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == ')') {
ans--;
if (ans < 0) {
count++;
ans = 0;
}
} else {
ans++;
}
}
cout << count << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
int t;
cin >> t;
while (t--) {
int k;
cin >> k;
int kk = sqrt(k);
int ans = kk * kk;
if (kk * kk == k) {
printf("%d 1\n", kk);
} else {
kk++;
if (k <= ans + kk) {
printf("%d %d\n", k - ans, kk);
} else
printf("%d %d\n", kk, kk - (k - ans - kk));
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t = 1;
cin >> t;
double dp[32] = {1,
2,
4,
8,
16,
32,
64,
128,
256,
512,
1024,
2048,
4096,
8192,
16384,
32768,
65536,
131072,
262144,
524288,
1048576,
2097152,
4194304,
8388608,
16777216,
33554432,
67108864,
134217728,
268435456,
536870912,
1.07374182e9,
2.14748365e9};
while (t--) {
long long n;
cin >> n;
vector<long long> v(n);
for (long long i = 0; i < n; i++) cin >> v[i];
long long ans = INT_MIN, top = v[0];
cout << fixed << setprecision(10);
for (long long i = 1; i < n; i++) {
if (v[i] >= top)
top = v[i];
else {
long long dif = top - v[i];
long long x = lower_bound(dp, dp + 32, dif) - dp;
if (v[i] + dp[x] != top) x--;
ans = max(ans, x);
}
}
if (ans == INT_MIN)
cout << 0 << endl;
else
cout << ans + 1 << endl;
;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
long long t[MAXN], sum[MAXN];
int n;
int ans[MAXN];
int getpos(long long val) {
int pos = lower_bound(t + 1, t + 1 + n, val) - t;
return pos;
}
int main() {
int cnt = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld", &t[i]);
}
for (int i = 1; i <= n; i++) {
ans[i] = 20;
int pos = getpos(t[i] - 89);
long long co = sum[i - 1] - sum[pos - 1];
if (co >= 50)
ans[i] = 0;
else if (50 - co < ans[i])
ans[i] = 50 - co;
pos = getpos(t[i] - 1439);
co = sum[i - 1] - sum[pos - 1];
if (co >= 120)
ans[i] = 0;
else if (120 - co < ans[i])
ans[i] = 120 - co;
sum[i] = sum[i - 1] + ans[i];
}
for (int i = 1; i <= n; i++) {
printf("%d\n", ans[i]);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int N, S, K;
int cnt[101010];
int main() {
int s, e;
scanf("%d %d", &N, &S);
if (N == 2) {
printf("%d\n", S);
return 0;
}
for (int i = 1; i < N; i++) {
scanf("%d %d", &s, &e);
cnt[s]++;
cnt[e]++;
}
for (int i = 1; i <= N; i++)
if (cnt[i] == 1) K++;
printf("%.12f\n", (double)S / K * 2);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
if (n == 1 || n == 2)
cout << "1\n1";
else if (n == 3)
cout << "2\n1 3";
else {
cout << n << "\n";
for (int i = 2; i <= n; i += 2) {
cout << i << " ";
}
for (int i = 1; i <= n; i += 2) {
cout << i << " ";
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long double pi = 3.1415926535897932385;
const long double E = 2.71828182845904523536;
const long long mod = 1e9 + 7;
const long long eps = 1e-8;
const long long inf = 1e9;
const int N = 1010;
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i == j)
printf("%d ", k);
else
printf("0 ");
}
printf("\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
set<int> s;
const int MAX = 150000;
int t[MAX];
int main() {
int n, q, k;
cin >> n >> k >> q;
for (int i = 0; i < n; i++) scanf("%d", t + i);
for (int i = 0; i < q; i++) {
int query;
scanf("%d", &query);
int x;
scanf("%d", &x);
x = t[x - 1];
if (query == 1) {
if (s.size() == k) {
set<int>::iterator it = s.begin();
if (x > *it) {
s.erase(*it);
s.insert(x);
}
} else {
s.insert(x);
}
} else {
if (s.count(x))
printf("YES\n");
else
printf("NO\n");
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int M = 998244353;
int pow(int a, int b) {
if (b == 0) {
return 1;
}
if (b % 2) {
return ((long long)a * pow(a, b - 1)) % M;
} else {
int temp = pow(a, b / 2);
return ((long long)temp * temp) % M;
}
}
int inv[3010];
int w[55];
int a[55];
int dp1[55][55][55];
int dp2[55][55][55];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < 3010; i++) {
inv[i] = pow(i, M - 2);
}
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int s = 0, s1 = 0, s2 = 0;
for (int i = 0; i < n; i++) {
cin >> w[i];
s += w[i];
if (a[i]) {
s1 += w[i];
}
}
s2 = s - s1;
for (int i = 0; i < n; i++) {
dp1[i][0][0] = 1;
}
for (int l = 0; l < m; l++) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < 55; j++) {
for (int k = 0; k < 55; k++) {
if (a[i]) {
dp2[i][j][k] = (long long)dp1[i][j][k] * (s2 - l + j) % M *
inv[s + 2 * j - l] % M;
if (k && j)
dp2[i][j][k] = (dp2[i][j][k] + (long long)dp1[i][j - 1][k - 1] *
(w[i] + k - 1) % M *
inv[s + 2 * j - l - 2] % M) %
M;
if (j)
dp2[i][j][k] = (dp2[i][j][k] + (long long)dp1[i][j - 1][k] *
(s1 + j - w[i] - k - 1) % M *
inv[s + 2 * j - 2 - l] % M) %
M;
} else {
dp2[i][j][k] = (long long)dp1[i][j][k] * (s2 - l + j - (w[i] - k)) %
M * inv[s + 2 * j - l] % M;
if (k)
dp2[i][j][k] = (dp2[i][j][k] + (long long)dp1[i][j][k - 1] *
(w[i] - (k - 1)) % M *
inv[s + 2 * j - l] % M) %
M;
if (j)
dp2[i][j][k] =
(dp2[i][j][k] + (long long)dp1[i][j - 1][k] * (s1 + j - 1) %
M * inv[s + 2 * j - 2 - l] % M) %
M;
}
}
}
}
for (int i = 0; i < 55; i++) {
for (int j = 0; j < 55; j++) {
for (int k = 0; k < 55; k++) {
dp1[i][j][k] = dp2[i][j][k];
}
}
}
}
for (int i = 0; i < n; i++) {
int ans = 0;
for (int j = 0; j < 55; j++) {
for (int k = 0; k < 55; k++) {
if (a[i]) {
int temp = (long long)(w[i] + k) * dp1[i][j][k] % M;
ans = (ans + temp) % M;
} else {
int temp = (long long)(w[i] - k) * dp1[i][j][k] % M;
ans = (ans + temp) % M;
}
}
}
cout << ans << endl;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
set<vector<string>> st;
int main() {
vector<string> a;
for (int i = 0; i < 6; i++) {
string s;
cin >> s;
a.push_back(s);
}
sort(a.begin(), a.end());
do {
if (a[0].front() == a[1].front() && a[0].back() == a[2].front() &&
a[1].back() == a[3].front() && a[3].back() == a[4].front() &&
a[2].back() == a[5].front() && a[4].back() == a[5].back() &&
a[0].size() + a[5].size() - 1 == a[3].size() &&
a[1].size() + a[4].size() - 1 == a[2].size() &&
a[2][a[1].size() - 1] == a[3][a[0].size() - 1]) {
vector<string> ans = vector<string>(a[2].size());
for (int i = 0; i < (int)a[2].size(); i++) {
for (int j = 0; j < (int)a[3].size(); j++) ans[i].push_back('.');
}
for (int j = 0; j < (int)a[0].size(); j++) {
ans[0][j] = a[0][j];
}
for (int i = 0; i < (int)a[1].size(); i++) {
ans[i][0] = a[1][i];
}
for (int i = 0; i < (int)a[2].size(); i++) {
ans[i][(int)a[0].size() - 1] = a[2][i];
}
for (int j = 0; j < (int)a[3].size(); j++) {
ans[(int)a[1].size() - 1][j] = a[3][j];
}
for (int i = 0; i < (int)a[4].size(); i++) {
ans[(int)a[1].size() - 1 + i][(int)a[3].size() - 1] = a[4][i];
}
for (int j = 0; j < (int)a[5].size(); j++) {
ans[(int)a[2].size() - 1][a[0].size() - 1 + j] = a[5][j];
}
st.insert(ans);
}
} while (next_permutation(a.begin(), a.end()));
if (st.empty())
printf("Impossible\n");
else {
vector<string> ans = *st.begin();
for (int i = 0; i < (int)ans.size(); i++) printf("%s\n", ans[i].c_str());
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int week = n / 7;
int a = n % 7;
cout << week * 2 + max(a - 5, 0);
cout << " " << week * 2 + min(a, 2);
cout << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int HW_MAX = 200005, N_MAX = 2005, MOD = 1000000007;
int H, W, N;
long long factorial[HW_MAX];
pair<int, int> cells[N_MAX];
long long paths[N_MAX];
long long fast_power(long long a, long long power) {
long long p = 1;
while (power > 0) {
if (power & 1) {
p = p * a % MOD;
}
a = a * a % MOD;
power >>= 1;
}
return p;
}
long long inverse(long long a) { return fast_power(a, MOD - 2); }
long long num_paths(long long height, long long width) {
return factorial[height + width] *
inverse(factorial[height] * factorial[width] % MOD) % MOD;
}
int main() {
factorial[0] = 1;
for (int i = 1; i < HW_MAX; i++) {
factorial[i] = i * factorial[i - 1] % MOD;
}
scanf("%d %d %d", &H, &W, &N);
for (int i = 0; i < N; i++) {
scanf("%d %d", &cells[i].first, &cells[i].second);
cells[i].first--;
cells[i].second--;
}
sort(cells, cells + N);
cells[N] = make_pair(H - 1, W - 1);
for (int i = 0; i <= N; i++) {
paths[i] = num_paths(cells[i].first, cells[i].second);
}
for (int i = 0; i < N; i++) {
for (int j = i + 1; j <= N; j++) {
if (cells[i].first <= cells[j].first &&
cells[i].second <= cells[j].second) {
int height = cells[j].first - cells[i].first;
int width = cells[j].second - cells[i].second;
paths[j] -= paths[i] * num_paths(height, width) % MOD;
paths[j] = (paths[j] + MOD) % MOD;
}
}
}
printf("%d\n", (int)paths[N]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool smax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T>
inline bool smin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
long long p[55][2][120];
inline long long check(long long l, long long r, long long s, long long bs) {
if (l < r) swap(l, r);
int n = 0;
for (long long k = s; k; k >>= 1, n++)
;
if (l == r && n != l + 1) return 0;
if (l > r && n != l && n != l + 1) return 0;
for (int i = 0; i <= n; i++)
for (int k = 0; k < 2; k++) {
for (int c = 0; c <= bs; c++) p[i][k][c] = 0;
}
p[0][0][0] = 1;
for (int i = 0; i < n; i++) {
int _lb = i < l, _rb = i < r, __rb = i == r - 1;
for (int lb = i == l - 1; lb <= _lb; lb++) {
for (int add = 0; add < 2; add++) {
int rb = (1 & s >> i) ^ lb ^ add, k = (lb + rb + add) >> 1;
if (rb >= __rb && rb <= _rb) {
for (int c = 0; c <= 2 * i && c <= bs; c++)
p[i + 1][k][c + lb + rb] += p[i][add][c];
}
}
}
}
return p[n][0][bs];
}
int main() {
long long s;
cin >> s;
long long res = 0;
for (long long h = 1; h <= 50; h++) {
long long c = (1ll << h) - 1, x = s / c, r = s % c;
r += (1ll << h) - 1;
if (x > 0)
for (int bit = 1; bit <= h; bit++)
if ((bit + r) % 2 == 0 && __builtin_popcountll((bit + r) / 2) == bit)
res++;
}
for (long long lh = 1; lh < 50; lh++)
for (long long rh = 1; rh < 50; rh++) {
long long c = (((1ll << lh) - 1 + (1ll << rh) - 1) * 2 + 1);
long long x = s / c, r = s % c;
if (x > 0 && r <= (1ll << lh) - 1 - lh + (1ll << (rh + 1)) - 1 - rh - 1) {
r += (1ll << (lh + 1)) - 1 + (1ll << (rh + 1)) - 1;
r += 1 - (1ll << (rh + 1)) - (1ll << lh);
for (int bitsum = 2; bitsum <= lh + rh; bitsum++) {
if ((bitsum + r) % 2 == 0)
res += check(lh, rh, (r + bitsum) / 2, bitsum);
}
}
}
cout << res << endl;
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
struct Restrict {
int type;
int a, b, c;
};
int n, m, q;
vector<Restrict> bad;
bool ok(int root, int mask1, int child, int mask2) {
for (auto r : bad) {
if (!(mask1 & (1 << r.a)) || !(mask1 & (1 << r.b))) continue;
if (((mask2 & (1 << r.a)) > 0) == ((mask2 & (1 << r.b)) > 0)) continue;
if (r.type == 0) {
if (r.b == root) swap(r.a, r.b);
if (r.a != root || r.b != child) return false;
} else if (r.c != root)
return false;
}
return true;
}
long long dp[1 << 13][13];
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
bad.push_back({0, a - 1, b - 1, 0});
}
for (int i = 0; i < q; i++) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
if (a == b && a != c) return printf("0\n"), 0;
bad.push_back({1, a - 1, b - 1, c - 1});
}
for (int i = 0; i < n; i++) dp[1 << i][i] = 1;
for (int mask = 1; mask < (1 << n); mask++)
for (int root = 0; root < n; root++)
if (mask & (1 << root)) {
int high = -1;
for (int i = 0; i < n; i++)
if ((mask & (1 << i)) && i != root) high = i;
if (high == -1) continue;
int sub = (mask - 1) & mask;
while (sub) {
if ((sub & (1 << high)) && !(sub & (1 << root))) {
for (int i = 0; i < n; i++)
if (sub & (1 << i)) {
if (ok(root, mask, i, sub))
dp[mask][root] += dp[mask ^ sub][root] * dp[sub][i];
}
}
sub = (sub - 1) & mask;
}
}
printf("%lld\n", dp[(1 << n) - 1][0]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 10;
int dp[maxn][maxn], a[maxn];
pair<int, int> bck[maxn][maxn];
int up[maxn][maxn];
vector<int> v;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
if (n == 2) {
cout << max(a[1], a[2]) << "\n";
return cout << 1 << " " << 2, 0;
}
if (n == 1) {
cout << a[1] << "\n";
return cout << 1, 0;
}
dp[2][1] = max(a[2], a[3]);
bck[2][1] = make_pair(2, 3);
dp[2][2] = max(a[1], a[3]);
bck[2][2] = make_pair(1, 3);
dp[2][3] = max(a[1], a[2]);
bck[2][3] = make_pair(1, 2);
for (int i = 2; i <= n - 3; i += 2) {
for (int j = 1; j < i + 2; j++) {
dp[i + 2][j] = dp[i][j] + max(a[i + 2], a[i + 3]);
bck[i + 2][j] = make_pair(i + 2, i + 3), up[i + 2][j] = j;
if (j == 1)
dp[i + 2][i + 2] = dp[i][1] + max(a[1], a[i + 3]),
bck[i + 2][i + 2] = make_pair(1, i + 3),
up[i + 2][i + 2] = 1,
dp[i + 2][i + 3] = dp[i][1] + max(a[1], a[i + 2]),
bck[i + 2][i + 3] = make_pair(1, i + 2),
up[i + 2][i + 3] = 1;
else {
if (dp[i + 2][i + 2] >= dp[i][j] + max(a[j], a[i + 3]))
dp[i + 2][i + 2] = dp[i][j] + max(a[j], a[i + 3]),
bck[i + 2][i + 2] = make_pair(i + 3, j),
up[i + 2][i + 2] = j;
if (dp[i + 2][i + 3] >= dp[i][j] + max(a[j], a[i + 2]))
dp[i + 2][i + 3] = dp[i][j] + max(a[j], a[i + 2]),
bck[i + 2][i + 3] = make_pair(i + 2, j),
up[i + 2][i + 3] = j;
}
}
}
int ans, y;
if (n % 2) {
ans = dp[n - 1][1] + a[1];
bck[n][0] = make_pair(0, 1);
y = 1;
for (int i = 2; i <= n; i++)
if (ans >= dp[n - 1][i] + a[i])
ans = dp[n - 1][i] + a[i], bck[n][0] = make_pair(0, i), y = i;
} else {
ans = dp[n - 2][1] + max(a[1], a[n]);
bck[n][0] = make_pair(1, n);
for (int i = 2; i <= n - 1; i++)
if (ans >= dp[n - 2][i] + max(a[i], a[n]))
ans = dp[n - 2][i] + max(a[i], a[n]), bck[n][0] = make_pair(n, i),
y = i;
}
cout << ans << "\n";
if (n % 2)
v.push_back(y), n--;
else
v.push_back(n), v.push_back(y), n -= 2;
int x_, y_;
for (int i = n; i >= 2; i -= 2) {
v.push_back(max(bck[i][y].first, bck[i][y].second));
v.push_back(min(bck[i][y].first, bck[i][y].second));
y_ = up[i][y];
y = y_;
}
for (int i = v.size() - 1; i > 0; i -= 2)
cout << v[i] << " " << v[i - 1] << "\n";
if (v.size() % 2) cout << v[0];
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int T;
cin >> T;
while (T--) {
int n;
cin >> n;
vector<int> a(2 * n);
for (auto &i : a) cin >> i;
vector<int> b;
int head = -1;
for (int i = 0; i < 2 * n; i++) {
if (a[i] > head) b.push_back(0);
b.back()++;
head = max(head, a[i]);
}
vector<int> dp(n + 1);
dp[0] = 1;
for (auto &j : b) {
for (int i = n; i >= j; i--) {
dp[i] |= dp[i - j];
}
}
if (dp[n])
cout << "YES\n";
else
cout << "NO\n";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, q[10];
cin >> a >> b >> c;
q[1] = a + a + b + b;
q[2] = a + a + b + c + a;
q[3] = a + b + c;
q[4] = a + c + c + a;
q[5] = b + c + c + b;
q[6] = b + b + a + c + a;
sort(q + 1, q + 6);
cout << q[1];
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, y = 0;
cin >> a >> b;
while (b >= a) {
a = 3 * a;
b = 2 * b;
y++;
}
cout << y;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef struct ll {
int l, r, in, t, c;
} node;
int cmp(const void *x, const void *y) {
node *a = (node *)x, *b = (node *)y;
if (a->t == b->t) {
return a->in - b->in;
} else
return a->t - b->t;
}
int main() {
int m, n, i, j, k;
node a[102];
scanf("%d%d", &n, &m);
for (i = 0; i < m; i++) {
a[i].in = i;
scanf("%d%d%d%d", &a[i].l, &a[i].r, &a[i].t, &a[i].c);
}
qsort(a, m, sizeof(node), cmp);
int sum = 0;
int b[102] = {0};
for (i = 0; i < m; i++) {
for (j = a[i].l; j <= a[i].r; j++) {
if (b[j] == 0) {
b[j]++;
sum += a[i].c;
}
}
}
printf("%d\n", sum);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int i, j, k, n, m, K, t, nn;
int a[610], id[610], du[610];
double c[610][610], b[110][110], d[110];
inline void gaosi() {
for (i = 1; i <= n; i++) {
for (j = i; j <= n; j++)
if (c[j][i]) {
for (k = i; k <= t; k++) swap(c[i][k], c[j][k]);
break;
}
for (j = t; j >= i; j--) c[i][j] /= c[i][i];
for (j = i + 1; j <= n; j++)
if (c[j][i])
for (k = t; k >= i; k--) c[j][k] -= c[j][i] * c[i][k];
}
for (i = n; i; i--)
for (j = 1; j <= i - 1; j++)
for (k = n + 1; k <= t; k++) c[j][k] -= c[j][i] * c[i][k];
for (i = 1; i <= nn; i++) d[i] = c[1][n + i];
for (i = 1; i <= n; i++)
if (a[i])
for (j = 1; j <= nn; j++) b[id[i] - n][j] = c[i][j + n];
}
inline void mul() {
int i, j;
double a[110] = {};
for (i = 1; i <= nn; i++)
for (j = 1; j <= nn; j++) a[j] += d[i] * b[i][j];
for (i = 1; i <= nn; i++) d[i] = a[i];
}
inline void multi() {
int i, j, k;
double a[110][110] = {};
for (i = 1; i <= nn; i++)
for (j = 1; j <= nn; j++)
for (k = 1; k <= nn; k++) a[i][k] += b[i][j] * b[j][k];
for (i = 1; i <= nn; i++)
for (j = 1; j <= nn; j++) b[i][j] = a[i][j];
}
inline void work() {
K -= 2;
for (; K; K /= 2) {
if (K & 1) mul();
multi();
}
printf("%.12lf\n", d[nn]);
}
int main() {
scanf("%d%d%d", &n, &m, &K);
t = n;
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (a[i]) id[i] = ++t;
}
nn = t - n;
for (i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
du[x]++, du[y]++;
if (a[y])
c[x][id[y]]--;
else
c[x][y]++;
if (a[x])
c[y][id[x]]--;
else
c[y][x]++;
}
for (i = 1; i <= n; i++) c[i][i] -= du[i];
gaosi();
work();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int INF = 0x7f7f7f7f;
const long double eps = 1e-9;
const int maxn = 1010;
int main() {
ios_base::sync_with_stdio(false);
string s;
cin >> s;
int o, c, sharp;
o = c = sharp = 0;
int idx;
for (int i = 0; i < (int)(s.size()); i++) {
if (s[i] == '(')
o++;
else
c++;
if (s[i] == '#') sharp++, idx = i;
if (c > o) {
puts("-1");
return 0;
}
}
int ans = o - c + 1;
o = c = 0;
for (int i = 0; i < (int)(s.size()); i++) {
if (s[i] == '(')
o++;
else if (i == idx)
c += ans;
else
c++;
if (c > o) {
puts("-1");
return 0;
}
}
for (int i = 0; i < sharp - 1; i++) cout << 1 << "\n";
cout << ans << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int T;
cin >> T;
for (int t = 0; t < T; t++) {
int N;
cin >> N;
vector<long long int> a_vec(N, 0);
long long int even = 0;
for (int n = 0; n < N; n++) {
long long int a;
cin >> a;
a_vec[n] = a;
if (n % 2 == 0) even += a;
}
long long int cm = 0;
long long int bm = 0;
for (int i = 1; i < N; i = i + 2) {
long long int x = a_vec[i] - a_vec[i - 1];
cm = max(0ll, cm + x);
bm = max(bm, cm);
}
cm = 0;
for (int i = 2; i < N; i = i + 2) {
long long int x = a_vec[i - 1] - a_vec[i];
cm = max(0ll, cm + x);
bm = max(bm, cm);
}
long long int res = even + bm;
cout << res << "\n";
}
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:500000000")
using namespace std;
int nextInt() {
int n;
scanf("%d", &n);
return n;
}
long long nextLong() {
long long n;
scanf("%lld", &n);
return n;
}
const double PI = acos(-1.0);
const double EPS = 1e-9;
const int INF = (int)2e9;
pair<int, int> r[5009], c[5009];
int main() {
int n, m, k;
scanf("%d %d %d", &n, &m, &k);
for (int i = 1; i <= k; ++i) {
int t, x, a;
scanf("%d %d %d", &t, &x, &a);
if (t == 1) {
r[x] = make_pair(a, i);
} else {
c[x] = make_pair(a, i);
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (r[i].second >= c[j].second) {
printf("%d ", r[i].first);
} else {
printf("%d ", c[j].first);
}
}
printf("\n");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char *argv[]) {
int n, m;
scanf("%d %d", &n, &m);
int l = 1, r = n;
bool noans = false;
for (int i = 1; i <= m; i++) {
char a[10], b[10], c[10], d[10];
int p;
memset(a, 0, sizeof(a));
memset(b, 0, sizeof(b));
memset(c, 0, sizeof(c));
memset(d, 0, sizeof(d));
scanf("%s", a);
getchar();
scanf("%s", b);
getchar();
scanf("%s", c);
getchar();
scanf("%s", d);
getchar();
scanf("%d", &p);
if (noans) continue;
int D = 0;
if (strcmp(c, "left") == 0)
D = 1;
else
D = 2;
if (D == 1) {
if (p - 1 < r) r = p - 1;
} else {
if (p + 1 > l) l = p + 1;
}
if (r < l) noans = true;
}
if (noans)
printf("-1\n");
else
printf("%d\n", r - l + 1);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string to_string(string s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string)s); }
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
const long double eps = 1e-12;
const int N = 2000 + 9;
int x[N], y[N];
struct node {
int m, f, to[4], d;
};
bool vis[2002][10][10][10][10][10];
node top;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x[i] >> y[i];
}
queue<node> q;
top.f = 1;
q.push(top);
vis[top.m][top.f][top.to[0]][top.to[1]][top.to[2]][top.to[3]] = 1;
while (!q.empty()) {
top = q.front();
q.pop();
if (top.m == n && top.to[3] == 0) {
break;
}
if (top.f < 9) {
node tmp = top;
tmp.f++;
bool &foo = vis[tmp.m][tmp.f][tmp.to[0]][tmp.to[1]][tmp.to[2]][tmp.to[3]];
if (foo == 0) {
foo = 1;
tmp.d = top.d + 1;
q.push(tmp);
}
}
if (top.f > 1) {
node tmp = top;
tmp.f--;
bool &foo = vis[tmp.m][tmp.f][tmp.to[0]][tmp.to[1]][tmp.to[2]][tmp.to[3]];
if (foo == 0) {
foo = 1;
tmp.d = top.d + 1;
q.push(tmp);
}
}
for (int i = 0; i < 4; i++) {
if (top.to[i] == top.f) {
node tmp = top;
tmp.to[i] = 0;
sort(tmp.to, tmp.to + 4);
bool &foo =
vis[tmp.m][tmp.f][tmp.to[0]][tmp.to[1]][tmp.to[2]][tmp.to[3]];
if (foo == 0) {
foo = 1;
tmp.d = top.d + 1;
q.push(tmp);
}
}
}
if (top.m < n && top.to[0] == 0) {
if (top.f == x[top.m + 1]) {
node tmp = top;
tmp.m++;
tmp.to[0] = y[tmp.m];
sort(tmp.to, tmp.to + 4);
bool &foo =
vis[tmp.m][tmp.f][tmp.to[0]][tmp.to[1]][tmp.to[2]][tmp.to[3]];
if (foo == 0) {
foo = 1;
tmp.d = top.d + 1;
q.push(tmp);
}
}
}
}
cout << top.d << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e6 + 10;
const int inf = 0x3f3f3f3f;
const int inff = -1e9;
const int mod = 1e10 + 1;
const long double PI = 3.14159265358979323846;
int main() {
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
long long res = n;
for (int i = 2; i <= MAX; i++)
if (n % i == 0) {
res += i;
break;
}
res += 2 * (k - 1);
cout << res << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
long long arr[100005];
vector<long long> v1, v2;
long long mi = INT_MAX;
for (long long i = 0; i < n; i++) {
cin >> arr[i];
mi = min(mi, arr[i]);
}
for (long long i = 0; i < n; i++) {
if (arr[i] % mi == 0) {
v1.push_back(i);
v2.push_back(arr[i]);
}
}
sort(v2.begin(), v2.end());
for (long long i = 0; i < v1.size(); i++) arr[v1[i]] = v2[i];
if (is_sorted(arr, arr + n)) {
cout << "YES"
<< "\n";
} else
cout << "NO"
<< "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int SIZE = 2e5 + 2;
long long int first[SIZE], last[SIZE], values[SIZE];
void solve() {
long long int N, K, X;
cin >> N >> K >> X;
for (long long int i = 1; i <= N; i++) {
cin >> values[i];
}
long long int _max = 1;
for (long long int i = 1; i <= K; i++) {
_max *= X;
}
long long int res = 0;
for (long long int i = 1; i <= N; i++) {
first[i] = first[i - 1] | values[i];
}
for (long long int i = N; i > 0; i--) {
last[i] = last[i + 1] | values[i];
}
for (long long int i = 1; i <= N; i++) {
long long int cur = first[i - 1] | (values[i] * _max) | last[i + 1];
res = max(res, cur);
}
cout << res << endl;
}
int main() {
long long int T;
T = 1;
while (T-- > 0) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000;
struct line {
int a, b, c;
};
struct point {
double x, y;
};
double orientation(point a, point b, point c) {
double l = (b.x - a.x) * (c.y - a.y);
double r = (b.y - a.y) * (c.x - a.x);
return l - r;
}
bool intersect(line ln, point a, point b) {
point fst, snd;
if (ln.b != 0) {
fst.x = 0;
fst.y = double(-ln.c) / double(ln.b);
} else {
fst.y = 0;
fst.x = double(-ln.c) / double(ln.a);
}
snd.x = fst.x - ln.b;
snd.y = fst.y + ln.a;
return orientation(fst, snd, a) * orientation(fst, snd, b) < 0;
}
int main(int argc, const char* argv[]) {
srand((unsigned)time(0));
point a, b;
cin >> a.x >> a.y >> b.x >> b.y;
int n;
cin >> n;
vector<line> A(n);
for (int i = 0; i < n; ++i) {
cin >> A[i].a >> A[i].b >> A[i].c;
}
int ans = 0;
for (int i = 0; i < n; ++i) {
if (intersect(A[i], a, b)) ++ans;
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10, mod = 1e9 + 7, INF = 0x3f3f3f3f;
inline long long mul(long long a, long long b) { return a * b % mod; }
inline long long add(long long a, long long b) {
a += b;
return a >= mod ? a - mod : a;
}
int n;
inline long long cal(int x, int y) { return n / ((1 << x) * (y ? 3 : 1)); }
int f[maxn][20][3];
int main() {
cin >> n;
int x = 0;
while ((1 << (x + 1)) <= n) ++x;
f[1][x][0] = 1;
if ((1 << (x - 1)) * 3 <= n) f[1][x - 1][1] = 1;
for (int i = 1; i < n; ++i)
for (int j = 0; j <= x; ++j)
for (int k = 0; k <= 1; ++k) {
f[i + 1][j][k] = add(f[i + 1][j][k], mul(f[i][j][k], cal(j, k) - i));
if (j)
f[i + 1][j - 1][k] = add(f[i + 1][j - 1][k],
mul(f[i][j][k], cal(j - 1, k) - cal(j, k)));
if (k)
f[i + 1][j][k - 1] = add(f[i + 1][j][k - 1],
mul(f[i][j][k], cal(j, k - 1) - cal(j, k)));
}
cout << f[n][0][0];
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, abcd[4];
vector<int> adjs[5000];
int ttag[5000], tsize[5000];
bool dp[5000][5000];
void processTree(int k, int parent) {
if (adjs[k].size() == 1) {
tsize[k] = 1;
for (int i = 0; i < 4; i++) {
if (k + 1 == abcd[i]) {
ttag[k] = i + 1;
break;
}
}
return;
}
for (int adj : adjs[k]) {
if (adj != parent) {
processTree(adj, k);
tsize[k] += tsize[adj];
ttag[k] |= ttag[adj];
}
}
}
void addSubtreeObjs(vector<int>& objs, int k, int parent) {
for (int adj : adjs[k]) {
if (adj != parent) {
if (!ttag[adj])
objs.push_back(tsize[adj]);
else
addSubtreeObjs(objs, adj, k);
}
}
}
bool knapsack(int ac, int bd) {
vector<int> objs;
for (int sroot : adjs[0]) {
if (ttag[sroot] == ac || ttag[sroot] == bd)
addSubtreeObjs(objs, sroot, 0);
else
objs.push_back(tsize[sroot]);
}
memset(dp, false, sizeof(dp));
dp[0][0] = true;
for (int i = 0; i < objs.size(); i++) {
for (int j = 0; j < n; j++) {
if (dp[i][j]) {
dp[i + 1][j] = dp[i + 1][j + objs[i]] = true;
}
}
}
return dp[objs.size()][(tsize[0] - 2) / 2];
}
int main() {
scanf("%d\n", &n);
scanf("%d %d %d %d\n", &abcd[0], &abcd[1], &abcd[2], &abcd[3]);
for (int i = 1; i < n; i++) {
int p;
scanf("%d", &p);
adjs[p - 1].push_back(i);
adjs[i].push_back(p - 1);
}
processTree(0, -1);
bool res = tsize[0] % 2 == 0 && knapsack(1, 2) && knapsack(3, 4);
printf("%s\n", res ? "YES" : "NO");
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
int c1 = c - b;
int c2 = d - a;
int c3 = c + d - a - b;
int ar[100005], br[100005], cr[100005];
memset(ar, 0, sizeof ar);
memset(br, 0, sizeof br);
memset(cr, 0, sizeof cr);
for (int i = 1; i <= n; i++) {
if (c1 + i >= 1 && c1 + i <= n) {
ar[c1 + i] = 1;
}
if (c2 + i >= 1 && c2 + i <= n) {
br[c2 + i] = 1;
}
if (c3 + i >= 1 && c3 + i <= n) {
cr[c3 + i] = 1;
}
}
long long int ans = 0;
for (int i = 1; i <= n; i++) {
if (ar[i] && br[i] && cr[i]) ans++;
}
long long int n1 = (long long int)n;
ans *= n1;
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, flag;
vector<int> a1, b1;
cin >> n;
long long fct = 0, sct = 0;
for (long long i(0); i < n; i++) {
cin >> a;
b = a;
if (a > 0) {
fct += a;
a1.push_back(a);
} else {
a *= -1;
sct += a;
b1.push_back(a);
}
}
if (fct > sct) {
flag = 1;
} else if (sct > fct) {
flag = 2;
} else if (fct == sct) {
int ismatch;
int k = min(a1.size(), b1.size());
for (int i(0); i < k; i++) {
if (i == k - 1 && a1[i] == b1[i]) {
if (a1.size() > b1.size())
flag = 1;
else if (a1.size() < b1.size())
flag = 2;
else {
if (b > 0)
flag = 1;
else
flag = 2;
}
}
if (a1[i] > b1[i]) {
flag = 1;
break;
} else if (a1[i] < b1[i]) {
flag = 2;
break;
}
}
}
if (flag == 1)
cout << "first";
else
cout << "second";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int const N = 3e5 + 2;
int n, k, v[N];
int main() {
string s;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; ++i) scanf("%d", v + i);
cin >> s;
long long an = 0;
for (int i = 0; i < n; ++i) {
vector<int> curr;
char x = s[i];
curr.push_back(v[i]);
while (i < n - 1 && s[i + 1] == x) {
++i;
curr.push_back(v[i]);
}
sort(curr.begin(), curr.end());
reverse(curr.begin(), curr.end());
for (int j = 0; j < curr.size() && j < k; ++j)
an = (long long)an + (long long)curr[j];
}
cout << an;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
int x[25];
int start;
bool dfs(int cur, int p, int mask, int sum) {
if (1.0 * (clock() - start) / CLOCKS_PER_SEC > 0.9) return false;
if (cur > n) return true;
if ((mask & (1 << cur)) == 0) return false;
if (sum == x[cur] - 1) return dfs(cur + 1, cur + 2, mask, 0);
if (p > n) return false;
if ((mask & (1 << p)) == 0) {
if (!(x[p] == x[p - 1] && (mask & (1 << (p - 1)) == 0)))
if (x[p] < x[cur] - 1 && sum + x[p] <= x[cur] - 1)
if (dfs(cur, p + 1, mask | (1 << p), sum + x[p])) return true;
}
if (dfs(cur, p + 1, mask, sum)) return true;
return false;
}
int MAIN() {
start = clock();
cin >> n;
for (int i = 1; i <= n; i++) cin >> x[i];
sort(x + 1, x + 1 + n);
reverse(x + 1, x + 1 + n);
if (dfs(1, 2, 2, 0))
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
int main() {
ios ::sync_with_stdio(false);
cout << fixed << setprecision(16);
return MAIN();
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m, cnt;
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
for (int j = 0; j < m; j++) {
cout << "#";
}
} else if (i % 2 && cnt % 2 == 0) {
cnt++;
for (int j = 0; j < m; j++) {
if (j < m - 1)
cout << ".";
else
cout << "#";
}
} else {
cnt++;
for (int j = m - 1; j >= 0; j--) {
if (j == m - 1)
cout << "#";
else
cout << ".";
}
}
cout << '\n';
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline long long gcd(long long a, long long b) {
return (b == 0 ? a : gcd(b, a % b));
}
const int MAXN = 200005;
const char INF = 100;
string T[55];
int n;
char pd[2][40][1 << 20];
int G[50][22];
char solve(int p, int k, int mask) {
if (k == 2 * n - 1) return 0;
if (pd[p][k][mask] == INF) {
char ans = INF;
int v[26] = {0};
int aux = n - abs(n - k);
for (int i = 0; i < aux; ++i) {
if ((1 << i) & mask) {
int a = i, b = i + 1;
if (k >= n) a--, b--;
if (a >= 0) v[G[k + 1][a]] |= 1 << a;
if (k < n || i < aux - 1) v[G[k + 1][b]] |= 1 << b;
}
}
for (int i = 0; i < 26; ++i) {
if (!v[i]) continue;
char tmp = solve(p ^ 1, k + 1, v[i]);
if (i == 0) tmp++;
if (i == 1) tmp--;
if (p) {
if (ans == INF || tmp < ans) ans = tmp;
} else {
if (ans == INF || tmp > ans) ans = tmp;
}
}
pd[p][k][mask] = ans;
}
return pd[p][k][mask];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
while (cin >> n) {
for (int i = 0; i < n; ++i) cin >> T[i];
for (int i = 1; i < 2 * n; ++i) {
int x, y;
if (i >= n) {
x = n - 1, y = i - n;
} else {
x = i - 1, y = 0;
}
int j = 0;
while (x >= 0) G[i][j++] = T[x--][y++] - 'a';
}
for (int i = 0; i < 40; ++i)
for (int j = 0; j < 1 << 20; ++j) pd[0][i][j] = pd[1][i][j] = INF;
int res = solve(1, 1, 1);
if (T[0][0] == 'a') res++;
if (T[0][0] == 'b') res--;
if (res > 0) {
cout << "FIRST" << endl;
} else if (res < 0) {
cout << "SECOND" << endl;
} else {
cout << "DRAW" << endl;
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007ll;
long long parity_ways[2][2];
int gcd[4001][4001];
void modadd(long long &a, long long b) {
a += b;
if (a >= mod) {
a -= mod;
}
}
int main() {
int w, h;
scanf("%d %d", &w, &h);
++w;
++h;
for (int a = 0; a < 2; ++a) {
for (int b = 0; b < 2; ++b) {
parity_ways[a][b] =
(long long)(w / 2 + (!a && (w & 1))) * (h / 2 + (!b && (h & 1)));
}
}
long long sol = 0;
for (int a = 0; a < 2; ++a) {
for (int b = 0; b < 2; ++b) {
for (int c = 0; c < 2; ++c) {
for (int d = 0; d < 2; ++d) {
for (int e = 0; e < 2; ++e) {
for (int f = 0; f < 2; ++f) {
int x1 = c - a, y1 = d - b, x2 = e - a, y2 = f - b;
int area = x1 * y2 - y1 * x2;
if (area < 0) {
area = -area;
}
if (area % 2 == 0) {
modadd(sol, parity_ways[a][b] * parity_ways[c][d] % mod *
parity_ways[e][f] % mod);
}
}
}
}
}
}
}
long long all_points = (long long)w * h % mod;
long long zeros = all_points;
modadd(zeros, all_points * (all_points - 1) % mod * 3 % mod);
modadd(zeros, all_points * (w - 1) % mod * (w - 2) % mod);
modadd(zeros, all_points * (h - 1) % mod * (h - 2) % mod);
for (int i = 0; i < w; ++i) {
for (int j = 0; j < h; ++j) {
if (i == 0)
gcd[i][j] = j;
else if (j == 0)
gcd[i][j] = i;
else if (i < j)
gcd[i][j] = gcd[j % i][i];
else
gcd[i][j] = gcd[i % j][j];
}
}
for (int x = 1; x < w; ++x) {
for (int y = 1; y < h; ++y) {
if (gcd[x][y] >= 2) {
modadd(zeros,
(gcd[x][y] - 1) * (w - x) % mod * (h - y) % mod * 12 % mod);
}
}
}
sol = (sol - zeros + mod) % mod;
printf("%d\n", int(sol));
return 0;
}
| 8 |
#include <bits/stdc++.h>
const int mod = 1e9 + 7;
const int N = 1e6 + 50;
int ksm(int u, int v) {
int res = 1;
for (; v; v >>= 1, u = 1ll * u * u % mod)
if (v & 1) res = 1ll * res * u % mod;
return res;
}
int n, k, f[N], Sum, Ans, fac;
int main() {
scanf("%d%d", &n, &k);
f[0] = fac = 1;
Ans = n;
for (int i = 1; i <= n; i++) {
Sum = (Sum + f[i - 1]) % mod;
if (i > k) Sum = (Sum - f[i - k - 1] + mod) % mod;
f[i] = 1ll * Sum * ksm(i, mod - 2) % mod;
Ans = (Ans - f[i - 1] + mod) % mod;
if (i != 1) fac = 1ll * fac * (i - 1) % mod;
}
printf("%d\n", 1ll * fac * Ans % mod);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
static const int MAXN = 1e5;
int data[MAXN];
vector<pair<int, int> > ans;
multiset<int> mul;
int n, k;
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; ++i) scanf("%d", data + i);
int j = 0, mx = -1;
for (int i = 0; i < n; ++i) {
mul.insert(data[i]);
while (*mul.rbegin() - *mul.begin() > k) mul.erase(mul.find(data[j++]));
if (i - j + 1 > mx) {
mx = i - j + 1;
ans.clear();
}
if (i - j + 1 == mx) ans.push_back(make_pair(j + 1, i + 1));
}
int si = ans.size();
printf("%d %d\n", mx, si);
for (int i = 0; i < si; ++i) printf("%d %d\n", ans[i].first, ans[i].second);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-10;
const int MOD = 1000000007;
const int INF = 1000000000;
const long long int LINF = 1 << 30;
template <typename T>
void printv(vector<T> const& s) {
for (int i = (0); i < (((int)(s).size())); i++) {
cout << s[i] << " ";
}
cout << endl;
}
signed main() {
cin.tie(0);
cout << setprecision(10);
int n;
cin >> n;
vector<string> a(n);
for (int i = (0); i < (n); i++) cin >> a[i];
map<int, int> m;
for (int i = (0); i < (n); i++) {
int cnt = 0;
stack<bool> st;
for (int j = (0); j < (((int)(a[i]).size())); j++) {
if (a[i][j] == '(') {
st.push(1);
cnt++;
} else {
if (!st.empty() && st.top() == 1)
st.pop();
else
st.push(0);
cnt--;
}
}
bool ok = true;
if (!st.empty()) {
bool c = st.top();
st.pop();
while (!st.empty()) {
if (c != st.top()) {
ok = false;
break;
} else {
st.pop();
}
}
}
if (ok) m[cnt]++;
}
int ans = 0;
vector<int> c;
for (auto i = (m).begin(); i != (m).end(); i++) {
if (i->first >= 0) c.push_back(i->first);
}
for (int i = (0); i < (((int)(c).size())); i++) {
if (c[i] == 0)
ans += m[c[i]] / 2;
else
ans += min(m[c[i]], m[-c[i]]);
}
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize("Ofast", "unroll-loops", "omit-frame-pointer", "inline")
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
char F[200];
inline void out(long long x) {
if (x == 0) return (void)(putchar('0'));
long long tmp = x > 0 ? x : -x;
if (x < 0) putchar('-');
int cnt = 0;
while (tmp > 0) {
F[cnt++] = tmp % 10 + '0';
tmp /= 10;
}
while (cnt > 0) putchar(F[--cnt]);
}
const int maxn = 1e6 + 7;
int a[110], n, sum;
int main() {
n = read();
for (int i = 1; i <= n; i++) {
a[i] = read();
sum += a[i];
}
sort(a + 1, a + 1 + n);
for (int i = 0; i <= n; i++, sum = sum - a[i] + 5)
if (sum >= 4.5 * n) {
out(i);
return 0;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char s[1501], c[1];
int main() {
int n, q;
scanf("%d%s%d", &n, s + 1, &q);
while (q--) {
int m, l = 0, ans = 0, cnt = 0;
scanf("%d %s", &m, c);
for (int r = 1; r <= n; r++) {
cnt += s[r] == c[0];
while (r - l - cnt > m) cnt -= s[++l] == c[0];
ans = max(ans, r - l);
}
printf("%d\n", ans);
}
}
| 4 |
#include <bits/stdc++.h>
const int N = 2e5 + 10;
long long bit[N];
using namespace std;
vector<pair<long long, int>> v;
void update(int x, int n) {
for (; x <= n; x += x & -x) bit[x]++;
}
long long get(int x) {
long long res = 0;
for (; x > 0; x -= x & -x) {
res += bit[x];
}
return res;
}
int main() {
long long t;
int n;
cin >> n >> t;
for (int i = 1; i <= n; ++i) {
int tm;
cin >> tm;
if (i == 1) {
v.push_back({tm, i});
} else {
long long k = 1LL * v[i - 2].first;
k += tm;
v.push_back({k, i});
}
}
sort(v.begin(), v.end());
long long ans = 1LL * n;
ans *= (ans + 1);
ans /= 2;
int i = 0;
for (auto p : v) {
while (i < n && p.first - v[i].first >= t) {
update(v[i].second, n);
++i;
}
ans -= get(p.second - 1);
if (p.first >= t) ans--;
}
cout << ans << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
inline int MOOD(int &x) {
while (x >= mod) x -= mod;
return x;
}
const int maxN = 2e3 + 5;
int N, M;
char mp[maxN][maxN];
int po[maxN][maxN][2];
int dp[maxN][maxN][2] = {0};
int pre[maxN][maxN][2] = {0};
int main() {
scanf("%d%d", &N, &M);
for (int i = 1; i <= N; i++) scanf("%s", mp[i] + 1);
for (int i = 1; i <= N; i++) {
po[i][M + 1][0] = 0;
for (int j = M; j >= 1; j--) {
po[i][j][0] = po[i][j + 1][0];
if (mp[i][j] == '.') po[i][j][0]++;
}
}
for (int j = 1; j <= M; j++) {
po[N + 1][j][1] = 0;
for (int i = N; i >= 1; i--) {
po[i][j][1] = po[i + 1][j][1];
if (mp[i][j] == '.') po[i][j][1]++;
}
}
if (mp[N][M] == 'R') {
printf("0\n");
return 0;
}
if (N == 1 && M == 1) {
printf("1\n");
return 0;
}
dp[N][M][0] = dp[N][M][1] = 1;
pre[N][M][0] = pre[N][M][1] = 1;
for (int i = N, det; i >= 1; i--) {
for (int j = M; j >= 1; j--) {
if (i == N && j == M) continue;
det = po[i][j + 1][0];
dp[i][j][0] = pre[i][j + 1][1] - pre[i][j + det + 1][1] + mod;
MOOD(dp[i][j][0]);
det = po[i + 1][j][1];
dp[i][j][1] = pre[i + 1][j][0] - pre[i + det + 1][j][0] + mod;
MOOD(dp[i][j][1]);
pre[i][j][0] = pre[i + 1][j][0] + dp[i][j][0];
MOOD(pre[i][j][0]);
pre[i][j][1] = pre[i][j + 1][1] + dp[i][j][1];
MOOD(pre[i][j][1]);
}
}
int ans = dp[1][1][0] + dp[1][1][1];
printf("%d\n", MOOD(ans));
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5, M = N << 1, L = M << 1;
int To[L], Ne[L], St[M], d[M], en, a[N], b[N], t[M], tn, n;
inline __attribute__((always_inline)) void addedge(int u, int v) {
To[++en] = v, Ne[en] = St[u], St[u] = en;
To[++en] = u, Ne[en] = St[v], St[v] = en;
++d[u], ++d[v];
}
bool vi[M];
struct rt {
int d, n;
inline __attribute__((always_inline)) rt(int d = 0, int n = 0) : d(d), n(n) {}
};
inline __attribute__((always_inline)) rt operator+(const rt& a, const rt& b) {
return rt(a.d + b.d, a.n + b.n);
}
rt dfs(int u) {
if (vi[u]) return rt(0, 0);
vi[u] = 1;
rt ret = rt(d[u], 1);
for (int i = St[u]; i; i = Ne[i]) ret = ret + dfs(To[i]);
return ret;
}
inline __attribute__((always_inline)) bool check(int x) {
if (x > tn) return 0;
fill(St + 1, St + 1 + tn, 0), fill(d + 1, d + tn + 1, 0), en = 0;
for (int i = 1; i <= n; ++i) {
if (x < a[i])
return 0;
else if (a[i] <= x && x < b[i])
addedge(a[i], a[i]);
else
addedge(a[i], b[i]);
}
fill(vi + 1, vi + 1 + tn, 0);
for (int i = 1; i <= tn; ++i) {
if (!vi[i]) {
rt res = dfs(i);
if ((res.d >> 1) > res.n) return 0;
}
}
return 1;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d%d", &a[i], &b[i]);
t[++tn] = a[i], t[++tn] = b[i];
}
sort(t + 1, t + tn + 1);
tn = unique(t + 1, t + tn + 1) - t - 1;
for (int i = 1; i <= n; ++i) {
a[i] = lower_bound(t + 1, t + tn + 1, a[i]) - t;
b[i] = lower_bound(t + 1, t + tn + 1, b[i]) - t;
}
int l = 1, r = tn;
while (l <= r) {
int mid = (l + r) >> 1;
if (check(mid))
r = mid - 1;
else
l = mid + 1;
}
assert(l > 0);
if (!check(l))
puts("-1");
else
printf("%d\n", t[check(r) ? r : l]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y, n;
cin >> n >> x >> y;
if ((x == n / 2 || x == n / 2 + 1) && (y == n / 2 || y == n / 2 + 1))
cout << "NO";
else
cout << "YES";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long solve(vector<long long>& a, long long k, long long s, long long n) {
long long i, tmp, res;
res = 0;
for (i = 0; i < n; i++) {
tmp = a[i] - 1 - s;
if (tmp >= 0) {
tmp = sqrt(tmp / 3.0);
if (a[i] - 3 * tmp * tmp - 3 * tmp - 1 < s) {
tmp--;
}
if (tmp >= a[i]) {
tmp = a[i] - 1;
}
res += tmp + 1;
}
}
if (res >= k) {
return 1;
}
return 0;
}
long long bs(vector<long long>& a, long long k, long long l, long long h,
long long n) {
if (h > l) {
long long m;
m = ceil((h + l) / 2.0);
if (solve(a, k, m, n)) {
return bs(a, k, m, h, n);
}
return bs(a, k, l, m - 1, n);
}
return h;
}
int main() {
std::ios::sync_with_stdio(false);
long long n, k, i, res, tmp, s;
cin >> n >> k;
vector<long long> a(n), b(n);
for (i = 0; i < n; i++) {
cin >> a[i];
}
res = bs(a, k, -4E18, 4E18, n);
s = 0;
for (i = 0; i < n; i++) {
tmp = a[i] - 1 - res;
if (tmp >= 0) {
tmp = sqrt(tmp / 3.0);
if (a[i] - 3 * tmp * tmp - 3 * tmp - 1 < res) {
tmp--;
}
if (tmp >= a[i]) {
tmp = a[i] - 1;
}
b[i] = tmp + 1;
s += tmp + 1;
}
}
if (s > k) {
for (i = 0; i < n; i++) {
tmp = b[i] - 1;
if (a[i] - 3 * tmp * tmp - 3 * tmp - 1 == res) {
b[i]--;
s--;
if (s == k) {
break;
}
}
}
}
for (i = 0; i < n; i++) {
cout << b[i] << ' ';
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string a, b;
cin >> n;
cin >> a >> b;
int sum = 0;
for (int i = 0; i < n; i++) {
int d = abs(a[i] - b[i]);
if (d > 5) {
d = 10 - d;
}
sum += d;
}
cout << sum << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int h1, h2;
int a, b;
cin >> h1 >> h2;
cin >> a >> b;
int k = 0;
if (h1 + 8 * a >= h2)
k = 0;
else if (a <= b) {
k = -1;
} else {
h1 = h1 + 8 * a;
while (h1 < h2) {
h1 = h1 + 12 * (a - b);
k++;
}
}
cout << k;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-9, PI = acos(-1.);
const long long LINF = 0x3f3f3f3f3f3f3f3f, LMOD = 1011112131415161719ll;
const int INF = 0x3f3f3f3f, MOD = 1e9 + 7;
const int N = 1e6 + 10;
map<long long, long long> rt;
int q;
long long a, b;
int main() {
for (long long i = 1; i < N; i++) rt[i * i * i] = i;
scanf("%d", &q);
while (q--) {
scanf("%lld%lld", &a, &b);
long long r = rt[a * b];
printf("%s\n", r and a % r == 0 and b % r == 0 ? "Yes" : "No");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int par[100010], sz[100010], c[100010], dp[100010];
bool isLucky(int x) {
while (x) {
if (x % 10 != 4 && x % 10 != 7) return false;
x /= 10;
}
return true;
}
int find(int x) { return (par[x] == x) ? x : par[x] = find(par[x]); }
void upd(int val, int wt) {
for (int i = n; i >= val; i--) dp[i] = min(dp[i], dp[i - val] + wt);
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) par[i] = i, sz[i] = 1;
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d %d", &u, &v);
int U = find(u), V = find(v);
if (U != V) {
if (sz[U] <= sz[V])
sz[V] += sz[U], sz[U] = 0, par[U] = V;
else
sz[U] += sz[V], sz[V] = 0, par[V] = U;
}
}
for (int i = 1; i <= n; i++) c[sz[i]]++, dp[i] = 1e9;
for (int i = 1; i <= n; i++)
if (c[i]) {
for (int j = 1; j <= c[i]; j <<= 1) upd(j * i, j), c[i] -= j;
upd(c[i] * i, c[i]);
}
int res = 1e9;
for (int i = 1; i <= n; i++)
if (isLucky(i)) res = min(res, dp[i]);
printf("%d\n", res == 1e9 ? -1 : res - 1);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int inf = INT_MAX;
const long long int INF = LLONG_MAX;
const long long int mod = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
if (n == 1) {
cout << -1 << endl;
continue;
}
cout << 2;
n--;
while (n--) cout << 3;
cout << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, a, five = 0, zero = 0, b, i;
cin >> t;
while (t--) {
cin >> a;
if (a == 5)
five++;
else
zero++;
}
if (zero == 0)
cout << -1 << endl;
else if (five < 9)
cout << 0 << endl;
else {
b = five / 9;
string s = "555555555";
while (b--) cout << s;
while (zero--) cout << 0;
cout << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long modExp(long long x, long long n, long long mod = 1000000007) {
if (n == 0)
return 1;
else if (n % 2 == 0)
return modExp((x * x) % mod, n / 2, mod) % mod;
else
return (x * modExp((x * x) % mod, n / 2, mod)) % mod;
}
void solve() {
long long x, n;
cin >> x >> n;
set<long long> xf;
long long i = 2;
while (i <= x) {
if (i * i > x) {
xf.insert(x);
break;
}
while (x % i == 0) {
xf.insert(i);
x = x / i;
}
i++;
}
long long ans = 1;
for (set<long long>::iterator it = xf.begin(); it != xf.end(); it++) {
long long fac = *it;
long long mul = 0;
long long no = n;
while (no >= fac) {
mul += no / fac;
no /= fac;
}
ans = (ans * modExp(fac, mul)) % 1000000007;
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long test = 1;
while (test--) solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
long long a[n];
long long b[n];
vector<int> q;
vector<int> w;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
q.push_back(a[i]);
w.push_back(b[i]);
}
sort(a, a + n);
sort(b, b + n);
int ans1 = a[0];
int ans2 = b[n - 1];
for (int i = 0; i < n; i++) {
if (q[i] == ans1 && ans2 == w[i]) {
cout << i + 1;
return 0;
}
}
cout << -1;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
long long int n;
long long int p[N], a[N], dp[N];
vector<long long int> adj[N];
void dfs(long long int u) {
for (auto v : adj[u]) {
dfs(v);
}
if (!((int)(adj[u]).size())) {
dp[u] = 1;
} else {
if (a[u]) {
for (auto it : adj[u]) {
dp[u] = min(dp[it], dp[u]);
}
} else {
dp[u] = 0;
for (auto it : adj[u]) {
dp[u] += dp[it];
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 2; i <= n; i++) {
cin >> p[i];
adj[p[i]].push_back(i);
}
for (int i = 1; i <= n; i++) {
dp[i] = INT_MAX;
}
long long int leaf = 0;
for (int i = 1; i <= n; i++) {
if (!((int)(adj[i]).size())) {
leaf++;
}
}
dfs(1);
cout << leaf - dp[1] + 1;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> a[15], b[15];
set<int> ans, store[15];
int main() {
int n, m, x, y;
while (cin >> n >> m) {
for (int i = 0; i < n; i++) {
cin >> x >> y;
a[i] = make_pair(min(x, y), max(x, y));
}
for (int i = 0; i < m; i++) {
cin >> x >> y;
b[i] = make_pair(min(x, y), max(x, y));
}
int flag = 0, sum = 0;
for (int i = 0; i < n; i++) {
set<int> dict;
for (int j = 0; j < m; j++) {
if (a[i] == b[j]) continue;
if (a[i].first == b[j].first || a[i].first == b[j].second) {
dict.insert(a[i].first);
if (store[j].size() == 1 && *store[j].begin() != a[i].first) {
flag = 1;
break;
}
store[j].insert(a[i].first);
}
if (a[i].second == b[j].second || a[i].second == b[j].first) {
dict.insert(a[i].second);
if (store[j].size() == 1 && *store[j].begin() != a[i].second) {
flag = 1;
break;
}
store[j].insert(a[i].second);
}
}
if (dict.size() > 1) {
flag = 1;
break;
} else if (dict.size() == 1) {
ans.insert(*dict.begin());
sum++;
}
}
if (flag)
cout << -1 << endl;
else if (ans.size() == 1)
cout << *ans.begin() << endl;
else
cout << 0 << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int num[300500];
long long int pos[300500];
long long int st[300500 * 4];
long long int n, N;
long long int recur(long long int v, long long int l, long long int r,
long long int left, long long int right) {
if (right <= l || r <= left) return 0;
if (left <= l && r <= right) return st[v];
long long int mid = (l + r) >> 1;
long long int ans = 0;
ans += recur(v * 2 + 0, l, mid, left, right);
ans += recur(v * 2 + 1, mid, r, left, right);
return ans;
}
void change(long long int pos, long long int value) {
pos += N;
st[pos] = value;
while (1 < pos) {
pos /= 2;
st[pos] = st[pos * 2 + 0] + st[pos * 2 + 1];
}
}
int main() {
cin >> n;
for (N = 1; N <= n; N *= 2)
;
for (long long int i = 0; i < ((long long int)(n + 1)); ++i)
if (i) {
cin >> num[i];
pos[num[i]] = i;
}
for (long long int i = 0; i < ((long long int)(n)); ++i)
if (i) {
if (pos[i] < pos[i + 1])
change(i, 0);
else
change(i, 1);
}
long long int q;
cin >> q;
for (long long int i = 0; i < ((long long int)(q)); ++i) {
long long int type, x, y;
cin >> type >> x >> y;
if (type == 1) {
cout << 1 + recur(1, 0, N, x, y) << endl;
} else {
long long int nx = num[x];
long long int ny = num[y];
swap(num[x], num[y]);
swap(pos[nx], pos[ny]);
for (long long int step = 0; step < ((long long int)(2)); ++step) {
long long int t = step == 0 ? nx : ny;
if (t != 1) change(t - 1, pos[t - 1] < pos[t] ? 0 : 1);
if (t != n) change(t, pos[t] < pos[t + 1] ? 0 : 1);
}
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long ab(long long x) { return x > 0LL ? x : -x; }
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long q;
cin >> q;
while (q--) {
long long n, m;
cin >> n >> m;
if (m > n) {
cout << 0 << '\n';
continue;
}
long long f = m % 10;
long long m1 = m;
vector<long long> v;
v.push_back(0);
while (m1 <= n) {
v.push_back(m1 % 10);
m1 += m;
if (m1 % 10 == f) {
break;
}
}
for (int i = 1; i < v.size(); i++) v[i] += v[i - 1];
long long sum = (n / m) / (v.size() - 1) * v[v.size() - 1] +
v[(n / m) % (v.size() - 1)];
cout << sum << '\n';
}
return 0;
}
| 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.