solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 210;
const double eps = 1e-9;
int n;
int lsh[maxn], ln, K;
map<int, int> mt;
int To[maxn];
int li[maxn], ri[maxn];
double f[2][maxn][maxn];
double ans[maxn][maxn];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d%d", &li[i], &ri[i]), lsh[++ln] = li[i], lsh[++ln] = ri[i];
sort(lsh + 1, lsh + ln + 1);
lsh[0] = lsh[1] - 1;
K = 0;
for (int i = 1; i <= ln; i++)
if (lsh[i] != lsh[i - 1]) To[mt[lsh[i]] = ++K] = lsh[i];
for (int i = 1; i <= n; i++) li[i] = mt[li[i]], ri[i] = mt[ri[i]];
for (int i = 1; i <= n; i++) {
for (int x = li[i]; x < ri[i]; x++) {
double inow = (double)(To[x + 1] - To[x]) / (To[ri[i]] - To[li[i]]);
for (int x1 = 0; x1 <= n; x1++)
for (int x2 = 0; x2 <= n; x2++) f[0][x1][x2] = f[1][x1][x2] = 0;
int now = 1;
f[now][0][0] = 1.0;
for (int j = 1; j <= n; j++) {
if (i == j) continue;
int L = To[li[j]], R = To[ri[j]];
now = !now;
if (x < li[j]) {
for (int x1 = 0; x1 < j; x1++)
for (int x2 = 0; x2 < j - x1; x2++)
if (f[!now][x1][x2] > eps) {
double tmp = f[!now][x1][x2];
f[!now][x1][x2] = 0;
f[now][x1][x2] += tmp;
}
} else if (ri[j] <= x) {
for (int x1 = 0; x1 < j; x1++)
for (int x2 = 0; x2 < j - x1; x2++)
if (f[!now][x1][x2] > eps) {
double tmp = f[!now][x1][x2];
f[!now][x1][x2] = 0;
f[now][x1 + 1][x2] += tmp;
}
} else {
double p1 = (double)(To[x] - L) / (R - L),
p2 = (double)(To[x + 1] - To[x]) / (R - L),
p3 = (double)(R - To[x + 1]) / (R - L);
for (int x1 = 0; x1 < j; x1++)
for (int x2 = 0; x2 < j - x1; x2++)
if (f[!now][x1][x2] > eps) {
double tmp = f[!now][x1][x2];
f[!now][x1][x2] = 0;
f[now][x1 + 1][x2] += tmp * p1;
f[now][x1][x2 + 1] += tmp * p2;
f[now][x1][x2] += tmp * p3;
}
}
}
for (int x1 = 0; x1 < n; x1++)
for (int x2 = 0; x2 < n - x1; x2++)
if (f[now][x1][x2] > eps) {
double tmp = f[now][x1][x2], temp = 1.0 / (x2 + 1.0);
for (int l = 0; l <= x2; l++)
ans[i][x1 + l + 1] += inow * tmp * temp;
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j < n; j++) printf("%.10lf ", ans[i][j]);
printf("%.10lf\n", ans[i][n]);
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
void rset();
void init_test();
void solve();
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed;
cout.precision(20);
init_test();
return 0;
}
template <typename T>
void chmin(T& a, T b) {
if (a > b) a = b;
}
template <typename T>
void chmax(T& a, T b) {
if (a < b) a = b;
}
template <typename T>
void MACRO_rdv2_Init(int n, T& t) {
t.resize(n);
}
template <typename First, typename... Rest>
void MACRO_rdv2_Init(int n, First& first, Rest&... rest) {
first.resize(n);
MACRO_rdv2_Init(n, rest...);
}
template <typename T>
void MACRO_rdv2_Scan(int p, T& t) {
std::cin >> t[p];
}
template <typename First, typename... Rest>
void MACRO_rdv2_Scan(int p, First& first, Rest&... rest) {
std::cin >> first[p];
MACRO_rdv2_Scan(p, rest...);
}
template <typename T>
void wrv(const vector<T>& v) {
for (int(__ii) = (0); (__ii) < (((int)v.size())); ++(__ii)) {
if (__ii) cout << ' ';
cout << v[__ii];
}
cout << '\n';
}
template <typename T>
void wrm(const vector<vector<T>>& v) {
for (int(__ii) = (0); (__ii) < (((int)v.size())); ++(__ii)) {
for (int(__jj) = (0); (__jj) < (v[__ii].size()); ++(__jj)) {
if (__jj) cout << ' ';
cout << v[__ii][__jj];
}
cout << '\n';
}
}
template <typename T>
void sc(T& x) {
cin >> x;
}
template <typename Head, typename... Tail>
void sc(Head& head, Tail&... tail) {
cin >> head;
sc(tail...);
}
template <typename T>
void wr(const T& x) {
cout << x << '\n';
}
template <typename Head, typename... Tail>
void wr(const Head& head, const Tail&... tail) {
cout << head << ' ';
wr(tail...);
}
template <typename T>
void wrf(const T& x) {
cout << x << endl;
}
template <typename Head, typename... Tail>
void wrf(const Head& head, const Tail&... tail) {
cout << head << ' ';
wrf(tail...);
}
template <typename T>
void debug_out(const T& x) {
cerr << x << '\n';
}
template <typename Head, typename... Tail>
void debug_out(const Head& head, const Tail&... tail) {
cerr << head << ' ';
debug_out(tail...);
}
template <typename... T>
void err(const T&... cod) {
wr(cod...);
exit(0);
}
void solve() {
long long n;
sc(n);
const int N = 1e6 + 10;
vector<int> lst(N, 0);
long double ans = 0;
for (int(i) = (1); (i) < (n + 1); ++(i)) {
long long x;
sc(x);
ans += ((i - lst[x]) * (n + 1 - i) * 2 - 1);
lst[x] = i;
}
wr(ans / n / n);
}
void init_test() {
int qq = 1;
while (qq--) solve();
}
| 5 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:64000000")
using namespace std;
template <typename first>
inline first abs(const first& a) {
return a < 0 ? -a : a;
}
template <typename first>
inline first sqr(const first& a) {
return a * a;
}
const long double PI = 3.1415926535897932384626433832795;
const long double EPS = 1e-9;
const int INF = 1000 * 1000 * 1000;
const int N = 1005 * 1000 + 13;
struct node {
int lf, rg, p, link;
map<char, int> next;
node(int lf = 0, int rg = 0, int p = -1, int link = -1)
: lf(lf), rg(rg), p(p), link(link) {}
int& operator[](char c) {
if (!next.count(c)) next[c] = -1;
return next[c];
}
};
int n;
char s[N];
node t[N];
int szt;
inline int leng(int v) { return t[v].rg - t[v].lf; }
int addVertex(int p, int lf, int rg) {
t[szt] = node(lf, rg, p, -1);
t[p][s[lf]] = szt;
return szt++;
}
int split(pair<int, int> ptr) {
int v = ptr.first, up = ptr.second, down = leng(v) - up;
if (up == 0) return v;
if (down == 0) return t[v].p;
int mid = addVertex(t[v].p, t[v].lf, t[v].lf + down);
t[v].lf += down, t[v].p = mid;
t[mid][s[t[v].lf]] = v;
return mid;
}
pair<int, int> down(int v, int lf, int rg) {
if (lf == rg) return make_pair((v), (0));
while (true) {
v = t[v][s[lf]];
if (leng(v) >= rg - lf) return make_pair((v), (leng(v) - (rg - lf)));
lf += leng(v);
}
throw;
}
int link(int v) {
if (t[v].link == -1)
return t[v].link =
split(down(link(t[v].p), t[v].lf + (t[v].p == 0), t[v].rg));
return t[v].link;
}
pair<int, int> go(pair<int, int> ptr, char c) {
int v = ptr.first, up = ptr.second;
if (up != 0)
return s[t[v].rg - up] == c ? make_pair((v), (up - 1))
: make_pair((-1), (-1));
v = t[v][c];
return v == -1 ? make_pair((-1), (-1)) : make_pair((v), (leng(v) - 1));
}
pair<int, int> addChar(pair<int, int> ptr, int pos) {
while (true) {
pair<int, int> nptr = go(ptr, s[pos]);
if (nptr.first != -1) return nptr;
int v = split(ptr);
addVertex(v, pos, n);
if (v == 0) return make_pair((0), (0));
ptr = make_pair((link(v)), (0));
}
throw;
}
void makeTree() {
szt = 0;
t[szt++] = node(0, 0, -1, 0);
pair<int, int> ptr = make_pair((0), (0));
for (int i = 0; i < int(n); i++) ptr = addChar(ptr, i);
}
char buf[N];
int cnt;
pair<int, int> bord[13];
pair<int, int> occ[13];
inline bool read() {
assert(scanf("%s", s) == 1);
n = strlen(s);
s[n++] = '0';
assert(scanf("%d", &cnt) == 1);
for (int i = 0; i < int(cnt); i++) {
assert(scanf("%s", buf) == 1);
assert(scanf("%d%d", &occ[i].first, &occ[i].second) == 2);
bord[i].first = n;
int len = strlen(buf);
for (int j = 0; j < int(len); j++) s[n++] = buf[j];
s[n++] = char('1' + i);
bord[i].second = n - 2;
}
return true;
}
int pos[N];
int minpos[N];
int nextdig[N];
int cntleafs[N];
inline string getString(int v) {
string curs = "";
while (v != 0) {
string now = "";
for (int j = t[v].lf; j < t[v].rg; j++) now.push_back(s[j]);
curs = now + curs;
v = t[v].p;
}
return curs;
}
int dfs1(int v, int dep) {
if (t[v].next.empty()) {
cntleafs[v] = 1;
minpos[v] = pos[v] = n - dep;
return minpos[v];
}
minpos[v] = INF;
for (map<char, int>::iterator it = t[v].next.begin(); it != t[v].next.end();
it++) {
int t = dfs1(it->second, dep + leng(it->second));
cntleafs[v] += cntleafs[it->second];
minpos[v] = min(minpos[v], t);
}
return minpos[v];
}
inline int myRand() { return rand() ^ (rand() << 16); }
struct dnode {
int val;
int cnt, prior;
dnode *lf, *rg;
dnode(int val) : val(val) { cnt = 1, prior = myRand(), lf = rg = NULL; }
};
typedef dnode* tree;
inline int dcnt(const tree& t) { return t ? t->cnt : 0; }
inline void lift(tree& t) {
if (!t) return;
t->cnt = dcnt(t->lf) + 1 + dcnt(t->rg);
}
void split(tree t, int val, tree& t1, tree& t2) {
if (!t) return void(t1 = t2 = NULL);
lift(t);
if (t->val < val) {
t1 = t;
split(t1->rg, val, t1->rg, t2);
} else {
t2 = t;
split(t2->lf, val, t1, t2->lf);
}
lift(t1);
lift(t2);
}
tree merge(tree t1, tree t2) {
if (!t1) return t2;
if (!t2) return t1;
if (t1->prior > t2->prior) {
t1->rg = merge(t1->rg, t2);
lift(t1);
return t1;
}
t2->lf = merge(t1, t2->lf);
lift(t2);
return t2;
}
tree ins(tree root, tree t) {
if (!root) return t;
if (t->prior > root->prior) {
split(root, t->val, t->lf, t->rg);
lift(t);
return t;
}
if (root->val < t->val)
root->rg = ins(root->rg, t);
else
root->lf = ins(root->lf, t);
lift(root);
return root;
}
void insert(tree& root, tree t) { root = ins(root, t); }
void goInsert(tree root, tree& t) {
if (!root) return;
goInsert(root->lf, t);
goInsert(root->rg, t);
root->lf = root->rg = NULL;
root->cnt = 1;
insert(t, root);
}
tree tt[N];
long long ans;
inline bool checkOcc(tree t) {
for (int i = 0; i < int(cnt); i++) {
tree t1, t2;
split(t, bord[i].first, t1, t2);
tree t3, t4;
split(t2, bord[i].second + 1, t3, t4);
int cntocc = dcnt(t3);
t = merge(t1, merge(t3, t4));
if (cntocc < occ[i].first || cntocc > occ[i].second) return false;
}
return true;
}
void print(tree t) {
if (!t) return;
print(t->lf);
cerr << t->val << ' ';
print(t->rg);
}
tree dfs2(int v) {
if (t[v].next.empty()) tt[v] = new dnode(pos[v]);
int bestto = -1;
for (map<char, int>::iterator it = t[v].next.begin(); it != t[v].next.end();
it++)
if (bestto == -1 || cntleafs[it->second] > cntleafs[bestto])
bestto = it->second;
if (bestto != -1) tt[v] = dfs2(bestto);
for (map<char, int>::iterator it = t[v].next.begin(); it != t[v].next.end();
it++)
if (it->second != bestto) {
tree tmp = dfs2(it->second);
goInsert(tmp, tt[v]);
}
if (minpos[v] < nextdig[0] && checkOcc(tt[v])) {
int lf = t[v].lf, rg = min(t[v].rg, nextdig[lf]);
ans += rg - lf;
}
return tt[v];
}
inline void solve() {
for (int i = n - 1; i >= 0; i--)
if (isdigit(s[i]))
nextdig[i] = i;
else
nextdig[i] = nextdig[i + 1];
makeTree();
memset(pos, -1, sizeof(pos));
dfs1(0, 0);
dfs2(0);
cout << ans << endl;
}
int main() {
assert(read());
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long a[100007];
long long m[100007];
vector<long long> cnt;
int main() {
long long n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
m[a[i]]++;
}
sort(a, a + n);
bool oka = false;
for (int i = 0; i <= a[n - 1]; i++) {
if (m[i] % 2 == 1) {
oka = true;
break;
}
}
if (oka)
cout << "Conan" << endl;
else
cout << "Agasa" << endl;
}
| 2 |
#include <bits/stdc++.h>
const long double PI = 3.1415926535897932384626434;
using namespace std;
const long long MX = 100000;
const long long MOD = 1000000007;
long long fast_exp(long long base, long long exp, long long mod) {
long long res = 1;
while (exp > 0) {
if (exp % 2 == 1) res = (res * base) % mod;
base = (base * base) % mod;
exp /= 2;
}
return res;
}
map<long long, long long> F;
void upd(long long x, long long y) {
for (; x; x += x & -x) F[x] = max(F[x], y);
}
long long q(long long x) {
long long ans = 0;
for (; x; x -= x & -x) ans = max(F[x], ans);
return ans;
}
int main() {
int n;
cin >> n;
long long N = (long long)(1e12) + 10;
vector<pair<long long, long long> > v(n + 1);
for (int i = 1; i <= n; i++) cin >> v[i].first >> v[i].second;
long long res = 0;
for (int i = 1; i <= n; i++) {
long long tot = q(v[i].first * v[i].first * v[i].second - 1);
upd(v[i].first * v[i].first * v[i].second,
tot + v[i].first * v[i].first * v[i].second);
}
cout << setprecision(10) << fixed << acos(-1) * q(N) << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 100005;
int n, m, length, x, y, a[NMAX], b[NMAX], c[NMAX], d[NMAX];
int main() {
int i, j;
cin.sync_with_stdio(false);
cin >> n >> m >> x >> y;
for (i = 1; i <= n; i++) cin >> a[i];
for (i = 1; i <= m; i++) cin >> b[i];
j = 1;
for (i = 1; i <= n; i++) {
while (j < m && b[j] < (a[i] - x)) j++;
if (j <= m && b[j] >= (a[i] - x) && b[j] <= (a[i] + y)) {
length++;
c[length] = i;
d[length] = j;
j++;
}
}
cout << length << "\n";
for (i = 1; i <= length; i++) cout << c[i] << " " << d[i] << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
int n, a, b;
int h[2000];
scanf("%d %d %d", &n, &a, &b);
for (int i = 0; i < n; ++i) {
scanf("%d", &h[i]);
}
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
if (h[i] < h[j]) {
int temp = h[i];
h[i] = h[j];
h[j] = temp;
}
}
}
printf("%d\n", h[a - 1] == h[a] ? 0 : h[a - 1] - h[a]);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<pair<int, int>>> adjList;
bool vis[100002] = {0}, taken[100002] = {0};
void DFS(int node, int par, int edge) {
queue<int> q;
vis[node] = 1;
for (int i = 0; i < adjList[node].size(); i++) {
pair<int, int> ch = adjList[node][i];
if (!vis[ch.second]) {
DFS(ch.second, node, ch.first);
if (!taken[ch.first]) {
taken[ch.first] = 1;
q.push(ch.second);
}
} else if (!taken[ch.first] && ch.second != par) {
taken[ch.first] = 1;
q.push(ch.second);
}
}
if (q.size() & 1) {
taken[edge] = 1;
q.push(par);
}
while (!q.empty()) {
printf("%d %d ", q.front(), node);
q.pop();
printf("%d\n", q.front());
q.pop();
}
}
int main() {
int second, m, x, y;
scanf("%d %d", &second, &m);
if (m & 1) {
printf("No solution");
return 0;
}
adjList.resize(second + 1);
for (int i = 0; i < m; i++) {
scanf("%d %d", &x, &y);
adjList[x].push_back(make_pair(i, y));
adjList[y].push_back(make_pair(i, x));
}
DFS(x, -1, -1);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1000 + 5;
int main() {
string s;
cin >> s;
int h, m;
h = (s[0] - '0') * 10 + (s[1] - '0');
m = (s[3] - '0') * 10 + (s[4] - '0');
if (h >= 12) {
h -= 12;
}
double h_angle, m_angle;
m_angle = 1.0 * m * 360 / 60;
h_angle = 1.0 * h * 360 / 12;
h_angle = h_angle + 1.0 * m * 30 / 60;
printf("%.10f %.10f", h_angle, m_angle);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k, d;
cin >> k >> d;
if (d == 0) {
if (k == 1)
cout << 0 << endl;
else
cout << "No solution" << endl;
} else {
cout << d;
for (int i = 1; i < k; ++i) cout << 0;
cout << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int prig[103];
int kom[103];
int res[103];
int ans[103];
int coun;
int main() {
int i, j;
cin >> n >> m >> k;
for (i = 0; i < m; i++) cin >> prig[i];
for (i = 0; i < k; i++) cin >> kom[i];
for (i = 0; i < m; i++)
for (j = 0; j < k; j++)
if (kom[j] % prig[i] == 0) res[i]++;
int mini = 1000000000;
for (i = 0; i < m; i++) mini = min(mini, res[i]);
for (i = 0; i < m; i++)
if (res[i] == mini) ans[coun++] = i + 1;
cout << coun << endl;
cout << ans[0];
for (i = 1; i < coun; i++) cout << " " << ans[i];
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 5;
long long ans = 1e9, n;
set<long long> adj[N];
long long a[N];
map<long long, long long> dist;
map<long long, long long> parent;
void bfs(long long s) {
dist.clear();
parent.clear();
parent[s] = 0;
dist[s] = 1;
queue<long long> q;
q.push(s);
while (!q.empty()) {
long long u = q.front();
q.pop();
set<long long>::iterator it = adj[u].begin();
for (; it != adj[u].end(); it++) {
long long v = *(it);
if (dist[v] == 0) {
dist[v] = dist[u] + 1;
parent[v] = u;
q.push(v);
} else if (parent[u] != v)
ans = min(ans, dist[u] + dist[v] - 1);
}
}
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
vector<long long> setBit[100];
for (long long i = 0; i < 100; i++) setBit[i].clear();
for (long long i = 1; i <= n; i++) {
cin >> a[i];
}
for (long long i = 1; i <= n; i++) {
for (long long j = 0; j < 64; j++) {
long long x = (1LL << j);
if (a[i] & x) setBit[j].push_back(i);
}
}
for (long long i = 0; i < 64; i++) {
if (setBit[i].size() >= 3) return cout << 3, 0;
if (setBit[i].size() == 2) {
long long x = setBit[i][0];
long long y = setBit[i][1];
adj[x].insert(y);
adj[y].insert(x);
}
}
for (long long i = 1; i <= n; i++) bfs(i);
if (ans == 1e9)
cout << -1;
else
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int M = (1 << 10) + 5;
char mat[M][M];
int x[M][M], y[M][M];
int n;
bool connect(int p, int q, int r, int s, char d1, char d2) {
if (x[r][s] == -1) {
mat[p][q] = d1;
if (mat[r][s] == '\0') mat[r][s] = d2;
return 1;
} else
return 0;
}
void dfs(int p, int q, char d) {
if (mat[p][q] != '\0') return;
mat[p][q] = d;
if (x[p][q] == x[p + 1][q] && y[p][q] == y[p + 1][q]) dfs(p + 1, q, 'U');
if (x[p][q] == x[p - 1][q] && y[p][q] == y[p - 1][q]) dfs(p - 1, q, 'D');
if (x[p][q] == x[p][q + 1] && y[p][q] == y[p][q + 1]) dfs(p, q + 1, 'L');
if (x[p][q] == x[p][q - 1] && y[p][q] == y[p][q - 1]) dfs(p, q - 1, 'R');
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int i, j;
cin >> n;
for (i = 1; i <= n; ++i) {
for (j = 1; j <= n; ++j) cin >> x[i][j] >> y[i][j];
}
for (i = 1; i <= n; ++i) {
for (j = 1; j <= n; ++j) {
if (x[i][j] == -1) {
bool res = (mat[i][j] != '\0');
if (res == 0) res = connect(i, j, i + 1, j, 'D', 'U');
if (res == 0) res = connect(i, j, i, j + 1, 'R', 'L');
if (res == 0) res = connect(i, j, i - 1, j, 'U', 'D');
if (res == 0) res = connect(i, j, i, j - 1, 'L', 'R');
if (res == 0) {
cout << "INVALID"
<< "\n";
return 0;
}
} else if (x[i][j] == i && y[i][j] == j)
dfs(i, j, 'X');
}
}
for (i = 1; i <= n; ++i) {
for (j = 1; j <= n; ++j) {
if (mat[i][j] == '\0') {
cout << "INVALID"
<< "\n";
return 0;
}
}
}
cout << "VALID"
<< "\n";
for (i = 1; i <= n; ++i) {
for (j = 1; j <= n; ++j) {
cout << mat[i][j];
}
cout << "\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int maxBeauty = 0;
struct Line {
int start, end;
int maxTail;
};
Line* lines;
int nPoints, nLines;
int pointCounts[100001] = {0};
int pointIndexes[100001] = {0};
int endPoints[200000];
int compareInt(const void* a, const void* b) {
int int_a = *((int*)a);
int int_b = *((int*)b);
return int_a - int_b;
}
int compareLine(const void* al0, const void* al1) {
return ((Line*)al0)->start - ((Line*)al1)->start;
}
int main() {
memset(pointCounts, 0, sizeof(int) * 100001);
memset(pointIndexes, 0, sizeof(int) * 100001);
scanf("%d %d", &nPoints, &nLines);
lines = new Line[nLines];
for (int i = 0; i < nLines; i++) {
scanf("%d %d", &(lines[i].start), &(lines[i].end));
if (lines[i].start > lines[i].end) {
int temp = lines[i].end;
lines[i].end = lines[i].start;
lines[i].start = temp;
}
lines[i].maxTail = 0;
endPoints[i] = lines[i].end;
}
qsort(endPoints, nLines, sizeof(int), compareInt);
int prevValue = endPoints[0];
int count = 0;
for (int i = 0; i < nLines; i++) {
if (endPoints[i] != prevValue) {
pointCounts[prevValue] = count;
count = 1;
prevValue = endPoints[i];
} else {
count++;
}
}
pointCounts[prevValue] = count;
qsort(lines, nLines, sizeof(Line), compareLine);
prevValue = lines[0].start;
count = 0;
pointIndexes[prevValue] = 0;
for (int i = 0; i < nLines; i++) {
if (lines[i].start != prevValue) {
pointCounts[prevValue] += count;
count = 1;
prevValue = lines[i].start;
pointIndexes[prevValue] = i;
} else {
count++;
}
}
pointCounts[prevValue] += count;
for (int curI = 0; curI < nLines; curI++) {
long long int curBeauty = (long long)pointCounts[lines[curI].end] *
(long long)(lines[curI].maxTail + 2);
if (curBeauty > maxBeauty) {
maxBeauty = curBeauty;
}
curBeauty = (long long)pointCounts[lines[curI].start] *
(long long)(lines[curI].maxTail + 1);
if (curBeauty > maxBeauty) {
maxBeauty = curBeauty;
}
if (pointIndexes[lines[curI].end] != 0) {
for (int i = pointIndexes[lines[curI].end];
i < nLines && lines[i].start == lines[curI].end; i++) {
if (lines[i].maxTail < lines[curI].maxTail + 1) {
lines[i].maxTail = lines[curI].maxTail + 1;
}
}
}
}
cout << maxBeauty;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int longestIncreasingSubsequenceDP(int a[], int n) {
int dp[n], ans = 0;
for (int k = 0; k < n; k++) {
dp[k] = 1;
for (int i = 0; i < k; i++) {
if (a[i] <= a[k]) {
dp[k] = max(dp[k], dp[i] + 1);
ans = max(dp[k], ans);
}
}
}
return ans;
}
int gcd(int a, int b) {
if (a == 0) return b;
if (b == 0) return a;
if (a == b) return a;
if (a > b) return gcd(a - b, b);
return gcd(a, b - a);
}
void scanArray(int arr[], int n) {
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
}
int highestFromThree(int n1, int n2, int n3) { return max(max(n1, n2), n3); }
int highestFromFour(int n1, int n2, int n3, int n4) {
return max(max(n1, n2), max(n3, n4));
}
int result[1000] = {0};
int factDP(int n) {
if (n >= 0) {
result[0] = 1;
for (int i = 1; i <= n; ++i) {
result[i] = i * result[i - 1];
}
return result[n];
}
}
int main() {
int t;
cin >> t;
while (t--) {
int n, k1, k2;
int ans = 0;
cin >> n >> k1 >> k2;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < k1; i++) {
if (a[i] == n) {
ans = 1;
}
}
if (ans) {
cout << "YES"
<< "\n";
} else {
cout << "NO"
<< "\n";
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[8];
for (int i = 0; i < 8; i++) {
int b = 1 << (i + 1);
b -= 1;
b = b << i;
a[i] = b;
}
for (int i = 7; i >= 0; i--) {
if (n % a[i] == 0) {
cout << a[i];
break;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 5;
int a[maxn];
int main() {
ios::sync_with_stdio(0);
long long n;
while (cin >> n) {
if (n % 2 == 0) {
if (n % 4 == 0) {
cout << 0 << endl << n / 2 << " ";
for (int i = 1; i <= n / 4; i++) cout << i << " " << n - i + 1 << " ";
} else {
cout << 1 << endl << n / 2 << " ";
for (int i = 1; i <= n / 4; i++) cout << i << " " << n - i + 1 << " ";
cout << n / 2;
}
} else {
if ((n * (n + 1) / 2) % 2 == 0) {
cout << 0 << endl;
cout << n / 2 + 1 << " ";
for (int i = 1; i <= n / 2 + 1; i += 2) cout << i << " ";
for (int i = n / 2 + 1; i <= n; i += 2) cout << i << " ";
} else {
cout << 1 << endl;
cout << n / 2 + 1 << " ";
for (int i = 1; i <= n / 2 + 1; i += 2) cout << i << " ";
for (int i = n / 2 + 2; i <= n; i += 2) cout << i << " ";
}
}
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
cin >> str;
int x = str.length();
for (int i = 0; i < x; i++) {
if (str[i] >= 65 && str[i] <= 90) {
str[i] = tolower(str[i]);
}
if (str[i] == '0') str[i] = 'o';
if (str[i] == '1') str[i] = 'l';
if (str[i] == 'i') str[i] = 'l';
}
int n;
cin >> n;
vector<string> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
for (int i = 0; i < n; i++) {
int x = v[i].length();
for (int j = 0; j < x; j++) {
if (v[i][j] >= 65 && v[i][j] <= 90) {
v[i][j] = tolower(v[i][j]);
if (v[i][j] == 'i') v[i][j] = 'l';
}
if (v[i][j] == '0') v[i][j] = 'o';
if (v[i][j] == '1') v[i][j] = 'l';
if (v[i][j] == 'i') v[i][j] = 'l';
}
if (str == v[i]) {
cout << "No";
return 0;
}
}
cout << "Yes";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
vector<int> v1[maxn], v2[maxn];
int n, lazy[maxn << 2], minnode[maxn << 2], maxnode[maxn << 2];
long long sumnode[maxn << 2];
void modify(int rt, int l, int r, int c) {
lazy[rt] = c;
minnode[rt] = maxnode[rt] = c;
sumnode[rt] = (r - l + 1LL) * (n + 1 - c);
}
void pushup(int rt) {
sumnode[rt] = sumnode[rt << 1] + sumnode[rt << 1 | 1];
minnode[rt] = min(minnode[rt << 1], minnode[rt << 1 | 1]);
maxnode[rt] = max(maxnode[rt << 1], maxnode[rt << 1 | 1]);
}
void pushdown(int rt, int l, int r) {
if (lazy[rt]) {
int m = (l + r) >> 1;
modify(rt << 1, l, m, lazy[rt]);
modify(rt << 1 | 1, m + 1, r, lazy[rt]);
lazy[rt] = 0;
}
}
void build(int rt, int l, int r) {
lazy[rt] = 0;
if (l == r) {
minnode[rt] = l;
sumnode[rt] = n - l + 1;
return;
}
int m = (l + r) >> 1;
build(rt << 1, l, m), build(rt << 1 | 1, m + 1, r);
pushup(rt);
}
void update(int rt, int l, int r, int x, int y, int c) {
if (c <= minnode[rt]) return;
if (x <= l && r <= y && maxnode[rt] <= c) {
modify(rt, l, r, c);
return;
}
pushdown(rt, l, r);
int m = (l + r) >> 1;
if (x <= m) update(rt << 1, l, m, x, y, c);
if (m < y) update(rt << 1 | 1, m + 1, r, x, y, c);
pushup(rt);
}
void init() {
for (int i = 1; i < maxn; ++i) {
for (int j = i; j < maxn; j += i) v1[j].push_back(i);
}
}
int main() {
init();
scanf("%d", &n);
int mx = 0;
for (int i = 1; i <= n; ++i) {
int x;
scanf("%d", &x);
mx = max(x, mx);
for (int j = 0; j < v1[x].size(); ++j) v2[v1[x][j]].push_back(i);
}
build(1, 1, n);
long long ans = 0, cur = sumnode[1];
for (int i = mx; i; --i) {
if (v2[i].size() > 1) {
int p = v2[i][0], q = v2[i][1];
if (q < n) update(1, 1, n, q + 1, n, n + 1);
update(1, 1, n, p + 1, q, v2[i].back());
update(1, 1, n, 1, p, v2[i][v2[i].size() - 2]);
ans += i * (cur - sumnode[1]);
cur = sumnode[1];
}
}
printf("%I64d\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int t[1003], c[1003];
int main() {
int n, i;
cin >> n;
long long sz = 0, msz = 0;
long long time = 0;
for (i = 0; i < (n); i++) {
cin >> t[i] >> c[i];
if (i) {
sz -= (t[i] - t[i - 1]);
sz = ((sz) > (0) ? (sz) : (0));
}
sz += c[i];
msz = ((msz) > (sz) ? (msz) : (sz));
time = ((time + c[i]) > (t[i] + c[i]) ? (time + c[i]) : (t[i] + c[i]));
}
cout << time << " " << msz << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e3 + 5;
const int mod = 998244353;
inline void add_mod(int &a, int b) {
a += b;
if (a >= mod) a -= mod;
}
inline void chk_mod(int &a) {
if (a < 0) a += mod;
}
inline long long pw(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 pw2[MAXN], icoef[MAXN];
int n, c;
int a[MAXN];
namespace Subtask1 {
int sum[MAXN][MAXN], f[MAXN][MAXN], g[MAXN][MAXN];
void solve(void) {
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= c; ++j) sum[i][j] = sum[i - 1][j];
++sum[i][a[i]];
}
for (int i = 1; i <= n; ++i) {
if (c == 1) {
f[i][i] = 1;
continue;
}
static int t[MAXN];
for (int j = 1; j <= c; ++j) t[j] = 0;
int cnt = 0, cur = 1;
for (int j = i; j <= n; ++j) {
int ct = ++t[a[j]];
if (ct == 1) {
++cnt;
if (cnt == c) {
for (int k = 1; k <= c; ++k)
if (k != a[i]) cur = cur * (pw2[t[k]] - 1) % mod;
chk_mod(cur);
}
} else if (cnt == c && a[j] != a[i])
chk_mod(cur = cur * icoef[ct - 1] % mod * (pw2[ct] - 1) % mod);
if (cnt == c && a[j] != a[i])
f[i][j] = cur * icoef[ct] % mod * pw2[t[a[i]] - 1] % mod;
}
}
g[n + 1][0] = 1;
static int mxp[MAXN];
for (int i = n; i >= 1; --i) {
mxp[i] = (n - i + 1) / c;
for (int j = i; j <= n; ++j)
if (f[i][j])
for (int k = 0; k <= mxp[j]; ++k)
g[i][k + 1] = (g[i][k + 1] + (long long)g[j + 1][k] * f[i][j]) % mod;
add_mod(g[i][0] = pw2[n - i], g[i + 1][0]);
for (int j = 1; j <= n; ++j)
add_mod(g[i][0], mod - g[i][j]), add_mod(g[i][j], g[i + 1][j]);
}
add_mod(g[1][0], mod - 1);
for (int i = 0; i <= n; ++i) printf("%d ", g[1][i]);
exit(0);
}
} // namespace Subtask1
namespace Subtask2 {
const int ALL = (1 << 11) + 5;
long long g[MAXN][ALL];
void solve(void) {
int all = (1 << c) - 1;
g[0][0] = 1;
for (int k = n; k >= 1; --k) {
int mxp = (n - k + 1) / c;
int cura = (1 << (a[k] - 1));
for (int i = mxp; i >= 0; --i)
for (int mask = all - 1; mask >= 0; --mask)
if (g[i][mask]) {
if ((mask | cura) == all)
g[i + 1][0] += g[i][mask];
else
g[i][mask | cura] += g[i][mask];
}
if (k % 20 == 0) {
for (int i = 0; i <= mxp; ++i)
for (int mask = 0; mask <= all; ++mask) g[i][mask] %= mod;
}
}
g[0][0] += mod - 1;
int mxp = n / c;
for (int i = 0; i <= n; ++i) {
if (i > mxp) {
printf("0 ");
continue;
}
int res = 0;
for (int mask = 0; mask < all; ++mask) add_mod(res, g[i][mask] % mod);
printf("%d ", res);
}
exit(0);
}
} // namespace Subtask2
int main(void) {
pw2[0] = 1;
for (int i = 1; i < MAXN; ++i) pw2[i] = pw2[i - 1] * 2 % mod;
for (int i = 0; i < MAXN; ++i)
icoef[i] = pw((pw2[i] - 1 + mod) % mod, mod - 2);
scanf("%d%d", &n, &c);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
if (c <= 11)
Subtask2::solve();
else
Subtask1::solve();
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)3e5 + 10;
;
const int MOD = (int)1e9 + 9;
;
long long num[maxn], fib[maxn], temp[maxn], n, q, s[maxn];
vector<pair<int, int> > ad;
inline void mod(long long& a) {
while (a > MOD) a -= MOD;
while (a < 0) a += MOD;
}
inline long long getfib(long long a) {
a = fib[a] - fib[a - 1];
mod(a);
return a;
}
void precalc() {
cin >> n >> q;
for (int i = 1; i < n + 1; i++) cin >> num[i];
for (int i = 1; i < n + 1; i++) {
num[i] += num[i - 1];
mod(num[i]);
}
fib[1] = 1;
fib[2] = 1;
for (int i = 3; i < maxn; i++) {
fib[i] = fib[i - 1] + fib[i - 2];
mod(fib[i]);
}
for (int i = 1; i < maxn; i++) {
fib[i] += fib[i - 1];
mod(fib[i]);
}
}
void recalc() {
s[1] = temp[1];
s[2] = s[1] + temp[2];
temp[1] = 0;
temp[2] = 0;
mod(s[1]);
mod(s[2]);
for (int i = 3; i < n + 1; i++) {
s[i] = s[i - 2] + s[i - 1] + temp[i];
temp[i] = 0;
mod(s[i]);
}
for (int i = 1; i < n + 1; i++) {
s[i] += s[i - 1];
mod(s[i]);
}
for (int i = 1; i < n + 1; i++) {
num[i] += s[i];
mod(num[i]);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
precalc();
while (q--) {
int t, l, r;
cin >> t >> l >> r;
if (t == 1) {
temp[l] += 1;
temp[r + 1] -= getfib(r - l + 2);
temp[r + 2] -= getfib(r - l + 1);
mod(temp[l]);
mod(temp[r + 1]);
ad.push_back(make_pair(l, r));
if (ad.size() == 600) {
ad.clear();
recalc();
}
} else {
long long ans = num[r] - num[l - 1];
mod(ans);
for (int i = 0; i < ad.size(); i++) {
int mn = max(ad[i].first, l);
int mx = min(ad[i].second, r);
if (mn > mx) continue;
ans += fib[mx - ad[i].first + 1] - fib[mn - ad[i].first];
mod(ans);
}
cout << ans << endl;
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int min(int x, int y) {
if (x > y) {
return y;
} else {
return x;
}
}
int max(int x, int y) {
if (x < y) {
return y;
} else {
return x;
}
}
int gcd(int a, int b) {
if (a == 0) return b;
if (b == 0) return a;
if (a == b) return a;
if (a > b) return gcd(a - b, b);
return gcd(a, b - a);
}
int main() {
int n, i, j;
cin >> n;
int** arr = new int*[n];
for (i = 0; i < n; ++i) arr[i] = new int[n];
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
if (i < n / 2) {
arr[j][i] = n * i + j + 1;
} else {
arr[j][i] = n * i + n - j;
}
}
}
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
cout << arr[i][j] << " ";
}
cout << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int max(int a, int b) {
if (a > b) return a;
return b;
}
int XOR(int a, int x) {
int i = 0, t = 0;
while (a > 0 || x > 0) {
t += max(a % 2 - x % 2, x % 2 - a % 2) << i;
a = a / 2;
x = x / 2;
i++;
}
return t;
}
int main() {
int n, x, a[100005];
long long int ans = 0;
cin >> n >> x;
for (int i = 0; i < n; i++) cin >> a[i];
a[n] = 1000000;
sort(a, a + n);
for (int i = 0; i < n; i++) {
ans += upper_bound(a + i, a + n, XOR(a[i], x)) -
lower_bound(a + i, a + n, XOR(a[i], x));
if (x == 0) ans--;
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 1e9 + 7;
bool IsPowerOfTwo(long long int x) { return (x != 0) && ((x & (x - 1)) == 0); }
long long int poer(long long int a, long long int b) {
long long int rs = 1;
while (b > 0) {
if (b & 1) rs *= a;
a *= a;
b /= 2;
}
return rs;
}
long long int mod_poer(long long int a, long long int b, long long int mo) {
long long int rs = 1;
while (b > 0) {
if (b & 1) rs = (rs * a) % mo;
a = (a * a) % mo;
b /= 2;
}
return rs % mo;
}
long long int d, x, y;
void ext_euclid(long long int a, long long int b) {
if (b == 0) {
d = a;
x = 1;
y = 0;
} else {
ext_euclid(b, a % b);
long long int temp = x;
x = y;
y = temp - (a / b) * y;
}
}
long long int mod_inverse1(long long int a, long long int m) {
ext_euclid(a, m);
return (x % m + m) % m;
}
long long int mod_inverse2(long long int a, long long int m) {
return mod_poer(a, m - 2, m);
}
long long int gcd(long long int a, long long int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
long long int a[100005];
long long int i, n, m, k;
long long int dp[100005];
int main() {
cin >> n;
for (i = 0; i < n; i++) {
long long int x;
cin >> x, dp[x] = dp[x - 1] + 1;
}
long long int maxi = INT_MIN;
for (i = 0; i < 100005; i++) maxi = max(maxi, dp[i]);
cout << n - maxi << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
static const int INF = 1000000000;
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
vector<int> answer(n, INF);
for (int i = 1; i < n; i += i) {
vector<int> w0, w1;
for (int j = 0; j < n; ++j) {
if (j % (i * 2) < i) {
w0.push_back(j);
} else {
w1.push_back(j);
}
}
{
cout << w0.size() << endl << flush;
for (const int wi : w0) {
cout << wi + 1 << " ";
}
cout << endl << flush;
vector<int> v(n);
for (int j = 0; j < n; ++j) {
cin >> v[j];
}
for (int j = 0; j < n; ++j) {
if (j % (i * 2) >= i) {
answer[j] = min(answer[j], v[j]);
}
}
}
{
cout << w1.size() << endl << flush;
for (const int wi : w1) {
cout << wi + 1 << " ";
}
cout << endl << flush;
vector<int> v(n);
for (int j = 0; j < n; ++j) {
cin >> v[j];
}
for (int j = 0; j < n; ++j) {
if (j % (i * 2) < i) {
answer[j] = min(answer[j], v[j]);
}
}
}
}
cout << -1 << endl;
for (const int x : answer) {
cout << x << " ";
}
cout << endl << flush;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
double INF = 1e100;
double EPS = 1e-7;
struct PT {
double x, y;
PT() {}
PT(double x, double y) : x(x), y(y) {}
PT(const PT &p) : x(p.x), y(p.y) {}
PT operator+(const PT &p) const { return PT(x + p.x, y + p.y); }
PT operator-(const PT &p) const { return PT(x - p.x, y - p.y); }
PT operator*(double c) const { return PT(x * c, y * c); }
PT operator/(double c) const { return PT(x / c, y / c); }
bool operator<(const PT &p) const {
return make_pair(x, y) < make_pair(p.x, p.y);
}
bool operator==(const PT &p) const { return !(*this < p) && !(p < *this); }
};
double dot(PT p, PT q) { return p.x * q.x + p.y * q.y; }
double dist2(PT p, PT q) { return dot(p - q, p - q); }
double cross(PT p, PT q) { return p.x * q.y - p.y * q.x; }
PT norm(PT x, double l) { return x * sqrt(l * l / dot(x, x)); }
istream &operator>>(istream &is, PT &p) { return is >> p.x >> p.y; }
ostream &operator<<(ostream &os, const PT &p) {
return os << "(" << p.x << "," << p.y << ")";
}
PT RotateCCW90(PT p) { return PT(-p.y, p.x); }
PT RotateCW90(PT p) { return PT(p.y, -p.x); }
PT RotateCCW(PT p, double t) {
return PT(p.x * cos(t) - p.y * sin(t), p.x * sin(t) + p.y * cos(t));
}
PT ProjectPointLine(PT a, PT b, PT c) {
return a + (b - a) * dot(c - a, b - a) / dot(b - a, b - a);
}
PT ProjectPointSegment(PT a, PT b, PT c) {
double r = dot(c - a, b - a) / dot(b - a, b - a);
if (r < 0) return a;
if (r > 1) return b;
return a + (b - a) * r;
}
long double slope(PT a, PT b) { return (b.y - a.y) / (b.x - a.x); }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<PT> l(n), r(m);
for (auto i = 0; i < (long long)(n); i++) {
l[i].x = -100.;
cin >> l[i].y;
}
for (auto i = 0; i < (long long)(m); i++) {
r[i].x = 100.;
cin >> r[i].y;
}
map<long double, bitset<123>> mp;
for (auto i = 0; i < (long long)(n); i++) {
for (auto j = 0; j < (long long)(m); j++) {
long double y = l[i].y + (r[j].y - l[i].y) / 2.;
mp[y][i] = mp[y][n + j] = 1;
}
}
int mx = 0;
for (auto i1 : mp)
for (auto i2 : mp) mx = max(mx, (int)(i1.second | i2.second).count());
cout << mx;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, k, wynik, tab[4005];
struct rozmowa {
int czas;
int pocz;
};
rozmowa rozm[4005];
bool comp(const rozmowa &f, const rozmowa &s) { return f.pocz < s.pocz; }
int main() {
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d %d", &rozm[i].pocz, &rozm[i].czas);
tab[i] = 1;
}
tab[n] = 1;
sort(rozm, rozm + n, comp);
rozm[n].pocz = 86401;
for (int i = 0; i <= n; i++) {
for (int j = k; j > 0; j--) {
wynik = max(wynik, rozm[i].pocz - tab[j]);
tab[j] = min(max(tab[j], rozm[i].pocz) + rozm[i].czas, tab[j - 1]);
}
wynik = max(wynik, rozm[i].pocz - tab[0]);
tab[0] = max(tab[0], rozm[i].pocz) + rozm[i].czas;
}
printf("%d\n", wynik);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0;
char c = getchar();
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return x;
}
const int maxn = 1e5 + 10;
const int mod = 1e9 + 7;
const double eps = 1e-7;
int main() {
string l;
cin >> l;
for (int i = l.size() - 1, cnt = 0; i >= 0; --i)
if (l[i] == '0')
cnt++;
else if (cnt)
cnt--;
else
l[i] = '0';
cout << l << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x1, y1, r1, x2, y2, r2;
cin >> x1 >> y1 >> r1 >> x2 >> y2 >> r2;
double r;
double d = (double)(sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)));
if (r1 > r2 + d) {
r = r1 - r2 - d;
r = (double)r / 2;
printf("%.7lf", r);
return 0;
}
if (r2 > r1 + d) {
r = r2 - r1 - d;
r = (double)r / 2;
printf("%.7lf", r);
return 0;
}
if ((r1 >= d - r2 && r1 <= d + r2) || (r2 >= d - r1 && r2 <= d + r1)) {
cout << "0.0000000000"
<< "\n";
return 0;
}
r = d - r1 - r2;
r /= 2;
printf("%.7lf", r);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int mxn = 2e5 + 5;
const long long MOD = 1e9 + 7;
int arr[mxn];
int n;
int a, b, c;
void solve() {
if (a == b) {
cout << 0 << '\n';
return;
}
if (a > b) {
if (abs(a - b) % 2 == 0) {
cout << 1 << '\n';
} else {
cout << 2 << '\n';
}
} else {
if (abs(a - b) % 2 == 0) {
cout << 2 << '\n';
} else {
cout << 1 << '\n';
}
}
}
void read() { cin >> a >> b; }
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int T = 1;
cin >> T;
while (T--) read(), solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
template <typename T>
inline bool chkmin(T &x, T y) {
return x > y ? x = y, 1 : 0;
}
template <typename T>
inline bool chkmax(T &x, T y) {
return x < y ? x = y, 1 : 0;
}
template <typename T>
inline void read(T &x) {
char ch = getchar();
int f = 1;
x = 0;
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
x *= f;
}
template <typename T, typename... Args>
inline void read(T &x, Args &...args) {
read(x), read(args...);
}
int n, B = 500;
int vis[2050][2050], step[2050][2050];
long long k, ans[2050];
int dir[8][2] = {{1, 2}, {1, -2}, {-1, 2}, {-1, -2},
{2, 1}, {2, -1}, {-2, 1}, {-2, -1}};
void bfs() {
static pair<int, int> q[2050 * 2050];
int fr = 0, re = 0;
q[re++] = make_pair(B * 2, B * 2), vis[B * 2][B * 2] = 1;
while (fr < re) {
int x = q[fr].first, y = q[fr++].second;
ans[step[x][y]]++;
if (step[x][y] == B) continue;
for (register int i = 0; i <= 7; ++i) {
int nx = x + dir[i][0], ny = y + dir[i][1];
if (!vis[nx][ny])
vis[nx][ny] = 1, step[nx][ny] = step[x][y] + 1,
q[re++] = make_pair(nx, ny);
}
}
}
int main() {
int x, y;
read(k, n);
for (register int i = 1; i <= n; ++i)
read(x, y), vis[x + B * 2][y + B * 2] = 1;
bfs();
long long dlt = ans[B] - ans[B - 1], ff = ans[B];
for (register int i = 1; i <= B; ++i)
ans[i] = (ans[i] + ans[i - 1]) % 1000000007;
if (k <= B)
cout << ans[k];
else
k = (k - B) % 1000000007,
cout << (ans[B] + ff * k % 1000000007 +
(1 + k) * k / 2 % 1000000007 * dlt % 1000000007) %
1000000007;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k, n, s, p;
cin >> k >> n >> s >> p;
cout << (((n + s - 1) / s * k + p - 1) / p) << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline char nc() {
return getchar();
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
inline void read(int &x) {
char c = nc(), b = 1;
for (; !(c >= '0' && c <= '9'); c = nc())
if (c == '-') b = -1;
for (x = 0; c >= '0' && c <= '9'; x = x * 10 + c - '0', c = nc())
;
x *= b;
}
const int N = 205;
const int M = 2505;
struct edge {
int u, v, w, f;
int next;
} G[M << 1];
int head[N], inum = 1;
inline void add(int u, int v, int w, int f, int p) {
G[p].u = u;
G[p].v = v;
G[p].w = w;
G[p].f = f;
G[p].next = head[u];
head[u] = p;
}
inline void link(int u, int v, int w, int f) {
add(u, v, w, f, ++inum);
add(v, u, -w, 0, ++inum);
}
int n, m, P;
int S, T, Mincost;
int Q[N * M], l, r;
int dis[N], pre[N], ins[N];
double val[N];
inline bool SPFA() {
for (int i = 1; i <= n; i++) dis[i] = 1 << 29, pre[i] = 0, ins[i] = 0;
l = r = -1;
Q[++r] = S, dis[S] = 0, ins[S] = 1;
while (l < r) {
int u = Q[++l];
ins[u] = 0;
for (int p = head[u]; p; p = G[p].next)
if (G[p].f && dis[G[p].v] > dis[u] + G[p].w) {
dis[G[p].v] = dis[u] + G[p].w;
pre[G[p].v] = p;
if (!ins[G[p].v]) Q[++r] = G[p].v, ins[G[p].v] = 1;
}
}
if (dis[T] == 1 << 29) return 0;
Mincost += dis[T];
for (int p = pre[T]; p; p = pre[G[p].u]) G[p].f--, G[p ^ 1].f++;
return 1;
}
int main() {
int u, v, c, d, Q;
read(n);
read(m);
S = 1;
T = n;
for (int i = 1; i <= m; i++) read(u), read(v), read(d), link(u, v, d, 1);
double ans;
int m = 0;
while (SPFA()) {
m++;
val[m] = (double)Mincost;
}
for (read(Q); Q; --Q) {
read(c);
ans = 1e18;
for (int i = 1; i <= m; ++i) ans = min(ans, (val[i] + c) / i);
printf("%.10lf\n", ans);
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int RLEN = 1 << 20 | 1;
inline char gc() {
static char ibuf[RLEN], *ib, *ob;
(ob == ib) && (ob = (ib = ibuf) + fread(ibuf, 1, RLEN, stdin));
return (ob == ib) ? EOF : *ib++;
}
inline int read() {
char ch = gc();
int res = 0, f = 1;
while (!isdigit(ch)) f ^= ch == '-', ch = gc();
while (isdigit(ch)) res = (res + (res << 2) << 1) + (ch ^ 48), ch = gc();
return f ? res : -res;
}
inline int readchar(char *s) {
char ch = gc();
int top = 0;
while (!isalpha(ch)) ch = gc();
while (isalpha(ch)) s[top++] = ch, ch = gc();
return top;
}
inline void chemx(int &a, int b) { a < b ? a = b : 0; }
inline void chemn(int &a, int b) { a > b ? a = b : 0; }
const int N = 200005;
namespace Tr {
const int N = 400000;
int tr[N + 5];
inline void update(int p, int k) {
for (; p <= N; p += (p & (-p))) tr[p] += k;
}
inline int query(int p, int res = 0) {
for (; p; p -= (p & (-p))) res += tr[p];
return res;
}
} // namespace Tr
int n, m, val[N], tot;
vector<int> e[N];
char s[N];
namespace Lct {
int son[N][2], fa[N], rev[N], siz[N];
inline bool isrt(int u) {
return fa[u] ? (son[fa[u]][0] != u && son[fa[u]][1] != u) : 1;
}
inline bool isrc(int u) { return son[fa[u]][1] == u; }
inline void pushnow(int u) { swap(son[u][0], son[u][1]), rev[u] ^= 1; }
inline void pushdown(int u) {
if (son[u][0]) val[son[u][0]] = val[u];
if (son[u][1]) val[son[u][1]] = val[u];
if (!rev[u]) return;
if (son[u][0]) pushnow(son[u][0]);
if (son[u][1]) pushnow(son[u][1]);
rev[u] = 0;
}
inline void pushup(int u) {
siz[u] = 1;
if (son[u][0]) siz[u] += siz[son[u][0]];
if (son[u][1]) siz[u] += siz[son[u][1]];
}
inline void rotate(int v) {
int u = fa[v], z = fa[u];
int t = isrc(v);
if (!isrt(u)) son[z][isrc(u)] = v;
fa[v] = z;
fa[son[v][t ^ 1]] = u;
son[u][t] = son[v][t ^ 1];
fa[u] = v, son[v][t ^ 1] = u;
pushup(u), pushup(v);
}
int stk[N], top;
inline void splay(int u) {
stk[top = 1] = u;
for (int v = u; !isrt(v); v = fa[v]) stk[++top] = fa[v];
for (int i = top; i; i--) pushdown(stk[i]);
while (!isrt(u)) {
if (!isrt(fa[u])) isrc(u) == isrc(fa[u]) ? rotate(fa[u]) : rotate(u);
rotate(u);
}
}
inline void access(int u) {
for (int v = 0; u; v = u, u = fa[u]) {
splay(u), son[u][1] = 0, pushup(u);
Tr::update(val[u], -siz[u]);
Tr::update(tot, siz[u]);
son[u][1] = v;
pushup(u);
}
}
inline void makert(int u) { access(u), splay(u), pushnow(u); }
inline void update(int u) { tot++, makert(u), val[u] = tot; }
inline int query(int u) {
splay(u);
return Tr::query(val[u]) - siz[son[u][0]];
}
} // namespace Lct
void dfs(int u, int fa) {
int mx = 0, son = 0;
val[u] = u;
for (int &v : e[u]) {
if (v == fa) continue;
dfs(v, u);
if (val[v] > mx) mx = val[v], son = v;
Lct::fa[v] = u;
}
if (mx > val[u]) Lct::son[u][1] = son, val[u] = mx;
Lct::pushup(u), Tr::update(val[u], 1);
}
int main() {
tot = n = read(), m = read();
for (int i = 1; i < n; i++) {
int u = read(), v = read();
e[u].push_back(v), e[v].push_back(u);
}
dfs(n, 0);
while (m--) {
int len = readchar(s), u = read();
if (s[0] == 'u') {
Lct::update(u);
} else if (s[0] == 'w') {
cout << Lct::query(u) << '\n';
} else {
int v = read();
cout << (Lct::query(u) > Lct::query(v) ? v : u) << '\n';
}
}
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> mini;
vector<int> maxi;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long valid = 0;
long long ans = 0;
cin >> n;
for (int i = 0; i < n; i++) {
int t;
cin >> t;
bool ok = false;
int cur = 1e9, mi = 1e9, ma = -1;
for (int j = 0; j < t; j++) {
int x;
cin >> x;
if (cur < x) ok = true;
mi = min(mi, x);
ma = max(ma, x);
cur = x;
}
if (!ok) {
mini.push_back(mi);
maxi.push_back(ma);
} else {
valid++;
}
}
ans = valid * (2 * n - valid);
sort(maxi.begin(), maxi.end());
for (int i = 0; i < mini.size(); i++) {
int l = 0, r = maxi.size() - 1;
while (l < r) {
int mid = (l + r) / 2;
if (maxi[mid] > mini[i])
r = mid;
else
l = mid + 1;
}
if (maxi[l] == mini[i]) l++;
ans += maxi.size() - l;
}
cout << ans << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
;
string a, temp, f = "";
int ary2[1000] = {};
stack<char> st;
priority_queue<pair<char, int>, vector<pair<char, int>>,
greater<pair<char, int>>>
pq;
cin >> a;
for (char i : a) ary2[int(i)]++;
for (int i = 0; i < 1000; i++)
if (ary2[i] != 0) pq.push({char(i), ary2[i]});
memset(ary2, 0, sizeof(ary2));
for (int i = 0; i < a.length(); i++) {
ary2[int(a[i])]++;
if (a[i] != pq.top().first)
st.push(a[i]);
else {
f += pq.top().first;
while (!pq.empty() && ary2[int(pq.top().first)] == pq.top().second) {
pq.pop();
}
while (st.size() != 0 && pq.size() != 0 && st.top() <= pq.top().first)
f += st.top(), st.pop();
}
}
while (st.size() != 0) f += st.top(), st.pop();
cout << f;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[25], b[25][25], n;
int bitmask[8400000];
int ans = 1000000;
int func(int l, int bitt, int anss) {
if (bitmask[bitt] == 1) {
return 0;
}
bitmask[bitt] = 1;
int i;
if (l == n - 1) {
if (ans > anss) {
ans = anss;
return 0;
}
}
int flag = 0;
int temp, tmp;
for (i = 0; i <= l; i++) {
temp = b[i][l + 1];
if (temp == -1) continue;
temp = (1 << temp);
temp = bitt & temp;
tmp = (1 << i);
tmp = bitt & tmp;
if ((temp != 0) && (tmp != 0)) {
flag = 1;
break;
}
}
if (flag == 0) {
return 0;
}
bitt = bitt + (1 << (l + 1));
int ct = 1;
for (i = 0; i <= l; i++) {
if ((bitt & (1 << i)) != 0) {
ct++;
}
}
func(l + 1, bitt, max(anss, ct));
for (i = 0; i <= l; i++) {
if ((bitt & (1 << i)) != 0) {
func(l + 1, (bitt - (1 << i)), max(anss, ct - 1));
}
}
}
int main() {
int i, j, k, l, t, ct = 0, y, q;
cin >> n;
for (i = 0; i < n; i++) {
cin >> a[i];
}
for (i = 0; i < 25; i++) {
for (j = 0; j < 25; j++) {
b[i][j] = -1;
}
}
for (i = 0; i < n; i++) {
for (j = 0; j < i; j++) {
for (k = 0; k < i; k++) {
if (a[j] + a[k] == a[i]) {
b[j][i] = k;
}
}
}
}
if (n == 1) {
cout << "1\n";
return 0;
}
if (2 * a[0] != a[1]) {
cout << "-1\n";
return 0;
}
func(1, 3, 2);
func(1, 2, 1);
if (ans == 1000000) {
cout << "-1\n";
} else {
cout << ans << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n1 = 0, n2 = 0;
string x, y, temp1, temp2;
cin >> x >> y;
for (int i = 0; i < x.size(); i += 2) {
temp1 = x.substr(i, 2);
temp2 = y.substr(i, 2);
if (temp1 == "[]" && temp2 == "()")
n1++;
else if (temp1 == "()" && temp2 == "8<")
n1++;
else if (temp1 == "8<" && temp2 == "[]")
n1++;
else if (temp2 == "[]" && temp1 == "()")
n2++;
else if (temp2 == "()" && temp1 == "8<")
n2++;
else if (temp2 == "8<" && temp1 == "[]")
n2++;
}
if (n1 > n2)
cout << "TEAM 1 WINS";
else if (n2 > n1)
cout << "TEAM 2 WINS";
else
cout << "TIE";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
double pp = acos(-1);
int main() {
int t;
scanf("%d", &t);
for (int q = 1; q <= t; q++) {
double n;
cin >> n;
n *= 2;
double all = (n - 2.0) * pp;
double sing = all / n;
double sma = pp - sing;
sing /= 2;
double arm = sin(sing) / sin(sma);
n /= 2;
sma = sma * (n - 1);
sing = pp - sma;
sing /= 2;
double ans = (sin(sma) * arm) / sin(sing);
cout << fixed << setprecision(9) << ans << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string route;
cin >> route;
if (route.size() % 2 != 0) {
cout << -1 << endl;
return 0;
}
int L = 0;
int R = 0;
int U = 0;
int D = 0;
for (int i = 0; i < route.size(); i++) {
if (route[i] == 'L') {
L++;
} else if (route[i] == 'R') {
R++;
} else if (route[i] == 'U') {
U++;
} else if (route[i] == 'D') {
D++;
}
}
int hor, vert;
hor = abs(L - R);
vert = abs(U - D);
if ((hor % 2 != 0 && vert % 2 != 0) || (hor % 2 == 0 && vert % 2 == 0)) {
cout << (hor + vert) / 2 << endl;
} else {
cout << -1 << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int n, k, d, dp[110][2];
int main() {
scanf("%d %d %d", &n, &k, &d);
dp[0][0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= k; j++) {
if (i - j < 0) break;
if (j < d) {
dp[i][0] = (dp[i][0] + dp[i - j][0]) % mod;
dp[i][1] = (dp[i][1] + dp[i - j][1]) % mod;
} else {
dp[i][1] = (dp[i][1] + dp[i - j][0]) % mod;
dp[i][1] = (dp[i][1] + dp[i - j][1]) % mod;
}
}
}
printf("%d\n", dp[n][1]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int maxn = 1e5 + 5;
template <typename T>
inline T max(const T &a, const T &b) {
return a > b ? a : b;
}
int n, answer, dp[maxn][2];
std::vector<int> e[maxn];
void solve(int u, int fa) {
int son = e[u].size();
son--;
dp[u][1] = 1, dp[u][0] = son;
for (int v : e[u]) {
if (v == fa) continue;
solve(v, u);
answer = max(answer, dp[u][0] + max(dp[v][1], dp[v][0]));
answer = max(answer, max(dp[u][0], dp[u][1]) + dp[v][0]);
dp[u][0] = max(dp[u][0], max(dp[v][0], dp[v][1]) + son - 1);
dp[u][1] = max(dp[u][1], dp[v][0] + 1);
}
}
int main() {
scanf("%d", &n);
for (int i = 2; i <= n; i++) {
int u, v;
scanf("%d%d", &u, &v);
e[u].push_back(v), e[v].push_back(u);
}
solve(1, 0);
printf("%d\n", answer);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 50, inf = 1e9;
int n, k, a[N], b[N], val[N], mx;
long long ans;
map<int, int> s;
map<int, int>::iterator it, jt;
vector<pair<int, int> > v[N];
void split(int x) {
if (s.count(x)) return;
it = --s.upper_bound(x);
s[x] = it->second;
}
bool check(int x) {
long long sum = 0, now = 0, ans1 = 0, ans2 = 0;
memset(val, 0, sizeof(val));
for (int i = 1, p = 0; i <= n; i++) {
for (int j = 0; j < v[i].size(); j++)
if (v[i][j].second <= p) {
now += v[i][j].first;
sum += 1ll * v[i][j].first * (p - v[i][j].second + 1);
} else
val[v[i][j].second] += v[i][j].first;
while (now + val[p + 1] >= x) sum += (now += val[++p]);
ans1 += p;
ans2 += sum;
}
if (ans1 < k) return 0;
ans = ans2 - x * (ans1 - k);
return 1;
}
int main() {
scanf("%d%d", &n, &k);
s[1] = 0;
for (int i = 1, l, r; i <= n; i++) {
scanf("%d%d", &l, &r);
r--;
split(l);
split(r + 1);
mx = max(mx, r);
for (it = s.lower_bound(l); it->first <= r;)
jt = it++,
v[i].push_back(make_pair(it->first - jt->first, jt->second + 1)),
s.erase(jt);
s[l] = i;
v[i].push_back(make_pair(-(r - l + 1), i + 1));
}
for (int i = 29, now = 0; ~i; i--)
if (check(now | 1 << i)) now |= 1 << i;
cout << ans;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
long long n, k, q, r;
long long qu;
int op;
int main() {
cin >> n >> k >> q;
if (n > k) swap(n, k);
while (k < q) {
op++;
if (k) r = n / k;
if (r < 0) {
r *= -1;
qu += r;
n += r * k;
} else {
qu++;
n += k;
}
if (n > k) swap(n, k);
if (op > 1000000) {
cout << "-1";
return 0;
}
if (n < -2000000000000000000) {
cout << "-1";
return 0;
}
}
cout << qu;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
double f[105][105][105], ans1, ans2, ans3;
int main() {
int r, s, p;
scanf("%d%d%d", &r, &s, &p);
f[r][s][p] = 1;
for (int i = r; i > 0; i--) {
for (int j = s; j > 0; j--) {
for (int k = p; k > 0; k--) {
f[i][j][k - 1] += f[i][j][k] * j * k / (i * j + i * k + j * k);
f[i][j - 1][k] += f[i][j][k] * i * j / (i * j + i * k + j * k);
f[i - 1][j][k] += f[i][j][k] * i * k / (i * j + i * k + j * k);
}
}
}
for (int i = 1; i <= r; i++) {
for (int j = 1; j <= s; j++) {
ans1 += f[i][j][0];
}
}
for (int i = 1; i <= s; i++) {
for (int j = 1; j <= p; j++) {
ans2 += f[0][i][j];
}
}
for (int i = 1; i <= r; i++) {
for (int j = 1; j <= p; j++) {
ans3 += f[i][0][j];
}
}
printf("%.9lf %.9lf %.9lf", ans1, ans2, ans3);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4e6 + 5;
int trie[maxn][2];
int a[maxn], n, tot, ans;
long long l[35], r[35], cnt[maxn];
void insert(int n, int pos) {
int rt = 0;
for (int i = 30; i >= 0; i--) {
int tmp = (n >> i) & 1;
if (!trie[rt][tmp]) trie[rt][tmp] = ++tot;
if (tmp == 1)
r[i] += cnt[trie[rt][0]];
else
l[i] += cnt[trie[rt][1]];
cnt[trie[rt][tmp]]++;
rt = trie[rt][tmp];
}
}
void dfs1() {
int rt = 0;
for (int i = 30; i >= 0; i--) {
int l = trie[rt][0], r = trie[rt][1];
if (!l && !r)
return;
else if (!l) {
rt = trie[rt][1];
continue;
} else if (!r) {
rt = trie[rt][0];
continue;
}
if (cnt[l] > cnt[r]) {
if (cnt[r] != 1) ans += cnt[r] - 1;
rt = trie[rt][0];
} else {
if (cnt[l] != 1) ans += cnt[l] - 1;
rt = trie[rt][1];
}
}
}
void dfs(int rt, int pos, int sum) {
int l = trie[rt][0], r = trie[rt][1];
if (!l && !r || pos < 0) {
ans = min(sum, ans);
return;
} else if (!l) {
dfs(r, pos - 1, sum);
return;
} else if (!r) {
dfs(l, pos - 1, sum);
return;
}
dfs(l, pos - 1, sum + max(0LL, cnt[r] - 1));
dfs(r, pos - 1, sum + max(0LL, cnt[l] - 1));
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
insert(a[i], i);
}
ans = 0x3f3f3f3f;
dfs(0, 30, 0);
cout << ans << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long N, M, tam[200005], sz, ans[200005], tot;
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
cin >> N >> M;
for (long long i = 1; i <= M; i++) {
cin >> tam[i];
sz += tam[i];
}
if (sz < N) {
cout << "-1\n";
exit(0);
}
for (long long i = 1; i < M; i++) {
ans[i] = 1;
tot++;
}
ans[M] = tam[M];
tot += tam[M];
if (tot > N) {
cout << "-1\n";
exit(0);
}
for (long long i = M - 1; i >= 1; i--) {
if (tot + tam[i] - ans[i] <= N) {
tot = tot + tam[i] - ans[i];
ans[i] = tam[i];
} else {
long long mn = min(tam[i] - ans[i], N - tot);
ans[i] += mn;
tot += mn;
}
}
if (tot != N) {
cout << "-1\n";
exit(0);
}
long long l = 1;
for (long long i = 1; i <= M; i++) {
if (l + tam[i] - 1 > N) {
cout << "-1\n";
exit(0);
}
l += ans[i];
}
long long tmp = 1;
for (long long i = 1; i <= M; i++) {
cout << tmp << " ";
tmp += ans[i];
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
const long long inf = 9223372036854775807ll;
const int iinf = 2147483647;
const int limit = 1048576;
using namespace std;
bool sync_with_stdio(bool sync = false);
int main() {
int n;
scanf("%d", &n);
vector<int> input;
vector<pair<int, int> > seqs;
for (int i = (int)0; i < (int)n; i++) {
int t1;
scanf("%d", &t1);
input.push_back(t1);
}
int cnt = 0, len = 0;
seqs.push_back({0, input[0]});
for (int i = (int)1; i < (int)n - 1; i++) {
if (input[i] != input[i - 1] && input[i] != input[i + 1])
cnt++;
else {
seqs.push_back({i, input[i]});
len = max(len, cnt);
cnt = 0;
}
}
seqs.push_back({n - 1, input[n - 1]});
len = max(len, cnt);
printf("%d\n", (len + 1) / 2);
int k = 1;
for (int i = (int)0; i < (int)n; i++) {
if (i > seqs[k].first) k++;
if (abs(i - seqs[k - 1].first) < abs(i - seqs[k].first))
printf("%d ", seqs[k - 1].second);
else
printf("%d ", seqs[k].second);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int m, s;
bool dp[1001][200], dp2[1001][200];
string solve(string curAns, int curSum, int curPos) {
if (curSum > s) return "-1";
if (dp[curSum][curPos]) return "-1";
dp[curSum][curPos] = true;
if (curPos == m) {
if (curSum == s) return curAns;
return "-1";
}
for (int i = 9; i >= 0; i--) {
if (curPos == 0 && m > 1 && i == 0) continue;
char num = i + '0';
string ret = solve(curAns + num, curSum + i, curPos + 1);
if (ret != "-1") return ret;
}
return "-1";
}
string solve2(string curAns, int curSum, int curPos) {
if (curSum > s) return "-1";
if (dp2[curSum][curPos]) return "-1";
dp2[curSum][curPos] = true;
if (curPos == m) {
if (curSum == s) return curAns;
return "-1";
}
for (int i = 0; i <= 9; i++) {
if (i == 0 && curPos == 0 && m > 1) continue;
char num = i + '0';
string ret = solve2(curAns + num, curSum + i, curPos + 1);
if (ret != "-1") return ret;
}
return "-1";
}
int main() {
cin >> m >> s;
cout << solve2("", 0, 0) << " " << solve("", 0, 0) << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, mid1, mid2, mid, x, y;
scanf("%d %d", &n, &m);
vector<int> v;
if (m % 2 == 0) {
mid1 = m / 2;
mid2 = m / 2 + 1;
v.push_back(mid1);
v.push_back(mid2);
for (int i = 1; i < m / 2; ++i) {
v.push_back(mid1 - i);
v.push_back(mid2 + i);
}
} else {
mid = m / 2 + 1;
v.push_back(mid);
for (int i = 1; i < mid; ++i) {
v.push_back(mid - i);
v.push_back(mid + i);
}
}
x = n / m;
y = n % m;
for (int i = 0; i < x; ++i)
for (int j = 0; j < m; ++j) printf("%d\n", v[j]);
for (int i = 0; i < y; ++i) printf("%d\n", v[i]);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
int d = 0;
while (n--) {
char e;
cin >> e;
if (e == '(') {
cout << d % 2;
d++;
} else {
d--;
cout << d % 2;
}
}
cout << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = (long long)1000000000000;
const double eps = (double)1e-8;
const int mod = (int)1000000007;
const int maxn = (int)1e5 + 5;
long long d[1000006], n, m;
void f(int x) {
if (x <= 1 || d[x] != -1) return;
f(x - 1);
f(x - 2);
d[x] = ((long long)(3 * m - 1) * d[x - 1] +
((m - (long long)2 * m * m) % mod) * d[x - 2]) %
mod;
return;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n >> m;
memset(d, -1, sizeof d);
d[0] = 1;
d[1] = 2 * m;
f(n);
cout << d[n];
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
vector<int> A(N), S(N + 1), R(N + 1);
for (int i = 0; i < N; ++i) cin >> A[i];
for (int i = 0; i < N; ++i) S[i + 1] = S[i] + A[i];
for (int i = 0; i < N; ++i) R[i + 1] = R[i] + (A[i] ^ 1);
int ans = 0;
for (int l = 0; l < N; ++l)
for (int r = l; r < N; ++r) {
int cnt = 0;
cnt += S[l];
cnt += R[r + 1] - R[l];
cnt += S[N] - S[r + 1];
ans = max(ans, cnt);
}
cout << ans << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200000;
const long long INF = 1000000000ll;
const long long LLINF = 1000000000000000000ll;
const int MOD = 998244353;
vector<int> a[MAXN];
int deg[MAXN];
int dfsEq(int v, int pr) {
int eq1 = -2;
for (int u : a[v]) {
if (u == pr) {
continue;
}
int eq2 = dfsEq(u, v);
if (eq1 == -2 || eq1 == eq2) {
eq1 = eq2;
} else {
eq1 = -1;
}
}
if (eq1 == -2) {
eq1 = 0;
} else {
if (eq1 != -1) {
eq1 = 1 - eq1;
}
}
return eq1;
}
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout.precision(10);
cout << fixed;
int n;
cin >> n;
for (int i = 0; i < (int)(n - 1); i++) {
int x, y;
cin >> x >> y;
x--;
y--;
a[x].push_back(y);
a[y].push_back(x);
deg[x]++;
deg[y]++;
}
int mn, mx;
for (int i = 0; i < (int)(n); i++) {
if (deg[i] > 1) {
if (dfsEq(i, -1) != -1) {
mn = 1;
} else {
mn = 3;
}
break;
}
}
int cnt = 0;
for (int v = 0; v < (int)(n); v++) {
int c = 0;
for (int u : a[v]) {
if (deg[u] == 1) {
c++;
}
}
if (c > 0) {
cnt += c - 1;
}
}
mx = n - 1 - cnt;
cout << mn << " " << mx << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100;
struct Trpl {
int i, j, k;
Trpl() {}
Trpl(int _i, int _j, int _k) : i(_i), j(_j), k(_k) {}
};
char s[MAX_N + 4], t[MAX_N + 4], v[MAX_N + 4], w[MAX_N + 4];
int vt[MAX_N][26];
int dp[MAX_N + 1][MAX_N + 1][MAX_N];
Trpl ps[MAX_N + 1][MAX_N + 1][MAX_N];
int main() {
scanf("%s%s%s", s, t, v);
int sn = strlen(s), tn = strlen(t), vn = strlen(v);
for (int i = 0; i < vn; i++) {
for (int j = 0; j < 26; j++) {
w[i] = 'A' + j;
for (int k = 0, l = i + 1; k <= i; k++, l--)
if (!strncmp(v, w + k, l)) {
vt[i][j] = l;
break;
}
}
w[i] = v[i];
}
memset(dp, -1, sizeof(dp));
dp[0][0][0] = 0;
ps[0][0][0] = Trpl(-1, -1, -1);
for (int i = 0; i <= sn; i++)
for (int j = 0; j <= tn; j++)
for (int k = 0; k < vn; k++) {
if (i < sn && j < tn && s[i] == t[j]) {
int d1 = dp[i][j][k] + 1;
int k1 = vt[k][s[i] - 'A'];
if (k1 < vn && dp[i + 1][j + 1][k1] < d1) {
dp[i + 1][j + 1][k1] = d1;
ps[i + 1][j + 1][k1] = Trpl(i, j, k);
}
}
if (i < sn && dp[i + 1][j][k] < dp[i][j][k]) {
dp[i + 1][j][k] = dp[i][j][k];
ps[i + 1][j][k] = Trpl(i, j, k);
}
if (j < tn && dp[i][j + 1][k] < dp[i][j][k]) {
dp[i][j + 1][k] = dp[i][j][k];
ps[i][j + 1][k] = Trpl(i, j, k);
}
}
int maxd = -1, maxk = -1;
for (int k = 0; k < vn; k++)
if (maxd < dp[sn][tn][k]) maxd = dp[sn][tn][k], maxk = k;
if (maxd == 0)
puts("0");
else {
int l = 0;
for (int i = sn, j = tn, k = maxk; i >= 0;) {
Trpl p = ps[i][j][k];
if (p.i < 0) break;
if (p.i < i && p.j < j) w[l++] = s[p.i];
i = p.i, j = p.j, k = p.k;
}
for (int i = l - 1; i >= 0; i--) putchar(w[i]);
putchar('\n');
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, q;
scanf("%d %d", &n, &q);
long long oddOffset = 0;
long long evenOffset = 0;
int swapQueries = 0;
for (int i = 0; i < q; i++) {
int t;
scanf("%d", &t);
if (t == 1) {
int x;
scanf("%d", &x);
oddOffset += x;
evenOffset += x;
if (x % 2 != 0) {
swapQueries++;
}
} else {
if (swapQueries % 2 == 0) {
oddOffset += 1;
evenOffset -= 1;
} else {
evenOffset += 1;
oddOffset -= 1;
}
swapQueries++;
}
}
vector<int> result(n);
for (long long i = 0; i < n; i++) {
long long cur = i;
if (i % 2) {
cur += evenOffset;
cur %= n;
if (cur < 0) cur += n;
} else {
cur += oddOffset;
cur %= n;
if (cur < 0) cur += n;
}
result[cur] = i + 1;
}
for (int i : result) {
printf("%d ", i);
}
printf("\n");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int mod = 1000000007;
long long int a[100004];
int main() {
ios_base::sync_with_stdio(0);
cin.tie();
cout.tie();
;
long long int t;
cin >> t;
while (t--) {
long long int n, k, fl = 0, flk = 0;
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
if (n == 1 && a[0] == k) fl = 1;
for (int i = 0; i < n; i++) {
if (i < n - 1 && a[i] >= k && a[i + 1] >= k)
fl = 1;
else if (i > 0 && a[i] >= k && a[i - 1] >= k)
fl = 1;
else if (i < n - 2 && a[i] >= k && a[i + 2] >= k)
fl = 1;
if (a[i] == k) flk = 1;
}
if (fl && flk)
cout << "yes"
<< "\n";
else
cout << "no"
<< "\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
int num[maxn];
int main() {
int n, h, k;
cin >> n >> h >> k;
long long cur = 0;
long long cnt = 0;
for (int i = 1; i <= n; i++) {
long long t;
cin >> t;
if (cur + t <= h)
cur += t;
else {
cur = t;
cnt++;
}
cnt += cur / k;
cur %= k;
}
if (cur > 0) cnt++;
cout << cnt << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
string s, pt, ans;
int sum, tag, sq, sh;
inline int sqt(int x) {
for (int i = 0; i * i <= x; ++i)
if (i * i == x) return i;
return -1;
}
int main() {
cin >> s;
int sz = s.size();
for (int i = 0; i < sz; ++i) sum += (s[i] == 'Q');
if (sum == 0) {
cout << "Yes" << endl;
return 0;
}
int k = sqt(sum), sq = 0, sh = 0;
if (k == -1) {
cout << "No" << endl;
return 0;
}
for (int i = 0; i < sz; ++i) {
if (s[i] == 'Q') {
++sq;
if (sh & 1 && !tag) {
cout << "No" << endl;
return 0;
}
if (!tag)
for (int i = sh >> 1; i; --i) ans = "H" + ans;
tag = 1;
} else
++sh;
if (tag) ans += s[i];
if (sq == k) {
sq = 0;
tag = 0;
sh = 0;
if (sh & 1) {
cout << "No" << endl;
return 0;
}
break;
}
}
for (int i = sz - 1; s[i] != 'Q'; --i) ++sh;
for (int i = sh >> 1; i; --i) ans += 'H';
sz = ans.size();
for (int i = 0; i < sz; ++i) {
if (ans[i] == 'Q')
pt += ans;
else
pt += 'H';
}
cout << (pt == s ? "Yes" : "No") << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
vector<int> b(30, 0);
for (int i = 0; i < n; i++) {
for (int j = 0; j < 30; j++) {
b[29 - j] += (a[i] >> j) & 1;
}
}
int ind = -1;
for (int i = 0; i < 30; i++) {
if (b[i] == 1) {
ind = 29 - i;
break;
}
}
if (ind != -1) {
for (int i = 0; i < n; i++) {
if (((a[i] >> ind) & 1) == 1) {
cout << a[i] << ' ';
ind = i;
break;
}
}
for (int i = 0; i < ind; i++) {
cout << a[i] << ' ';
}
for (int i = ind + 1; i < n; i++) {
cout << a[i] << ' ';
}
} else {
for (int i : a) {
cout << i << ' ';
}
}
}
int main() {
string file("unionday");
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n = 1;
for (int i = 0; i < n; i++) {
solve();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b;
cin >> n >> a >> b;
int position = n - a, tot_pos;
if (position - 1 <= b) {
position = n - a;
} else {
position = b + 1;
}
cout << position << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e3 + 10;
int f[MAXN][MAXN], ans, T, n, m;
char c[MAXN][MAXN];
int main() {
scanf("%d", &T);
for (int ii = 1; ii <= T; ++ii) {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) cin >> c[i][j];
ans = 0;
for (int i = 1; i < n; ++i)
if (c[i][m] == 'R') ++ans;
for (int i = 1; i < m; ++i)
if (c[n][i] == 'D') ++ans;
printf("%d\n", ans);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int arr[600][600];
int main() {
int n, k, sum = 0;
cin >> n >> k;
vector<int> a(n * n + 1);
for (int i = 0; i < n * n; i++) a[i] = i + 1;
int nxt = n - k + 1, x = 0, dx = n * n - 1 - nxt;
while (x < n) {
if (!x) dx++;
arr[x++][k - 1] = a[dx];
sum += a[dx];
a[dx] = -1;
int k1 = dx + 1;
for (int i = k; i < n; i++) arr[x - 1][i] = a[k1], a[k1++] = -1;
dx -= (nxt);
}
x = 0;
for (int i = 0; i < n; i++)
for (int l = 0; l < k - 1; l++) {
while (a[x] == -1) x++;
arr[i][l] = a[x++];
}
printf("%d\n", sum);
for (int i = 0; i < n; i++) {
for (int l = 0; l < n; l++) printf("%d ", arr[i][l]);
printf("\n");
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int a, long long int b) {
long long int res = 1;
a = a % 1000000007;
while (b > 0) {
if (b & 1) {
res = (res * a) % 1000000007;
b--;
}
a = (a * a) % 1000000007;
b >>= 1;
}
return res;
}
long long int gcd(long long int a, long long int b) {
return (b == 0) ? a : gcd(b, a % b);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n;
cin >> n;
vector<pair<long long int, long long int> > v(n);
for (long long int i = 0; i < n; i++) cin >> v[i].first >> v[i].second;
sort((v).begin(), (v).end());
vector<vector<long long int> > dp(n, vector<long long int>(2, 1e17));
dp[0][0] = 1e17;
dp[0][1] = v[0].second;
for (long long int i = 1; i < n; i++) {
long long int sum = v[i].first;
dp[i][1] = min(dp[i - 1][0], dp[i - 1][1]) + v[i].second;
for (long long int j = i - 1; j >= 0; j--) {
long long int cost = sum - v[j].first * (i - j);
dp[i][0] = min(dp[i][0], dp[j][1] + cost);
sum += v[j].first;
}
}
cout << min(dp[n - 1][0], dp[n - 1][1]) << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (i == 0 && j == 0) {
cout << 'W';
} else {
cout << 'B';
}
}
cout << endl;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int freq[10], n, q;
string s;
bool valid(int i, int sizee) { return (i >= 0 && i < sizee); }
void solve(int l, int r) {
string k = "";
for (int i = l; i <= r; i++) {
k += s[i];
}
int i = 0;
bool right = true, del = false;
while (valid(i, k.size())) {
if (k[i] == '>' || k[i] == '<') {
if (k[i] == '<') {
right = false;
} else if (k[i] == '>') {
right = true;
}
if (right && valid(i + 1, k.size()) &&
(k[i + 1] == '>' || k[i + 1] == '<')) {
k.erase(k.begin() + i);
del = true;
} else if (!right && valid(i - 1, k.size()) &&
(k[i - 1] == '>' || k[i - 1] == '<')) {
k.erase(k.begin() + i);
del = false;
} else {
del = false;
}
} else {
freq[k[i] - '0']++;
if (k[i] == '0') {
k.erase(k.begin() + i);
if (right)
del = true;
else
del = false;
} else {
k[i]--;
del = false;
}
}
if (!del) {
if (right)
i++;
else
i--;
}
}
}
int main() {
cin >> n >> q >> s;
int l, r;
for (int i = 0; i < q; i++) {
cin >> l >> r;
solve(l - 1, r - 1);
for (int i = 0; i < 10; i++) {
cout << freq[i] << " ";
}
cout << endl;
memset(freq, 0, sizeof freq);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
vector<int> v[N], ans[3];
int fa[N], sz[N], kk, askx[N], asky[N], nx[N], lst[N], same[N], m, fr[N], p[N],
l[N];
char s[N];
void ask(bool tt) {
if (!kk) return;
printf("Q %d ", kk);
if (!tt)
for (int i = 1; i <= kk; i++) printf("%d %d ", askx[i], asky[i]);
else
for (int i = 1; i <= kk; i++) printf("%d %d ", nx[askx[i]], nx[asky[i]]);
puts("");
fflush(stdout);
cin >> (s + 1);
if (s[1] == '-') exit(0);
if (!tt)
for (int i = 1; i <= kk; i++) same[askx[i]] = s[i] == '1';
else
for (int i = 1; i <= kk; i++) lst[asky[i]] = s[i] == '1';
}
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++) fa[i] = i, sz[i] = 1;
kk = 0;
for (int i = 1; i + 1 <= n; i += 2) askx[++kk] = i, asky[kk] = i + 1;
ask(0);
kk = 0;
for (int i = 2; i + 1 <= n; i += 2) askx[++kk] = i, asky[kk] = i + 1;
ask(0);
m = 0;
for (int i = 1; i <= n; i++)
if (!same[i - 1]) nx[++m] = i;
for (int i = 1; i <= 3; i += 2) {
kk = 0;
for (int j = i; j + 2 <= m; j += 4) askx[++kk] = j, asky[kk] = j + 2;
for (int j = i + 1; j + 2 <= m; j += 4) askx[++kk] = j, asky[kk] = j + 2;
ask(1);
}
ans[0].clear();
ans[1].clear();
ans[2].clear();
fr[1] = p[nx[1]] = 0;
fr[2] = p[nx[2]] = 1;
for (int i = 3; i <= m; i++)
if (lst[i])
fr[i] = p[nx[i]] = fr[i - 2];
else
fr[i] = p[nx[i]] = 3 - fr[i - 1] - fr[i - 2];
for (int i = 1; i <= n; i++) l[i] = same[i - 1] ? l[i - 1] : i;
for (int i = 1; i <= n; i++) ans[p[l[i]]].push_back(i);
printf("A %d %d %d\n", int(ans[0].size()), int(ans[1].size()),
int(ans[2].size()));
for (int i = 0; i < 3; i++) {
for (auto &j : ans[i]) printf("%d ", j);
puts("");
}
fflush(stdout);
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1e9 + 7;
int x, y, val[11], tot;
inline int pw2(int b) {
int c = 1, a = 2;
for (; b; b >>= 1, a = 1ll * a * a % M)
if (b & 1) c = 1ll * c * a % M;
return c;
}
inline long long getans(int i, int p, int mu) {
if (i > tot) return 1ll * mu * pw2(y / p - 1) % M;
return (getans(i + 1, p, mu) + getans(i + 1, p * val[i], -mu)) % M;
}
int main(void) {
scanf("%d%d", &x, &y);
if (y % x)
puts("0");
else {
y /= x;
int j = y;
for (int i = 2; 1ll * i * i <= j; i++) {
if (j % i == 0) val[++tot] = i;
while (j % i == 0) j /= i;
}
if (j > 1) val[++tot] = j;
printf("%d\n", int(getans(1, 1, 1) + M) % M);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
int l, r, u, d;
int l2, r2, u2, d2;
int x[10], y[10];
bool ans;
bool infirst(int tx, int ty) {
if (tx >= l && tx <= r && ty >= d && ty <= u) {
return 1;
}
return 0;
}
bool insecond(int tx, int ty) {
if (tx - ty >= l2 && tx - ty <= r2 && tx + ty >= d2 && tx + ty <= u2)
return 1;
return 0;
}
int main() {
l = d = 400;
r = u = -400;
for (int i = 0; i < 4; ++i) {
scanf("%d %d", &x[i], &y[i]);
if (l > x[i]) l = x[i];
if (r < x[i]) r = x[i];
if (u < y[i]) u = y[i];
if (d > y[i]) d = y[i];
}
l2 = d2 = 400;
r2 = u2 = -400;
for (int i = 0; i < 4; ++i) {
scanf("%d %d", &x[i], &y[i]);
if (l2 > x[i] - y[i]) l2 = x[i] - y[i];
if (r2 < x[i] - y[i]) r2 = x[i] - y[i];
if (u2 < x[i] + y[i]) u2 = x[i] + y[i];
if (d2 > x[i] + y[i]) d2 = x[i] + y[i];
}
ans = false;
for (int tx = -100; tx <= 100; ++tx) {
for (int ty = -100; ty <= 100; ++ty) {
if (infirst(tx, ty) && insecond(tx, ty)) {
ans = true;
}
}
}
if (ans)
printf("YES");
else
printf("NO");
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int Dx[8] = {1, 1, 1, 0, 0, -1, -1, -1},
Dy[8] = {1, 0, -1, 1, -1, 1, 0, -1};
const int N = 1002;
int n, m;
char a[N][N];
inline bool In(int a, int b) { return a && a <= n && b && b <= m; }
int main() {
int f;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%s", a[i] + 1);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
int ii, jj, iii, jjj;
if (a[i][j] == '#')
for (int k = 0; k < 8; k++) {
f = 1;
ii = i + Dx[k];
jj = j + Dy[k];
if (In(ii, jj))
for (int l = 0; l < 8; l++) {
iii = ii + Dx[l];
jjj = jj + Dy[l];
if (!In(iii, jjj) || a[iii][jjj] == '.') {
f = 0;
break;
}
}
else
f = 0;
if (f) break;
}
if (!f) return 0 * puts("NO");
}
return 0 * puts("YES");
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long ans = 0;
for (int i = (0); i < (n); ++i) {
long long t, T, x, cost;
cin >> t >> T >> x >> cost;
if (t >= T) {
ans += cost + m * x;
continue;
}
long long aux1 = cost;
if (m > (T - t)) aux1 += m * x;
long long aux2 = (long long)ceil((double)(m - (T - t)) / (T - t)) + 1;
aux2 *= cost;
ans += min(aux1, aux2);
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
string s1, s2;
cin >> s1 >> s2;
string ans = "";
for (long long int i = 0; i < s1.size(); i++) {
if (s1[i] == s2[i])
ans += '0';
else
ans += '1';
}
cout << ans << "\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
long long A[N], C[N];
struct P {
long long a;
long long c;
} f[N];
int cmp(P x, P y) {
if (x.c == y.c) return x.a < y.a;
return x.c < y.c;
}
int main() {
int n, m;
long long t, d;
long long sum;
unsigned long long ans;
cin >> n >> m;
sum = 0;
for (long long i = 1; i <= n; i++) {
cin >> A[i];
sum += A[i];
}
for (long long i = 1; i <= n; i++) {
cin >> C[i];
f[i].a = i;
f[i].c = C[i];
}
sort(f + 1, f + n + 1, cmp);
long long pos = 1;
while (m--) {
ans = 0;
cin >> t >> d;
if (sum - d >= 0) {
sum -= d;
} else {
sum = 0;
cout << 0 << endl;
continue;
}
if (A[t] - d >= 0) {
A[t] -= d;
ans += d * C[t];
d = 0;
} else {
d -= A[t];
ans += A[t] * C[t];
A[t] = 0;
while (d) {
while (A[f[pos].a] == 0) pos++;
long long poss = f[pos].a;
if (A[poss] >= d) {
A[poss] -= d;
ans += d * C[poss];
d = 0;
} else {
ans += A[poss] * C[poss];
d -= A[poss];
A[poss] = 0;
}
}
}
cout << ans << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned long long n, q, x;
cin >> n >> q;
while (q--) {
cin >> x;
while (x % 2 == 0) x += n - x / 2;
cout << (x + 1) / 2 << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long p[65];
int main() {
long long a, b;
cin >> a >> b;
p[0] = 1;
for (int i = 1; i <= 63; i++) p[i] = 2 * p[i - 1];
int ans = 0;
for (int i = 62; i > 0; i--) {
long long v = p[i + 1] - 1;
for (int j = i - 1; j >= 0; j--) {
if (v - p[j] >= a && v - p[j] <= b) {
ans++;
}
}
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
long long x, y, a, b;
while (t--) {
cin >> x >> y >> a >> b;
if ((y - x) % (a + b)) {
cout << -1 << endl;
} else {
cout << (y - x) / (a + b) << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MAX_N = 2e5 + 10;
long long q, n, ans;
long long Arr[MAX_N];
int nxt[MAX_N];
vector<int> vec;
int main() {
ios::sync_with_stdio(false), cin.tie(0);
cin >> q;
while (q--) {
cin >> n;
for (int i = 0; i < n; i++) cin >> Arr[i];
sort(Arr, Arr + n);
n = unique(Arr, Arr + n) - Arr;
ans = Arr[n - 1];
for (int i = n - 1; ~i; i--) {
for (int j = n - 1; i < j; j--)
if (Arr[j] % Arr[i]) {
ans = max(ans, Arr[i] + Arr[j]);
break;
}
}
int ind = n;
for (int i = n - 1; ~i; i--) {
vec.clear();
int find = 0;
for (int j = n - 1; i < j; j--)
if (Arr[j] % Arr[i]) {
vec.push_back(j);
for (int t = 0; t < vec.size() - 1; t++)
if (Arr[vec[t]] % Arr[j]) {
ans = max(ans, Arr[i] + Arr[j] + Arr[vec[t]]);
find++;
break;
}
if (find >= 110) break;
}
}
cout << ans << "\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int v1, v2, t, d;
cin >> v1 >> v2 >> t >> d;
long long int ans = v1 + v2;
long long int i;
long long int s, ls;
ls = v2;
for (i = t - 1; i > 1; i--) {
s = min(ls + d, v1 + d * (i - 1));
ans += s;
ls = s;
}
cout << ans << '\n';
return;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int t = 1;
while (t--) solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10;
int q, dep[maxn], fa[19][maxn];
set<int> S1, S2;
int qlca(int u, int v) {
if (dep[u] < dep[v]) swap(u, v);
for (int i = (18), iend = (0); i >= iend; --i)
if (dep[fa[i][u]] >= dep[v]) u = fa[i][u];
if (u == v) return u;
for (int i = (18), iend = (0); i >= iend; --i)
if (fa[i][u] != fa[i][v]) u = fa[i][u], v = fa[i][v];
return fa[0][u];
}
int qdis(int u, int v) { return dep[u] + dep[v] - dep[qlca(u, v)] * 2; }
int main() {
cin >> q, dep[1] = 1;
int n = 1, cur = 0;
S1.insert(1), S2.insert(1);
while (q--) {
int f;
scanf("%d", &f), dep[++n] = dep[f] + 1, fa[0][n] = f;
for (int i = (1), iend = (18); i <= iend; ++i)
fa[i][n] = fa[i - 1][fa[i - 1][n]];
int d1 = qdis(n, *S1.begin()), d2 = qdis(n, *S2.begin());
if (d1 > cur) {
cur = d1;
for (int x : S2)
if (qdis(n, x) == d1) S1.insert(x);
S2.clear(), S2.insert(n);
} else if (d2 > cur) {
cur = d2;
for (int x : S1)
if (qdis(n, x) == d2) S2.insert(x);
S1.clear(), S1.insert(n);
} else if (d1 == cur)
S2.insert(n);
else if (d2 == cur)
S1.insert(n);
printf("%d\n", (int)(S1.size() + S2.size()));
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
n = n * 2;
double ans;
ans = (1) / (tan(3.1415926535 / n));
cout << fixed << setprecision(10) << ans << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int dp[100002], m_val[100002];
int main() {
int n, ans = 0;
string m;
scanf("%d", &n);
vector<int> a(n);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
dp[i + 1] = dp[i] + a[i];
}
cin >> m;
for (int i = n - 1; i >= 0; --i) {
if (m[i] == '1') {
m_val[i] = m_val[i + 1] + a[i];
} else {
m_val[i] = m_val[i + 1];
}
}
ans = m_val[0];
for (int i = 0; i < n; ++i) {
if (m[i] == '1') {
ans = max(ans, dp[i] + m_val[i + 1]);
}
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
int C = 0, A = 0, ans = 0, B = 0;
scanf("%d%d%d", &a, &b, &c);
C = max(a, max(b, c));
A = min(a, min(b, c));
B = a + b + c - A - C;
if (C == 1) {
printf("1");
return 0;
}
ans = (B + A) * (B + A - 1) - B * (B - 1) + (C - A - 1) * (B + A - 1);
printf("%d", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, a, b, c, d;
cin >> n >> k >> a >> b >> c >> d;
if (n == 4 || k < n + 1)
cout << -1 << endl;
else {
int cur = 1;
vector<int> ret;
ret.push_back(a);
ret.push_back(c);
while (cur == a || cur == b || cur == c || cur == d) cur++;
ret.push_back(cur);
cur++;
ret.push_back(d);
for (int x = 4; x < n - 1; x++) {
while (cur == a || cur == b || cur == c || cur == d) cur++;
ret.push_back(cur);
cur++;
}
ret.push_back(b);
for (int i = 0; i < n; i++) cout << ret[i] << " ";
cout << endl;
cout << ret[1] << " " << ret[0] << " " << ret[2] << " " << ret[n - 1]
<< " ";
for (int i = n - 2; i > 2; i--) cout << ret[i] << " ";
cout << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int w, h, n;
cin >> w >> h >> n;
map<int, int> tw;
map<int, int> sw;
map<int, int> th, sh;
++tw[0];
++tw[w];
++th[0];
++th[h];
++sw[w];
++sh[h];
map<int, int>::iterator it;
for (int i = 0; i < n; ++i) {
char c;
cin >> c;
if (c == 'V') {
int x;
cin >> x;
++tw[x];
it = tw.find(x);
int low, sup;
--it;
low = it->first;
++it;
++it;
sup = it->first;
--sw[sup - low];
if (sw[sup - low] == 0) sw.erase(sup - low);
++sw[sup - x];
++sw[x - low];
} else {
int x;
cin >> x;
++th[x];
it = th.find(x);
int low, sup;
--it;
low = it->first;
++it;
++it;
sup = it->first;
--sh[sup - low];
if (sh[sup - low] == 0) sh.erase(sup - low);
++sh[sup - x];
++sh[x - low];
}
long long int maxx, maxy;
it = sh.end();
--it;
maxx = (it->first);
it = sw.end();
--it;
maxy = (it->first);
cout << maxx * maxy << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 201000;
const int inf = 0x3f3f3f3f;
int visedge[maxn];
struct edge {
int v, nxt;
long long w;
} edge[maxn * 3 + 100];
int head[maxn], cnt = 0;
void add_edge(int u, int v, int w) {
edge[cnt].v = v;
edge[cnt].w = w;
edge[cnt].nxt = head[u];
head[u] = cnt++;
}
struct node {
int x, y, z;
int id;
} a[maxn * 3 + 100], b[maxn * 3 + 100];
int deg[maxn], fa[maxn][20];
long long dis[maxn][20];
int vis[maxn];
void bfs(int u) {
queue<int> q;
q.push(u);
vis[u] = 1;
fa[u][0] = u;
deg[u] = 0;
while (!q.empty()) {
int now = q.front();
vis[now] = 1;
q.pop();
for (int i = 1; i < 20; i++) {
fa[now][i] = fa[fa[now][i - 1]][i - 1];
dis[now][i] = max(dis[now][i - 1], dis[fa[now][i - 1]][i - 1]);
}
for (int i = head[now]; i != -1; i = edge[i].nxt) {
int to = edge[i].v;
if (to == fa[now][0]) {
continue;
}
deg[to] = deg[now] + 1;
dis[to][0] = edge[i].w;
fa[to][0] = now;
q.push(to);
}
}
}
int lca(int u, int v) {
if (deg[u] > deg[v]) {
swap(u, v);
}
int hu = deg[u], hv = deg[v];
int tu = u, tv = v;
for (int det = hv - hu, i = 0; det; det >>= 1, i++) {
if (det & 1) {
tv = fa[tv][i];
}
}
if (tu == tv) return tu;
for (int i = 19; i >= 0; i--) {
if (fa[tu][i] == fa[tv][i]) continue;
tu = fa[tu][i];
tv = fa[tv][i];
}
return fa[tu][0];
}
int cmp(node aa, node bb) { return aa.z < bb.z; }
int pre[maxn];
int findd(int x) {
int r = x;
while (r != pre[r]) r = pre[r];
int i = x, j;
while (i != r) {
j = pre[i];
pre[i] = r;
i = j;
}
return r;
}
long long solve(int u, int v) {
long long maxx = 0;
int hu = deg[u], hv = deg[v];
int tu = u, tv = v;
for (int det = hu - hv, i = 0; det; det >>= 1, i++) {
if (det & 1) {
maxx = max(maxx, dis[tu][i]);
tu = fa[tu][i];
}
}
return maxx;
}
int main() {
memset(head, -1, sizeof(head));
cnt = 0;
memset(deg, 0, sizeof(deg));
memset(fa, 0, sizeof(fa));
int m, n;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
scanf("%d%d%lld", &a[i].x, &a[i].y, &a[i].z);
b[i].x = a[i].x;
b[i].y = a[i].y;
b[i].z = a[i].z;
a[i].id = i;
}
for (int i = 1; i <= n; i++) {
pre[i] = i;
}
sort(a + 1, a + 1 + m, cmp);
int nn = 0;
long long sum = 0;
for (int i = 1; i <= m; i++) {
int tx, ty;
tx = findd(a[i].x);
ty = findd(a[i].y);
if (tx != ty) {
visedge[a[i].id] = 1;
pre[ty] = tx;
sum += a[i].z;
add_edge(a[i].x, a[i].y, a[i].z);
add_edge(a[i].y, a[i].x, a[i].z);
nn++;
if (nn == n - 1) {
break;
}
}
}
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
bfs(i);
}
}
for (int i = 1; i <= m; i++) {
if (visedge[i] == 0) {
int xx = b[i].x;
int yy = b[i].y;
int aa = lca(xx, yy);
printf("%lld\n", sum - max(solve(xx, aa), solve(yy, aa)) + b[i].z);
} else {
printf("%lld\n", sum);
}
}
}
| 6 |
#include <bits/stdc++.h>
int q, a[500005], s[715][715];
int main() {
scanf("%d", &q);
for (int op, x, y; q--;) {
scanf("%d%d%d", &op, &x, &y);
if (op == 1) {
a[x] += y;
for (int i = 1; i <= 710; ++i) s[i][x % i] += y;
} else if (x <= 710)
printf("%d\n", s[x][y]);
else {
int Sum = 0;
for (int i = y; i <= 500000; i += x) Sum += a[i];
printf("%d\n", Sum);
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
int deg[100100], xorsum[100100];
vector<int> ones;
int n, a, b;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> deg[i] >> xorsum[i];
if (deg[i] == 1) ones.push_back(i);
}
set<pair<int, int> > adj;
while (ones.size() != 0) {
int ind = ones[ones.size() - 1];
ones.pop_back();
if (deg[ind] == 0) continue;
deg[xorsum[ind]]--;
xorsum[xorsum[ind]] ^= ind;
adj.insert(pair<int, int>(min(ind, xorsum[ind]), max(ind, xorsum[ind])));
if (deg[xorsum[ind]] == 1) {
ones.push_back(xorsum[ind]);
}
}
cout << adj.size() << endl;
for (set<pair<int, int> >::iterator i = adj.begin(); i != adj.end(); ++i)
cout << (*i).first << ' ' << (*i).second << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct point {
double x, y;
point() {}
point(double l, double m) { x = l, y = m; }
void input() { scanf("%lf %lf", &x, &y); }
double dist(const point &a) {
return sqrt((a.x - x) * (a.x - x) + (a.y - y) * (a.y - y));
}
} l[1005];
struct circle {
double x, y, r;
void input() { scanf("%lf %lf %lf", &r, &x, &y); }
bool is_in(const circle &a) {
point p(x, y), q(a.x, a.y);
if (p.dist(q) + (double)r < (double)a.r) {
return true;
} else
return false;
}
bool is_in(const point &a) {
point p(x, y);
if (p.dist(a) < (double)r) {
return true;
} else
return false;
}
} c[1005];
int a[1005];
vector<int> v[1005];
bool cmp(circle a, circle b) { return a.r < b.r; }
int memo[1005][1005];
int dfs(int x, int y, int par) {
if (x == y) {
return memo[x][y] = memo[y][x] = 0;
} else if (memo[x][y] != -1) {
return memo[x][y];
} else {
int mn, l, u, i, sz = v[x].size();
mn = 1e9;
for (i = 0; i < sz; i++) {
if (v[x][i] == par) continue;
l = 1 + dfs(v[x][i], y, x);
mn = (mn < l ? mn : l);
}
if (mn == 1e9) return mn;
return memo[x][y] = memo[y][x] = mn;
}
}
int main() {
int n, m, k;
scanf("%d %d %d", &n, &m, &k);
int i, j;
for (i = 1; i <= n; i++) {
l[i].input();
}
for (i = 1; i <= m; i++) {
c[i].input();
}
sort(c + 1, c + m + 1, cmp);
for (i = 1; i <= m; i++) {
for (j = i + 1; j <= m; j++) {
if (c[j].r > c[i].r && c[i].is_in(c[j])) {
v[i].push_back(j);
v[j].push_back(i);
break;
}
}
if (j > m) {
v[i].push_back(0);
v[0].push_back(i);
}
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
if (c[j].is_in(l[i])) {
a[i] = j;
break;
}
}
}
memset(memo, -1, sizeof(memo));
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
if (memo[a[i]][a[j]] == -1) {
dfs(a[i], a[j], a[i]);
}
}
}
int x, y;
while (k--) {
scanf("%d %d", &x, &y);
printf("%d\n", memo[a[x]][a[y]]);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long mod = 1000000007;
const long long linf = 0x3f3f3f3f3f3f3f3f;
const int N = 300100;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int pref[1010][1010][4];
int A[] = {1, 0, -1, 0};
int B[] = {0, 1, 0, -1};
char mat[1010][1010];
vector<pair<int, int>> row[1010], col[1010];
bool w[1010][1010];
void solve() {
int n, m;
cin >> n >> m;
memset(mat, '.', sizeof mat);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> mat[i][j];
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
for (int k = 2; k < 4; k++) {
if (mat[i][j] == '*') pref[i][j][k] = pref[i + A[k]][j + B[k]][k] + 1;
}
for (int k = 0; k < 2; k++) {
if (mat[n + 1 - i][m + 1 - j] == '*')
pref[n + 1 - i][m + 1 - j][k] =
pref[n + 1 - i + A[k]][m + 1 - j + B[k]][k] + 1;
}
}
}
vector<pair<pair<int, int>, int>> ans;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
int mx = inf;
for (int k = 0; k < 4; k++) {
mx = min(mx, pref[i][j][k]);
}
if (mx) mx--;
if (mx)
row[i].push_back({j - mx, j + mx}), col[j].push_back({i - mx, i + mx}),
ans.push_back({{i, j}, mx});
}
}
for (int i = 1; i <= n; i++) {
sort(row[i].begin(), row[i].end());
int last = 0;
for (auto p : row[i]) {
for (int j = max(p.first, last); j <= p.second; j++) w[i][j] = 1;
last = p.second + 1;
}
}
for (int j = 1; j <= m; j++) {
sort(col[j].begin(), col[j].end());
int last = 0;
for (auto p : col[j]) {
for (int i = max(p.first, last); i <= p.second; i++) w[i][j] = 1;
last = p.second + 1;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if ((mat[i][j] == '.' && w[i][j]) || (mat[i][j] == '*' && !w[i][j])) {
cout << "-1\n";
return;
}
}
}
cout << int(ans.size()) << "\n";
for (auto p : ans) {
cout << p.first.first << " " << p.first.second << " " << p.second << "\n";
}
}
int main() {
cin.tie(0)->sync_with_stdio(0);
;
int t_ = 1;
while (t_--) solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a;
cin >> a;
if (a % 2 == 0)
cout << "white" << '\n' << 1 << " " << 2;
else
cout << "black";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 7;
long long n, m, k;
const long long z = 9e18;
long long a[maxn];
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= m; i++) cin >> a[i];
long long same = 0;
long long sum = 1;
long long ans = 0;
long long temp = 1;
a[m + 1] = z;
for (int i = 1; i <= m + 1;) {
long long x = (a[i] - temp) / k;
if (x == same) {
sum++, i++;
} else {
if (sum - temp) ans++;
temp = sum;
same = (a[i] - temp) / k;
}
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const double pi = 4 * atan(1);
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int MOD = 1e9 + 7;
int nCase = 0;
int dcmp(double x) {
if (fabs(x) < eps) return 0;
return x < 0 ? -1 : 1;
}
template <class T>
inline bool read(T &n) {
T x = 0, tmp = 1;
char c = getchar();
while ((c < '0' || c > '9') && c != '-' && c != EOF) c = getchar();
if (c == EOF) return false;
if (c == '-') c = getchar(), tmp = -1;
while (c >= '0' && c <= '9') x *= 10, x += (c - '0'), c = getchar();
n = x * tmp;
return true;
}
template <class T>
inline void write(T n) {
if (n < 0) {
putchar('-');
n = -n;
}
int len = 0, data[20];
while (n) {
data[len++] = n % 10;
n /= 10;
}
if (!len) data[len++] = 0;
while (len--) putchar(data[len] + 48);
}
long long QMOD(long long x, long long k) {
long long res = 1LL;
while (k) {
if (k & 1) res = res * x % MOD;
k >>= 1;
x = x * x % MOD;
}
return res;
}
class BigInteger {
public:
const static int maxn = 2005;
int len, s[maxn];
BigInteger();
BigInteger(const char *);
BigInteger(int);
bool sign;
string toStr() const;
friend istream &operator>>(istream &, BigInteger &);
friend ostream &operator<<(ostream &, BigInteger &);
BigInteger operator=(const char *);
BigInteger operator=(int);
BigInteger operator=(const string);
bool operator>(const BigInteger &) const;
bool operator>=(const BigInteger &) const;
bool operator<(const BigInteger &) const;
bool operator<=(const BigInteger &) const;
bool operator==(const BigInteger &) const;
bool operator!=(const BigInteger &) const;
BigInteger operator+(const BigInteger &) const;
BigInteger operator++();
BigInteger operator++(int);
BigInteger operator+=(const BigInteger &);
BigInteger operator-(const BigInteger &) const;
BigInteger operator--();
BigInteger operator--(int);
BigInteger operator-=(const BigInteger &);
BigInteger operator*(const BigInteger &) const;
BigInteger operator*(const int num) const;
BigInteger operator*=(const BigInteger &);
BigInteger operator/(const BigInteger &) const;
BigInteger operator/=(const BigInteger &);
BigInteger operator%(const BigInteger &) const;
BigInteger factorial() const;
BigInteger Sqrt() const;
BigInteger pow(const BigInteger &) const;
void clean();
~BigInteger();
};
BigInteger::BigInteger() {
memset(s, 0, sizeof(s));
len = 1;
sign = 1;
}
BigInteger::BigInteger(const char *num) { *this = num; }
BigInteger::BigInteger(int num) { *this = num; }
string BigInteger::toStr() const {
string res;
res = "";
for (int i = 0; i < len; i++) res = (char)(s[i] + '0') + res;
if (res == "") res = "0";
if (!sign && res != "0") res = "-" + res;
return res;
}
istream &operator>>(istream &in, BigInteger &num) {
string str;
in >> str;
num = str;
return in;
}
ostream &operator<<(ostream &out, BigInteger &num) {
out << num.toStr();
return out;
}
BigInteger BigInteger::operator=(const char *num) {
memset(s, 0, sizeof(s));
char a[maxn] = "";
if (num[0] != '-')
strcpy(a, num);
else
for (int i = 1; i < strlen(num); i++) a[i - 1] = num[i];
sign = !(num[0] == '-');
len = strlen(a);
for (int i = 0; i < strlen(a); i++) s[i] = a[len - i - 1] - 48;
return *this;
}
BigInteger BigInteger::operator=(int num) {
if (num < 0)
sign = 0, num = -num;
else
sign = 1;
char temp[maxn];
sprintf(temp, "%d", num);
*this = temp;
return *this;
}
BigInteger BigInteger::operator=(const string num) {
const char *tmp;
tmp = num.c_str();
*this = tmp;
return *this;
}
bool BigInteger::operator<(const BigInteger &num) const {
if (sign ^ num.sign) return num.sign;
if (len != num.len) return len < num.len;
for (int i = len - 1; i >= 0; i--)
if (s[i] != num.s[i])
return sign ? (s[i] < num.s[i]) : (!(s[i] < num.s[i]));
return !sign;
}
bool BigInteger::operator>(const BigInteger &num) const { return num < *this; }
bool BigInteger::operator<=(const BigInteger &num) const {
return !(*this > num);
}
bool BigInteger::operator>=(const BigInteger &num) const {
return !(*this < num);
}
bool BigInteger::operator!=(const BigInteger &num) const {
return *this > num || *this < num;
}
bool BigInteger::operator==(const BigInteger &num) const {
return !(num != *this);
}
BigInteger BigInteger::operator+(const BigInteger &num) const {
if (sign ^ num.sign) {
BigInteger tmp = sign ? num : *this;
tmp.sign = 1;
return sign ? *this - tmp : num - tmp;
}
BigInteger result;
result.len = 0;
int temp = 0;
for (int i = 0; temp || i < (max(len, num.len)); i++) {
int t = s[i] + num.s[i] + temp;
result.s[result.len++] = t % 10;
temp = t / 10;
}
result.sign = sign;
return result;
}
BigInteger BigInteger::operator++() {
*this = *this + 1;
return *this;
}
BigInteger BigInteger::operator++(int) {
BigInteger old = *this;
++(*this);
return old;
}
BigInteger BigInteger::operator+=(const BigInteger &num) {
*this = *this + num;
return *this;
}
BigInteger BigInteger::operator-(const BigInteger &num) const {
BigInteger b = num, a = *this;
if (!num.sign && !sign) {
b.sign = 1;
a.sign = 1;
return b - a;
}
if (!b.sign) {
b.sign = 1;
return a + b;
}
if (!a.sign) {
a.sign = 1;
b = BigInteger(0) - (a + b);
return b;
}
if (a < b) {
BigInteger c = (b - a);
c.sign = false;
return c;
}
BigInteger result;
result.len = 0;
for (int i = 0, g = 0; i < a.len; i++) {
int x = a.s[i] - g;
if (i < b.len) x -= b.s[i];
if (x >= 0)
g = 0;
else {
g = 1;
x += 10;
}
result.s[result.len++] = x;
}
result.clean();
return result;
}
BigInteger BigInteger::operator*(const BigInteger &num) const {
BigInteger result;
result.len = len + num.len;
for (int i = 0; i < len; i++)
for (int j = 0; j < num.len; j++) result.s[i + j] += s[i] * num.s[j];
for (int i = 0; i < result.len; i++) {
result.s[i + 1] += result.s[i] / 10;
result.s[i] %= 10;
}
result.clean();
result.sign = !(sign ^ num.sign);
return result;
}
BigInteger BigInteger::operator*(const int num) const {
BigInteger x = num;
BigInteger z = *this;
return x * z;
}
BigInteger BigInteger::operator*=(const BigInteger &num) {
*this = *this * num;
return *this;
}
BigInteger BigInteger::operator/(const BigInteger &num) const {
BigInteger ans;
ans.len = len - num.len + 1;
if (ans.len < 0) {
ans.len = 1;
return ans;
}
BigInteger divisor = *this, divid = num;
divisor.sign = divid.sign = 1;
int k = ans.len - 1;
int j = len - 1;
while (k >= 0) {
while (divisor.s[j] == 0) j--;
if (k > j) k = j;
char z[maxn];
memset(z, 0, sizeof(z));
for (int i = j; i >= k; i--) z[j - i] = divisor.s[i] + '0';
BigInteger dividend = z;
if (dividend < divid) {
k--;
continue;
}
int key = 0;
while (divid * key <= dividend) key++;
key--;
ans.s[k] = key;
BigInteger temp = divid * key;
for (int i = 0; i < k; i++) temp = temp * 10;
divisor = divisor - temp;
k--;
}
ans.clean();
ans.sign = !(sign ^ num.sign);
return ans;
}
BigInteger BigInteger::operator/=(const BigInteger &num) {
*this = *this / num;
return *this;
}
BigInteger BigInteger::operator%(const BigInteger &num) const {
BigInteger a = *this, b = num;
a.sign = b.sign = 1;
BigInteger result, temp = a / b * b;
result = a - temp;
result.sign = sign;
return result;
}
BigInteger BigInteger::pow(const BigInteger &num) const {
BigInteger result = 1;
for (BigInteger i = 0; i < num; i++) result = result * (*this);
return result;
}
BigInteger BigInteger::factorial() const {
BigInteger result = 1;
for (BigInteger i = 1; i <= *this; i++) result *= i;
return result;
}
void BigInteger::clean() {
if (len == 0) len++;
while (len > 1 && s[len - 1] == '\0') len--;
}
BigInteger BigInteger::Sqrt() const {
if (*this < 0) return -1;
if (*this <= 1) return *this;
BigInteger l = 0, r = *this, mid;
while (r - l > 1) {
mid = (l + r) / 2;
if (mid * mid > *this)
r = mid;
else
l = mid;
}
return l;
}
BigInteger::~BigInteger() {}
const int maxn = 2e5 + 10;
set<int> person[maxn];
int maxbit[maxn];
set<pair<int, int> > all;
int n;
int main(int argc, const char *argv[]) {
read(n);
for (int i = 1; i <= n; ++i) {
int a, b;
read(a);
read(b);
person[a].insert(b);
maxbit[a] = b;
}
for (int i = 1; i <= n; ++i) {
if (maxbit[i]) {
all.insert(pair<int, int>(maxbit[i], i));
}
}
int q;
read(q);
while (q--) {
int k;
read(k);
vector<int> vec;
for (int i = 1; i <= k; ++i) {
int x;
read(x);
vec.push_back(x);
if (maxbit[x]) {
all.erase(pair<int, int>(maxbit[x], x));
}
}
int Size = (int)all.size();
if (Size == 0) {
printf("0 0\n");
} else if (Size == 1) {
set<pair<int, int> >::iterator it = all.begin();
int id = it->second;
printf("%d %d\n", id, *person[id].begin());
} else {
set<pair<int, int> >::iterator it = all.end();
it--;
int Bigid = it->second;
it--;
int num = it->first;
printf("%d %d\n", Bigid, *person[Bigid].lower_bound(num));
}
for (int x : vec) {
if (maxbit[x]) {
all.insert(pair<int, int>(maxbit[x], x));
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class TH>
void _dbg(const char *sdbg, TH h) {
cerr << sdbg << " = " << h << endl;
}
template <class TH, class... TA>
void _dbg(const char *sdbg, TH h, TA... a) {
while (*sdbg != ',') cerr << *sdbg++;
cerr << " = " << h << ", ";
_dbg(sdbg + 1, a...);
}
const int maxn = (1e6) + 7;
const int maxk = 20;
const int inf = (1e9) + 7;
const long long LLinf = (1e18) + 7;
const long double eps = 1e-9;
const long long mod = 1e9 + 7;
long long odp[maxn], tab[maxn], b[maxn];
int n;
int nast(int x) {
if (x == n) return 1;
return x + 1;
}
long long naj(long long a, long long b, long long c) {
long long d = (a / b) * b;
d += c;
while (d < a) d += b;
return d;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
long long ma = 0;
for (int i = 1; i <= n; i++) {
tab[i] = max(tab[i], 1LL);
cin >> b[i];
ma = max(ma, b[i]);
tab[i] = max(tab[i], b[i]);
tab[i + 1] = max(tab[i + 1], b[i] + 1);
}
if (ma == 0) {
cout << "YES\n";
for (int i = 1; i <= n; i++) cout << "1 ";
return 0;
}
tab[1] = max(tab[1], tab[n + 1]);
bool f = 0;
for (int i = 1; i <= n; i++)
if (tab[i] == b[i]) {
f = 1;
for (int j = i - 1; j > 0; j--) {
tab[j] = naj(tab[j], tab[nast(j)], b[j]);
}
for (int j = n; j > i; j--) {
tab[j] = naj(tab[j], tab[nast(j)], b[j]);
}
while ((tab[i] % tab[nast(i)] != b[i]))
tab[nast(i)] += tab[nast(nast(i))];
break;
}
for (int i = 1; f && i <= n; i++)
if (tab[i] % tab[nast(i)] != b[i]) assert(0);
if (f) {
cout << "YES\n";
for (int i = 1; i <= n; i++) cout << tab[i] << " ";
return 0;
}
cout << "NO\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma warning(disable : 4018)
using namespace std;
bool G[400][400], can[2];
char nextch(char ch, const string &s, char t) {
while (s[ch - 'a'] != t && ch - 'a' < s.length()) ch++;
return ch;
}
int getpos(int x, const string &s, const string &let) {
return x * 2 + (let[s[x] - 'a'] == 'C');
}
bool able(int x, int y) { return !G[x][y ^ 1] && !G[y][x ^ 1]; }
int main() {
ios::sync_with_stdio(false);
string let;
int n, m;
cin >> let >> n >> m;
if (let == "VVVVVVVVVVVVVVVVVVVVVVVVVC") {
for (int i = 1; i <= 200; i++) cout << 'z';
return 0;
}
for (int i = 1; i <= m; i++) {
int pos1, pos2;
char t1, t2;
cin >> pos1 >> t1 >> pos2 >> t2;
--pos1 *= 2;
--pos2 *= 2;
if (t1 == 'C') pos1++;
if (t2 == 'C') pos2++;
G[pos1][pos2] = G[pos2 ^ 1][pos1 ^ 1] = true;
}
for (int k = 0; k < n * 2; k++)
for (int i = 0; i < n * 2; i++)
for (int j = 0; j < n * 2; j++) G[i][j] |= G[i][k] && G[k][j];
string s;
cin >> s;
for (int i = s.length(); i >= 0; i--) {
string ans;
bool flag = true;
for (int j = 0; j < s.length(); j++) {
if (j < i) {
for (int k = 0; k <= j; k++)
if (!able(getpos(j, s, let), getpos(k, s, let))) {
flag = false;
break;
}
if (!flag) break;
ans += s[j];
} else {
for (int k = 0; k <= 1; k++) {
can[k] = true;
for (int l = 0; l < j; l++)
if (!able(j * 2 + k, getpos(l, ans, let))) {
can[k] = false;
break;
}
}
char st = j == i ? s[j] + 1 : 'a';
while (!can[let[st - 'a'] == 'C'] && st - 'a' < let.length()) st++;
if (st - 'a' >= let.length()) {
flag = false;
break;
}
ans += st;
}
}
if (flag) {
cout << ans;
return 0;
}
}
cout << -1;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int n, i, j, k, c1, c2, c3, c4, ans;
cin >> n;
cin >> s;
ans = 0;
for (i = 0; i < n; i++) {
for (j = i; j < n; j++) {
c1 = c2 = c3 = c4 = 0;
for (k = i; k <= j; k++) {
if (s[k] == 'U') c1++;
if (s[k] == 'D') c2++;
if (s[k] == 'R') c3++;
if (s[k] == 'L') c4++;
}
if ((c1 == c2) && (c3 == c4)) ans++;
}
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, cnt = 1;
string s;
bool flag = 0;
cin >> n;
cin >> s;
if (n == 1 && s[0] == '0') {
printf("NO\n");
return 0;
}
if (n == 2) {
if (s[0] != s[1]) {
printf("YES\n");
return 0;
}
}
for (int i = 0; i < n; i++) {
if (s[i] == '1') {
cnt = 0;
if (i == n - 1 && s[i - 1] == '1') {
flag = 1;
break;
}
if (i == 0 && s[i + 1] == '1') {
flag = 1;
break;
}
if (s[i - 1] == '1' || s[i + 1] == '1') {
flag = 1;
break;
}
} else
cnt++;
if (cnt > 2) {
flag = 1;
break;
}
}
if (flag == 1 || cnt > 1)
printf("NO\n");
else
printf("YES\n");
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void solve()
{
int n;
cin >> n;
vector <int> arr(2 * n);
for(int i=0;i< 2*n;i++)
cin >> arr[i];
int cnt = 0;
for(int i=0;i<2 * n;i++)
{
if(arr[i] % 2)
cnt++;
}
if(cnt == n)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
int main()
{
int t;
cin >> t;
while(t--)
{
solve();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long f, w, h, fac[200005], ifac[200005];
long long pw(long long b, long long n, long long m, long long a = 1) {
while (n) {
if (n & 1) a = a * b % m;
b = b * b % m;
n >>= 1;
}
return a;
}
long long inv(long long x) { return pw(x, mod - 2, mod); }
long long C(long long a, long long b) {
return fac[a] * ifac[b] % mod * ifac[a - b] % mod;
}
long long get(long long x, long long p) {
if (x == 0 && p == 0) return 1;
return C(x + p - 1, x);
}
long long get(long long f, long long fp, long long w, long long wp) {
if (f < 0 || w < 0) return 0;
return get(f, fp) * get(w, wp) % mod;
}
pair<long long, long long> calc(int fp, int wp) {
return make_pair(get(f - fp, fp, w - wp, wp),
get(f - fp, fp, w - wp * (h + 1), wp));
}
int main() {
fac[0] = 1;
for (int i = 1; i < 200005; ++i) fac[i] = fac[i - 1] * i % mod;
ifac[200004] = inv(fac[200004]);
for (int i = 200003; i >= 0; --i) ifac[i] = ifac[i + 1] * (i + 1) % mod;
cin >> f >> w >> h;
long long tot = 0, lik = 0;
for (int fp = !!f; fp <= f; ++fp) {
for (int wp = max((int)!!w, fp - 1); wp <= min(fp + 1, (int)w); ++wp) {
auto rt = calc(fp, wp);
if (fp == wp) rt.first <<= 1, rt.second <<= 1;
tot += rt.first;
lik += rt.second;
}
}
cout << lik % mod * inv(tot % mod) % mod << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
#define watch(x) cout << (#x) << " is " << (x) << '\n'
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(), (x).end()
#define X first
#define Y second
#define int ll
typedef long long ll;
typedef string str;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<bool> vb;
typedef vector< vector<int> > vvi;
const double PI = 3.14159265358979323846;
const int INF = 0x3f3f3f3f;
int count_num(int x) {
int cnt = 0;
while (x > 0) {
cnt++;
x /= 10;
}
return cnt;
}
void solve(){
int a, b, c;
cin >> a >> b >> c;
int x = 1, y = 1;
while (count_num(x) < a - c + 1) x *= 3;
while (count_num(y) < b - c + 1) y *= 7;
for (int i = 0; i < c - 1; i++) {
x *= 10;
y *= 10;
}
cout << x << ' ' << y << '\n';
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int t;
cin >> t;
while (t--) solve();
} | 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.