solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100004;
int n;
int pre[maxn], countx[maxn] = {0};
bool a[maxn], vis[maxn];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int t;
scanf("%d", &t);
a[i] = t;
}
for (int i = 1; i <= n; i++) {
scanf("%d", &pre[i]);
countx[pre[i]]++;
}
memset(vis, false, sizeof(vis));
int max = 0, maxn;
for (int i = 1; i <= n; i++)
if (a[i]) {
int sum = 1, x = pre[i];
while (countx[x] <= 1 && x != 0 && (!vis[x])) {
vis[x] = true;
sum++;
x = pre[x];
}
if (sum > max) {
max = sum;
maxn = i;
}
}
stack<int> ans;
printf("%d\n", max);
int i;
for (i = maxn; max--; i = pre[i]) ans.push(i);
while (ans.size() > 0) {
printf("%d ", ans.top());
ans.pop();
}
printf("\n");
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 5;
const int mod = 1e9 + 7;
int cnt[512];
long long qpow(long long base, long long p) {
long long ret = 1;
while (p) {
if (p & 1) ret = ret * base % mod;
base = base * base % mod;
p >>= 1;
}
return ret;
}
char DNA[maxn];
int main() {
int n;
cin >> n;
scanf("%s", DNA);
int max_cnt = 0;
for (int i = (0); i < (n); ++i) {
++cnt[DNA[i]];
}
max_cnt = max(cnt['A'], max(cnt['G'], max(cnt['T'], cnt['C'])));
int p = 0;
if (cnt['A'] == max_cnt) ++p;
if (cnt['G'] == max_cnt) ++p;
if (cnt['T'] == max_cnt) ++p;
if (cnt['C'] == max_cnt) ++p;
long long ans = qpow(p, n);
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cout.flush();
int n, ar[10005] = {0}, i;
map<int, int> mp;
cin >> n;
int j = 1, fst, scnd;
for (i = 2; i <= n; i++) {
cout << "?"
<< " " << j << " " << i << endl;
cin >> fst;
cout << "?"
<< " " << i << " " << j << endl;
cin >> scnd;
if (fst > scnd) {
ar[j] = fst;
mp[fst]++;
j = i;
} else {
ar[i] = scnd;
mp[scnd]++;
}
}
for (i = 1; i <= n; i++) {
if (mp[i] == 0) {
ar[j] = i;
}
}
cout << "!"
<< " ";
for (i = 1; i <= n; i++) cout << ar[i] << " ";
cout << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mN = 2e5;
int n[mN], N;
vector<int> g[mN];
void dfs(int i, int p) {
n[i] = n[p] + 1;
for (int j : g[i])
if (j != p) dfs(j, i);
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0);
cout << fixed << setprecision(12);
cin >> N;
for (int i = 1, x, y; i < N; ++i) {
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
dfs(1, 0);
double r = 0;
for (int i = 1; i <= N; ++i) r += 1.0 / n[i];
cout << r << '\n';
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 10005;
const int MAXO = 105;
const int INF = 0x3f3f3f3f;
vector<int> e[MAXN];
int val[MAXN], mx[MAXN][MAXO], mi[MAXN][MAXO];
void dfs(int u, int t) {
for (int j = 0; j < MAXO; j++) mx[u][j] = -INF, mi[u][j] = INF;
if (val[u] > 0) {
mx[u][0] = mi[u][0] = val[u];
return;
}
int l = e[u][0], r = e[u][1];
dfs(l, t), dfs(r, t);
for (int i = 0; i < MAXO; i++)
if (mx[l][i] > -INF)
for (int j = 0; i + j + 1 < MAXO; j++)
if (mx[r][j] > -INF) {
mx[u][i + j + t] = max(mx[u][i + j + t], mx[l][i] + mx[r][j]);
mx[u][i + j + 1 - t] = max(mx[u][i + j + 1 - t], mx[l][i] - mi[r][j]);
mi[u][i + j + t] = min(mi[u][i + j + t], mi[l][i] + mi[r][j]);
mi[u][i + j + 1 - t] = min(mi[u][i + j + 1 - t], mi[l][i] - mx[r][j]);
}
}
char str[MAXN];
int main() {
int P, M, n = 0;
scanf("%s%d%d", str, &P, &M);
stack<int> stk;
for (int i = 0; str[i]; i++) {
if (str[i] == '(')
stk.push(++n);
else if (str[i] == ')') {
int t = stk.top();
stk.pop();
if (!stk.empty()) e[stk.top()].push_back(t);
} else if (str[i] >= '1' && str[i] <= '9') {
if (stk.empty()) return 0 * printf("%d\n", str[i] - '0');
e[stk.top()].push_back(++n);
val[n] = str[i] - '0';
}
}
dfs(1, P < M);
return 0 * printf("%d\n", mx[1][min(P, M)]);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n;
cin >> n;
cout << n / 2520;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long dp[100001][202];
int n;
pair<int, int> ara[100001];
int d[100001], taka[100001];
vector<int> add[100001], ers[100001];
long long dp_func(int pos, int m) {
if ((n - pos + 1) <= m) return 0;
if (pos > n) return 0;
if (dp[pos][m] != -1) return dp[pos][m];
long long ret = 0;
if (ara[pos].first)
ret = dp_func(-ara[pos].second + 1, m) - ara[pos].first;
else
ret = dp_func(pos + 1, m);
if (m) ret = min(ret, dp_func(pos + 1, m - 1));
return dp[pos][m] = ret;
}
int main() {
int i, j, k, l, m;
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= k; i++) {
scanf("%d%d%d%d", &l, &j, &d[i], &taka[i]);
add[l].push_back(i);
ers[j].push_back(i);
}
set<pair<pair<int, int>, int> > s;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < add[i].size(); j++) {
int in = add[i][j];
s.insert(make_pair(make_pair(-taka[in], -d[in]), in));
}
if (s.size()) {
pair<pair<int, int>, int> dum = *s.begin();
ara[i] = dum.first;
}
for (int j = 0; j < ers[i].size(); j++) {
int in = ers[i][j];
s.erase(make_pair(make_pair(-taka[in], -d[in]), in));
}
}
memset(dp, -1, sizeof dp);
long long ans = dp_func(1, m);
cout << ans << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using lli = long long;
using ii = pair<long long, long long>;
using vi = vector<long long>;
using vvi = vector<vector<long long>>;
using vp = vector<pair<long long, long long>>;
long long mod = 1e9 + 7;
vector<vector<ii>> g;
lli par[100100];
lli ra[100100];
lli find(lli i) {
if (i != par[i]) return par[i] = find(par[i]);
return i;
}
void merge(lli x, lli y) {
lli xr = find(x), yr = find(y);
if (xr == yr) return;
if (ra[xr] >= ra[yr]) {
ra[xr] += ra[yr];
par[yr] = xr;
} else {
ra[yr] += ra[xr];
par[xr] = yr;
}
}
long long dist[100100];
void dfs(long long node, long long par) {
for (auto v : g[node]) {
if ((v.first) != par) {
dist[v.first] = min(dist[node] + v.second, dist[v.first]);
dfs(v.first, node);
}
}
}
void solve() {
long long n, x, y, w;
cin >> n;
g.resize(n + 1);
vector<pair<long long, ii>> edges;
for (long long i = 1; i <= n; i++) {
par[i] = i;
ra[i] = 1;
dist[i] = 1e18;
}
for (long long i = 1; i < n; i++) {
cin >> x >> y >> w;
edges.push_back(make_pair(w, make_pair(x, y)));
}
sort(edges.begin(), edges.end());
long long cost = 0;
for (long long i = 0; i < (n - 1); i++) {
if (find(edges[i].second.first) != find(edges[i].second.second)) {
cost += edges[i].first;
g[edges[i].second.first].push_back(
make_pair(edges[i].second.second, edges[i].first));
g[edges[i].second.second].push_back(
make_pair(edges[i].second.first, edges[i].first));
merge(edges[i].second.first, edges[i].second.second);
}
}
dist[1] = 0;
dfs(1, 0);
long long res = 0;
for (long long i = 2; i <= n; i++) {
res = max(res, dist[i]);
}
cout << 2 * cost - res << "\n";
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long _t = 1;
for (long long ix = 1; ix <= _t; ix++) solve();
cerr << "Time Taken:" << (float)clock() / CLOCKS_PER_SEC << "secs" << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
const double pi = acos(-1.0);
const long long inf = 1e+9;
template <typename T>
istream &operator>>(istream &, vector<T> &);
template <typename T>
ostream &operator<<(ostream &, const vector<T> &);
const int maxn = 4 * 200005;
vector<vector<int> > g;
int vtx[2][maxn] = {};
vector<int> tin, tout, lvl;
vector<pair<int, int> > mas[2];
int timer;
void dfs(int v, int p = -1, int level = 0) {
lvl[v] = level % 2;
tin[v] = timer++;
mas[level % 2].push_back(make_pair(tin[v], v));
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (to != p) {
dfs(to, v, level + 1);
}
}
tout[v] = timer;
}
void add(int v, int idx, int tl, int tr, int l, int r, int val) {
if (l > r) return;
if (tl == l && tr == r) {
vtx[idx][v] += val;
} else {
int tm = (tl + tr) / 2;
add(2 * v, idx, tl, tm, l, min(tm, r), val);
add(2 * v + 1, idx, tm + 1, tr, max(l, tm + 1), r, val);
}
}
int get(int v, int idx, int tl, int tr, int pos) {
if (tl == tr && tl == pos)
return vtx[idx][v];
else {
int tm = (tl + tr) / 2;
if (pos <= tm) {
return vtx[idx][v] + get(2 * v, idx, tl, tm, pos);
} else {
return vtx[idx][v] + get(2 * v + 1, idx, tm + 1, tr, pos);
}
}
}
int getV(int idx, int v) {
int pos =
lower_bound(mas[idx].begin(), mas[idx].end(), make_pair(tin[v], v)) -
mas[idx].begin();
return get(1, idx, 0, mas[idx].size() - 1, pos);
}
void upd(int idx, int v, int val) {
int l1 = lower_bound(mas[idx].begin(), mas[idx].end(), make_pair(tin[v], v)) -
mas[idx].begin();
int r1 =
upper_bound(mas[idx].begin(), mas[idx].end(), make_pair(tout[v], -1)) -
mas[idx].begin() - 1;
add(1, idx, 0, mas[idx].size() - 1, l1, r1, val);
idx ^= 1;
int l2 = lower_bound(mas[idx].begin(), mas[idx].end(), make_pair(tin[v], v)) -
mas[idx].begin();
int r2 =
upper_bound(mas[idx].begin(), mas[idx].end(), make_pair(tout[v], -1)) -
mas[idx].begin() - 1;
add(1, idx, 0, mas[idx].size() - 1, l2, r2, -val);
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
vector<int> a(n);
g.resize(n);
tin.resize(n);
tout.resize(n);
lvl.resize(n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < n - 1; i++) {
int u, v;
scanf("%d %d", &u, &v);
u--;
v--;
g[u].push_back(v);
g[v].push_back(u);
}
dfs(0);
for (int i = 0; i < m; i++) {
int type;
scanf("%d", &type);
if (type == 1) {
int x, val;
scanf("%d %d", &x, &val);
x--;
upd(lvl[x], x, val);
} else {
int x;
scanf("%d", &x);
x--;
printf("%d\n", getV(lvl[x], x) + a[x]);
}
}
return 0;
}
template <typename T>
istream &operator>>(istream &is, vector<T> &v) {
for (int i = 0; i < v.size(); ++i) is >> v[i];
return is;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
for (int i = 0; i < v.size(); ++i) os << v[i] << " ";
return os;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
char s[1000010];
const int MOD = 1000000007;
int lst[26];
set<pair<int, char> > pos;
int dp[26], sum = 0;
int main() {
scanf("%d %d\n%s", &n, &k, s);
m = strlen(s);
for (int i = 0; i < k; ++i) {
lst[i] = -1;
pos.insert(make_pair(-1, 'a' + i));
}
for (int i = 0; i < m; ++i) {
sum = (sum - dp[s[i] - 'a'] + MOD) % MOD;
pos.erase(make_pair(lst[s[i] - 'a'], s[i]));
dp[s[i] - 'a'] = (1 + dp[s[i] - 'a'] + sum) % MOD;
sum = (sum + dp[s[i] - 'a']) % MOD;
lst[s[i] - 'a'] = i;
pos.insert(make_pair(lst[s[i] - 'a'], s[i]));
}
for (int i = m; i < m + n; ++i) {
char id = pos.begin()->second;
sum = (sum - dp[id - 'a'] + MOD) % MOD;
pos.erase(make_pair(lst[id - 'a'], id));
dp[id - 'a'] = (1 + dp[id - 'a'] + sum) % MOD;
sum = (sum + dp[id - 'a']) % MOD;
lst[id - 'a'] = i;
pos.insert(make_pair(lst[id - 'a'], id));
}
printf("%d\n", (sum + 1) % MOD);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int a[2030];
void obrni(int idx) {
int l = 1, r = idx;
while (l < r) {
swap(a[l], a[r]);
l++;
r--;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
bool moze = 1;
for (int i = 1; i <= n; i++) {
if (i % 2 != a[i] % 2) {
cout << -1 << '\n';
moze = 0;
break;
}
}
if (!moze) continue;
vector<int> p;
for (int i = n; i > 1; i -= 2) {
int idxn = 0, idxn1 = 0;
for (int j = 1; j <= i; j++) {
if (a[j] == i) idxn = j;
}
p.push_back(idxn);
obrni(idxn);
for (int j = 1; j <= i; j++) {
if (a[j] == i - 1) idxn1 = j;
}
p.push_back(idxn1 - 1);
obrni(idxn1 - 1);
p.push_back(idxn1 + 1);
obrni(idxn1 + 1);
p.push_back(3);
obrni(3);
p.push_back(i);
obrni(i);
}
cout << int((p).size()) << '\n';
for (auto x : p) cout << x << ' ';
cout << '\n';
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
const long long MAX = 1e6;
const long long MOD = 1e9 + 7;
const long long base = 257;
const long double eps = 1e-7;
long long a[MAX], n;
string s;
vector<long long> v;
long long ans[MAX], l[MAX][6], r[MAX][6];
void solve() {
memset(l, -1, sizeof(l));
memset(r, -1, sizeof(r));
if (a[1] > 1) {
ans[0] = -1;
return;
}
l[1][1] = r[1][1] = 1;
for (long long i = 2; i <= n; i++) {
for (long long j = 2; j <= 5; j++) {
if (l[i - 1][j - 1] != -1) {
l[i][j] = l[i - 1][j - 1];
r[i][j] = r[i - 1][j - 1];
}
}
for (long long j = 2; j <= 5; j++) {
if (l[i - 1][j] != -1) {
if (l[i][1] == -1) {
l[i][1] = INF;
}
l[i][1] = min(l[i][1], l[i - 1][j] + 1);
r[i][1] = max(r[i][1], r[i - 1][j] + 1);
}
}
bool flag = 0;
if (a[i] > 0) {
for (long long j = 1; j <= 5; j++) {
if (l[i][j] != -1) {
if (l[i][j] <= a[i] && a[i] <= r[i][j]) {
l[i][j] = r[i][j] = a[i];
} else
l[i][j] = r[i][j] = -1;
} else
r[i][j] = -1;
}
}
for (long long j = 1; j <= 5; j++) {
if (l[i][j] <= r[i][j] && l[i][j] != -1) {
flag = 1;
}
}
if (!flag) {
ans[0] = -1;
return;
}
}
}
void print() {
if (ans[0] == -1) {
cout << "-1";
return;
}
long long Ans = 0, j = 2;
for (long long i = 2; i <= 5; i++) {
if (l[n][i] <= r[n][i] && l[n][i] != -1) {
if (r[n][i] > Ans) {
j = i;
Ans = r[n][i];
}
}
}
if (Ans <= 0) {
cout << "-1";
return;
}
cout << Ans << "\n";
long long old = n;
while (n > 0) {
for (long long i = 0; i < j; i++) {
ans[n - i] = Ans;
}
n -= j;
Ans--;
for (long long i = 2; i <= 5; i++) {
if (l[n][i] <= Ans && Ans <= r[n][i]) {
j = i;
}
}
}
cout << ans[1] << " ";
for (long long i = 2; i <= old; i++) {
cout << ans[i] << " ";
}
}
signed main() {
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
}
solve();
print();
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void loadData(void);
void proc(void);
void printRes(void);
int n;
int a[100005];
int b[100005];
int pos[100005];
int main(int argc, char** argv) {
loadData();
proc();
return 0;
}
void proc(void) {
for (int i = 0; i < n; i++) pos[a[i]] = i;
for (int i = 0; i < n; i++)
printf("%d%c", pos[b[i]] + 1, i == n - 1 ? '\n' : ' ');
return;
}
void loadData(void) {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < n; i++) scanf("%d", &b[i]);
return;
}
void printRes(void) { return; }
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
inline void chkmin(T1 &x, T2 y) {
if (x > y) x = y;
}
template <typename T1, typename T2>
inline void chkmax(T1 &x, T2 y) {
if (x < y) x = y;
}
inline int readChar();
template <class T = int>
inline T readInt();
template <class T>
inline void writeInt(T x, char end = 0);
inline void writeChar(int x);
inline void writeWord(const char *s);
static const int buf_size = 4096;
inline int getChar() {
static char buf[buf_size];
static int len = 0, pos = 0;
if (pos == len) {
pos = 0, len = fread(buf, 1, buf_size, stdin);
}
if (pos == len) {
return -1;
}
return buf[pos++];
}
inline int readChar() {
int c = getChar();
while (c <= 32) {
c = getChar();
}
return c;
}
template <class T>
inline T readInt() {
int s = 1, c = readChar();
T x = 0;
if (c == '-') s = -1, c = getChar();
while ('0' <= c && c <= '9') x = x * 10 + c - '0', c = getChar();
return s == 1 ? x : -x;
}
static int write_pos = 0;
static char write_buf[buf_size];
inline void writeChar(int x) {
if (write_pos == buf_size)
fwrite(write_buf, 1, buf_size, stdout), write_pos = 0;
write_buf[write_pos++] = x;
}
template <class T>
inline void writeInt(T x, char end) {
if (x < 0) writeChar('-'), x = -x;
char s[24];
int n = 0;
while (x || !n) s[n++] = '0' + x % 10, x /= 10;
while (n--) writeChar(s[n]);
if (end) writeChar(end);
}
inline void writeWord(const char *s) {
while (*s) writeChar(*s++);
}
struct Flusher {
~Flusher() {
if (write_pos) fwrite(write_buf, 1, write_pos, stdout), write_pos = 0;
}
} flusher;
using namespace std;
const int MOD = 1000000;
set<pair<long long, long long> > ss;
int q;
long long m;
int could(pair<long long, long long> a, pair<long long, long long> b,
pair<long long, long long> c) {
b.first -= a.first;
b.second -= a.second;
c.first -= a.first;
c.second -= a.second;
return ((long double)b.first * (long double)c.second -
(long double)b.second * (long double)c.first) <= 0;
}
int main() {
scanf("%d %lld", &q, &m);
int ij = 0;
ss.insert(make_pair(0, 0));
for (int i = 0; i < q; i++) {
int k = readInt(), t = readInt(), h = readInt();
if (k == 1) {
long long x = (t + ij) % MOD + 1;
long y = (h + ij) % MOD + 1;
auto it = ss.lower_bound(make_pair(x, 0));
if (it != ss.end() && it->second <= y) {
continue;
}
auto it2 = prev(it);
if (it != ss.end() && could(*it2, make_pair(x, y), *it)) {
continue;
}
it = ss.insert(make_pair(x, y)).first;
while (next(it) != ss.end() && next(it)->first == x) {
ss.erase(next(it));
}
while (prev(it) != ss.begin() && could(*prev(prev(it)), *prev(it), *it)) {
ss.erase(prev(it));
}
} else {
long long a = (h + ij) % MOD + 1;
long long b = (t + ij) % MOD + 1;
auto it = ss.lower_bound(make_pair((a + b - 1) / b, 0));
bool good = 0;
if (it != ss.end()) {
if (it->second * b <= m) {
good = 1;
} else {
auto it2 = prev(it);
if (could(make_pair(it2->first * b, it2->second * b), make_pair(a, m),
make_pair(it->first * b, it->second * b))) {
good = 1;
}
}
}
if (good) {
writeWord("YES\n");
ij = i + 1;
} else {
writeWord("NO\n");
}
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
std::vector<int> guga(1000, -1);
void adddd() {
for (int i = 1; i <= 1000000; i++) i++;
}
using namespace std;
char G[101][101];
int D[101][101];
int main() {
adddd();
long long n, m;
cin >> n >> m;
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= m; i++) {
cin >> G[k][i];
if (G[k][i] != '*' && G[k][i] != '.') D[k][i] = G[k][i] - '0';
if (G[k][i] == '.') D[k][i] = 0;
}
}
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= m; i++) {
if (G[k][i] != '*' && G[k][i] != '.') {
int t = 0;
if (G[k + 1][i] == '*') t++;
if (G[k - 1][i] == '*') t++;
if (G[k][i + 1] == '*') t++;
if (G[k][i - 1] == '*') t++;
if (G[k + 1][i + 1] == '*') t++;
if (G[k - 1][i - 1] == '*') t++;
if (G[k + 1][i - 1] == '*') t++;
if (G[k - 1][i + 1] == '*') t++;
if (D[k][i] != t) {
cout << "NO";
return 0;
}
}
if (G[k][i] == '.') {
int t = 0;
if (G[k + 1][i] == '*') t++;
if (G[k - 1][i] == '*') t++;
if (G[k][i + 1] == '*') t++;
if (G[k][i - 1] == '*') t++;
if (G[k + 1][i + 1] == '*') t++;
if (G[k - 1][i - 1] == '*') t++;
if (G[k + 1][i - 1] == '*') t++;
if (G[k - 1][i + 1] == '*') t++;
if (D[k][i] != t) {
cout << "NO";
return 0;
}
}
}
}
cout << "YES";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void giai() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
int maxx = a[0];
int ind = 0;
for (int i = 1; i < n; i++) {
if (a[i] > maxx) {
maxx = a[i];
ind = i;
}
}
int cnt = 0;
for (int i = 0; i < n; i++)
if (a[i] == maxx) cnt++;
if (cnt == n)
cout << -1 << endl;
else {
ind = 0;
for (int i = 0; i < n; i++) {
if (a[i] == maxx) {
if ((i > 0 && a[i - 1] != maxx) || (i + 1 < n && a[i + 1] != maxx)) {
cout << i + 1 << endl;
return;
}
}
}
cout << -1 << endl;
}
}
int main() {
long long g;
cin >> g;
while (g--) {
giai();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e6 + 5, MOD = 1e5 + 7;
const long double eps = 1e-9;
const long double pai = acosl(-1.0);
long double dis(long double x1, long double y1, long double x2,
long double y2) {
return sqrtl((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long double x1, x2, y1, y2, r1, r2;
cin >> x1 >> y1 >> r1 >> x2 >> y2 >> r2;
long double d = dis(x1, y1, x2, y2);
if (r1 + r2 <= d + eps) {
cout << "0";
} else if (max(r1, r2) - min(r1, r2) + eps >= d) {
cout << fixed << setprecision(10) << pai * min(r1, r2) * min(r1, r2);
} else {
long double theta1, theta2;
theta1 = 2.0 * acosl((r1 * r1 + d * d - r2 * r2) / (2.0 * r1 * d));
theta2 = 2.0 * acosl((r2 * r2 + d * d - r1 * r1) / (2.0 * r2 * d));
long double ans;
ans = 0.5 * (r1 * r1 * (theta1 - sinl(theta1)) +
r2 * r2 * (theta2 - sinl(theta2)));
cout << fixed << setprecision(10) << ans;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
return x * f;
}
const long long MAXN = 400010;
const long long INF = 1e9;
const double eps = 1e-10;
const double PI = acos(-1);
long long N, K;
struct pdd {
double l, r;
pdd(double ll = 0, double rr = 0) {
l = ll;
r = rr;
}
} q[MAXN + 1], q1[MAXN + 1];
inline void Shuffle(double &a) {
while (a < 0) a += 2 * PI;
while (a >= 2 * PI) a -= 2 * PI;
}
struct data {
double x, y, b, d;
inline void Init() {
d = sqrt(x * x + y * y);
b = asin(y / d);
b = (x < 0 ? PI - b : b);
Shuffle(b);
}
inline pdd getangle(double r) {
if (d < r + eps) return pdd(INF, INF);
double a = acos(r / d);
Shuffle(a);
return pdd(b - a, b + a);
}
} p[MAXN + 1];
double sta[MAXN + 1], s[MAXN + 1];
long long sum[MAXN + 1];
long long c[MAXN + 1], n, top, top2;
inline void Add(long long x, long long k) {
for (; x <= n; x += (x & (-x))) c[x] += k;
}
inline long long Query(long long x) {
long long ret = 0;
for (; x; x -= (x & (-x))) ret += c[x];
return ret;
}
bool cmprl(pdd a, pdd b) { return (a.r == b.r ? a.l < b.l : a.r < b.r); }
inline long long check(double r) {
long long m = 0, m2 = 0;
top = 0;
for (long long i = 1; i <= N; i++) {
pdd sq = p[i].getangle(r);
if (sq.l == INF) {
continue;
}
Shuffle(sq.r);
Shuffle(sq.l);
if (sq.l > sq.r) swap(sq.l, sq.r);
if (sq.r - sq.l > PI) {
swap(sq.l, sq.r);
sq.r += 2 * PI;
}
sq.r -= eps;
q1[++m] = sq;
sta[++top] = sq.l;
sta[++top] = sq.r;
++m2;
if (sq.r >= 2 * PI) {
sq.l -= 2 * PI;
sq.r -= 2 * PI;
q1[++m] = sq;
sta[++top] = sq.l;
sta[++top] = sq.r;
}
}
sort(sta + 1, sta + top + 1);
top2 = 0;
double last;
s[top2 = 1] = sta[1];
last = sta[1];
for (long long i = 2; i <= top; i++) {
if (fabs(sta[i] - last) < eps) continue;
s[++top2] = sta[i];
last = sta[i];
}
n = top2;
for (long long i = 0; i <= n + 1; i++) c[i] = sum[i] = 0;
for (long long i = 1; i <= m; i++) {
q[i].l = lower_bound(s + 1, s + n + 1, q1[i].l - eps) - s;
q[i].r = lower_bound(s + 1, s + n + 1, q1[i].r - eps) - s;
++sum[(long long)q[i].r + 1];
}
for (long long i = 1; i <= n + 1; i++) sum[i] += sum[i - 1];
sort(q + 1, q + m + 1, cmprl);
long long ret = 0, nw = 1;
for (long long i = 1; i <= n; i++) {
while (nw <= m && q[nw].r == i) {
if (s[(long long)q[nw].l] >= 0)
ret += Query(q[nw].l) - sum[(long long)q[nw].l];
Add(q[nw].l, 1);
++nw;
}
}
return m2 * (m2 - 1) / 2 - ret + (N - m2) * (m2 + N - 1) / 2;
}
int main() {
N = read(), K = read();
for (long long i = 1; i <= N; i++) {
p[i].x = read(), p[i].y = read();
p[i].Init();
}
double l = 0, r = 20000, ans = INF;
long long tms = 40;
while (tms) {
double mid = (l + r) / 2.0;
if (check(mid) >= K)
ans = min(mid, ans), r = mid;
else
l = mid;
--tms;
}
printf("%.12lf\n", ans);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e5;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
string s = "abcd";
int n;
cin >> n;
int p = n % 4;
n = n / 4;
string ans = "";
while (n--) {
ans += s;
}
if (p == 0) {
cout << ans << endl;
} else if (p == 1) {
cout << ans + 'a' << endl;
} else if (p == 2) {
cout << ans + "ab" << endl;
} else {
cout << ans + "abc" << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1005, mod = 1000000007;
inline int read() {
int ret, f = 1;
char c;
while ((c = getchar()) && (c < '0' || c > '9'))
if (c == '-') f = -1;
ret = c - '0';
while ((c = getchar()) && (c >= '0' && c <= '9'))
ret = (ret << 3) + (ret << 1) + c - '0';
return ret * f;
}
int n, num[maxn], rt[maxn];
long long f[maxn], s[maxn];
int main() {
n = read();
int fa;
long long ans = 0, tmp;
for (int i = 1; i <= n; ++i) {
fa = read();
num[i] = num[fa] + 1;
if (fa != i) {
rt[i] = rt[fa];
tmp = ((num[i] << 1) + s[i - 1] - s[rt[i]] - f[fa] + mod + mod) % mod;
f[i] = (f[fa] + tmp) % mod;
} else {
rt[i] = fa;
tmp = 2;
}
s[i] = (s[i - 1] + tmp) % mod;
ans = (ans + tmp) % mod;
}
printf("%lld", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int inf = 1e9 + 9;
const long long linf = 4e18 + 18;
const int N = 3e5;
int n, q, s[N + 1];
void solve() {
cin >> n >> q;
s[0] = 0;
for (int i = 0; i < n; ++i) {
char c;
cin >> c;
int x = (c == '+' ? 1 : -1);
s[i + 1] = s[i] + x * (i % 2 == 0 ? 1 : -1);
}
while (q--) {
int l, r;
cin >> l >> r;
--l;
int x = s[r] - s[l];
if (x % 2)
cout << "1\n";
else if (!x)
cout << "0\n";
else
cout << "2\n";
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int tt = 1;
cin >> tt;
while (tt--) {
solve();
cout << "\n";
}
}
| 4 |
#include <bits/stdc++.h>
int power(int a, int b) {
int z = 1;
while (b) {
if (b & 1) {
z *= a;
z %= 1000000007;
}
a *= a;
a %= 1000000007;
b /= 2;
}
return z % 1000000007;
}
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int n, m, a, b;
vector<unordered_set<int>> st;
vector<vector<int>> vec;
vector<int> v;
unordered_set<int> used;
void dfs(int s) {
queue<int> q;
q.push(s);
used.erase(used.find(s));
v.push_back(s);
while (!q.empty()) {
vector<int> vv;
int t = q.front();
q.pop();
for (auto x : used) {
if (st[t].find(x) == st[t].end()) {
q.push(x);
vv.push_back(x);
}
}
for (auto x : vv) {
v.push_back(x);
used.erase(used.find(x));
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
st.resize(n + 1);
for (int i = 0; i < m; ++i) {
cin >> a >> b;
st[a].insert(b);
st[b].insert(a);
}
for (int i = 1; i <= n; ++i) used.insert(i);
for (int i = 1; i <= n; ++i) {
if (used.find(i) != used.end()) {
v.clear();
dfs(i);
vec.push_back(v);
}
}
cout << vec.size() << "\n";
;
for (auto x : vec) {
cout << x.size() << " ";
sort(x.begin(), x.end());
for (auto y : x) cout << y << " ";
cout << "\n";
;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int P = 1e9 + 7;
int add(int a, int b) {
if ((a += b) >= P) a -= P;
return a;
}
int sub(int a, int b) {
if ((a -= b) < 0) a += P;
return a;
}
int mul(int a, int b) { return 1ll * a * b % P; }
int kpow(int a, int b) {
int r = 1;
for (; b; b >>= 1, a = mul(a, a)) {
if (b & 1) r = mul(r, a);
}
return r;
}
const int N = 1e5 + 7;
long long n, d, b, a[N], s[N], pr, pl, ans1, ans2, suml, sumr, usel, user;
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
cin >> n >> d >> b;
for (int i = (1); i < (n + 1); i++) cin >> a[i], s[i] = s[i - 1] + a[i];
for (int t = (1); t < (n / 2 + 1); t++) {
pr = min(n, t * d + t);
pl = max(1ll, n - t + 1 - t * d);
suml = s[pr] - s[0];
sumr = s[n] - s[pl - 1];
if (suml - usel >= b)
usel += b;
else
ans1++;
if (sumr - user >= b)
user += b;
else
ans2++;
}
cout << max(ans1, ans2);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int a, b;
int main() {
while (cin >> a >> b) {
int min = 0;
int temp = a;
while (temp) {
if (min < temp % 10) min = temp % 10;
temp /= 10;
}
temp = b;
while (temp) {
if (min < temp % 10) min = temp % 10;
temp /= 10;
}
min++;
int i = 0;
int c = 0;
temp = a + b;
while (a || b || c) {
int sum = a % 10 + b % 10 + c;
c = sum / min;
a /= 10;
b /= 10;
i++;
}
cout << i << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, y = 0;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') y = 1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();
return y ? -x : x;
}
template <typename T>
inline T read() {
T x = 0;
int y = 0;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') y = 1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();
return y ? -x : x;
}
int en[1000005], son[1000005][26], siz[1000005], deep[1000005], s[1000005],
f[4005][2005], h[1000005], c[1000005], num, k, cnt = 1, all;
char a[505];
struct edge {
int pre, to;
} e[1000005];
inline void add(int from, int to) {
e[++num] = (edge){h[from], to}, h[from] = num;
}
void insert() {
int len = strlen(a + 1), node = 1;
for (register int i = 1; i <= len; ++i) {
if (!son[node][a[i] - 'a']) son[node][a[i] - 'a'] = ++cnt, ++siz[node];
node = son[node][a[i] - 'a'];
}
++en[node];
}
void dfs(int node = 1, int dep = 0, int last = 0) {
if (node == 1 || siz[node] > 1 || en[node]) {
deep[++all] = dep, add(last, all), last = all, s[all] = en[node];
}
for (register int i = 0; i < 26; ++i)
if (son[node][i]) dfs(son[node][i], dep + 1, last);
}
void dp(int node = 1, int fa = 0) {
f[node][0] = 0;
for (register int i = h[node], x; i; i = e[i].pre) {
dp(x = e[i].to, node), s[node] += s[x];
for (register int j = min(s[node], k); j; --j)
for (register int k = min(s[x], j); k; --k)
f[node][j] = max(f[node][j], f[x][k] + f[node][j - k]);
}
for (register int i = 1; i <= s[node]; ++i)
f[node][i] += c[i] * (deep[node] - deep[fa]);
}
void trie_print() {
for (register int i = 1; i <= cnt; ++i)
for (register int j = 0; j < 26; ++j)
if (son[i][j]) printf("%d %d %c\n", i, son[i][j], j + 'a');
}
void graph_print() {
for (register int i = 1; i <= all; ++i)
for (register int j = h[i]; j; j = e[j].pre) printf("%d %d\n", i, e[j].to);
}
signed main() {
int n = read();
k = read();
for (register int i = 1; i <= n; ++i) scanf("%s", a + 1), insert();
for (register int i = 1; i <= k; ++i) c[i] = i * (i - 1) >> 1;
dfs(), dp();
printf("%d\n", f[1][k]);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 70;
const int MOD = 1e9 + 7;
const long long INF = 1e18 + 100;
inline string toStr(long long x) {
string tmp = "";
do tmp = char(x % 10 + '0') + tmp;
while (x /= 10);
return tmp;
}
inline long long toInt(string s) {
long long res = 0;
for (auto x : s) res = res * 10 + x - '0';
return res;
}
long long dp[MAXN][MAXN];
long long P(long long a, long long x) {
if (!x) return 1;
if (x == 1) return a;
long long tmp = P(a, x >> 1LL);
tmp = tmp * tmp;
return x % 2 ? tmp * a : tmp;
}
int main() {
long long base, tmp = 1, MAXV = 1e18;
;
cin >> base;
string s;
cin >> s;
int maxP = 1;
while (1) {
if (tmp > MAXV / base) break;
tmp *= base;
++maxP;
}
int n = ((int)(s).size());
for (int i = 0, _a = (n + 1); i < _a; ++i)
for (int j = (0), _b = (60); j <= _b; j++) dp[i][j] = INF;
dp[n - 1][1] = s[n - 1] - '0';
for (int i = (((int)(s).size()) - 2), _b = (0); i >= _b; i--)
for (int j = (1), _b = (maxP); j <= _b; j++)
if (n - i >= j) {
if (s[i] == '0' && j == 1) continue;
for (int k = (i), _b = (((int)(s).size()) - 1); k <= _b; k++) {
if (s[i] == '0' && k != i) continue;
bool can = true;
long long tmp = 0;
for (int t = i; t <= k; ++t) {
tmp = tmp * 10 + s[t] - '0';
if (tmp >= base) {
can = false;
break;
}
}
if (!can) break;
long long X = P(base, j - 1);
if (tmp > MAXV / X) continue;
if (k == s.size() - 1) {
dp[i][j] = min(dp[i][j], tmp * X);
} else {
if (dp[k + 1][j - 1] > MAXV - tmp * X) continue;
dp[i][j] = min(dp[i][j], dp[k + 1][j - 1] + tmp * X);
}
}
} else
break;
long long res = INF;
for (int j = (1), _b = (maxP); j <= _b; j++) res = min(res, dp[0][j]);
cout << res;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2 * 100 * 1000 + 5;
const int off = 1 << 18;
const int inf = 1e9 + 10;
const int MOD = 1e9 + 7;
int in[maxn], out[maxn], cnt[maxn], b[maxn], t[2 * off];
map<int, vector<pair<int, int>>> M;
int query(int w, int p, int k, int beg, int end) {
if (p == beg && k == end) return t[w];
int mid = (beg + end) / 2;
if (k <= mid) return query(w * 2, p, k, beg, mid);
if (p >= mid) return query(w * 2 + 1, p, k, mid, end);
return min(query(w * 2, p, mid, beg, mid),
query(w * 2 + 1, mid, k, mid, end));
}
int count(int p, int k, int val) {
vector<pair<int, int>> &v = M[val];
assert(v.size() > 0);
int beg = -1, mid, end = v.size() - 1;
while (beg + 1 < end) {
mid = (beg + end) / 2;
if (v[mid].first >= p)
end = mid;
else
beg = mid;
}
int from = end;
beg = 0;
end = v.size();
while (beg + 1 < end) {
mid = (beg + end) / 2;
if (v[mid].first <= k)
beg = mid;
else
end = mid;
}
int fin = beg;
int res = v[fin].second;
if (from > 0) res = (res + MOD - v[from].second) % MOD;
return res;
}
void update(int i, int c, int val) {
if (M[val].empty())
M[val].push_back(make_pair(i, c));
else
M[val].push_back(make_pair(i, (c + M[val].back().second) % MOD));
i += off;
t[i] = val;
i /= 2;
while (i > 0) {
t[i] = min(t[i * 2], t[i * 2 + 1]);
i /= 2;
}
}
int main() {
for (int i = 0; i < (2 * off); ++i) t[i] = inf;
int n;
cin >> n;
vector<pair<int, int>> v(n);
for (int i = 0; i < (n); ++i) cin >> v[i].first >> v[i].second;
sort(v.begin(), v.end());
for (int i = 0; i < (n); ++i) {
in[i] = v[i].second;
out[i] = v[i].first;
}
for (int i = 0; i < (n); ++i) {
int beg = -1, mid, end = i;
while (beg + 1 < end) {
mid = (beg + end) / 2;
if (out[mid] <= in[i])
beg = mid;
else
end = mid;
}
b[i] = beg;
int a = 0;
if (beg != -1) a = b[beg] + 1;
int x = 0;
if (a <= b[i]) x = query(1, a, b[i] + 1, 0, off);
int y = x + in[i] - out[i];
if (x == 0)
cnt[i] = 1;
else
cnt[i] = count(a, b[i], x);
update(i, cnt[i], y);
}
int W = in[0];
for (int i = 0; i < (n); ++i) W = max(W, in[i]);
vector<int> alive;
for (int i = 0; i < (n); ++i)
if (out[i] > W) alive.push_back(i);
assert(alive.size() > 0);
int E = t[off + alive[0]] + out[alive[0]];
for (int i = 0; i < (alive.size()); ++i)
E = min(E, t[off + alive[i]] + out[alive[i]]);
int res = 0;
for (int i = 0; i < (alive.size()); ++i) {
if (t[off + alive[i]] + out[alive[i]] == E) {
res = (res + cnt[alive[i]]) % MOD;
}
}
cout << res << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
int t;
long long x;
int main() {
for (scanf("%d", &t); t--;)
scanf("%lld", &x),
puts(x > 14 && 1 <= x % 14 && x % 14 <= 6 ? "YES" : "NO");
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string str, s;
int i, j, len, ans;
int main() {
cin >> str;
len = str.length();
for (ans = len - 1; ans > 0; --ans) {
for (j = 0; str[j] != '\0'; ++j) {
if (j + ans >= len) break;
s.clear();
for (i = 0; i < ans; ++i) s += str[j + i];
if (str.find(s, j + 1) != string::npos) {
cout << ans << endl;
return 0;
}
}
}
cout << "0" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, q;
cin >> n >> q;
vector<vector<bool> > mat(3, vector<bool>(n + 1, false));
long long front = 0, cross = 0, x, y;
for (long long i = 0; i < q; ++i) {
cin >> x >> y;
if (mat[x][y] == false) {
mat[x][y] = true;
if (y == 1) {
if (mat[1][y + 1] == true) ++cross;
} else if (y == n) {
if (mat[2][y - 1] == true) ++cross;
} else {
if (x == 1) {
if (mat[2][y] == true) {
++front;
}
if (mat[2][y + 1] == true) {
++cross;
}
if (mat[2][y - 1] == true) {
++cross;
}
} else {
if (mat[1][y] == true) {
++front;
}
if (mat[1][y + 1] == true) {
++cross;
}
if (mat[1][y - 1] == true) {
++cross;
}
}
}
} else {
mat[x][y] = false;
if (y == 1) {
if (mat[1][y + 1] == true) --cross;
} else if (y == n) {
if (mat[2][y - 1] == true) --cross;
} else {
if (x == 1) {
if (mat[2][y] == true) {
--front;
}
if (mat[2][y + 1] == true) {
--cross;
}
if (mat[2][y - 1] == true) {
--cross;
}
} else {
if (mat[1][y] == true) {
--front;
}
if (mat[1][y + 1] == true) {
--cross;
}
if (mat[1][y - 1] == true) {
--cross;
}
}
}
}
if (cross == 0 && front == 0)
cout << "Yes";
else
cout << "No";
cout << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 1;
const int MOD = 1e9 + 7;
const int INF = MOD;
const long double PI = 3.141592653589793;
const long double EPS = 1e-6;
int a[101][101];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int m, b;
cin >> m >> b;
long long ans = 0;
for (int i = 0; i <= m * b; ++i) {
int y = -(i + m - 1) / m + b;
ans = max(
ans, (y + 1) * 1ll * (i + 1) * i / 2 + 1ll * (i + 1) * y * (y + 1) / 2);
}
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, k, m, s;
long long res;
int a[100007];
int ile[1107];
long long dp[1107][1107];
long long fact[100007];
long long inv[100007];
map<int, int> cnt;
long long fpow(long long a, int b) {
if (b == 0) return 1;
if (b == 1) return a % 1000000007;
if (b % 2)
return a * fpow(a, b - 1) % 1000000007;
else {
long long q = fpow(a, b / 2);
return q * q % 1000000007;
}
}
long long dwumian(int n, int k) {
if (k > n) return 0;
if (k < 0) return 0;
return fact[n] * inv[n - k] % 1000000007 * inv[k] % 1000000007;
}
bool ciekawa(int a) {
while (a) {
if (a % 10 != 4 && a % 10 != 7) return 0;
a /= 10;
}
return 1;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
fact[0] = inv[0] = 1;
for (int i = 1; i < 100007; ++i) {
fact[i] = fact[i - 1] * i % 1000000007;
inv[i] = fpow(fact[i], 1000000007 - 2);
}
cin >> n >> k;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
if (ciekawa(a[i])) ++cnt[a[i]];
}
for (auto it : cnt) {
ile[++m] = it.second;
s += it.second;
}
dp[0][0] = 1;
for (int i = 1; i <= m; ++i) {
for (int j = 0; j <= m; ++j) {
dp[i][j] = dp[i - 1][j];
if (j > 0) dp[i][j] += dp[i - 1][j - 1] * ile[i];
dp[i][j] %= 1000000007;
}
}
for (int i = 0; i <= m; ++i) {
res += dp[m][i] * dwumian(n - s, k - i);
res %= 1000000007;
}
cout << res;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
priority_queue<long> pq;
int main() {
long n, m;
cin >> n >> m;
long long s = 0;
for (int i = 0; i < n; i++) {
long u, v;
cin >> u >> v;
s += u;
pq.push(u - v);
}
long sl = 0;
while (s > m && pq.size()) {
long x = pq.top();
pq.pop();
s -= x;
sl++;
}
if (s > m)
cout << "-1";
else
cout << sl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1E9;
const long long LINF = (long long)1E18;
const long double PI = acos(-1.0);
const long double EPS = 1E-7;
template <typename T>
T gcd(T a, T b) {
return (b == 0) ? abs(a) : gcd(b, a % b);
}
template <typename T>
inline T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
template <typename T>
inline T mod(T a, T b) {
a %= b;
if (a < 0) a += b;
return a;
}
template <typename T>
inline T sqr(T x) {
return x * x;
}
template <typename T>
inline T gmax(T a, T b) {
return (a > b ? a : b);
}
template <typename T>
inline T gmin(T a, T b) {
return (a < b ? a : b);
}
template <typename T>
inline string toString(T x) {
ostringstream oss;
oss << x;
return oss.str();
}
inline long long toInt(const string& st) {
istringstream iss(st);
long long x;
iss >> x;
return x;
}
inline long double toDouble(const string& st) {
istringstream iss(st);
long double x;
iss >> x;
return x;
}
inline string toLower(string st) {
for (int i = 0; i < (((int)(st).size())); i++) st[i] = tolower(st[i]);
return st;
}
inline string toUpper(string st) {
for (int i = 0; i < (((int)(st).size())); i++) st[i] = toupper(st[i]);
return st;
}
bool LOCAL = false, OUTPUT = true;
const char DEBUG_PARAM[] = "__LOCAL_TESTING";
const char IN[] = "_.in";
const char OUT[] = "_.out";
inline void init();
inline void run();
int ntest = 0, test;
int main(int argc, char* argv[]) {
if (argc > 1 && strcmp(argv[1], DEBUG_PARAM) == 0) {
LOCAL = true;
freopen(IN, "r", stdin);
}
init();
if (ntest == 0) {
cerr << "ntest = ?" << endl;
return 0;
}
for (test = 1; test <= ntest; ++test) {
run();
}
return 0;
}
inline void stop() { ntest = test - 1; }
const int dx[] = {-1, 0, 0, 1};
const int dy[] = {0, -1, 1, 0};
inline void init() {
OUTPUT = true;
ntest = 1;
}
const int MAXN = 100000 + 5;
int a[MAXN], d, f[MAXN], n;
inline void run() {
scanf("%d", &n);
for (int i = 0; i < (n); i++) {
scanf("%d", &a[i]);
d += a[i];
}
if (abs(d) % 3) {
cout << 0;
return;
}
d /= 3;
int e = 0;
for (int i = 0; i < (n); i++) {
e += a[i];
f[i + 1] = f[i] + (e == d);
}
e = 0;
long long ret = 0;
for (int i = (n - 1); i >= (0); i--) {
e += a[i];
if (i > 0 && e == d) ret += f[i - 1];
}
cout << ret;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int powmod(long long int a, int b, int n) {
long long int rm = 1;
while (b) {
if (b % 2) {
rm = (rm * a) % n;
}
a = (a * a) % n;
b /= 2;
}
return rm;
}
int seg[4 * int(2e5 + 1000)] = {0}, n, Q, l[int(2e5 + 1000)],
r[int(2e5 + 1000)], MaxReachIndex[int(2e5 + 1000)] = {0},
MaxReachPosition[int(2e5 + 1000)],
mxl[int(2e5 + 1000)] = {0}, x[int(2e5 + 1000)],
y[int(2e5 + 1000)];
int Parent[int(2e5 + 1000)][50], Cost[int(2e5 + 1000)][50] = {0};
vector<int> p;
void update(int n, int it, int f, int ind, int SetMaxIndex) {
if (it == f) {
seg[n] = SetMaxIndex;
return;
}
int m = (it + f) / 2;
if (ind <= m)
update(n * 2, it, m, ind, SetMaxIndex);
else
update(n * 2 + 1, m + 1, f, ind, SetMaxIndex);
seg[n] = max(seg[n * 2 + 1], seg[n * 2]);
}
int Query(int n, int it, int f, int q1, int q2) {
if (it == q1 && q2 == f) {
return seg[n];
}
int m = (it + f) / 2;
if (q2 <= m)
return Query(n * 2, it, m, q1, q2);
else if (q1 > m)
return Query(n * 2 + 1, m + 1, f, q1, q2);
else
return max(Query(n * 2, it, m, q1, m),
Query(n * 2 + 1, m + 1, f, m + 1, q2));
}
void BuildParentPart() {
for (int i = n; i >= 1; i--) {
if (mxl[i]) {
Parent[i][0] = MaxReachIndex[i] + 1;
Cost[i][0] = p[MaxReachIndex[i]] - MaxReachPosition[i];
for (int j = 1;; j++) {
if ((1 << j) > mxl[i]) break;
Parent[i][j] = Parent[Parent[i][j - 1]][j - 1];
Cost[i][j] = Cost[i][j - 1] + Cost[Parent[i][j - 1]][j - 1];
}
}
}
}
int Query2(int q1, int q2) {
if (q2 <= MaxReachIndex[q1]) return 0;
int maxwidth = 0, nn = q1;
long long int ans = 0;
for (int maxwidth = 18; maxwidth >= 0; maxwidth--) {
if ((1 << maxwidth) <= mxl[nn]) {
if (Parent[nn][maxwidth] <= q2) {
ans += Cost[nn][maxwidth];
nn = Parent[nn][maxwidth];
if (MaxReachIndex[nn] >= q2) return ans;
}
}
}
}
int bns(int q) {
int it = 0, m, f = n - 1;
while (it != f) {
m = (it + f) / 2;
if (p[m + 1] <= q)
it = m + 1;
else
f = m;
}
return f + 1;
}
int WhatTheFuck[4 * int(2e5 + 1000)];
void insert2(int n, int it, int f) {
if (it == f) {
WhatTheFuck[n] = p[f - 1] + l[f];
return;
}
int m = (it + f) / 2;
insert2(n * 2, it, m);
insert2(n * 2 + 1, m + 1, f);
WhatTheFuck[n] = max(WhatTheFuck[n * 2], WhatTheFuck[n * 2 + 1]);
}
int fuckyou(int n, int it, int f, int q1, int q2) {
if (it == q1 && q2 == f) return WhatTheFuck[n];
int m = (it + f) / 2;
if (q2 <= m)
return fuckyou(n * 2, it, m, q1, q2);
else if (q1 > m)
return fuckyou(n * 2 + 1, m + 1, f, q1, q2);
return max(fuckyou(n * 2, it, m, q1, m),
fuckyou(n * 2 + 1, m + 1, f, m + 1, q2));
}
int main() {
int q;
vector<int>::iterator low;
cin >> n;
for (int i = int(1); i <= (int)n; i++) {
scanf("%d", &q);
;
p.push_back(q);
scanf("%d", &l[i]);
;
}
insert2(1, 1, n);
cin >> Q;
for (int i = int(1); i <= (int)Q; i++) {
scanf("%d", &x[i]);
;
scanf("%d", &y[i]);
;
}
update(1, 1, n, n, n);
MaxReachIndex[n] = n;
MaxReachPosition[n] = p[n - 1] + l[n];
mxl[n] = 0;
for (int i = n - 1; i >= 1; i--) {
if (p[i - 1] + l[i] < p[i]) {
MaxReachIndex[i] = i;
MaxReachPosition[i] = p[i - 1] + l[i];
update(1, 1, n, i, i);
if (i < n)
mxl[i] = mxl[i + 1] + 1;
else
mxl[i] = 0;
} else {
int tind = bns(p[i - 1] + l[i]);
int id = Query(1, 1, n, i + 1, tind);
MaxReachIndex[i] = id;
MaxReachPosition[i] = fuckyou(1, 1, n, i, id);
update(1, 1, n, i, id);
if (id < n)
mxl[i] = mxl[id + 1] + 1;
else
mxl[i] = 0;
}
}
BuildParentPart();
for (int k = int(1); k <= (int)Q; k++) {
q = Query2(x[k], y[k]);
printf("%d\n", q);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int INF = int(1e9);
string s, t;
int a, b;
int main() {
ios_base::sync_with_stdio(false);
cin >> s >> t;
if (s == "monday") a = 1;
if (s == "tuesday") a = 2;
if (s == "wednesday") a = 3;
if (s == "thursday") a = 4;
if (s == "friday") a = 5;
if (s == "saturday") a = 6;
if (s == "sunday") a = 7;
if (t == "monday") b = 1;
if (t == "tuesday") b = 2;
if (t == "wednesday") b = 3;
if (t == "thursday") b = 4;
if (t == "friday") b = 5;
if (t == "saturday") b = 6;
if (t == "sunday") b = 7;
if (b == 7) {
if ((a + 2) % 7 == 0 || (a + 3) % 7 == 0 || a == b)
cout << "YES";
else
cout << "NO";
} else {
if ((a + 3) % 7 == b || (a + 2) % 7 == b || a == b)
cout << "YES";
else
cout << "NO";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int nl(long long s) {
int r = 0;
while (++r && s) s /= 10;
return r - 1;
}
int main(int argc, char** argv) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
std::cin >> n;
std::vector<long long> a;
a.resize(n);
for (int i = 0; i < n; i++) std::cin >> a[i];
int len = nl(a[0]);
long long res = 0;
long long mul = 1;
for (int i = 0; i < len; i++) {
long long sb = 0;
for (int j = 0; j < n; j++) {
long long dig = a[j] % 10;
a[j] /= 10;
sb += dig;
}
sb = (sb * n) % 998244353;
sb = (sb * mul) % 998244353;
res = (res + sb) % 998244353;
sb = (sb * 10) % 998244353;
res = (res + sb) % 998244353;
mul *= 100;
mul %= 998244353;
}
std::cout << res << std::endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long infl = 0x3f3f3f3f3f3f3f3fLL;
const long long infi = 0x3f3f3f3f;
mt19937_64 mt(chrono::steady_clock::now().time_since_epoch().count());
const long long mod = 998244353;
const long long N = 2e5 + 5;
void solve() {
long long n, m;
cin >> n >> m;
long long x = 0;
for (long long _ = 0; _ < n; _++) {
long long y;
cin >> y;
x += y;
}
cout << (x == m ? "YES" : "NO") << '\n';
}
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cout << fixed << setprecision(15);
long long t = 1;
cin >> t;
while (t--) solve();
return 0;
}
long long powm(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 divide(long long a, long long b) {
return (a % mod) * powm(b, mod - 2) % mod;
}
long long norm(long long a) {
while (a >= mod) a -= mod;
while (a < 0) a += mod;
return a;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, n, a, p, q, r;
set<int> x;
set<int>::iterator it;
cin >> n;
for (i = 0; i < n; i++) {
cin >> a;
x.insert(a);
}
if (x.size() <= 2)
cout << "YES" << endl;
else if (x.size() > 3)
cout << "NO" << endl;
else {
it = x.begin();
p = *it;
advance(it, 1);
q = *it;
advance(it, 1);
r = *it;
if (p + r == 2 * q)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, l, r, f[10003];
struct data {
int x, y;
} a[10003];
inline bool cmp(data a, data b) { return a.y < b.y || a.y == b.y && a.x > b.x; }
int main() {
cin >> n >> l >> r;
int s = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i].x, s += a[i].x;
}
for (int i = 1; i <= n; i++) {
cin >> a[i].y;
}
sort(a + 1, a + n + 1, cmp);
f[0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = s; j >= a[i].x; j--) {
if (f[j - a[i].x]) {
f[j] = max(f[j], f[j - a[i].x] + a[i].y * (j >= s - r && j <= s - l));
}
}
}
int ans = 0;
for (int i = 0; i <= s; i++) {
ans = max(ans, f[i]);
}
cout << ans - 1 << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
priority_queue<long long, vector<long long>, greater<long long> > Qa;
priority_queue<long long> Qb;
long long a[500050], b[500050];
int n, m;
const long long INF = 1e13;
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%I64d", a + i);
for (int i = 1; i <= n; i++) scanf("%I64d", b + i);
long long st = 0, en = INF, ans = 0;
while (st <= en) {
long long mid = (st + en) >> 1;
while (!Qa.empty()) Qa.pop();
while (!Qb.empty()) Qb.pop();
long long tmp = 0;
int sz = 0;
for (int i = 1; i <= n; i++) {
Qa.push(a[i]);
long long tmp1 = Qa.top() + b[i] - mid;
long long tmp2 = Qb.empty() ? INF : b[i] - Qb.top();
if (tmp1 <= tmp2 && tmp1 <= 0) {
tmp += tmp1;
sz++;
Qb.push(b[i]);
Qa.pop();
} else if (tmp2 < tmp1 && tmp2 < 0) {
tmp += tmp2;
Qb.pop();
Qb.push(b[i]);
}
}
if (sz >= m) {
ans = tmp + m * mid;
en = mid - 1;
} else {
st = mid + 1;
}
}
cout << ans << endl;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long max(long long a, long long b) { return a > b ? a : b; }
long long min(long long a, long long b) { return a < b ? a : b; }
int main() {
char a[200010], b[200010];
long long na, nb, nc;
while (cin >> a >> b) {
na = strlen(a);
nb = strlen(b);
nc = min(na, nb);
long long res = 0;
for (long long i = 0; i < nc; i++) {
if (a[na - i - 1] == b[nb - i - 1]) {
res++;
} else {
break;
}
}
cout << na + nb - 2 * res << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void run() {
string t;
cin >> t;
int fl = 0;
for (int i = 1; i < t.size(); ++i)
if (t[i] != t[i - 1]) fl = 1;
if (fl == 0) {
cout << t << '\n';
return;
}
string s;
s.reserve(t.size() * 2);
s.push_back(t[0]);
for (int i = 1; i < t.size(); ++i) {
if (s.back() == t[i]) s.push_back((!(t[i] - '0')) + '0');
s.push_back(t[i]);
}
cout << s << '\n';
}
int main() {
int T;
cin >> T;
while (T--) run();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
while (cin >> a >> b >> c) {
char s[a];
cin >> s;
int k = 0, l = 1, m = 1, ans, f, y;
int e = 0;
bool g = false, d = false;
if (a % b == 0) {
ans = a / b;
g = true;
d = true;
int e = 0;
cout << ans << endl;
for (int h = ans; h > 0; h--) {
for (f = 0; f < b; f++) {
cout << s[e];
e++;
}
cout << endl;
}
} else if (a % c == 0) {
ans = a / c;
g = true;
d = true;
cout << ans << endl;
for (int h = ans; h > 0; h--) {
for (f = 0; f < c; f++) {
cout << s[e];
e++;
}
cout << endl;
}
} else {
if (b > c) {
int temp = b;
b = c;
c = temp;
}
for (int i = 1; c * m <= a; i++) {
k = a - (b * i);
if (k % c == 0) {
e = 0;
ans = (k / c) + i;
cout << ans << endl;
int p = 0;
for (int j = 1; j <= i; j++) {
for (int k = 0; k < b; k++) {
cout << s[e];
e++;
}
cout << endl;
}
for (int j = 1; j <= k / c; j++) {
for (int k = 0; k < c; k++) {
cout << s[e];
e++;
}
cout << endl;
}
g = true;
break;
} else if (k < 1) {
break;
}
}
}
if (g == false) {
cout << -1 << endl;
}
}
}
| 2 |
#include <iostream>
#include <algorithm>
#include <utility>
#include <queue>
#include <vector>
#include <string.h>
#include <math.h>
typedef long long ll;
#define vi vector<int>
#define for(a,b) for(a=0;a<b;a++)
using namespace std;
void solve(){
int i,n; cin>>n;
vi a,b;
for(i,n) {int j; cin>>j; a.push_back(j);}
sort(a.begin(),a.end());
i=0;
while(i<a.size()-1){
int j=i+1;
while(a[i]==a[j]&&j<a.size()){
b.push_back(a[i]);
a.erase(a.begin()+j);
}
i++;
}
for(i,a.size())
cout<<a[i]<<" ";
for(i,b.size())
cout<<b[i]<<" ";
cout<<"\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t; cin>>t;
while(t--) solve();
/*cin.clear();
cin.get();
#ifndef ONLINE_JUDGE
freopen("input1.txt", "r" , stdin);
freopen("output1.txt", "w" , stdout);
#endif*/
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
const int AL = 26;
const int N = (int)1e6 + 9;
int powr(int n, int k) {
if (k == 0) return 1;
int v = powr(n, k / 2);
v = (v * 1ll * v) % MOD;
if (k & 1) v = (v * 1ll * n) % MOD;
return v;
}
int cnt[AL];
int f[N];
int inv[N];
int C(int a, int b) {
if (b == 0) return 1;
int v = f[a];
v = (v * 1ll * inv[b]) % MOD;
v = (v * 1ll * inv[a - b]) % MOD;
return v;
}
int ways(string a, string b) {
for (int j = 0; j < AL; j++) cnt[j] = 0;
for (auto x : a) {
cnt[x - 'a']++;
}
int answ = 0;
int mlt;
int sz = a.size();
int nsz;
int y;
bool ok;
for (int i = 0; i < b.size(); i++) {
nsz = sz - 1;
y = b[i] - 'a';
ok = false;
for (int t = 0; t < y; t++) {
if (cnt[t] > 0) ok = true;
}
if (ok) {
mlt = 1;
for (int r = AL - 1; r >= 0; r--) {
mlt = (mlt * 1ll * C(nsz, cnt[r])) % MOD;
nsz -= cnt[r];
nsz += (r == y);
}
answ = (answ + mlt) % MOD;
}
cnt[b[i] - 'a']--;
if (cnt[b[i] - 'a'] < 0) break;
sz--;
}
return answ;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
f[0] = 1;
inv[0] = 1;
for (int i = 1; i < N; i++) {
f[i] = (1ll * i * f[i - 1]) % MOD;
inv[i] = powr(f[i], MOD - 2);
}
string a, b;
cin >> a >> b;
cout << (ways(a, b) - ways(a, a) + MOD - 1) % MOD << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
const long long MOD = 1e9 + 7;
const double eps = 1e-9;
int n, m, sr, sc, a[N][N], dp[N][N], mod = 998244353;
vector<pair<int, pair<int, int> > > v;
int fast_pow(int b, int n) {
if (n == 1) return b;
if (n == 0) return 1;
if (n & 1) return (1ll * b * fast_pow(b, n - 1)) % mod;
int r = fast_pow(b, n / 2);
return (1ll * r * r) % mod;
}
inline int inverse(int x) { return fast_pow(x, mod - 2); }
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
scanf("%d", &a[i][j]);
v.push_back(make_pair(a[i][j], make_pair(i, j)));
}
}
scanf("%d%d", &sr, &sc);
sr--, sc--;
sort(v.begin(), v.end());
int sev = 0, srow = 0, scol = 0, srow2 = 0, scol2 = 0;
for (int i = 0, j, x, y, iv; i < v.size();) {
j = i;
iv = inverse(i);
while (j < v.size() && v[j].first == v[i].first) j++;
if (i)
for (int k = i; k < j; k++) {
x = v[k].second.first, y = v[k].second.second;
if (!i) continue;
dp[x][y] = ((1ll * x * x) % mod + (1ll * y * y) % mod) % mod;
dp[x][y] = (dp[x][y] + (1ll * sev * iv) % mod) % mod;
dp[x][y] = (dp[x][y] + (1ll * srow2 * iv) % mod) % mod;
dp[x][y] = (dp[x][y] + (1ll * scol2 * iv) % mod) % mod;
dp[x][y] =
(dp[x][y] - (1ll * (2ll * x * srow) % mod * iv) % mod + mod) % mod;
dp[x][y] =
(dp[x][y] - (1ll * (2ll * y * scol) % mod * iv) % mod + mod) % mod;
}
for (int k = i; k < j; k++) {
x = v[k].second.first, y = v[k].second.second;
sev = (sev + dp[x][y]) % mod;
srow = (srow + x) % mod;
scol = (scol + y) % mod;
srow2 = (srow2 + (1ll * x * x) % mod) % mod;
scol2 = (scol2 + (1ll * y * y) % mod) % mod;
}
i = j;
}
printf("%d\n", dp[sr][sc]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int SIZE = 1010;
bool mas[SIZE][SIZE];
long long n, m, a, b;
bool fl;
long long ans = 0;
inline void checkIt(const int &i, bool flag = false) {
fl = false;
if (mas[i][1] || mas[i][n])
fl = true;
else
for (int j = 2; j < n; ++j)
if (mas[i][j]) {
fl = true;
break;
}
if (!fl) {
++ans;
if (flag) return;
}
fl = false;
if (mas[1][n - i + 1] || mas[n][n - i + 1])
fl = true;
else
for (int j = 2; j < n; ++j)
if (mas[j][n - i + 1]) {
fl = true;
break;
}
if (!fl) {
++ans;
}
}
int main() {
ios_base::sync_with_stdio(0);
ifstream cin("/home/misha/in2");
cin >> n >> m;
for (int i = 0; i < m; ++i) {
cin >> a >> b;
mas[a][b] = true;
}
fl = false;
for (int i = 2; i <= (n / 2 + n % 2); ++i) {
if ((n & 1) && i == n / 2 + 1)
checkIt(i, true);
else {
checkIt(i);
checkIt(n - i + 1);
}
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
int main() {
int n, s1 = 0, s2 = 0, s3 = 0, i, j;
scanf("%d", &n);
int a[n][3];
for (i = 0; i < n; i++) {
for (j = 0; j < 3; j++) {
scanf("%d ", &a[i][j]);
}
}
for (i = 0; i < n; i++) {
for (j = 0; j < 3; j++) {
if (j == 0) {
s1 = s1 + a[i][j];
} else if (j == 1) {
s2 = s2 + a[i][j];
} else {
s3 = s3 + a[i][j];
}
}
}
if (s1 == 0 && s2 == 0 && s3 == 0) {
printf("YES");
} else {
printf("NO");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:536870912")
#pragma warning(disable : 4996)
using namespace std;
const int N = 5010, LOG = 15;
pair<int, int> a[N], t[LOG][N];
int p[N], col[N];
pair<int, int> f(int l, int r) {
if (l > r) return {0, N - 1};
int g = p[r - l + 1];
return max(t[g][l], t[g][r - (1 << g) + 1]);
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i].first);
a[i].second = i;
}
for (int i = 2; i < N; i++) p[i] = p[i / 2] + 1;
sort(a, a + n, greater<pair<int, int>>());
for (int i = 0; i < n; i++) {
t[0][i] = {a[i].first - a[i + 1].first, i};
}
for (int i = 1; i < LOG; i++) {
for (int j = 0; j <= n - (1 << i); j++) {
t[i][j] = max(t[i - 1][j], t[i - 1][j + (1 << (i - 1))]);
}
}
int mx[3] = {-1, -1, -1}, b[3];
for (int i = 0; i < n - 2; i++) {
if (mx[0] > t[0][i].first) continue;
for (int j = i + 1; j < n - 1; j++) {
if ((j - i) > (i + 1) * 2) break;
if (mx[1] > t[0][j].first && t[0][i].first == mx[0] ||
(j - i) * 2 < i + 1)
continue;
if (j + (max(i + 1, j - i) + 1) / 2 >= n) continue;
auto k = f(j + (max(i + 1, j - i) + 1) / 2,
min(n - 1, j + min(i + 1, j - i) * 2));
if (mx[0] != t[0][i].first || mx[1] != t[0][j].first || mx[2] < k.first) {
mx[0] = t[0][i].first;
mx[1] = t[0][j].first;
mx[2] = k.first;
b[0] = i;
b[1] = j;
b[2] = k.second;
}
}
}
for (int i = 0; i <= b[0]; i++) col[a[i].second] = 1;
for (int i = b[0] + 1; i <= b[1]; i++) col[a[i].second] = 2;
for (int i = b[1] + 1; i <= b[2]; i++) col[a[i].second] = 3;
for (int i = b[2] + 1; i < n; i++) col[a[i].second] = -1;
for (int i = 0; i < n; i++) printf("%d ", col[i]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
char s[1000];
int len, i;
int f(int a) {
int ret = 0;
for (int i = 0; i < 8; i++)
if (((1 << i) & (a)) > 0) ret += 1 << (7 - i);
return ret;
}
int main() {
gets(s);
len = strlen(s);
for (i = 0; i < len; i++) {
if (i == 0)
printf("%d\n", (256 - f(int(s[i]))) % 256);
else
printf("%d\n", (256 + f(int(s[i - 1])) - f(int(s[i]))) % 256);
}
}
| 2 |
#include <bits/stdc++.h>
int main() {
int a, ta, b, tb, i, x, t = 0, h, m;
scanf("%d %d %d %d", &a, &ta, &b, &tb);
scanf("%d:%d", &h, &m);
x = h * 60 + m;
for (i = (5 * 60); i < (24 * 60); i += b) {
if (i + tb > x && i < x + ta) {
t++;
}
}
printf("%d", t);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long MOD = 1000000007;
long long pw(long long a, long long b) {
long long r = 1;
while (b > 0) {
if (b & 1) {
r = (r * a) % MOD;
}
b = b >> 1;
a = (a * a) % MOD;
}
return r;
}
int main() {
int a, b, r;
cin >> a >> b >> r;
int n = 1;
int row = 0, col = 0;
if (a >= 2 * r) {
row = (a / (2 * r));
}
if (b >= 2 * r) {
col = (b / (2 * r));
}
if ((row * col) == 0) {
cout << "Second\n";
} else
cout << "First\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
ostream &ra(ostream &stream) {
stream << " ------->";
return stream;
}
int main(int argc, char *argv[]) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int tc;
cin >> tc;
while (tc--) {
int n, x;
cin >> n >> x;
vector<int> v(n);
for (auto &x : v) cin >> x;
sort(v.begin(), v.end());
int a = 1, i = 0;
while (1) {
if (a == v[i]) {
while (a == v[i]) i++;
a++;
} else if (x > 0) {
x--;
a++;
} else
break;
}
a--;
cout << a;
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
bool visited[N];
int n;
map<int, int> m;
vector<int> g[N];
vector<int> cats(N);
int out_degree[N];
map<int, int> ans;
int cnt = 0;
void bfs(int u) {
queue<int> q;
q.push(u);
visited[u] = true;
while (!q.empty()) {
int f = q.front();
q.pop();
int cnt = 0;
for (auto i = g[f].begin(); i != g[f].end(); i++) {
if (!visited[*i]) {
q.push(*i);
visited[*i] = true;
cnt++;
}
}
out_degree[f] = cnt;
}
}
void dfs_tofindDegree(int node) {
queue<int> q;
visited[node] = true;
q.push(node);
while (!q.empty()) {
int f = q.front();
int cnt = 0;
q.pop();
for (int child : g[node]) {
if (!visited[child]) {
q.push(child);
visited[child] = true;
cnt++;
}
}
out_degree[f] = cnt;
}
}
void dfs(int node) {
visited[node] = true;
cout << ans[node] << " ";
for (auto i : g[node]) {
if (!visited[i]) {
dfs(i);
}
}
}
int main() {
cin >> n;
vector<pair<int, int>> v;
int n1 = n;
while (n1--) {
int a, b;
cin >> a >> b;
v.push_back({a, b});
}
set<int> s;
for (int i = 0; i < n; i++) {
s.insert(v[i].first);
s.insert(v[i].second);
}
int ct = 1;
for (auto it : s) {
m.insert({it, ct});
ans.insert({ct, it});
ct++;
}
for (int i = 0; i < n; i++) {
g[m[v[i].first]].push_back(m[v[i].second]);
g[m[v[i].second]].push_back(m[v[i].first]);
}
bfs(1);
int temp = 0;
for (int i = 1; i <= s.size(); i++) {
if (out_degree[i] == 0) {
temp = i;
}
}
memset(visited, false, sizeof(visited));
dfs(temp);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 100, M = 1 << 13;
int n, a[N], MIN[M], f[M];
vector<int> p[M];
inline void ckmin(int &a, int b) { a = ((a < b) ? a : b); }
inline void ckmax(int &a, int b) { a = ((a > b) ? a : b); }
inline int read() {
int f = 1, x = 0;
char s = getchar();
while (s < '0' || s > '9') {
if (s == '-') f = -1;
s = getchar();
}
while (s >= '0' && s <= '9') {
x = x * 10 + s - '0';
s = getchar();
}
return x * f;
}
signed main() {
n = read();
for (int i = 1; i <= n; i++) a[i] = read(), p[a[i]].push_back(i);
memset(MIN, 0x3f, sizeof(MIN));
MIN[0] = 0;
for (int i = 1; i <= 5000; i++)
if (!p[i].empty()) {
vector<int> b = p[i];
memset(f, 0x3f, sizeof(f));
for (int j = 0; j < M; j++)
if (MIN[j] != 0x3f3f3f3f) {
int pos = lower_bound(b.begin(), b.end(), MIN[j]) - b.begin();
if (pos == (int)b.size())
f[j ^ i] = 0x3f3f3f3f;
else
f[j ^ i] = b[pos];
}
for (int j = 0; j < M; j++) ckmin(MIN[j], f[j]);
}
vector<int> ans;
for (int i = 0; i < M; i++)
if (MIN[i] != 0x3f3f3f3f) ans.push_back(i);
printf("%d\n", (int)ans.size());
for (int i : ans) printf("%d ", i);
printf("\n");
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool umin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool umax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
vector<int> adj[300009];
vector<pair<int, int> > add[300009];
int sz[300009], comp[300009], S;
int tin[300009], fup[300009], TIM, arr[300009], cnt[300009];
stack<int> st;
long long ans[300009];
void dfs(int nd, int pr) {
tin[nd] = fup[nd] = ++TIM;
st.push(nd);
for (int i = 0; i < int(adj[nd].size()); i++) {
int to = adj[nd][i];
if (to == pr) continue;
if (!tin[to]) {
dfs(to, nd);
umin(fup[nd], fup[to]);
} else
umin(fup[nd], tin[to]);
}
if (fup[nd] == tin[nd]) {
int aux;
S++;
do {
aux = st.top();
st.pop();
comp[aux] = S;
sz[S]++;
} while (aux != nd);
}
}
long long s[300009 << 2];
int lazy[300009 << 2];
void shift(int nd, int x, int y) {
int& ret = lazy[nd];
if (!ret) return;
int mid = (x + y) >> 1;
s[nd << 1] += (mid - x + 1) * 1LL * ret;
lazy[nd << 1] += ret;
s[nd << 1 | 1] += (y - mid) * 1LL * ret;
lazy[nd << 1 | 1] += ret;
ret = 0;
}
void inc(int l, int r, int nd, int x, int y) {
if (l > y or x > r) return;
if (l <= x and y <= r) {
lazy[nd]++;
s[nd] += (y - x + 1);
return;
}
shift(nd, x, y);
int mid = (x + y) >> 1;
inc(l, r, nd << 1, x, mid);
inc(l, r, nd << 1 | 1, mid + 1, y);
s[nd] = s[nd << 1] + s[nd << 1 | 1];
}
long long tap(int l, int r, int nd, int x, int y) {
if (l > y or x > r) return 0;
if (l <= x and y <= r) return s[nd];
shift(nd, x, y);
int mid = (x + y) >> 1;
return tap(l, r, nd << 1, x, mid) + tap(l, r, nd << 1 | 1, mid + 1, y);
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
while (m--) {
int u, v;
scanf("%d%d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = 1; i <= n; i++)
if (!tin[i]) dfs(i, -1);
int p = 1;
for (int i = 1; i <= n; i++) {
if (sz[comp[i]] > 1) {
cnt[comp[i]]++;
while (cnt[comp[i]] == sz[comp[i]]) cnt[comp[p]]--, p++;
}
arr[i] = p;
}
int q;
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
int l, r;
scanf("%d%d", &l, &r);
add[r].push_back(make_pair(l, i));
}
for (int i = 1; i <= n; i++) {
inc(arr[i], i, 1, 1, n);
for (__typeof((add[i]).begin()) it = (add[i]).begin(); it != (add[i]).end();
it++)
ans[it->second] = tap(it->first, i, 1, 1, n);
}
for (int i = 1; i <= q; i++) printf("%lld\n", ans[i]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 105;
int n, a[maxn];
int main() {
while (cin >> n) {
int sum = 0, cnt = 0;
vector<int> v;
for (int i = 1; i <= n; i++) {
cin >> a[i];
sum += a[i];
}
v.push_back(1);
cnt += a[1];
for (int i = 2; i <= n; i++) {
if (a[i] <= a[1] / 2) {
cnt += a[i];
v.push_back(i);
}
if (cnt >= sum / 2 + 1) {
break;
}
}
if (cnt >= sum / 2 + 1) {
printf("%d\n", v.size());
for (int i = 0; i < v.size(); i++) printf("%d ", v[i]);
printf("\n");
} else {
cout << 0 << endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.sync_with_stdio(0), cin.tie(0);
int n;
cin >> n;
int a[n];
int im = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] > a[im]) im = i;
}
bool ok = 1;
for (int i = im + 1; ok && i < n; i++) {
if (a[i] > a[i - 1]) ok = 0;
}
for (int i = im - 1; ok && i >= 0; i--)
if (a[i] > a[i + 1]) ok = 0;
if (ok)
puts("YES");
else
puts("NO");
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e3 + 100;
int k;
long long a[20][maxn];
int nk[20];
map<long long, pair<int, int> > mp;
long long sum = 0;
bool _is[1 << 17];
long long tol[20];
bool _a[20][maxn];
vector<pair<int, int> > que;
vector<vector<pair<int, int> > > dp[1 << 17];
pair<int, int> ans[20];
void dfs(int fir, int i, int j, int sta, int &flag) {
if (a[i][j] == fir) {
if (_a[i][j] && !_is[sta]) {
_is[sta] = 1;
flag = 1;
dp[sta].push_back(que);
return;
}
}
_a[i][j] = 1;
long long tmp = sum - (tol[i] - a[i][j]);
if (mp.find(tmp) == mp.end()) {
return;
}
int tfir = mp[tmp].first;
int tsec = mp[tmp].second;
if (sta >> tfir & 1) {
return;
}
que.push_back({tmp, i});
dfs(fir, tfir, tsec, sta | 1 << tfir, flag);
que.pop_back();
_a[i][j] = 0;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> k;
for (int i = 0; i < k; ++i) {
cin >> nk[i];
for (int j = 0; j < nk[i]; ++j) {
cin >> a[i][j];
mp[a[i][j]] = {i, j};
sum += a[i][j];
tol[i] += a[i][j];
}
}
if (sum % k) {
cout << "No" << endl;
} else {
sum /= k;
for (int i = 0; i < k; ++i) {
for (int j = 0; j < nk[i]; ++j) {
if (_a[i][j]) continue;
int tmp = 0;
dfs(a[i][j], i, j, 0, tmp);
}
}
for (int i = 1; i < 1 << k; ++i) {
if (!_is[i]) {
for (int j = i; j; j = j - 1 & i) {
if (_is[j] && _is[i ^ j]) {
for (auto l : dp[j]) {
dp[i].push_back(l);
}
for (auto l : dp[i ^ j]) {
dp[i].push_back(l);
}
_is[i] = 1;
break;
}
}
}
}
if (_is[(1 << k) - 1]) {
cout << "Yes" << endl;
for (auto i : dp[(1 << k) - 1]) {
for (auto j : i) {
ans[mp[j.first].first] = j;
}
}
for (int i = 0; i < k; ++i) {
cout << ans[i].first << " " << ans[i].second + 1 << endl;
}
} else {
cout << "No" << endl;
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
long long arr[200005];
long long fck[100005];
void merge(long long arr[], int l, int m, int r) {
int i, j, k;
int n1 = m - l + 1;
int n2 = r - m;
int L[n1], R[n2];
for (i = 0; i < n1; i++) L[i] = arr[l + i];
for (j = 0; j < n2; j++) R[j] = arr[m + 1 + j];
i = 0;
j = 0;
k = l;
while (i < n1 && j < n2) {
if (L[i] <= R[j]) {
arr[k] = L[i];
i++;
} else {
arr[k] = R[j];
j++;
}
k++;
}
while (i < n1) {
arr[k] = L[i];
i++;
k++;
}
while (j < n2) {
arr[k] = R[j];
j++;
k++;
}
}
void mergeSort(long long arr[], int l, int r) {
if (l < r) {
int m = l + (r - l) / 2;
mergeSort(arr, l, m);
mergeSort(arr, m + 1, r);
merge(arr, l, m, r);
}
}
int main() {
long long count, n, q, i, j, k, x, y, z, l, ans, min, f, len, m, r, c, t, max,
b, h;
scanf("%lld", &t);
for (i = 0; i < t; i++) {
scanf("%lld %lld %lld", &n, &x, &y);
for (j = 0; j < x; j++) scanf("%lld", &arr[j]);
for (j = 0; j < y; j++) scanf("%lld", &fck[j]);
mergeSort(arr, 0, x - 1);
mergeSort(fck, 0, y - 1);
m = x - 1;
n = y - 1;
while (arr[0] != 0 && fck[0] != 0) {
m = x - 1;
n = y - 1;
if (arr[m] > fck[n]) {
arr[m + 1] = fck[n];
fck[n] = 0;
x++;
y--;
mergeSort(arr, 0, x - 1);
}
if (arr[m] < fck[n]) {
fck[n + 1] = arr[m];
arr[m] = 0;
y++;
x--;
mergeSort(fck, 0, y - 1);
}
if (arr[0] == 0) {
printf("NO\n");
}
if (fck[0] == 0) printf("YES\n");
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, n, i;
cin >> n;
while (n--) {
cin >> a;
printf("%s\n", (360 % (180 - a)) == 0 ? "YES" : "NO");
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int N, P, K, dp[1003][103], n[1003][103], sz[2], v[2][1100], cum[3][1100], ans;
int q(int i, int l, int r) { return cum[i][r] - (l ? cum[i][l - 1] : 0); }
int main() {
scanf("%d %d %d", &N, &P, &K);
for (int i = (0); i < (2); i++) {
scanf("%d", &sz[i]);
for (int j = (0); j < (sz[i]); j++) {
int a;
scanf("%d", &a), a--;
v[i][a] = 1;
}
}
for (int i = (0); i < (1100); i++) {
cum[0][i] = v[0][i];
cum[1][i] = v[1][i];
cum[2][i] = v[0][i] & v[1][i];
if (i > 0) {
for (int j = (0); j < (3); j++) cum[j][i] += cum[j][i - 1];
}
}
for (int u = (1); u < (P + 1); u++) {
for (int i = (0); i < (N + 1); i++)
for (int d = max(0, 51 - i); i + d - 51 <= N && d < 103; d++) {
if (i > 0 && d < 102) n[i][d] = max(n[i][d], n[i - 1][d + 1]);
if (d > 0) n[i][d] = max(n[i][d], n[i][d - 1]);
int j = i + d - 51;
if (i < N) {
int ni = min(i + K, N), nj = j, nd = nj - ni + 51;
if (nd >= 0 && nd < 103) {
int c = q(0, i, ni - 1);
if (j > i) c -= q(2, i, j - 1);
n[ni][nd] = max(n[ni][nd], dp[i][d] + c);
}
}
if (j < N) {
int ni = i, nj = min(j + K, N), nd = nj - ni + 51;
if (nd >= 0 && nd < 103) {
int c = q(1, j, nj - 1);
if (i > j) c -= q(2, j, i - 1);
n[ni][nd] = max(n[ni][nd], dp[i][d] + c);
}
}
}
for (int i = (0); i < (1003); i++)
for (int d = (0); d < (103); d++) {
dp[i][d] = n[i][d];
ans = max(ans, dp[i][d]);
}
}
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m;
cin >> n >> m;
long long **a = new long long *[n];
long long *b = new long long[n];
long long *c = new long long[n];
for (long long i = 0; i < n; ++i) {
a[i] = new long long[m];
b[i] = 0;
c[i] = 0;
string s;
cin >> s;
for (long long j = 0; j < m; ++j) {
a[i][j] = (long long)s[j];
}
}
long long j = 0;
long long ans = 0;
while (true) {
bool removed = false;
for (long long i = 0; i < n - 1; ++i) {
c[i] = b[i];
}
if (j == m) {
break;
}
for (long long i = 0; i < n - 1; ++i) {
if (c[i] != 0) {
continue;
}
if (a[i][j] < a[i + 1][j]) {
c[i] = 1;
} else if (a[i][j] == a[i + 1][j]) {
c[i] = 0;
} else if (a[i][j] > a[i + 1][j]) {
removed = true;
++ans;
break;
}
}
if (!removed) {
for (long long i = 0; i < n - 1; ++i) {
b[i] = c[i];
}
}
++j;
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int tt;
cin >> tt;
while (tt--) {
int n;
cin >> n;
string x[n];
set<string> S;
for (int i = 0; i < n; ++i) {
cin >> x[i];
S.insert(x[i]);
}
set<string> s;
vector<string> v(n);
int c = 0;
for (int i = 0; i < n; ++i) {
if (s.find(x[i]) == s.end()) {
v[i] = x[i];
s.insert(x[i]);
} else {
c++;
int y = 1;
while (1) {
x[i][0] = char(int(x[i][0]) + 1);
if (x[i][0] > '9') x[i][0] = '0';
if (S.find(x[i]) == S.end()) {
v[i] = x[i];
S.insert(x[i]);
s.insert(x[i]);
break;
}
}
}
}
cout << c << endl;
for (auto i : v) cout << i << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
string s, t;
void reverse_prefix(int len) {
for (int i = 0; i < len; i++) {
if (i >= len - 1 - i) break;
swap(s[i], s[len - 1 - i]);
}
}
void solve() {
cin >> s >> t;
int n = s.size();
int zs = 0, os = 0, zt = 0, ot = 0;
for (int i = 0; i < n; i += 2) {
if (s[i] == s[i + 1]) {
if (s[i] == '1') {
os++;
} else {
zs++;
}
}
if (t[i] == t[i + 1]) {
if (t[i] == '1') {
ot++;
} else {
zt++;
}
}
}
if (zs != zt || os != ot) {
cout << "-1\n";
return;
}
vector<int> ops;
string ss = s;
int iter = 0;
do {
ops.clear();
s = ss;
for (int i = n - 2; i >= 0; i -= 2) {
if (s[i] == t[i] && s[i + 1] == t[i + 1]) continue;
vector<int> mas;
for (int j = 0; j <= i; j += 2) {
if (s[j] == t[i] && s[j + 1] == t[i + 1]) {
mas.push_back(j);
}
}
bool fl = false;
if (!mas.size()) {
fl = true;
for (int j = 0; j <= i; j += 2) {
if (s[j] != t[i] && s[j + 1] != t[i + 1]) {
mas.push_back(j);
}
}
}
assert(mas.size());
int pos = mas[rand() % mas.size()];
ops.push_back(pos + 2);
reverse_prefix(pos + 2);
if (fl) {
ops.push_back(2);
reverse_prefix(2);
}
ops.push_back(i + 2);
reverse_prefix(i + 2);
assert(s[i] == t[i] && s[i + 1] == t[i + 1]);
}
} while (ops.size() > n + 1);
cout << ops.size() << "\n";
for (int first : ops) {
cout << first << " ";
}
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
srand(time(0));
int t;
cin >> t;
for (int i = 0; i < t; i++) {
solve();
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-13;
const long double PI = acos(-1);
const int INF = (int)1e9;
const long long INFF = (long long)1e18;
const int mod = (int)1e9 + 7;
const int MXN = (int)1e5 + 7;
bitset<MXN> gg;
mt19937 rng(0x5EED);
int randint(int lb, int ub) {
return uniform_int_distribution<int>(lb, ub)(rng);
}
int main(void) {
int n, k;
scanf("%d %d", &n, &k);
int dep = 1;
int cur = 1, sum = 1;
while (sum != n) {
cur *= k;
sum += cur;
dep++;
}
int cnt = 60;
char com[5];
vector<int> buf;
while (cnt--) {
int a = randint(1, n);
int b = randint(1, n);
while (a == b) b = randint(1, n);
int num = 0;
buf.clear();
for (int i = 1; i < n + 1; ++i) {
printf("? %d %d %d\n", a, i, b);
fflush(stdout);
scanf("%s", com);
if (com[0] == 'Y') buf.push_back(i);
}
if ((int)(buf).size() == 2 * dep - 1) {
for (int x : buf) {
if (x == a || x == b) continue;
int num2 = 0;
for (int i = 1; i < n + 1; ++i) {
printf("? %d %d %d\n", a, i, x);
fflush(stdout);
scanf("%s", com);
if (com[0] == 'Y') num2++;
}
if (num2 == dep) {
printf("! %d\n", x);
return 0;
}
}
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
long long s[N];
void init() {
for (int i = 1; i < N; i++) s[i] = (long long)i * i * i;
}
int get(long long x) { return upper_bound(s + 1, s + N, x) - s - 1; }
pair<long long, long long> ans;
void solve(long long now, long long num, long long v) {
if (!now) {
ans = max(ans, make_pair(num, v));
return;
}
int tmp = get(now);
solve(now - s[tmp], num + 1, v + s[tmp]);
solve(s[tmp] - 1 - s[tmp - 1], num + 1, v + s[tmp - 1]);
}
int main() {
init();
long long n;
scanf("%lld", &n);
solve(n, 0, 0);
printf("%lld %lld\n", ans.first, ans.second);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int T;
cin >> T;
while (T--) {
int N;
cin >> N;
int A[N];
for (int i = 0; i < N; i++) cin >> A[i];
sort(A, A + N, greater<int>());
for (int i = 0; i < N; i++) cout << A[i] << " ";
cout << "\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3005;
const int inf = 1e9;
int n, m, k;
vector<int> g[maxn];
vector<int> st[3005][3005];
int d[3005][3005];
int pre[3005][3005];
struct qnode {
int u, v;
};
void dfs(int u) {
vector<int> path;
printf("%d\n", d[u][n]);
printf("1 ");
int t1 = n, t2;
while (t1 != 1) {
path.push_back(t1);
t2 = u;
u = pre[u][t1];
t1 = t2;
}
reverse(path.begin(), path.end());
for (int v : path) printf("%d ", v);
}
int judge(int a, int b, int c) {
for (int v : st[a][b])
if (v == c) return 0;
return 1;
}
void bfs(int s) {
queue<qnode> q;
q.push({0, s});
while (!q.empty()) {
qnode tt = q.front();
q.pop();
int u = tt.v;
if (u == n) {
dfs(tt.u);
exit(0);
}
for (int v : g[u]) {
if (d[u][v] == 0 && judge(tt.u, u, v)) {
d[u][v] = d[tt.u][u] + 1;
pre[u][v] = tt.u;
q.push({u, v});
}
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
g[x].push_back(y);
g[y].push_back(x);
}
for (int i = 1; i <= k; i++) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
st[a][b].push_back(c);
}
bfs(1);
printf("-1\n");
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const double EPS = 1e-8;
const double PI = 2 * acos(0);
const int MAXN = 2006;
struct Node {
int x, y;
bool operator<(Node b) const {
if (x != b.x) return x < b.x;
return y < b.y;
}
};
struct Math {
int n;
int MOD;
int SMALL_N;
long long *r;
long long *fac, *ifac;
long long **A, **C;
long long *twop, *iv_twop;
Math() {
n = -1;
MOD = 1;
SMALL_N = 3030;
}
void prepare(int n_, int MOD_) {
n = n_;
MOD = MOD_;
r = new long long[n + 1];
r[1] = 1;
for (int i = 2; i <= n; ++i)
r[i] = (MOD - (MOD / i) * r[MOD % i] % MOD) % MOD;
fac = new long long[n + 1];
fac[0] = 1;
for (int i = 1; i <= n; ++i) fac[i] = fac[i - 1] * i % MOD;
ifac = new long long[n + 1];
ifac[0] = ifac[1] = 1;
for (int i = 2; i <= n; ++i) ifac[i] = ifac[i - 1] * r[i] % MOD;
twop = new long long[n + 1];
iv_twop = new long long[n + 1];
twop[0] = iv_twop[0] = 1;
twop[1] = 2;
iv_twop[1] = (MOD + 1) / 2;
for (int i = 2; i <= n; ++i) {
twop[i] = twop[i - 1] * 2 % MOD;
iv_twop[i] = iv_twop[i - 1] * iv_twop[1] % MOD;
}
if (n <= SMALL_N) {
A = new long long *[n + 1];
for (int i = 0; i <= n; ++i) A[i] = new long long[n + 1];
memset(A, 0, sizeof(A));
for (int i = 0; i <= n; ++i) A[i][0] = 1;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= i; ++j) A[i][j] = A[i][j - 1] * (i - j + 1) % MOD;
}
if (n <= SMALL_N) {
C = new long long *[n + 1];
for (int i = 0; i <= n; ++i) C[i] = new long long[n + 1];
memset(C, 0, sizeof(C));
for (int i = 0; i <= n; ++i) C[i][0] = C[i][i] = 1;
for (int i = 1; i <= n; ++i)
for (int j = 1; j < i; ++j)
C[i][j] = (C[i][j - 1] + C[i - 1][j - 1]) % MOD;
}
}
long long getA(int n_, int k_) {
if (k_ < 0 || n_ < 0) return 0;
if (n_ <= n && n <= SMALL_N) return A[n_][k_];
return fac[n_] * ifac[n_ - k_] % MOD;
}
long long getC(int n_, int k_) {
if (k_ < 0 || n_ < 0) return 0;
if (n_ <= n && n <= SMALL_N) return C[n_][k_];
return fac[n_] * ifac[n_ - k_] % MOD * ifac[k_] % MOD;
}
};
int n, m, k;
Node node[MAXN];
long long dp[MAXN];
Math toan;
bool input() {
int u, v, x, y;
cin >> n >> m >> k;
for (int i = 1; i <= k; ++i) cin >> node[i].x >> node[i].y;
return !cin.fail();
}
void clear_input() { k = 0; }
void preprocess() {
sort(node + 1, node + k + 1);
toan.prepare(200005, MOD);
}
void process(int itest) {
int u, v, x, y;
node[k + 1].x = n, node[k + 1].y = m;
for (int i = 1; i <= k + 1; ++i) {
x = node[i].x;
y = node[i].y;
dp[i] = toan.getC(x + y - 2, x - 1);
for (int j = 1; j < i; ++j)
if (node[j].x <= x && node[j].y <= y)
dp[i] = ((dp[i] - dp[j] * toan.getC(x - node[j].x + y - node[j].y,
x - node[j].x)) %
MOD +
MOD) %
MOD;
}
cout << dp[k + 1] << endl;
}
void oneTest() {
while (input()) {
preprocess();
process(0);
clear_input();
}
}
void multiTest() {
int t;
cin >> t;
for (int it = 1; it <= t; ++it) {
input();
preprocess();
process(it);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
oneTest();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, c;
long long origA, origB, origC;
scanf("%lld%lld%lld", &a, &b, &c);
origA = a;
origB = b;
origC = c;
long long ans = 9000000000000000000ll;
for (int day1 = 0; day1 < 4; day1++) {
for (int day2 = 0; day2 < 4; day2++) {
a = origA;
b = origB;
c = origC;
if (day1 > 0) a++;
if (day1 > 1) b++;
if (day1 > 2) c++;
if (day2 < 3) c++;
if (day2 < 2) b++;
if (day2 < 1) a++;
long long fullDays = max(a, max(b, c));
ans = min(ans, 3ll * fullDays - (a + b + c));
}
}
printf("%lld\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
int extgcd(int a, int b, long long& x, long long& y) {
int d = a;
if (b == 0) {
x = 1;
y = 0;
} else {
d = extgcd(b, a % b, y, x);
y -= a / b * x;
}
return d;
}
int main() {
int A, B, C, d;
long long x, y;
scanf("%d %d %d", &A, &B, &C);
d = extgcd(A, B, x, y);
x *= (-C / d);
y *= (-C / d);
if (C % d)
printf("-1\n");
else
printf("%I64d %I64d\n", x, y);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 4e5 + 5;
long long n, m, q, cur = 1;
long long head[maxn], nex[maxn], to[maxn];
void add(long long u, long long v) {
nex[++cur] = head[u];
to[cur] = v;
head[u] = cur;
return;
}
long long dfn[maxn], low[maxn], dfsc;
long long st[maxn], top;
long long col[maxn], cols;
void Tarjan(long long now, long long nd) {
dfn[now] = low[now] = ++dfsc;
st[++top] = now;
for (int i = head[now]; i; i = nex[i]) {
long long t = to[i];
if (i == nd || t == 0) continue;
if (!dfn[t]) {
Tarjan(t, i ^ 1);
low[now] = min(low[now], low[t]);
if (low[t] > dfn[now]) {
cols++;
while (st[top] != t) {
col[st[top--]] = cols;
}
col[st[top--]] = cols;
}
} else {
low[now] = min(low[now], dfn[t]);
}
}
return;
}
long long ux[maxn], vx[maxn];
long long fa[maxn];
void init() {
for (int i = 1; i <= n; i++) fa[i] = i;
return;
}
long long find(long long x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
void merge(long long x, long long y) {
fa[find(x)] = find(y);
return;
}
void rebuild() {
for (int i = 1; i <= n; i++) {
if (!dfn[i]) {
Tarjan(i, -1);
cols++;
while (top > 0) {
col[st[top--]] = cols;
}
}
}
memset(head, 0, sizeof(head));
memset(nex, 0, sizeof(nex));
cur = 0;
init();
for (int i = 1; i <= m; i++) {
if (col[ux[i]] != col[vx[i]]) {
add(col[ux[i]], col[vx[i]]);
add(col[vx[i]], col[ux[i]]);
merge(col[ux[i]], col[vx[i]]);
}
}
return;
}
long long sz[maxn], dep[maxn];
long long anc[maxn][21];
long long dfn2[maxn], cntt;
void dfs(long long now, long long fa) {
dfn2[now] = ++cntt;
sz[now] = 1;
anc[now][0] = fa;
for (int i = 1; (1 << i) <= dep[now]; i++) {
anc[now][i] = anc[anc[now][i - 1]][i - 1];
}
for (int i = head[now]; i; i = nex[i]) {
long long t = to[i];
if (t == fa) continue;
dep[t] = dep[now] + 1;
dfs(t, now);
sz[now] += sz[t];
}
return;
}
long long lca(long long u, long long v) {
if (dep[u] < dep[v]) swap(u, v);
long long cnt = dep[u] - dep[v];
for (int i = 20; i >= 0; i--) {
if ((cnt >> i) & 1) u = anc[u][i];
}
if (u == v) return u;
for (int i = 20; i >= 0; i--) {
if (anc[u][i] != anc[v][i]) {
u = anc[u][i], v = anc[v][i];
}
}
return anc[u][0];
}
long long bt1[maxn], bt2[maxn];
inline long long llow(long long x) { return x & (-x); }
void upd(long long* arr, long long pos, long long x) {
for (int i = pos; i <= cols; i += llow(i)) {
arr[i] += x;
}
return;
}
long long que(long long* arr, long long pos) {
long long res = 0;
for (int i = pos; i; i -= llow(i)) {
res += arr[i];
}
return res;
}
int main() {
scanf("%lld %lld %lld", &n, &m, &q);
for (int i = 1; i <= m; i++) {
scanf("%lld %lld", &ux[i], &vx[i]);
add(ux[i], vx[i]);
add(vx[i], ux[i]);
}
rebuild();
for (int i = 1; i <= n; i++) {
if (!dfn2[i]) dfs(i, 0);
}
for (int i = 1; i <= q; i++) {
long long s, t;
scanf("%lld %lld", &s, &t);
s = col[s], t = col[t];
if (s == t) continue;
if (find(s) != find(t)) {
puts("No");
return 0;
}
long long lc = lca(s, t);
long long sum1 = que(bt1, dfn2[t]) - que(bt1, dfn2[lc]);
if (sum1 > 0) {
puts("No");
return 0;
}
sum1 = que(bt2, dfn2[s]) - que(bt2, dfn2[lc]);
if (sum1 > 0) {
puts("No");
return 0;
}
if (s != lc) upd(bt1, dfn2[s], 1), upd(bt1, dfn2[s] + sz[s], -1);
if (t != lc) upd(bt2, dfn2[t], 1), upd(bt2, dfn2[t] + sz[t], -1);
}
cout << "Yes" << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:36777216")
template <class T>
inline T &RD(T &);
template <class T>
inline void OT(const T &);
inline long long RD() {
long long x;
return RD(x);
}
inline double &RF(double &);
inline double RF() {
double x;
return RF(x);
}
inline char *RS(char *s);
inline char &RC(char &c);
inline char RC();
inline char &RC(char &c) {
scanf(" %c", &c);
return c;
}
inline char RC() {
char c;
return RC(c);
}
template <class T>
inline T &RDD(T &x) {
char c;
for (c = getchar(); c < '-'; c = getchar())
;
if (c == '-') {
x = '0' - getchar();
for (c = getchar(); '0' <= c && c <= '9'; c = getchar())
x = x * 10 + '0' - c;
} else {
x = c - '0';
for (c = getchar(); '0' <= c && c <= '9'; c = getchar())
x = x * 10 + c - '0';
}
return x;
}
inline long long RDD() {
long long x;
return RDD(x);
}
template <class T0, class T1>
inline T0 &RD(T0 &x0, T1 &x1) {
RD(x0), RD(x1);
return x0;
}
template <class T0, class T1, class T2>
inline T0 &RD(T0 &x0, T1 &x1, T2 &x2) {
RD(x0), RD(x1), RD(x2);
return x0;
}
template <class T0, class T1, class T2, class T3>
inline T0 &RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3) {
RD(x0), RD(x1), RD(x2), RD(x3);
return x0;
}
template <class T0, class T1, class T2, class T3, class T4>
inline T0 &RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4) {
RD(x0), RD(x1), RD(x2), RD(x3), RD(x4);
return x0;
}
template <class T0, class T1, class T2, class T3, class T4, class T5>
inline T0 &RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5) {
RD(x0), RD(x1), RD(x2), RD(x3), RD(x4), RD(x5);
return x0;
}
template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
inline T0 &RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5, T6 &x6) {
RD(x0), RD(x1), RD(x2), RD(x3), RD(x4), RD(x5), RD(x6);
return x0;
}
template <class T0, class T1>
inline void OT(const T0 &x0, const T1 &x1) {
OT(x0), OT(x1);
}
template <class T0, class T1, class T2>
inline void OT(const T0 &x0, const T1 &x1, const T2 &x2) {
OT(x0), OT(x1), OT(x2);
}
template <class T0, class T1, class T2, class T3>
inline void OT(const T0 &x0, const T1 &x1, const T2 &x2, const T3 &x3) {
OT(x0), OT(x1), OT(x2), OT(x3);
}
template <class T0, class T1, class T2, class T3, class T4>
inline void OT(const T0 &x0, const T1 &x1, const T2 &x2, const T3 &x3,
const T4 &x4) {
OT(x0), OT(x1), OT(x2), OT(x3), OT(x4);
}
template <class T0, class T1, class T2, class T3, class T4, class T5>
inline void OT(const T0 &x0, const T1 &x1, const T2 &x2, const T3 &x3,
const T4 &x4, const T5 &x5) {
OT(x0), OT(x1), OT(x2), OT(x3), OT(x4), OT(x5);
}
template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
inline void OT(const T0 &x0, const T1 &x1, const T2 &x2, const T3 &x3,
const T4 &x4, const T5 &x5, const T6 &x6) {
OT(x0), OT(x1), OT(x2), OT(x3), OT(x4), OT(x5), OT(x6);
}
inline char &RC(char &a, char &b) {
RC(a), RC(b);
return a;
}
inline char &RC(char &a, char &b, char &c) {
RC(a), RC(b), RC(c);
return a;
}
inline char &RC(char &a, char &b, char &c, char &d) {
RC(a), RC(b), RC(c), RC(d);
return a;
}
inline char &RC(char &a, char &b, char &c, char &d, char &e) {
RC(a), RC(b), RC(c), RC(d), RC(e);
return a;
}
inline char &RC(char &a, char &b, char &c, char &d, char &e, char &f) {
RC(a), RC(b), RC(c), RC(d), RC(e), RC(f);
return a;
}
inline char &RC(char &a, char &b, char &c, char &d, char &e, char &f, char &g) {
RC(a), RC(b), RC(c), RC(d), RC(e), RC(f), RC(g);
return a;
}
inline double &RF(double &a, double &b) {
RF(a), RF(b);
return a;
}
inline double &RF(double &a, double &b, double &c) {
RF(a), RF(b), RF(c);
return a;
}
inline double &RF(double &a, double &b, double &c, double &d) {
RF(a), RF(b), RF(c), RF(d);
return a;
}
inline double &RF(double &a, double &b, double &c, double &d, double &e) {
RF(a), RF(b), RF(c), RF(d), RF(e);
return a;
}
inline double &RF(double &a, double &b, double &c, double &d, double &e,
double &f) {
RF(a), RF(b), RF(c), RF(d), RF(e), RF(f);
return a;
}
inline double &RF(double &a, double &b, double &c, double &d, double &e,
double &f, double &g) {
RF(a), RF(b), RF(c), RF(d), RF(e), RF(f), RF(g);
return a;
}
inline void RS(char *s1, char *s2) { RS(s1), RS(s2); }
inline void RS(char *s1, char *s2, char *s3) { RS(s1), RS(s2), RS(s3); }
template <class T0, class T1>
inline void RDD(const T0 &a, const T1 &b) {
RDD(a), RDD(b);
}
template <class T0, class T1, class T2>
inline void RDD(const T0 &a, const T1 &b, const T2 &c) {
RDD(a), RDD(b), RDD(c);
}
template <class T>
inline void RST(T &A) {
memset(A, 0, sizeof(A));
}
template <class T>
inline void FLC(T &A, int x) {
memset(A, x, sizeof(A));
}
template <class T>
inline void CLR(T &A) {
A.clear();
}
template <class T0, class T1>
inline void RST(T0 &A0, T1 &A1) {
RST(A0), RST(A1);
}
template <class T0, class T1, class T2>
inline void RST(T0 &A0, T1 &A1, T2 &A2) {
RST(A0), RST(A1), RST(A2);
}
template <class T0, class T1, class T2, class T3>
inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3) {
RST(A0), RST(A1), RST(A2), RST(A3);
}
template <class T0, class T1, class T2, class T3, class T4>
inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4) {
RST(A0), RST(A1), RST(A2), RST(A3), RST(A4);
}
template <class T0, class T1, class T2, class T3, class T4, class T5>
inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5) {
RST(A0), RST(A1), RST(A2), RST(A3), RST(A4), RST(A5);
}
template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6) {
RST(A0), RST(A1), RST(A2), RST(A3), RST(A4), RST(A5), RST(A6);
}
template <class T0, class T1>
inline void FLC(T0 &A0, T1 &A1, int x) {
FLC(A0, x), FLC(A1, x);
}
template <class T0, class T1, class T2>
inline void FLC(T0 &A0, T1 &A1, T2 &A2, int x) {
FLC(A0, x), FLC(A1, x), FLC(A2, x);
}
template <class T0, class T1, class T2, class T3>
inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, int x) {
FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x);
}
template <class T0, class T1, class T2, class T3, class T4>
inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, int x) {
FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x), FLC(A4, x);
}
template <class T0, class T1, class T2, class T3, class T4, class T5>
inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, int x) {
FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x), FLC(A4, x), FLC(A5, x);
}
template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6, int x) {
FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x), FLC(A4, x), FLC(A5, x),
FLC(A6, x);
}
template <class T>
inline void CLR(priority_queue<T, vector<T>, less<T> > &Q) {
while (!Q.empty()) Q.pop();
}
template <class T>
inline void CLR(priority_queue<T, vector<T>, greater<T> > &Q) {
while (!Q.empty()) Q.pop();
}
template <class T0, class T1>
inline void CLR(T0 &A0, T1 &A1) {
CLR(A0), CLR(A1);
}
template <class T0, class T1, class T2>
inline void CLR(T0 &A0, T1 &A1, T2 &A2) {
CLR(A0), CLR(A1), CLR(A2);
}
template <class T0, class T1, class T2, class T3>
inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3) {
CLR(A0), CLR(A1), CLR(A2), CLR(A3);
}
template <class T0, class T1, class T2, class T3, class T4>
inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4) {
CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4);
}
template <class T0, class T1, class T2, class T3, class T4, class T5>
inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5) {
CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4), CLR(A5);
}
template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6) {
CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4), CLR(A5), CLR(A6);
}
template <class T>
inline void CLR(T &A, int n) {
for (int i = 0; i < int(n); ++i) CLR(A[i]);
}
template <class T>
inline T &SRT(T &A) {
sort(A.begin(), A.end());
return A;
}
template <class T, class C>
inline T &SRT(T &A, C B) {
sort(A.begin(), A.end(), B);
return A;
}
template <class T>
inline T &UNQ(T &A) {
A.resize(unique(SRT(A).begin(), SRT(A).end()) - A.begin());
return A;
}
int MOD = 99990001;
const int INF = 0x3f3f3f3f;
const long long INFF = 1LL << 60;
const double EPS = 1e-9;
const double OO = 1e20;
const double PI = acos(-1.0);
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};
template <class T>
inline void checkMin(T &a, const T b) {
if (b < a) a = b;
}
template <class T>
inline void checkMax(T &a, const T b) {
if (a < b) a = b;
}
template <class T>
inline void checkMin(T &a, T &b, const T x) {
checkMin(a, x), checkMin(b, x);
}
template <class T>
inline void checkMax(T &a, T &b, const T x) {
checkMax(a, x), checkMax(b, x);
}
template <class T, class C>
inline void checkMin(T &a, const T b, C c) {
if (c(b, a)) a = b;
}
template <class T, class C>
inline void checkMax(T &a, const T b, C c) {
if (c(a, b)) a = b;
}
template <class T>
inline T min(T a, T b, T c) {
return min(min(a, b), c);
}
template <class T>
inline T max(T a, T b, T c) {
return max(max(a, b), c);
}
template <class T>
inline T min(T a, T b, T c, T d) {
return min(min(a, b), min(c, d));
}
template <class T>
inline T max(T a, T b, T c, T d) {
return max(max(a, b), max(c, d));
}
template <class T>
inline T sqr(T a) {
return a * a;
}
template <class T>
inline T cub(T a) {
return a * a * a;
}
inline int ceil(int x, int y) { return (x - 1) / y + 1; }
inline int sgn(double x) { return x < -EPS ? -1 : x > EPS; }
inline int sgn(double x, double y) { return sgn(x - y); }
namespace BO {
inline bool _1(int x, int i) { return bool(x & 1 << i); }
inline bool _1(long long x, int i) { return bool(x & 1LL << i); }
inline long long _1(int i) { return 1LL << i; }
inline long long _U(int i) { return _1(i) - 1; };
inline int reverse_bits(int x) {
x = ((x >> 1) & 0x55555555) | ((x << 1) & 0xaaaaaaaa);
x = ((x >> 2) & 0x33333333) | ((x << 2) & 0xcccccccc);
x = ((x >> 4) & 0x0f0f0f0f) | ((x << 4) & 0xf0f0f0f0);
x = ((x >> 8) & 0x00ff00ff) | ((x << 8) & 0xff00ff00);
x = ((x >> 16) & 0x0000ffff) | ((x << 16) & 0xffff0000);
return x;
}
inline long long reverse_bits(long long x) {
x = ((x >> 1) & 0x5555555555555555LL) | ((x << 1) & 0xaaaaaaaaaaaaaaaaLL);
x = ((x >> 2) & 0x3333333333333333LL) | ((x << 2) & 0xccccccccccccccccLL);
x = ((x >> 4) & 0x0f0f0f0f0f0f0f0fLL) | ((x << 4) & 0xf0f0f0f0f0f0f0f0LL);
x = ((x >> 8) & 0x00ff00ff00ff00ffLL) | ((x << 8) & 0xff00ff00ff00ff00LL);
x = ((x >> 16) & 0x0000ffff0000ffffLL) | ((x << 16) & 0xffff0000ffff0000LL);
x = ((x >> 32) & 0x00000000ffffffffLL) | ((x << 32) & 0xffffffff00000000LL);
return x;
}
template <class T>
inline bool odd(T x) {
return x & 1;
}
template <class T>
inline bool even(T x) {
return !odd(x);
}
template <class T>
inline T low_bit(T x) {
return x & -x;
}
template <class T>
inline T high_bit(T x) {
T p = low_bit(x);
while (p != x) x -= p, p = low_bit(x);
return p;
}
template <class T>
inline T cover_bit(T x) {
T p = 1;
while (p < x) p <<= 1;
return p;
}
inline int low_idx(int x) { return __builtin_ffs(x); }
inline int low_idx(long long x) { return __builtin_ffsll(x); }
inline int high_idx(int x) { return low_idx(reverse_bits(x)); }
inline int high_idx(long long x) { return low_idx(reverse_bits(x)); }
inline int clz(int x) { return __builtin_clz(x); }
inline int clz(long long x) { return __builtin_clzll(x); }
inline int ctz(int x) { return __builtin_ctz(x); }
inline int ctz(long long x) { return __builtin_ctzll(x); }
inline int parity(int x) { return __builtin_parity(x); }
inline int parity(long long x) { return __builtin_parityll(x); }
inline int lg2(int a) { return 31 - clz(a); }
inline int lg2(long long a) { return 63 - clz(a); }
inline int count_bits(int x) { return __builtin_popcount(x); }
inline int count_bits(long long x) { return __builtin_popcountll(x); }
} // namespace BO
using namespace BO;
template <class T>
inline T &RD(T &x) {
char c;
for (c = getchar(); c < '0'; c = getchar())
;
x = c - '0';
for (c = getchar(); '0' <= c && c <= '9'; c = getchar()) x = x * 10 + c - '0';
return x;
}
inline double &RF(double &x) {
scanf("%lf", &x);
return x;
}
inline char *RS(char *s) {
scanf("%s", s);
return s;
}
int Case;
template <class T>
inline void OT(const T &x) {
cout << x << endl;
}
const int MAXN = int(4e5) + 9;
int rn, cn, vn;
int link[MAXN];
vector<vector<int> > eights, others;
bool vis[MAXN];
int diag1[MAXN], diag2[MAXN];
int rans[MAXN], cans[MAXN];
bool used[MAXN];
char tmp[MAXN * 2];
inline int vid(char s, int x) {
int b;
if (s == 'L')
b = 0;
else if (s == 'T')
b = rn;
else if (s == 'R')
b = rn + cn;
else if (s == 'B')
b = rn + rn + cn;
return b + x - 1;
}
inline char getstr(int v) {
if (v < rn)
return 'L';
else if (v < rn + cn)
return 'T';
else if (v < rn + rn + cn)
return 'R';
else
return 'B';
}
inline int getpos(int v) {
if (v < rn)
return v + 1;
else if (v < rn + cn)
return v - rn + 1;
else if (v < rn + rn + cn)
return v - rn - cn + 1;
else
return v - rn - rn - cn + 1;
}
inline int ctp(int v) {
if (v < rn + cn)
return v + rn + cn;
else
return v - rn - cn;
}
void dfs(int v, vector<int> &cyc) {
vis[v] = 1;
cyc.push_back(v);
int u = link[v];
int z = ctp(v);
if (!vis[u]) dfs(u, cyc);
if (!vis[z]) dfs(z, cyc);
}
void dump(const vector<int> &cyc, char *str) {
for (int i = 0; i < cyc.size(); i++) str[i] = getstr(cyc[i]);
str[cyc.size()] = '\0';
}
int is_eight(const vector<int> &cyc) {
if (cyc.size() != 8) return 0;
char rep[10];
dump(cyc, rep);
if (!strcmp(rep, "LTBLRBTR")) return 1;
if (!strcmp(rep, "LBTLRTBR")) return 2;
return 0;
}
void gao_eight() {
for (int e = 0; e < eights.size(); e++) {
const vector<int> &cyc = eights[e];
int type = is_eight(cyc);
if (type == 1) {
rans[e] = getpos(cyc[0]);
cans[e] = getpos(cyc[1]);
rans[rn - e - 1] = getpos(cyc[3]);
cans[cn - e - 1] = getpos(cyc[5]);
} else {
rans[rn - e - 1] = getpos(cyc[0]);
cans[e] = getpos(cyc[1]);
rans[e] = getpos(cyc[3]);
cans[cn - e - 1] = getpos(cyc[5]);
}
used[vid('L', e + 1)] = 1;
used[vid('L', rn - e)] = 1;
used[vid('R', e + 1)] = 1;
used[vid('R', rn - e)] = 1;
used[vid('T', e + 1)] = 1;
used[vid('T', cn - e)] = 1;
used[vid('B', e + 1)] = 1;
used[vid('B', cn - e)] = 1;
}
}
inline int gcd(int a, int b) {
while (b) {
int t = b;
b = a % b;
a = t;
}
return a;
}
void gen_diag() {
vector<int> a1, a2;
for (int i = rn - 1; i >= 0; i--)
if (!used[i]) a1.push_back(i);
for (int i = 0; i < cn; i++)
if (!used[rn + i]) a1.push_back(rn + i);
for (int i = 0; i < rn; i++)
if (!used[rn + cn + i]) a1.push_back(rn + cn + i);
for (int i = cn - 1; i >= 0; i--)
if (!used[rn + rn + cn + i]) a1.push_back(rn + rn + cn + i);
for (int i = 0; i < rn; i++)
if (!used[i]) a2.push_back(i);
for (int i = 0; i < cn; i++)
if (!used[rn + rn + cn + i]) a2.push_back(rn + rn + cn + i);
for (int i = rn - 1; i >= 0; i--)
if (!used[rn + cn + i]) a2.push_back(rn + cn + i);
for (int i = cn - 1; i >= 0; i--)
if (!used[rn + i]) a2.push_back(rn + i);
for (int i = 0; i < a1.size(); i++) diag1[a1[i]] = a1[a1.size() - i - 1];
for (int i = 0; i < a2.size(); i++) diag2[a2[i]] = a2[a2.size() - i - 1];
}
void dfs_diag(int v, int *diag, vector<int> &arr) {
vis[v] = 1;
arr.push_back(v);
int u = diag[v];
int z = ctp(v);
if (!vis[u]) dfs_diag(u, diag, arr);
if (!vis[z]) dfs_diag(z, diag, arr);
}
int lex_smallest_head(char s[], int n) {
for (int i = 0; i < n; i++) s[i + n] = s[i];
int i = 0, j = 1, k = 0;
while (j < n && k < n) {
if (s[i + k] == s[j + k])
k++;
else {
if (s[i + k] < s[j + k])
j += k + 1;
else
i += k + 1;
k = 0;
}
if (i == j) j++;
}
return i;
}
long long hashval(char *s, int len) {
const int pr = 3333331;
long long h = 0;
for (int i = 0; i < len; i++) {
int x;
if (s[i] == 'L')
x = 1;
else if (s[i] == 'T')
x = 2;
else if (s[i] == 'R')
x = 3;
else
x = 4;
h = h * pr + x;
}
return h;
}
long long hashval(const vector<int> &arr) {
char s[arr.size() + 1];
dump(arr, s);
return hashval(s, arr.size());
}
bool try_diag(int *diag) {
for (int i = 0; i < vn; i++) vis[i] = 0;
vector<pair<int, vector<int> > > diags;
for (int i = 0; i < vn; i++) {
vector<int> arr;
if (vis[i] || used[i]) continue;
dfs_diag(i, diag, arr);
int tl = arr.size();
dump(arr, tmp);
int si = lex_smallest_head(tmp, tl);
vector<int> aaa = arr;
for (int i = 0; i < tl; i++)
arr[i] = aaa[si + i < tl ? si + i : si + i - tl];
diags.push_back(make_pair(hashval(arr), arr));
}
vector<pair<int, vector<int> > > origs;
for (int o = 0; o < others.size(); o++) {
vector<int> &arr = others[o];
int tl = arr.size();
dump(arr, tmp);
int si = lex_smallest_head(tmp, tl);
vector<int> aaa = arr;
for (int i = 0; i < tl; i++)
arr[i] = aaa[si + i < tl ? si + i : si + i - tl];
origs.push_back(make_pair(hashval(arr), arr));
}
sort(diags.begin(), diags.end());
sort(origs.begin(), origs.end());
if (diags.size() != origs.size()) return 0;
for (int i = 0; i < diags.size(); i++) {
if (diags[i].first != origs[i].first) return 0;
if (diags[i].second.size() != origs[i].second.size()) return 0;
for (int j = 0; j < diags[i].second.size(); j++) {
int v1 = origs[i].second[j];
int v2 = diags[i].second[j];
if (getstr(v1) != getstr(v2)) return 0;
char c = getstr(v1);
if (c == 'L' || c == 'R')
rans[getpos(v2) - 1] = getpos(v1);
else
cans[getpos(v2) - 1] = getpos(v1);
}
}
return 1;
}
bool gao_other() {
gen_diag();
if (try_diag(diag1) || try_diag(diag2)) return 1;
return 0;
}
bool solve() {
vn = (rn + cn) * 2;
for (int i = 0; i < vn; i++) {
if (vis[i]) continue;
vector<int> cyc;
dfs(i, cyc);
if (is_eight(cyc))
eights.push_back(cyc);
else
others.push_back(cyc);
}
gao_eight();
if (!gao_other()) return 0;
for (int i = 0; i < rn; i++) printf("%d ", rans[i]);
puts("");
for (int i = 0; i < cn; i++) printf("%d ", cans[i]);
puts("");
return 1;
}
int main(void) {
RD(rn, cn);
for (int i = 0; i < rn + cn; i++) {
char s1, s2;
int x1, x2;
RC(s1, s2), RD(x1, x2);
x1 = vid(s1, x1), x2 = vid(s2, x2);
link[x1] = x2, link[x2] = x1;
}
if (!solve()) puts("No solution");
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100000 + 10;
const int INF = 0x3f3f3f3f;
int n, m, k;
int a[MAXN], b[MAXN];
int sum[MAXN], s[MAXN];
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= m; i++) cin >> b[i];
sort(a + 1, a + n + 1);
sort(b + 1, b + m + 1);
for (int i = 1; i <= m; i++)
if (b[i] >= a[1]) {
int pla = upper_bound(a + 1, a + n + 1, b[i]) - a - 1;
sum[pla]++;
}
int cnt = 0;
for (int i = n; i >= 1; i--) {
cnt += sum[i];
if (n - i + 1 > cnt) {
puts("YES");
return 0;
}
}
puts("NO");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int ri() {
int r;
cin >> r;
return r;
}
unsigned int rui() {
unsigned int r;
cin >> r;
return r;
}
long long rl() {
long long r;
cin >> r;
return r;
}
unsigned long long rul() {
unsigned long long r;
cin >> r;
return r;
}
double rd() {
double r;
cin >> r;
return r;
}
string rss() {
string r;
cin >> r;
return r;
}
string rs() {
string r;
getline(cin, r);
return r;
}
vector<string> rvs(int n) {
assert(n);
vector<string> r;
for (int i = 0; i < n; ++i) {
string s = rs();
while (s.empty()) s = rs();
r.push_back(s);
}
return r;
}
vector<int> rvi(int n) {
assert(n);
vector<int> r;
for (int i = 0; i < n; ++i) r.push_back(ri());
return r;
}
vector<unsigned int> rvui(int n) {
assert(n);
vector<unsigned int> r;
for (int i = 0; i < n; ++i) r.push_back(rui());
return r;
}
vector<long long> rvl(int n) {
assert(n);
vector<long long> r;
for (int i = 0; i < n; ++i) r.push_back(rl());
return r;
}
vector<unsigned long long> rvul(int n) {
assert(n);
vector<unsigned long long> r;
for (int i = 0; i < n; ++i) r.push_back(rul());
return r;
}
vector<double> rvd(int n) {
assert(n);
vector<double> r;
for (int i = 0; i < n; ++i) r.push_back(rd());
return r;
}
int main(int argc, const char* argv[]) {
int n = ri();
vector<int> v = rvi(n);
auto s = accumulate((v).begin(), (v).end(), 0);
int r = count_if((v).begin(), (v).end(), [&](int cur) {
return s % 2 == 1 && cur % 2 == 1 || s % 2 == 0 && cur % 2 == 0;
});
cout << r << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-12;
const int INF = 999999999;
int n;
vector<vector<int> > ans;
int f[26];
bool flag[256];
int res;
void Go(int t, vector<vector<int> >& a) {
if (t == int((ans).size())) return;
if (flag[n]) {
ans = vector<vector<int> >(a.begin(), a.begin() + t);
return;
}
for (int i = 0; i <= t; ++i) {
a[t][3] = i;
for (int d = 1; d <= 8; d <<= 1) {
int v = f[i] * d;
a[t][2] = d;
if (!(v > n || flag[v])) {
a[t][0] = 0;
f[t + 1] = v;
flag[v] = 1;
Go(t + 1, a);
flag[v] = 0;
}
a[t][0] = 1;
for (int j = 0; j <= t; ++j) {
int v2 = v + f[j];
if (v2 > n || flag[v2]) continue;
a[t][1] = j;
f[t + 1] = v2;
flag[v2] = 1;
Go(t + 1, a);
flag[v2] = 0;
}
}
}
}
void Solve() {
ans.clear();
if (n == 1) {
res = 0;
return;
}
memset(flag, 0, sizeof(flag));
f[0] = 1;
flag[1] = 1;
ans.resize(6);
vector<vector<int> > a(6, vector<int>(4));
Go(0, a);
}
void Output() {
printf("%d\n", int((ans).size()));
for (int i = 0; i < int((ans).size()); ++i) {
printf("lea e%cx, [", 'a' + i + 1);
if (ans[i][0] == 1) {
printf("e%cx + ", 'a' + ans[i][1]);
}
if (ans[i][2] > 1) {
printf("%d*", ans[i][2]);
}
printf("e%cx]\n", 'a' + ans[i][3]);
}
}
int main() {
scanf("%d", &n);
Solve();
Output();
return 0;
}
| 8 |
#include <bits/stdc++.h>
int main() {
int low = 0, high = (int)1e9 + 1;
int n;
std::cin >> n;
std::cout << 0 << " " << 0 << std::endl;
std::string s;
std::cin >> s;
std::string left = s;
for (int i = 1; i < n; ++i) {
int mid = (low + high) / 2;
std::cout << mid << " " << 0 << std::endl;
std::cin >> s;
if (s == left) {
low = mid;
} else {
high = mid;
}
}
int px = low + 2 > (int)1e9 ? low : low + 2;
std::cout << low + 1 << " 1 " << px << " 3 " << std::endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e6 + 1;
const int MOD = 1e9 + 7;
struct node {
int n4, n7, n47, n74;
};
bool tab[MAX], lazy[4 * MAX];
int n, q;
node seg[4 * MAX];
void build(int v = 1, int l = 0, int r = n - 1) {
if (l == r) {
seg[v].n7 = tab[l];
seg[v].n4 = !tab[l];
seg[v].n47 = seg[v].n74 = 1;
return;
}
int mid = (l + r) / 2;
build(2 * v, l, mid);
build(2 * v + 1, mid + 1, r);
seg[v].n7 = seg[2 * v].n7 + seg[2 * v + 1].n7;
seg[v].n4 = seg[2 * v].n4 + seg[2 * v + 1].n4;
seg[v].n47 = max(max(seg[2 * v].n4 + seg[2 * v + 1].n47,
seg[2 * v].n7 + seg[2 * v + 1].n7),
seg[2 * v].n47 + seg[2 * v + 1].n7);
seg[v].n74 = max(max(seg[2 * v].n74 + seg[2 * v + 1].n4,
seg[2 * v].n7 + seg[2 * v + 1].n7),
seg[2 * v].n7 + seg[2 * v + 1].n74);
}
void up(int v, int l, int r, int a, int b) {
if (lazy[v]) {
swap(seg[v].n4, seg[v].n7);
swap(seg[v].n47, seg[v].n74);
if (l != r) {
lazy[2 * v + 1] = !lazy[2 * v + 1];
lazy[2 * v] = !lazy[2 * v];
}
lazy[v] = 0;
}
if (l > b || r < a) return;
if (l >= a && r <= b) {
swap(seg[v].n4, seg[v].n7);
swap(seg[v].n47, seg[v].n74);
if (l != r) {
lazy[2 * v + 1] = !lazy[2 * v + 1];
lazy[2 * v] = !lazy[2 * v];
}
return;
}
int mid = (l + r) / 2;
up(2 * v, l, mid, a, b);
up(2 * v + 1, mid + 1, r, a, b);
seg[v].n7 = seg[2 * v].n7 + seg[2 * v + 1].n7;
seg[v].n4 = seg[2 * v].n4 + seg[2 * v + 1].n4;
seg[v].n47 = max(max(seg[2 * v].n4 + seg[2 * v + 1].n47,
seg[2 * v].n7 + seg[2 * v + 1].n7),
seg[2 * v].n47 + seg[2 * v + 1].n7);
seg[v].n74 = max(max(seg[2 * v].n74 + seg[2 * v + 1].n4,
seg[2 * v].n7 + seg[2 * v + 1].n7),
seg[2 * v].n7 + seg[2 * v + 1].n74);
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
cin >> n >> q;
for (int i = 0; i < n; ++i) {
char x;
cin >> x;
tab[i] = ((x - '0') & 1);
}
build();
while (q--) {
string s;
cin >> s;
if (s[0] == 'c')
cout << seg[1].n47 << "\n";
else {
int a, b;
cin >> a >> b;
up(1, 0, n - 1, a - 1, b - 1);
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<vector<int> > map;
int n;
cin >> n;
vector<int> v_sum(n, 0), h_sum(n, 0);
for (int i = 0; i < n; i++) {
vector<int> row(n);
for (int j = 0; j < n; j++) {
cin >> row[j];
v_sum[j] += row[j];
h_sum[i] += row[j];
}
map.push_back(row);
}
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (v_sum[j] > h_sum[i]) {
ans++;
}
}
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int ag[9][2], cg[9][2];
int main() {
std::ios::sync_with_stdio(false);
int n, m, k, s, t, t2, ans = 0;
cin >> n >> m >> k >> s;
memset(cg, 0x3f3f3f3f, sizeof(cg));
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
cin >> t;
ag[t - 1][0] = max(ag[t - 1][0], i + 1 + j + 1);
cg[t - 1][0] = min(cg[t - 1][0], i + 1 + j + 1);
ag[t - 1][1] = max(ag[t - 1][1], i - j);
cg[t - 1][1] = min(cg[t - 1][1], i - j);
}
cin >> t;
for (int i = 1; i < s; i++) {
cin >> t2;
ans = max(ans, ag[t - 1][0] - cg[t2 - 1][0]);
ans = max(ans, ag[t2 - 1][0] - cg[t - 1][0]);
ans = max(ans, ag[t - 1][1] - cg[t2 - 1][1]);
ans = max(ans, ag[t2 - 1][1] - cg[t - 1][1]);
t = t2;
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int MX = 10e6;
inline void solve() {
long long n;
cin >> n;
vector<long long> v(n);
for (long long i = 0; i < n; i++) {
cin >> v[i];
}
long long ans = -1;
if (v[0] * v[1] > ans) ans = v[0] * v[1];
for (long long i = 1; i < n - 1; i++) {
ans = max(ans, max(v[i] * v[i - 1], v[i] * v[i + 1]));
}
if (v[n - 1] * v[n - 2] > ans) ans = v[n - 1] * v[n - 2];
cout << ans << "\n";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
cin >> t;
while (t--) solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 100;
const int sq = 350;
const long long int mod = 95542721;
const long long int inf = 1e16;
bool mark[N];
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
string a;
cin >> a;
int n = a.size();
mark['A'] = mark['H'] = mark['I'] = mark['M'] = mark['O'] = mark['o'] =
mark['T'] = mark['U'] = true;
mark['V'] = mark['v'] = mark['W'] = mark['w'] = mark['X'] = mark['x'] =
mark['Y'] = true;
for (int i = 0; i < n; i++) {
if ((a[i] == a[n - i - 1] && mark[a[i]]) ||
(a[i] == 'p' && a[n - i - 1] == 'q') ||
(a[i] == 'b' && a[n - i - 1] == 'd'))
continue;
if ((a[i] == 'q' && a[n - i - 1] == 'p') ||
(a[i] == 'd' && a[n - i - 1] == 'b'))
continue;
cout << "NIE" << endl;
return 0;
}
cout << "TAK" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, count = 0;
string s;
cin >> n;
while (n--) {
cin >> s;
cin >> a >> b;
if (a >= 2400 && a <= 4000) {
if (b > 2400 && b <= 4000) {
if ((b - a) > 0) {
count++;
}
}
}
}
if (count > 0) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long choice(long long a, long long b) {
long long opt1 = min(a / 2, b);
a -= 2 * opt1;
b -= opt1;
long long opt2 = min(a, b / 2);
return opt1 + opt2;
}
void solve() {
long long a, b;
cin >> a >> b;
if ((a + b) / 3 <= min(a, b)) {
cout << (a + b) / 3 << endl;
return;
};
cout << min(a, b) << endl;
}
int main() {
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
int main() {
int n, m;
char s[105];
scanf("%d%d", &n, &m);
scanf("%s", s);
while (m--) {
int l, r;
char c1[2], c2[2];
scanf("%d%d%s%s", &l, &r, &c1, &c2);
for (int i = l - 1; i < r; i++) {
if (s[i] == c1[0]) s[i] = c2[0];
}
}
printf("%s", s);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)7 + (int)1e9;
const int N = 200005;
const double PI = 4 * atan(1);
const double eps = 1e-10;
const long long oo = 1e10;
const int K = 26;
int n, m;
vector<pair<pair<int, int>, long long> > e;
int id[N];
int getid(int u) { return (u == id[u] ? u : id[u] = getid(id[u])); }
bool uni(int u, int v) {
u = getid(u);
v = getid(v);
if (u == v) return 0;
id[u] = v;
return 1;
}
bool cmp(pair<pair<int, int>, long long> a, pair<pair<int, int>, long long> b) {
return a.second < b.second;
}
int u, v;
long long w;
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) {
id[i] = i;
}
for (int i = 0; i < m; i++) {
cin >> u >> v >> w;
u--;
v--;
e.push_back({{u, v}, w});
}
sort((e).begin(), (e).end(), cmp);
int ans = 0;
for (int i = 0; i < m; ++i) {
int j = i;
while (j < m && e[i].second == e[j].second) j++;
int cnt = j - i;
for (int k = i; k < j; k++) {
if (getid(e[k].first.first) == getid(e[k].first.second)) cnt--;
}
for (int k = i; k < j; k++) {
cnt -= uni(e[k].first.first, e[k].first.second);
}
ans += cnt;
i = j - 1;
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, i;
while (~scanf("%d%d%d", &a, &b, &c)) {
for (i = 0; i <= (a > 250 ? 250 : a); i++) {
if (i > a || 2 * i > b || 4 * i > c) break;
}
printf("%d\n", 7 * (i - 1));
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
const long long N = 300300;
const long long Q = 200200;
const long long mod = 998244353;
const long long MAGIC = sqrt(N);
using namespace std;
int n;
long long k;
long long a[N];
map<int, int> d[12];
void solve() {
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
long long x = a[i] % k;
for (int j = 1; j < 11; j++) {
x = x * 10 % k;
d[j][x]++;
}
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
long long g = 0, x = a[i];
while (x > 0) {
g++;
x /= 10;
}
x = a[i] % k;
if (d[g].find((k - x) % k) != d[g].end()) {
ans += d[g][(k - x) % k];
}
for (int j = 0; j < g; j++) {
x = x * 10 % k;
}
x = (x + a[i]) % k;
ans -= (x == 0);
}
cout << ans << "\n";
}
bool mtest = false;
int main() {
ios_base::sync_with_stdio(0);
int TE = 1;
if (mtest) cin >> TE;
while (TE--) solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, al, bl, ff, i;
int s[30000], a[30000], b[30000];
set<int> vis[30000];
void dfs() {
if (al == n) return;
if (al + bl == n) {
ff = 1;
return;
}
if (al < 2 || s[al + bl] - a[al - 1] == a[al - 1] - a[al - 2]) {
a[al] = s[al + bl];
if (al > 1) vis[al + bl].insert(a[al] - a[al - 1]);
al++;
dfs();
if (ff) return;
al--;
}
if (bl < 2 ||
s[al + bl] - b[bl - 1] == b[bl - 1] - b[bl - 2] &&
(vis[al + bl].find(b[bl - 1] - b[bl - 2]) == vis[al + bl].end())) {
b[bl] = s[al + bl];
bl++;
dfs();
if (ff) return;
bl--;
}
}
int main() {
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%d", &s[i]);
ff = al = bl = 0;
dfs();
if (ff) {
for (i = 0; i < al; i++) printf("%d ", a[i]);
printf("\n");
for (i = 0; i < bl; i++) printf("%d ", b[i]);
printf("\n");
} else
printf("No solution\n");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void cmax(int &a, int b) {
if (a < b) a = b;
}
void cmin(int &a, int b) {
if (a > b) a = b;
}
int re() {
char ch = getchar();
int f = 1, ret = 0;
while (ch < '0' || '9' < ch) {
if (ch == '-') f = -1;
ch = getchar();
}
while ('0' <= ch && ch <= '9') {
ret = ret * 10 + ch - '0';
ch = getchar();
}
return f * ret;
}
int a[110];
int b[110];
int main() {
int n = re(), m = re();
for (int i = 0; i < n; i++) a[i] = re();
int gay = 0, ou = 0;
int top = 0;
for (int i = 0; i < n - 1; i++) {
if (a[i] & 1)
gay++;
else
ou++;
if (gay == ou) b[top++] = abs(a[i + 1] - a[i]);
}
sort(b, b + top);
int ans = 0;
int i = 0;
while (b[i] <= m && i < top) {
m -= b[i++];
ans++;
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
double avg[2001][2001][2][2];
int next_right[2000];
int next_left[2000];
int pos[2000];
int n, h;
double p;
double getleft(int index, int fall_to_left) {
if (index == 0)
return h;
else if (!fall_to_left)
return min(pos[index] - pos[index - 1], h);
else
return min(max(0, pos[index] - pos[index - 1] - h), h);
}
double getright(int index, int fall_to_right) {
if (index == n - 1)
return h;
else if (!fall_to_right)
return min(pos[index + 1] - pos[index], h);
else
return min(max(0, pos[index + 1] - pos[index] - h), h);
}
double solve(int left, int right, int fall_to_left, int fall_to_right) {
if (avg[left][right][fall_to_left][fall_to_right] >= 0)
return avg[left][right][fall_to_left][fall_to_right];
if (right == left + 1)
return avg[left][right][fall_to_left][fall_to_right] =
p * getleft(left, fall_to_left) +
(1 - p) * getright(left, fall_to_right);
double result = 0;
result +=
0.5 * p *
(getleft(left, fall_to_left) + solve(left + 1, right, 0, fall_to_right));
result += 0.5 * (1 - p) *
(getright(right - 1, fall_to_right) +
solve(left, right - 1, fall_to_left, 0));
double temp;
int ileft = next_right[left];
if (ileft >= right)
temp = getright(right - 1, fall_to_right) + pos[right - 1] - pos[left];
else
temp =
pos[ileft - 1] + h - pos[left] + solve(ileft, right, 1, fall_to_right);
result += 0.5 * (1 - p) * temp;
int iright = next_left[right - 1];
if (iright < left)
temp = pos[right - 1] - (pos[left] - getleft(left, fall_to_left));
else
temp = pos[right - 1] - (pos[iright + 1] - h) +
solve(left, iright + 1, fall_to_left, 1);
result += 0.5 * p * temp;
avg[left][right][fall_to_left][fall_to_right] = result;
return result;
}
int main() {
cin.sync_with_stdio(false);
cout.sync_with_stdio(false);
cin >> n >> h >> p;
for (int i = 0; i < n; i++) cin >> pos[i];
sort(pos, pos + n);
for (int left = 0; left < n; left++)
for (int right = 1; right <= n; right++)
for (int fall_to_left = 0; fall_to_left < 2; fall_to_left++)
for (int fall_to_right = 0; fall_to_right < 2; fall_to_right++)
avg[left][right][fall_to_left][fall_to_right] = -1;
int i = 0;
int last = i;
while (i < n) {
i++;
while (i < n && pos[i] - pos[i - 1] < h) i++;
for (int j = last; j < i; j++) next_right[j] = i;
last = i;
}
i = n - 1;
last = i;
while (i >= 0) {
i--;
while (i >= 0 && pos[i + 1] - pos[i] < h) i--;
for (int j = last; j > i; j--) next_left[j] = i;
last = i;
}
cout << fixed << setprecision(10) << solve(0, n, 0, 0) << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
char S[5005];
char T[10][5005];
int X[10], Y[10];
int m, nS, cnt;
int main() {
while (scanf("%s", S) == 1) {
scanf("%d", &m);
for (int i = 0; i < (m); i++) scanf("%s%d%d", T[i], &X[i], &Y[i]);
nS = strlen(S);
vector<pair<int, unsigned int> > V((nS * (nS + 1)) / 2);
cnt = 0;
for (int i = 0; i < nS; ++i) {
unsigned int H = 0;
for (int j = i; j < nS; ++j) {
H = H * 27 + S[j] - 'a' + 1;
V[cnt++] = make_pair(j - i + 1, H);
}
}
sort(V.begin(), V.end());
int nV = unique(V.begin(), V.end()) - V.begin();
V.resize(nV);
vector<vector<pair<int, unsigned int> > > W(m);
for (int k = 0; k < (m); k++) {
unsigned int H = 0;
int t = strlen(T[k]);
cnt = 0;
W[k].resize((t * (t + 1)) / 2);
for (int i = 0; i < t; ++i) {
unsigned int H = 0;
for (int j = i; j < t; ++j)
H = H * 27 + T[k][j] - 'a' + 1, W[k][cnt++] = make_pair(j - i + 1, H);
}
sort(W[k].begin(), W[k].end());
}
int ans = 0;
for (int i = 0; i < (nV); i++) {
cnt = 0;
for (int j = 0; j < (m); j++) {
int temp = upper_bound(W[j].begin(), W[j].end(), V[i]) -
lower_bound(W[j].begin(), W[j].end(), V[i]);
cnt += (temp >= X[j] && temp <= Y[j]);
}
if (cnt == m) ans++;
}
printf("%d\n", ans);
}
}
| 7 |
#include <bits/stdc++.h>
using namespace ::std;
long long n;
long long C(long long a, long long b) {
if (a < b) return 0;
long long ans = 1LL;
if (a - b > b) b = a - b;
for (int i = 1; i <= a - b; i++) ans = ans * (b + i) / i;
return ans;
}
int main() {
cin >> n;
cout << 120LL * C(n, 5) * C(n, 5) << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
vector<vector<int>> pb(27);
vector<int> app(27, 0), vec(27, 0);
int main() {
cin.tie(0);
std::ios::sync_with_stdio(false);
int n, a;
char b;
string t, s = "", out = "";
cin >> n >> t;
while (n--) s += t;
for (int i = 0; i < s.size(); i++) {
pb[s[i] - 'a'].push_back(i);
}
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a >> b;
s[pb[b - 'a'][a - 1]] = '*';
pb[b - 'a'].erase(pb[b - 'a'].begin() + a - 1);
}
for (int i = 0; i < s.size(); i++)
if (s[i] != '*') cout << s[i];
cout << "\n";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> h(N);
for (int i = 0; i < h.size(); ++i) {
cin >> h[i];
}
vector<int> res(N);
int tallest = -1;
for (int i = h.size() - 1; i >= 0; --i) {
if (h[i] <= tallest) {
res[i] = tallest + 1 - h[i];
} else {
tallest = h[i];
}
}
bool first = true;
for (auto el : res) {
if (first)
first = false;
else
cout << " ";
cout << el;
}
cout << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, ans;
char a[1009];
scanf("%d", &n);
scanf("%s", a);
if (n == 1) {
if (a[0] == '0')
printf("No\n");
else
printf("Yes\n");
return 0;
}
if (a[0] == '0' && a[1] == '0') {
printf("No\n");
return 0;
}
if (a[n - 1] == '0' && a[n - 2] == '0') {
printf("No\n");
return 0;
}
bool flag = 1;
for (int i = 0; i < n - 1; i++)
if (a[i] == '1' && a[i + 1] == '1') flag = 0;
if (flag == 0) {
printf("No\n");
return 0;
}
for (int i = 0; i < n - 2; i++)
if (a[i] == '0' && a[i + 1] == '0' && a[i + 2] == '0') flag = 0;
if (flag == 0) {
printf("No\n");
return 0;
}
printf("Yes\n");
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double l, d, g, v, r, t;
cin >> l >> d >> v >> g >> r;
t = g + r;
int n;
n = d / (v * t);
t = t * n;
if (d / v < t + g)
printf("%.8lf", l / v);
else
printf("%.8lf", l / v + (t + g + r - d / v));
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void gmin(T &x, const T &y) {
if (x > y) x = y;
}
template <class T>
inline void gmax(T &x, const T &y) {
if (x < y) x = y;
}
const int BufferSize = 1 << 16;
char buffer[BufferSize], *Bufferhead, *Buffertail;
bool Terminal;
inline char Getchar() {
if (Bufferhead == Buffertail) {
int l = fread(buffer, 1, BufferSize, stdin);
if (!l) {
Terminal = 1;
return 0;
}
Buffertail = (Bufferhead = buffer) + l;
}
return *Bufferhead++;
}
template <class T>
inline bool read(T &x) {
x = 0;
char c = Getchar(), rev = 0;
while (c < '0' || c > '9') {
c = Getchar();
rev |= c == '-';
if (Terminal) return 0;
}
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = Getchar();
if (c == '.') {
c = Getchar();
double t = 0.1;
while (c >= '0' && c <= '9')
x = x + (c - '0') * t, c = Getchar(), t = t / 10;
}
x = rev ? -x : x;
return 1;
}
template <class T1, class T2>
inline bool read(T1 &x, T2 &y) {
return read(x) & read(y);
}
template <class T1, class T2, class T3>
inline bool read(T1 &x, T2 &y, T3 &z) {
return read(x) & read(y) & read(z);
}
template <class T1, class T2, class T3, class T4>
inline bool read(T1 &x, T2 &y, T3 &z, T4 &w) {
return read(x) & read(y) & read(z) & read(w);
}
inline bool reads(char *x) {
char c = Getchar();
while (c < 33 || c > 126) {
c = Getchar();
if (Terminal) return 0;
}
while (c >= 33 && c <= 126) (*x++) = c, c = Getchar();
*x = 0;
return 1;
}
template <class T>
inline void print(T x, const char c = '\n') {
if (!x) {
putchar('0');
putchar(c);
return;
}
if (x < 0) putchar('-'), x = -x;
int m = 0, a[20];
while (x) a[m++] = x % 10, x /= 10;
while (m--) putchar(a[m] + '0');
putchar(c);
}
const int inf = 0x3f3f3f3f;
const int N = 100005, M = 100005, mod = 1e9 + 7;
template <class T, class S>
inline void ch(T &x, const S y) {
x = (x + y) % mod;
}
inline int exp(int x, int y, const int mod = ::mod) {
int ans = 1;
while (y) {
if (y & 1) ans = (long long)ans * x % mod;
x = (long long)x * x % mod;
y >>= 1;
}
return ans;
}
long long dp[105][12][12], f[12][105];
inline long long solve(int x, int a, int b) {
if (!x) {
if (!b) return 1;
return 0;
}
if (~dp[x][a][b]) return dp[x][a][b];
dp[x][a][b] = 0;
if (a) dp[x][a][b] += solve(x - 1, a - 1, b + 1) * a;
if (b) dp[x][a][b] += solve(x - 1, a + 1, b - 1) * b;
return dp[x][a][b];
}
inline long long calc(int b, int x) { return solve(x - 1, b - 1, 1) * (b - 1); }
inline long long get(int b, long long n) {
if (!n) return 0;
int m = 0, a[105];
while (n) a[++m] = n % b, n /= b;
reverse(a + 1, a + m + 1);
long long ans = 0;
for (int i = 2; i < m; i += 2) ans += calc(b, i);
if (m % 2 == 0) {
int x = b, y = 0;
bool vis[12];
memset(vis, 0, sizeof(vis));
ans += (a[1] - 1) * solve(m - 1, b - 1, 1);
for (int i = 2; i <= m; i++) {
if (vis[a[i - 1]])
y--, x++;
else
x--, y++;
vis[a[i - 1]] ^= 1;
for (int j = 0; j < a[i]; j++)
if (vis[j])
ans += solve(m - i, x + 1, y - 1);
else
ans += solve(m - i, x - 1, y + 1);
}
if (vis[a[m]])
y--, x++;
else
x--, y++;
if (!y) ans++;
}
return ans;
}
int main() {
int Q;
read(Q);
memset(dp, -1, sizeof(dp));
memset(f, -1, sizeof(f));
while (Q--) {
int b;
long long l, r;
read(b, l, r);
print(get(b, r) - get(b, l - 1));
}
return 0;
}
| 7 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.