solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1201000;
bool palin(int x) {
vector<int> a, b;
while (x > 0) {
a.push_back(x % 10);
b.push_back(x % 10);
x /= 10;
}
reverse(a.begin(), a.end());
for (int i = 0; i < (int)a.size(); ++i)
if (a[i] != b[i]) return false;
return true;
}
bool prime[MAXN];
void init() {
const int NSQRT = (int)sqrt(MAXN);
for (int i = 3; i < NSQRT; i += 2) {
if (prime[i]) continue;
for (int j = i * i; j < MAXN; j += i) prime[j] = 1;
}
for (int i = 0; i < MAXN; ++i) {
prime[i] ^= 1;
if ((i & 1) == 0) prime[i] = 0;
}
prime[0] = prime[1] = 0;
prime[2] = 1;
}
int pi[MAXN];
int rub[MAXN];
int main(void) {
init();
for (int i = 1; i < MAXN; ++i) {
pi[i] = pi[i - 1];
rub[i] = rub[i - 1];
if (prime[i]) ++pi[i];
if (palin(i)) ++rub[i];
}
int p, q;
scanf("%d%d", &p, &q);
for (int i = MAXN - 1; i >= 1; --i) {
if (pi[i] * (long long)q <= rub[i] * (long long)p) {
printf("%d\n", i);
return 0;
}
}
printf("Palindromic tree is better than splay tree\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int res;
vector<set<int>> g;
vector<int> used;
vector<int> selected;
void bfs(int start) {
vector<int> seen = {start};
queue<int> q;
used[start] = 1;
q.push(start);
while (!q.empty()) {
int v = q.front();
q.pop();
assert(selected[v]);
assert((int)g[v].size() < k);
selected[v] = 0;
res--;
for (auto t : g[v]) {
g[t].erase(v);
if (selected[t] && (int)g[t].size() < k && !used[t]) {
seen.push_back(t);
used[t] = 1;
q.push(t);
}
}
}
for (auto t : seen) {
used[t] = 0;
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int m;
cin >> n >> m >> k;
used.resize(n);
g.resize(n);
vector<pair<int, int>> q;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
g[u].insert(v);
g[v].insert(u);
q.push_back({u, v});
}
reverse(q.begin(), q.end());
selected.assign(n, 1);
res = n;
for (int i = 0; i < n; i++) {
if ((int)g[i].size() < k && selected[i]) {
bfs(i);
}
}
vector<int> ans;
for (auto [u, v] : q) {
ans.push_back(res);
g[u].erase(v);
g[v].erase(u);
if ((int)g[u].size() < k && selected[u]) {
bfs(u);
}
if ((int)g[v].size() < k && selected[v]) {
bfs(v);
}
}
reverse(ans.begin(), ans.end());
for (auto t : ans) {
cout << t << '\n';
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int inf = int(1e9);
const double eps = 1e-9;
const double pi = 4 * atan(double(1));
const int N = 1000;
const int dx[4] = {-1, 0, 1, 0};
const int dy[4] = {0, -1, 0, 1};
char a[N + 10][N + 10];
int d[N + 10][N + 10];
int q[2 * N * N + 10];
int main() {
int n, m;
scanf("%d %d", &n, &m);
gets(a[0]);
for (int i = 0; i < n; i++) {
gets(a[i]);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
d[i][j] = inf;
}
}
int l = 0, r = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i][j] == 'E') {
d[i][j] = 0;
q[r++] = i;
q[r++] = j;
}
}
}
while (l < r) {
int x = q[l++], y = q[l++];
for (int i = 0; i < 4; i++) {
int nx = x + dx[i], ny = y + dy[i];
if (nx < 0 || nx >= n || ny < 0 || ny >= m | a[nx][ny] == 'T') {
continue;
}
if (d[nx][ny] > d[x][y] + 1) {
d[nx][ny] = d[x][y] + 1;
q[r++] = nx;
q[r++] = ny;
}
}
}
int dist = -1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i][j] == 'S') {
dist = d[i][j];
}
}
}
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i][j] >= '0' && a[i][j] <= '9' && d[i][j] <= dist) {
ans += a[i][j] - '0';
}
}
}
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int OO = (int)2e9;
const double PI = 2 * acos(0.0);
const double EPS = 1e-9;
int dcmp(double a, double b) { return fabs(a - b) <= EPS ? 0 : a > b ? 1 : 2; }
int DI[] = {-1, 0, 1, 0, 1, -1, -1, 1};
int DJ[] = {0, 1, 0, -1, 1, -1, 1, -1};
double sx = 0;
int n, k, A;
vector<pair<int, int> > v;
vector<int> ps;
vector<vector<int> > comb;
double zbt(int x) { return (double)x / 100.0; }
void t() {
double sum = 0;
vector<pair<int, int> > tmp = v;
for (int i = 0; i < (int)n; i++) tmp[i].second += (ps[i] * 10);
int one = 0;
for (int i = 0; i < (int)comb.size(); i++) {
one = 0;
int B = 0;
double p = 1.0;
for (int j = 0; j < (int)comb[i].size(); j++) {
if (comb[i][j] == 1) {
p *= zbt(tmp[j].second);
one++;
} else {
p *= (1 - zbt(tmp[j].second));
B += tmp[j].first;
}
}
if (one > n / 2)
sum += p;
else {
double a = A;
a = a / (double)(A + B);
sum += (a * p);
}
}
sx = max(sx, sum);
}
void solve(int idx, int rem) {
if (idx == n) {
t();
return;
}
for (int i = 0; i <= rem; i++)
if ((i * 10) + v[idx].second <= 100) {
ps[idx] = i;
solve(idx + 1, rem - i);
ps[idx] = 0;
}
}
void combs(int idx, vector<int> ret) {
if (idx == n) {
comb.push_back(ret);
return;
}
ret.push_back(1);
combs(idx + 1, ret);
ret.back() = 0;
combs(idx + 1, ret);
}
int main() {
cin >> n >> k >> A;
v.resize(n);
ps.resize(n, 0);
vector<int> asda;
combs(0, asda);
for (int i = 0; i < (int)n; i++) cin >> v[i].first >> v[i].second;
solve(0, k);
printf("%.9f\n", sx);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using LL = int64_t;
const int INF = 0x3fffffff;
const double EPS = 1e-9;
const double PI = 2 * asin(1);
int g_n, g_m;
vector<bool> vb;
vector<int> vi_ans, vi_dge;
vector<vector<int>> vvi_edge;
void pretreat() {}
bool input() {
cin >> g_n >> g_m;
if (cin.eof()) return false;
vb.clear(), vb.resize(g_n + 1);
vi_ans.clear(), vi_ans.resize(g_n + 1);
vi_dge.clear(), vi_dge.resize(g_n + 1);
vvi_edge.clear(), vvi_edge.resize(g_n + 1);
for (int i = 0, u, v; i < g_m; ++i) {
scanf(" %d %d", &u, &v);
vvi_edge[u].push_back(v);
vvi_edge[v].push_back(u);
++vi_dge[u], ++vi_dge[v];
}
return true;
}
void solve() {
queue<int> qi;
for (int i = 1; i <= g_n; ++i) {
if (vi_dge[i] > 1) qi.push(i), vb[i] = true;
}
while (!qi.empty()) {
int u = qi.front();
qi.pop();
vb[u] = false;
if (vi_dge[u] < 2) continue;
vi_ans[u] ^= 1;
int k = 0;
for (int i = 0; i < vvi_edge[u].size(); ++i) {
int v = vvi_edge[u][i];
if (vi_ans[u] == vi_ans[v])
++vi_dge[v], ++k;
else
--vi_dge[v];
if (!vb[v] && vi_dge[v] > 1) qi.push(v), vb[v] = true;
}
vi_dge[u] = k;
if (k > 1) qi.push(u), vb[u] = true;
}
for (int i = 1; i <= g_n; ++i) printf("%d", vi_ans[i]);
puts("");
}
int main() {
pretreat();
while (input()) {
solve();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int p[1005];
int a[1005];
int b[1005];
int main() {
int i, j, m, n, t;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &p[i]);
}
for (i = 1; i <= n; i++) {
memset(b, 0, sizeof(b));
a[0] = i;
b[i]++;
for (j = 1;; j++) {
a[j] = p[a[j - 1]];
b[a[j]]++;
if (b[a[j]] == 2) {
printf("%d ", a[j]);
break;
}
}
}
printf("\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
const int Mod = 1000000007;
const int INF = 0x3f3f3f3f;
const long long LL_INF = 0x3f3f3f3f3f3f3f3f;
const double e = exp(1);
const double PI = acos(-1);
const double ERR = 1e-10;
int n, cnt;
int head[maxn];
long long d[maxn];
bool vis[maxn];
struct edge {
int v, nxt;
long long w;
} Edge[6 * maxn];
struct node {
long long d;
int id;
node(long long _d, int _id) : d(_d), id(_id) {}
const bool operator<(const node b) const { return d > b.d; }
};
void init() {
for (int i = 0; i <= n; i++) head[i] = -1;
cnt = 0;
}
void addedge(int u, int v, long long w) {
Edge[cnt].v = v;
Edge[cnt].w = w;
Edge[cnt].nxt = head[u];
head[u] = cnt++;
}
priority_queue<node> que;
void Dijkstra() {
memset(d, 0x3f, sizeof(d));
d[0] = 0;
que.push(node(d[0], 0));
while (!que.empty()) {
node now = que.top();
que.pop();
if (vis[now.id]) continue;
vis[now.id] = true;
for (int i = head[now.id]; i != -1; i = Edge[i].nxt) {
int v = Edge[i].v;
long long w = Edge[i].w;
if (d[v] > d[now.id] + w) {
d[v] = d[now.id] + w;
que.push(node(d[v], v));
}
}
}
}
int main() {
int m, u, v;
long long w;
scanf("%d%d", &n, &m);
init();
for (int i = 1; i <= m; i++) {
scanf("%d%d%lld", &u, &v, &w);
addedge(u, v, 2 * w);
addedge(v, u, 2 * w);
}
for (int i = 1; i <= n; i++) {
scanf("%lld", &w);
addedge(0, i, w);
addedge(i, 0, w);
}
Dijkstra();
for (int i = 1; i <= n; i++) {
if (i > 1) printf(" ");
printf("%lld", d[i]);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int tree[4 * N];
int a[N];
void update(int node, int s, int e, int p, int val) {
if (s > p or e < p) return;
if (s >= p and e <= p) {
tree[node] = val;
return;
}
int mid = (s + e) / 2;
update(2 * node, s, mid, p, val);
update(2 * node + 1, mid + 1, e, p, val);
tree[node] = max(tree[2 * node], tree[2 * node + 1]);
}
int get(int node, int s, int e, int l, int r) {
if (l > e or r < s) return 0;
if (s >= l and e <= r) {
return tree[node];
}
int mid = (s + e) / 2;
int left = get(2 * node, s, mid, l, r);
int right = get(2 * node + 1, mid + 1, e, l, r);
return max(left, right);
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
int ans = 0;
for (int i = 1; i <= n; i++) {
int cur = get(1, 1, n, 1, a[i] - 1) + 1;
ans = max(ans, cur);
update(1, 1, n, a[i], cur);
}
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
#define ld long double
#define ll long long
#define int ll
#define FF first.first
#define FS first.second
#define SF second.first
#define SS second.second
#define PB push_back
#define MP make_pair
#define all(cont) cont.begin(),cont.end()
#define rall(cont) cont.rbegin(), cont.rend()
#define FOR(i, j) for(int i=0;i<j;i++)
#define RFOR(i, j) for (int i=j;i>=0;i--)
#define GO cin.tie(NULL);
#define FAST ios_base::sync_with_stdio(false);
typedef pair<int,int> pii;
typedef vector<int> VI;
typedef vector<pii> VPII;
// Your function
//DEBBUGGING STUFF, JUST USE deb(a,b,c) and it will print the variables;
#define deb(...) logger(#__VA_ARGS__, __VA_ARGS__)
template<typename ...Args>
void logger(string vars, Args&&... values) {
cout << vars << " = ";
string delim = "";
(..., (cout << delim << values, delim = ", "));
cout<<endl;
}
struct segtree{
int* arr;
int* lazy;
int size;
int neutro;
int lneutro;
int op(int a,int b){
return max(a,b);
}
int lazyop(int a,int b){
return a+b;
}
segtree(vector<int>&v,int neut,int lazyneut){
neutro=neut;
lneutro=lazyneut;
int n=v.size();
size=1;
while(size<n){
size*=2;
}
arr = new int[2*size];
lazy = new int[2*size];
for (int i=0;i<2*size;i++){
lazy[i]=lneutro;
arr[i]=neutro;
}
build(v,0,0,size);
}
void build(vector<int>&v,int x,int l,int r){
if (r-l==1){
if (l<v.size()){
arr[x]=v[l];
}
return;
}
int mid = l + (r-l)/2;
build(v,2*x+1,l,mid);
build(v,2*x+2,mid,r);
arr[x]=op(arr[2*x+1],arr[2*x+2]);
}
void propagate(int x,int l,int r){
arr[x]=lazyop(lazy[x],arr[x]);
if(r-l==1){
lazy[x]=lneutro;
return;
}
lazy[2*x+1]=lazyop(lazy[x],lazy[2*x+1]);
lazy[2*x+2]=lazyop(lazy[x],lazy[2*x+2]);
lazy[x]=lneutro;
}
void update(int v,int l,int r,int x,int lx,int rx){
propagate(x,lx,rx);
if (lx>=r || rx<=l)return;
if (lx>=l && rx<=r){
lazy[x]=lazyop(v,lazy[x]);
propagate(x,lx,rx);
return;
}
int mid = lx + (rx-lx)/2;
update(v,l,r,2*x+1,lx,mid);
update(v,l,r,2*x+2,mid,rx);
arr[x]=op(arr[2*x+1],arr[2*x+2]);
}
void update(int l,int r,int v){
return update(v,l,r,0,0,size);
}
int query(int l,int r,int x,int lx,int rx){
propagate(x,lx,rx);
if (lx>=r || rx<=l)return neutro;
if (lx>=l && rx<=r){
return arr[x];
}
int mid = lx + (rx-lx)/2;
return op(query(l,r,2*x+1,lx,mid),query(l,r,2*x+2,mid,rx));
}
int query(int l,int r){
return query(l,r,0,0,size);
}
};
int32_t main(){
GO FAST;
int n;cin>>n;
vector<int> v(n);
FOR(i,n)cin>>v[i];
map<int,vector<int>> caras;
map<int,vector<int>,greater<int>> caras1;
FOR(i,n)caras[v[i]].PB(i);
FOR(i,n)caras1[v[i]].PB(i);
vector<int>P(n);
vector<int>S(n);
FOR(i,n){
P[i]=i+1;
S[i]=n-i;
}
segtree pref(P,INT_MIN,0);
segtree suf(S,INT_MIN,0);
vector<int> ans(n);
for (auto k:caras){
for (auto k1:k.second){
ans[k1]=pref.query(k1,n)-pref.query(k1,k1+1)+suf.query(0,k1+1)-suf.query(k1,k1+1);
ans[k1]++;
ans[k1]/=2;
}
for (auto k1:k.second){
pref.update(k1,n,-2);
suf.update(0,k1+1,-2);
}
}
pref=segtree(P,INT_MIN,0);
suf=segtree(S,INT_MIN,0);
vector<int> ans1(n);
for (auto k:caras1){
for (auto k1:k.second){
//deb(k1);
ans1[k1]=pref.query(k1,n)-pref.query(k1,k1+1)+suf.query(0,k1+1)-suf.query(k1,k1+1);
//ans1[k1]++;
ans1[k1]/=2;
}
for (auto k1:k.second){
pref.update(k1,n,-2);
suf.update(0,k1+1,-2);
}
}
FOR(i,n){
cout<<max(ans[i],ans1[i])<<" ";
}
cout<<endl;
} | 9 |
#include <bits/stdc++.h>
using namespace std;
void err(istream_iterator<string> it) { cerr << endl; }
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << " | ";
err(++it, args...);
}
vector<long long int> v1, v2;
string s1, s2, s3;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int a, b, c, d, e, f, i, j, k, cnt1 = 0, cnt2 = 0, sum1 = 0,
sum2 = 0, chk1 = 0, chk2 = 0, T;
cin >> T;
while (T--) {
v1.clear();
cin >> a;
for (i = 0; i < a; i++) {
cin >> b;
v1.push_back(b);
}
if (v1[0] < v1.back()) {
cout << "YES" << '\n';
} else {
cout << "NO" << '\n';
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
if (i % 2 == 1) {
for (int j = 1; j <= m; j++) {
cout << "#";
}
cout << "\n";
} else if (i % 2 == 0 && i % 4 != 0) {
for (int j = 1; j < m; j++) {
cout << ".";
}
cout << "#\n";
} else if (i % 4 == 0) {
cout << "#";
for (int j = 2; j <= m; j++) {
cout << ".";
}
cout << "\n";
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct bign {
int d[1005], len;
void clean() {
while (len > 1 && !d[len - 1]) len--;
}
bign() {
memset(d, 0, sizeof(d));
len = 1;
}
bign(int num) { *this = num; }
bign(char* num) { *this = num; }
bign operator=(const char* num) {
memset(d, 0, sizeof(d));
len = strlen(num);
for (int i = 0; i < len; i++) d[i] = num[len - 1 - i] - '0';
clean();
return *this;
}
bign operator=(int num) {
char s[20];
sprintf(s, "%d", num);
*this = s;
return *this;
}
bign operator+(const bign& b) {
bign c = *this;
int i;
for (i = 0; i < b.len; i++) {
c.d[i] += b.d[i];
if (c.d[i] > 9) c.d[i] %= 10, c.d[i + 1]++;
}
while (c.d[i] > 9) c.d[i++] %= 10, c.d[i]++;
c.len = max(len, b.len);
if (c.d[i] && c.len <= i) c.len = i + 1;
return c;
}
bign operator-(const bign& b) {
bign c = *this;
int i;
for (i = 0; i < b.len; i++) {
c.d[i] -= b.d[i];
if (c.d[i] < 0) c.d[i] += 10, c.d[i + 1]--;
}
while (c.d[i] < 0) c.d[i++] += 10, c.d[i]--;
c.clean();
return c;
}
bign operator*(const bign& b) const {
int i, j;
bign c;
c.len = len + b.len;
for (j = 0; j < b.len; j++)
for (i = 0; i < len; i++) c.d[i + j] += d[i] * b.d[j];
for (i = 0; i < c.len - 1; i++) c.d[i + 1] += c.d[i] / 10, c.d[i] %= 10;
c.clean();
return c;
}
bign operator/(const bign& b) {
int i, j;
bign c = *this, a = 0;
for (i = len - 1; i >= 0; i--) {
a = a * 10 + d[i];
for (j = 0; j < 10; j++)
if (a < b * (j + 1)) break;
c.d[i] = j;
a = a - b * j;
}
c.clean();
return c;
}
bign operator%(const bign& b) {
int i, j;
bign a = 0;
for (i = len - 1; i >= 0; i--) {
a = a * 10 + d[i];
for (j = 0; j < 10; j++)
if (a < b * (j + 1)) break;
a = a - b * j;
}
return a;
}
bign operator+=(const bign& b) {
*this = *this + b;
return *this;
}
bool operator<(const bign& b) const {
if (len != b.len) return len < b.len;
for (int i = len - 1; i >= 0; i--)
if (d[i] != b.d[i]) return d[i] < b.d[i];
return false;
}
bool operator>(const bign& b) const { return b < *this; }
bool operator<=(const bign& b) const { return !(b < *this); }
bool operator>=(const bign& b) const { return !(*this < b); }
bool operator!=(const bign& b) const { return b < *this || *this < b; }
bool operator==(const bign& b) const { return !(b < *this) && !(b > *this); }
string str() const {
char s[1005] = {};
for (int i = 0; i < len; i++) s[len - 1 - i] = d[i] + '0';
return s;
}
};
bign inf;
bign n, m, k, l, s, t, r, T, ans, cas;
istream& operator>>(istream& in, bign& x) {
string s;
in >> s;
x = s.c_str();
return in;
}
ostream& operator<<(ostream& out, const bign& x) {
out << x.str();
return out;
}
int checker(bign x) {
bign f = ((x - (m + 1)));
bign p = x - (m + 1) + 1;
if (f % 2 == 0)
f = f / 2;
else
p = p / 2;
bign o = f * p;
if (o + x >= n) return 1;
return 0;
}
int main() {
int i, j;
cin >> n >> m;
if (m >= n || n == 1) {
cout << n;
return 0;
}
bign L = m + 1, R = 1;
for (i = 1; i <= 20; i++) R = R * 10;
while (L <= R) {
bign mid = (L + R) / 2;
if (checker(mid)) {
ans = mid;
R = mid - 1;
} else
L = mid + 1;
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
string s;
cin >> s;
int n = s.size();
vector<int> a;
for (int i = 0; i < n;) {
int j = i + 1;
while (j < n && s[j] == s[i]) ++j;
a.push_back(j - i);
i = j;
}
if (s.back() == s[0]) {
a[0] += a.back();
a.pop_back();
}
for (int _n(a.size()), i(0); i < _n; i++) a[i] = min(a[i], 2);
auto it = find(a.begin(), a.end(), 2);
if (it == a.end()) {
cout << a.size() / 2 << endl;
return 0;
}
rotate(a.begin(), it, a.end());
int ans = 0;
for (int i = 0; i < a.size();) {
if (a[i] == 2) {
ans++;
i++;
continue;
}
int j = i + 1;
int cnt = 1;
while (j < a.size() && a[j] == 1) {
++cnt;
j++;
}
ans += cnt / 2;
i = j;
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 5e5 + 2;
const int M = 1e9 + 7;
long long n, tab[501], res;
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 0; i < n; ++i) cin >> tab[i];
if (n == 1)
res = tab[0];
else if (n == 2)
res = tab[1] | tab[0];
else {
for (int i = 0; i < n; ++i)
for (int j = i + 1; j < n; ++j)
for (int k = j + 1; k < n; ++k)
res = max(res, tab[i] | tab[j] | tab[k]);
}
cout << res;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5e5 + 100;
char str[MAXN];
const long double eps = 1e-9;
long double y_1, y_2, yw, xb, yb, r;
pair<long double, long double> ptarget, pstart;
long double f1(long double x) {
long double tg = x / (yw - ptarget.second - r);
return atan(tg);
}
long double f2(long double x) {
long double tg = (pstart.first - x) / (yw - pstart.second - r);
return atan(tg);
}
long double find(long double l, long double r) {
while (l + eps < r) {
long double m = (l + r) / 2;
if (f1(m) + eps < f2(m))
l = m;
else
r = m;
}
return l;
}
int main() {
cin >> y_1 >> y_2 >> yw >> xb >> yb >> r;
ptarget = make_pair(0, y_1 + r);
pstart = make_pair(xb, yb);
long double res_x = find(0 + eps, pstart.first - eps);
long double delta = r / sin(f1(res_x));
if (y_2 + eps < ptarget.second + delta)
puts("-1");
else {
cout.setf(ios::fixed);
cout << setprecision(15) << res_x;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void c_p_c() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int main() {
c_p_c();
long int i, n;
vector<pair<string, string>> v;
string s1, s2;
while (cin >> n) {
while (n--) {
cin >> s1 >> s2;
for (i = 0; i < v.size(); i++) {
if (v[i].second == s1) {
v[i].second = s2;
break;
}
}
if (i == v.size()) {
v.push_back(make_pair(s1, s2));
}
}
cout << v.size() << '\n';
for (i = 0; i < v.size(); i++) {
cout << v[i].first << " " << v[i].second << '\n';
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, res;
int main() {
scanf("%d", &n);
res = n / 2;
if (n % 2)
res = res * (n / 2 + 1);
else
res = res * res;
printf("%d\n", res);
for (int i = 1; i <= n; ++i)
if (i % 2)
for (int j = 1; j <= n; ++j)
if (!(j % 2)) cout << i << ' ' << j << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int const maxn = 200010;
int s[maxn], t[maxn];
int main() {
long long n;
cin >> n;
s[1] = 1;
for (int i = 2; i <= n; i++) {
cin >> s[i];
}
int k = n;
int j = 1;
while (k != 1) {
t[j] = k;
k = s[k];
j++;
}
t[j] = 1;
for (int i = j; i > 0; i--) cout << t[i] << " ";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
struct pr {
int x, y;
} u, d, l, r, ul, ur, dl, dr;
int main() {
scanf("%d%d%d", &n, &u.x, &u.y);
ul = ur = dl = dr = d = l = r = u;
for (int i = (2); i <= (n); ++i) {
pr x;
scanf("%d%d", &x.x, &x.y);
if (x.x < u.x) u = x;
if (x.x > d.x) d = x;
if (x.y < l.y) l = x;
if (x.y > r.y) r = x;
if (x.x + x.y < ul.x + ul.y) ul = x;
if (x.x + x.y > dr.x + dr.y) dr = x;
if (x.x - x.y < ur.x - ur.y) ur = x;
if (x.x - x.y > dl.x - dl.y) dl = x;
}
printf("%d", max(max(d.x + r.y - ul.x - ul.y, d.x - l.y - ur.x + ur.y),
max(dl.x - dl.y - u.x + r.y, dr.x + dr.y - u.x - l.y)) *
2);
for (int i = (4); i <= (n); ++i) printf(" %d", (d.x - u.x + r.y - l.y) * 2);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int factor[5] = {0, 1, 1, 2, 9};
long long choose(int n, int k);
int main() {
int n, k;
cin >> n >> k;
long long ret = 1;
for (int i = 2; i <= k; i++) ret += factor[i] * choose(n, i);
cout << ret << '\n';
}
long long choose(int n, int k) {
long long ret = 1;
for (int i = 1; i <= k; i++) {
ret *= n - i + 1;
ret /= i;
}
return ret;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m, t, i, j, a[200005], b[200005];
long long sum[200005];
double c;
int main() {
scanf("%d%d%lf", &n, &t, &c);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i <= n; i++) sum[i] = sum[i - 1] + a[i];
scanf("%d", &m);
for (i = 0; i < m; i++) scanf("%d", &b[i]);
int p = 0;
double mean = 0;
for (i = 1; i <= n; i++) {
mean = (mean + (a[i] * 1.0) / t) / c;
double now;
if (i >= t) {
now = (sum[i] - sum[i - t]) * 1.0 / t;
if (p < m && b[p] == i) {
printf("%.12lf %.12lf %.12lf\n", now, mean, fabs(mean - now) / now);
p++;
}
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
namespace io {
const int __SIZE = (1 << 21) + 1;
char ibuf[__SIZE], *iS, *iT, obuf[__SIZE], *oS = obuf, *oT = oS + __SIZE - 1,
__c, qu[55];
int __f, qr, _eof;
inline void flush() { fwrite(obuf, 1, oS - obuf, stdout), oS = obuf; }
inline void gc(char &x) {
x = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, __SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
}
inline void pc(char x) {
*oS++ = x;
if (oS == oT) flush();
}
inline void pstr(const char *s) {
int __len = strlen(s);
for (__f = 0; __f < __len; ++__f) pc(s[__f]);
}
inline void gstr(char *s) {
for (__c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, __SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
__c < 32 || __c > 126 || __c == ' ';)
__c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, __SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
for (; __c > 31 && __c < 127 && __c != ' ';
++s, __c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, __SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
*s = __c;
*s = 0;
}
template <class I>
inline bool gi(I &x) {
_eof = 0;
for (__f = 1,
__c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, __SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
(__c < '0' || __c > '9') && !_eof;
__c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, __SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++)) {
if (__c == '-') __f = -1;
_eof |= __c == EOF;
}
for (x = 0; __c <= '9' && __c >= '0' && !_eof;
__c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, __SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
x = x * 10 + (__c & 15), _eof |= __c == EOF;
x *= __f;
return !_eof;
}
template <class I>
inline void gp(I x) {
if (!x) pc('0');
if (x < 0) pc('-'), x = -x;
while (x) qu[++qr] = x % 10 + '0', x /= 10;
while (qr) pc(qu[qr--]);
}
struct Flusher_ {
~Flusher_() { flush(); }
} io_flusher_;
} // namespace io
using io::gc;
using io::gi;
using io::gp;
using io::gstr;
using io::pc;
using io::pstr;
void scan() { return; }
template <class T, typename... Args>
void scan(T &a, Args &&...args) {
gi(a);
scan(args...);
return;
}
template <typename T>
void scann(T a, T b) {
for (auto it = a; it != b; ++it) scan(*it);
}
template <typename T>
void scerr(T a, T b) {
for (auto it = a; it != b; ++it) cerr << *it << " ";
cerr << '\n';
}
void print() {
pc('\n');
return;
}
template <class T, typename... Args>
void print(T a, Args... args) {
gp(a);
pc(' ');
print(args...);
return;
}
void cer() { return; }
template <class T, typename... Args>
void cer(T a, Args... args) {
cerr << " " << a;
cer(args...);
return;
}
const int N = 2e5 + 10;
const int M = 1e6 + 2;
const long long mod = 1e9 + 7;
const int inf = 1e9;
const long long INF = 1e16;
void data() {}
int n, m, k, x[N], y[N], COL = 1;
struct tree {
tree *l, *r;
int mn, p;
tree() {
mn = 0;
p = 0;
l = r = nullptr;
}
} * tx[10000], *ty[10000];
void make(tree *v) {
if (v->l == nullptr) v->l = new tree();
if (v->r == nullptr) v->r = new tree();
}
void push(tree *v) {
if (v->p) {
make(v);
v->l->p += v->p;
v->r->p += v->p;
v->mn += v->p;
v->p = 0;
}
}
void upd(int l, int r, int val, int tl, int tr, tree *v) {
push(v);
if (r < tl || tr < l) return;
if (l <= tl && tr <= r) {
v->p += val;
push(v);
return;
}
int tm = (tl + tr) / 2;
make(v);
upd(l, r, val, tl, tm, v->l);
upd(l, r, val, tm + 1, tr, v->r);
v->mn = min(v->l->mn, v->r->mn);
}
int getmin(int tl, int tr, tree *v) {
if (v->mn != 0) return inf;
if (tl == tr) return tl;
make(v);
push(v);
push(v->l);
push(v->r);
int tm = (tl + tr) / 2;
if (v->l->mn == 0)
return getmin(tl, tm, v->l);
else
return getmin(tm + 1, tr, v->r);
}
int getmax(int tl, int tr, tree *v) {
if (v->mn != 0) return -inf;
if (tl == tr) return tl;
make(v);
push(v);
push(v->l);
push(v->r);
int tm = (tl + tr) / 2;
if (v->r->mn == 0)
return getmax(tm + 1, tr, v->r);
else
return getmax(tl, tm, v->l);
}
bool check(int t) {
map<int, vector<pair<int, int>>> evx, evy;
int nmnx, nmny, nmxx, nmxy, leftx = inf, lefty = inf;
for (int i = 1; i <= k; ++i) {
nmnx = max(x[i] - t, 1);
nmxx = min(x[i] + t, m);
nmny = max(y[i] - t, 1);
nmxy = min(y[i] + t, n);
evx[nmnx].push_back(make_pair(nmny, nmxy));
evx[nmxx + 1].push_back(make_pair(-nmny, -nmxy));
evy[nmny].push_back(make_pair(nmnx, nmxx));
evy[nmxy + 1].push_back(make_pair(-nmnx, -nmxx));
leftx = min(nmnx - 1, leftx);
lefty = min(nmny - 1, lefty);
}
evx[1].push_back(make_pair(0, 0));
evy[1].push_back(make_pair(0, 0));
evx[n].push_back(make_pair(0, 0));
evy[m].push_back(make_pair(0, 0));
int ans_min_y = inf;
int ans_max_y = -inf;
for (auto i = evx.begin(); i != evx.end(); i++) {
if (i->first == m + 1) {
continue;
}
for (auto it : i->second) {
if (it.first == 0) continue;
if (it.first > 0)
upd(it.first, it.second, 1, 1, n, tx[COL]);
else
upd(-it.first, -it.second, -1, 1, n, tx[COL]);
}
ans_min_y = min(ans_min_y, getmin(1, n, tx[COL]));
ans_max_y = max(ans_max_y, getmax(1, n, tx[COL]));
}
int ans_min_x = inf;
int ans_max_x = -inf;
for (auto i = evy.begin(); i != evy.end(); i++) {
if (i->first == n + 1) {
continue;
}
for (auto it : i->second) {
if (it.first == 0) continue;
if (it.first > 0)
upd(it.first, it.second, 1, 1, m, ty[COL]);
else
upd(-it.first, -it.second, -1, 1, m, ty[COL]);
}
ans_min_x = min(ans_min_x, getmin(1, m, ty[COL]));
ans_max_x = max(ans_max_x, getmax(1, m, ty[COL]));
}
int ret =
max((ans_max_x - ans_min_x + 1) / 2, (ans_max_y - ans_min_y + 1) / 2);
COL++;
return (ret <= t);
}
int main() {
data();
scan(m, n, k);
for (int i = 0; i < 10000; ++i) {
tx[i] = new tree();
ty[i] = new tree();
}
for (int i = 1; i <= k; ++i) {
scan(x[i], y[i]);
}
int l = -1;
for (int r = inf; r >= 1; r /= 2) {
while (l + r <= inf && !check(l + r)) l += r;
}
print(l + 1);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<pair<int, int> > counts;
map<int, int> cnt;
for (int i = 0; i < n; i++) {
int first;
cin >> first;
cnt[first]++;
}
for (auto t : cnt) {
counts.push_back({t.second, t.first});
}
sort(counts.begin(), counts.end());
int it = 0;
int sum = 0;
int max_sz = 0;
int row = -1;
for (int len = 1; len <= n; len++) {
while (it < (int)counts.size() && counts[it].first < len) {
sum += counts[it++].first;
}
int total = sum + len * (counts.size() - it);
int now_sz = (total / len) * len;
if (now_sz < (long long)len * len) continue;
if (now_sz > max_sz) {
max_sz = now_sz;
row = len;
}
}
cout << max_sz << "\n";
int col = max_sz / row;
cout << row << " " << col << "\n";
vector<pair<int, int> > lst;
for (int j = 0; j < col; j++) {
for (int i = 0; i < row; i++) {
lst.push_back({i, (i + j) % col});
}
}
int now = 0;
vector<vector<int> > matrix(row, vector<int>(col, 0));
for (int i = counts.size() - 1; i >= 0; i--) {
counts[i].first = min(counts[i].first, row);
while (now < lst.size() && counts[i].first) {
matrix[lst[now].first][lst[now].second] = counts[i].second;
counts[i].first--;
now++;
}
}
for (int i = 0; i < row; i++) {
for (int j = 0; j < col; j++) {
cout << matrix[i][j] << " ";
}
cout << "\n";
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
pair<long, long> p;
vector<pair<long, long> > v;
long n, m, i, j, a, b1 = 0, c1 = 0, a1 = 0;
cin >> n;
for (i = 0; i < n; i++) {
cin >> a;
if (a % 3 == 0) a1++;
if (a % 3 == 1) b1++;
if (a % 3 == 2) c1++;
}
cout << a1 / 2 + min(b1, c1);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, i, j, b[1001], k;
string s1[1001], s2[1001], c, s3[1001], s4[1001];
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) {
cin >> s1[i] >> s2[i];
}
for (i = n; i >= 1; i--)
if (!b[i]) {
c = s1[i];
for (j = i - 1; j >= 1; j--) {
if (!b[j] && c == s2[j]) {
c = s1[j];
b[j] = 1;
}
}
s3[++k] = c;
s4[k] = s2[i];
}
cout << k << "\n";
for (i = 1; i <= k; i++) cout << s3[i] << " " << s4[i] << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
typedef struct {
int x, y;
} CAMB;
int main() {
int n, c = 0, i, j, can = 1, Ncorrec, Nmatr;
scanf("%d", &n);
int *Numat[n], *aux[n];
int Canmat[n];
for (i = 0; i < n; i++) {
scanf("%d", &Canmat[i]);
c += Canmat[i];
Numat[i] = (int *)malloc(sizeof(int) * Canmat[i]);
aux[i] = (int *)malloc(sizeof(int) * Canmat[i]);
}
CAMB numero[c];
CAMB camb[c * 2];
c = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < Canmat[i]; j++) {
scanf("%d", &(Numat[i][j]));
numero[Numat[i][j] - 1].x = i;
numero[Numat[i][j] - 1].y = j;
c++;
aux[i][j] = c;
}
}
for (i = 0; i < n; i++) {
for (j = 0; j < Canmat[i]; j++) {
Nmatr = Numat[i][j];
Ncorrec = aux[i][j];
if (Ncorrec != Nmatr) {
Numat[i][j] = Ncorrec;
Numat[numero[Ncorrec - 1].x][numero[Ncorrec - 1].y] = Nmatr;
numero[Nmatr - 1].x = numero[Ncorrec - 1].x;
numero[Nmatr - 1].y = numero[Ncorrec - 1].y;
numero[Ncorrec - 1].x = i;
numero[Ncorrec - 1].y = j;
camb[can - 1].x = i;
camb[can - 1].y = j;
camb[can].x = numero[Nmatr - 1].x;
camb[can].y = numero[Nmatr - 1].y;
can = can + 2;
}
}
}
if (can != 1) {
can = can - 2;
printf("%d\n", (can / 2 + 1));
for (i = 0; i <= can; i = i + 2) {
printf("%d %d %d %d \n", camb[i].x + 1, camb[i].y + 1, camb[i + 1].x + 1,
camb[i + 1].y + 1);
}
} else {
printf("0");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 4e5 + 5;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
long long a[MAXN], b[MAXN], c[MAXN];
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
a[0] = -1e9;
b[0] = -1e9;
c[0] = -1e9;
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (int i = 1; i <= m; i++) scanf("%lld", &b[i]);
for (int i = 1; i <= k; i++) scanf("%lld", &c[i]);
sort(a + 1, a + 1 + n);
sort(b + 1, b + 1 + m);
sort(c + 1, c + 1 + k);
long long ans = INF;
for (int i = 1; i <= n; i++) {
long long aa = a[i];
long long b0 = lower_bound(b + 1, b + 1 + m, a[i]) - b;
long long bb = b[b0];
long long c0 = lower_bound(c + 1, c + 1 + k, a[i]) - c;
long long cc = c[c0];
long long tmp =
(aa - bb) * (aa - bb) + (cc - bb) * (cc - bb) + (aa - cc) * (aa - cc);
ans = min(ans, tmp);
bb = b[b0 - 1];
cc = c[c0 - 1];
tmp =
(aa - bb) * (aa - bb) + (cc - bb) * (cc - bb) + (aa - cc) * (aa - cc);
ans = min(ans, tmp);
bb = b[b0];
cc = c[c0 - 1];
tmp =
(aa - bb) * (aa - bb) + (cc - bb) * (cc - bb) + (aa - cc) * (aa - cc);
ans = min(ans, tmp);
bb = b[b0 - 1];
cc = c[c0];
tmp =
(aa - bb) * (aa - bb) + (cc - bb) * (cc - bb) + (aa - cc) * (aa - cc);
ans = min(ans, tmp);
}
for (int i = 1; i <= m; i++) {
long long bb = b[i];
long long a0 = lower_bound(a + 1, a + 1 + n, b[i]) - a;
long long aa = a[a0];
long long c0 = lower_bound(c + 1, c + 1 + k, b[i]) - c;
long long cc = c[c0];
long long tmp =
(aa - bb) * (aa - bb) + (cc - bb) * (cc - bb) + (aa - cc) * (aa - cc);
ans = min(ans, tmp);
aa = a[a0 - 1];
cc = c[c0 - 1];
tmp =
(aa - bb) * (aa - bb) + (cc - bb) * (cc - bb) + (aa - cc) * (aa - cc);
ans = min(ans, tmp);
aa = a[a0];
cc = c[c0 - 1];
tmp =
(aa - bb) * (aa - bb) + (cc - bb) * (cc - bb) + (aa - cc) * (aa - cc);
ans = min(ans, tmp);
aa = a[a0 - 1];
cc = c[c0];
tmp =
(aa - bb) * (aa - bb) + (cc - bb) * (cc - bb) + (aa - cc) * (aa - cc);
ans = min(ans, tmp);
}
for (int i = 1; i <= k; i++) {
long long cc = c[i];
long long b0 = lower_bound(b + 1, b + 1 + m, c[i]) - b;
long long bb = b[b0];
long long a0 = lower_bound(a + 1, a + 1 + n, c[i]) - a;
long long aa = a[a0];
long long tmp =
(aa - bb) * (aa - bb) + (cc - bb) * (cc - bb) + (aa - cc) * (aa - cc);
ans = min(ans, tmp);
bb = b[b0 - 1];
aa = a[a0 - 1];
tmp =
(aa - bb) * (aa - bb) + (cc - bb) * (cc - bb) + (aa - cc) * (aa - cc);
bb = b[b0];
aa = a[a0 - 1];
tmp =
(aa - bb) * (aa - bb) + (cc - bb) * (cc - bb) + (aa - cc) * (aa - cc);
ans = min(ans, tmp);
bb = b[b0 - 1];
aa = a[a0];
tmp =
(aa - bb) * (aa - bb) + (cc - bb) * (cc - bb) + (aa - cc) * (aa - cc);
ans = min(ans, tmp);
}
printf("%lld\n", ans);
for (int i = 1; i <= n; i++) a[i] = 0;
for (int i = 1; i <= m; i++) b[i] = 0;
for (int i = 1; i <= k; i++) c[i] = 0;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m, d, a[150001];
int64_t _dpa[150001], _dpb[150001], *dpa = _dpa, *dpb = _dpb, b[150001],
t[150001], delta, window_end;
deque<pair<int64_t, int>> q;
int main() {
scanf("%d%d%d", &n, &m, &d);
scanf("%d%lld%lld", a, b, t);
for (int i = 1; i <= n; ++i) dpa[i] = *b - abs(i - *a);
for (int i = 1; i < m; ++i) {
swap(dpa, dpb);
q.clear();
scanf("%d%lld%lld", a + i, b + i, t + i);
delta = (t[i] - t[i - 1]) * d;
window_end = min(delta, int64_t(n));
for (int j = 1; j <= window_end; ++j) {
while (!q.empty() && q.back().first <= dpb[j]) q.pop_back();
q.emplace_back(dpb[j], j);
}
for (int j = 1; j <= n; ++j) {
if (++window_end <= n) {
while (!q.empty() && q.back().first <= dpb[window_end]) q.pop_back();
q.emplace_back(dpb[window_end], window_end);
}
while (q.front().second < j - delta) q.pop_front();
dpa[j] = q.front().first + b[i] - abs(j - i[a]);
}
}
printf("%lld", *max_element(dpa + 1, dpa + 1 + n));
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool a[1010][1010];
int main() {
long long n, x, y, ans = 0, one = 1, two = 2;
cin >> n;
while (n--) {
cin >> x >> y;
a[x][y] = true;
}
cout << endl;
for (long long x = 1; x <= 1000; x++) {
long long c = 0;
for (long long i = x, j = 1; i <= 1000 && j <= 1000; i++, j++) {
c += a[i][j];
}
ans += (((c * (c - one)) / two));
}
for (long long y = 2; y <= 1000; y++) {
long long c = 0;
for (long long i = 1, j = y; i <= 1000 && j <= 1000; i++, j++) {
c += a[i][j];
}
ans += (((c * (c - one)) / two));
}
for (long long x = 1; x <= 1000; x++) {
long long c = 0;
for (long long i = x, j = 1000; i <= 1000 && j > 0; i++, j--) {
c += a[i][j];
}
ans += (((c * (c - one)) / two));
}
for (long long y = 999; y > 0; y--) {
long long c = 0;
for (long long i = 1, j = y; i <= 1000 && j > 0; i++, j--) {
c += a[i][j];
}
ans += (((c * (c - one)) / two));
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int p[4];
for (int i = 0; i < 4; i++) scanf("%d", p + i);
int a, b;
scanf("%d%d", &a, &b);
sort(p, p + 4);
int ans = 0;
do {
for (int x = a; x <= b; x++)
if ((((x % p[0]) % p[1]) % p[2]) % p[3] == x) ans++;
} while (next_permutation(p, p + 4));
printf("%d\n", ans / 24);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long mod1 = 19260817;
const long long mod2 = 19660813;
char s[10005];
int p;
int m;
int mn;
int n;
int cnt;
int cur;
int father[10005];
int dp[10005][105][2];
int son[10005][2];
void dfs(int rt) {
if (son[rt][0]) dfs(son[rt][0]);
if (son[rt][1]) dfs(son[rt][1]);
for (int i = 0; i <= mn; ++i) {
for (int j = 0; j + i <= mn; ++j) {
dp[rt][i + j + (p <= m)][0] =
max(dp[rt][i + j + (p <= m)][0],
dp[son[rt][0]][i][0] + dp[son[rt][1]][j][0]);
dp[rt][i + j + (p > m)][0] =
max(dp[rt][i + j + (p > m)][0],
dp[son[rt][0]][i][0] - dp[son[rt][1]][j][1]);
dp[rt][i + j + (p <= m)][1] =
min(dp[rt][i + j + (p <= m)][1],
dp[son[rt][0]][i][1] + dp[son[rt][1]][j][1]);
dp[rt][i + j + (p > m)][1] =
min(dp[rt][i + j + (p > m)][1],
dp[son[rt][0]][i][1] - dp[son[rt][1]][j][0]);
}
}
}
int main() {
for (int i = 0; i < 10005; ++i)
for (int j = 0; j < 105; ++j)
dp[i][j][0] = -1000000000, dp[i][j][1] = 1000000000;
scanf("%s", s + 1);
n = (int)strlen(s + 1);
scanf("%d %d", &p, &m);
mn = min(p, m);
cur = 1;
cnt = 1;
for (int i = 1; i <= n; ++i) {
if (s[i] == '(' || s[i] == '?') {
++cnt;
father[cnt] = cur;
son[cur][son[cur][0] ? 1 : 0] = cnt;
cur = cnt;
} else if (s[i] == ')') {
cur = father[cur];
} else {
dp[cur][0][0] = dp[cur][0][1] = s[i] - '0';
cur = father[cur];
}
}
dfs(1);
printf("%d\n", dp[1][mn][0]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long a[200005];
int main() {
long long n;
while (scanf("%lld", &n) == 1) {
for (int i = 0; i < n; i++) scanf("%lld", &a[i]);
long long sum = 0;
long long sum1 = 0;
long long sum3 = 0;
long long l = 0;
long long r = n - 1;
while (l <= r) {
if (sum1 <= sum3) {
sum1 += a[l];
l++;
} else {
sum3 += a[r];
r--;
}
if (sum1 == sum3) sum = sum1;
}
printf("%lld\n", sum);
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v;
bool check(int m, int k, string &s) {
int last = -1, t = 1;
bool f = 1;
for (int i = 0; i < v.size(); i++) {
if (v[i] - last > m) {
if (i == 0 || v[i] - v[i - 1] > m) {
return 0;
}
last = v[i - 1];
t++;
}
if (last != v[i] && i == int(v.size()) - 1 && s.size() - (last + 1) > m) {
last = v[i];
t++;
}
}
if (s.size() - (last + 1) > m) {
f = 0;
}
return t <= k && f;
}
int main() {
ios ::sync_with_stdio(false);
cin.tie(0);
int k;
string s;
cin >> k;
getline(cin, s);
getline(cin, s);
for (int i = 0; i < s.size(); i++) {
if (s[i] == ' ' || s[i] == '-') v.push_back(i);
}
int l = 0, r = s.size();
while (r - l > 1) {
int m = (l + r) / 2;
if (check(m, k, s))
r = m;
else
l = m;
}
cout << r;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5000 + 10;
vector<pair<int, int> > vp;
long long triangleArea(pair<int, int>& a, pair<int, int>& b,
pair<int, int>& c) {
return abs((long long)(b.first - a.first) * (c.second - a.second) -
(long long)(b.second - a.second) * (c.first - a.first));
}
void findMaximumTriangle(pair<int, int>& a, pair<int, int>& b,
pair<int, int>& c) {
a = vp[0], b = vp[1], c = vp[2];
long long area = triangleArea(a, b, c);
long long temp;
int i;
bool flag = 1;
while (flag) {
flag = 0;
for (i = 0; i < vp.size(); i++) {
temp = triangleArea(vp[i], b, c);
if (area < temp) {
area = temp;
a = vp[i];
flag = 1;
}
}
for (i = 0; i < vp.size(); i++) {
temp = triangleArea(vp[i], a, c);
if (area < temp) {
area = temp;
b = vp[i];
flag = 1;
}
}
for (i = 0; i < vp.size(); i++) {
temp = triangleArea(vp[i], a, b);
if (area < temp) {
area = temp;
c = vp[i];
flag = 1;
}
}
}
}
void outAns(pair<int, int>& a, pair<int, int>& b, pair<int, int>& c) {
printf("%d %d\n", a.first + b.first - c.first,
a.second + b.second - c.second);
printf("%d %d\n", b.first + c.first - a.first,
b.second + c.second - a.second);
printf("%d %d\n", a.first + c.first - b.first,
a.second + c.second - b.second);
}
int main(void) {
int n;
long long S;
scanf("%d%I64d", &n, &S);
int i, x, y;
for (i = 0; i < n; i++) {
scanf("%d%d", &x, &y);
vp.push_back(make_pair(x, y));
}
sort(vp.begin(), vp.end());
vp.resize(distance(vp.begin(), unique(vp.begin(), vp.end())));
pair<int, int> a, b, c;
findMaximumTriangle(a, b, c);
outAns(a, b, c);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
char A[300];
int cnt[5];
char data[5] = "ACGT";
int main() {
int n;
scanf("%d", &n);
scanf("%s", A);
for (int i = 0; A[i]; i++) {
if (A[i] == 'A')
cnt[0]++;
else if (A[i] == 'C')
cnt[1]++;
else if (A[i] == 'G')
cnt[2]++;
else if (A[i] == 'T')
cnt[3]++;
else
cnt[4]++;
}
int big = 0, dif = 0;
;
for (int i = 0; i < 4; i++) big = max(big, cnt[i]);
for (int i = 0; i < 4; i++) {
cnt[i] = big - cnt[i];
dif += cnt[i];
}
if (dif > cnt[4]) {
printf("===");
return 0;
}
if ((cnt[4] - dif) % 4 != 0) {
printf("===");
return 0;
}
int flag = 0;
for (int i = 0; A[i]; i++) {
if (A[i] == '?') {
flag = 0;
for (int j = 0; j < 4; j++) {
if (cnt[j] > 0) {
A[i] = data[j];
cnt[j]--;
flag = 1;
break;
}
}
if (flag == 0) {
for (int j = 0; j < 4; j++) cnt[j]++;
i--;
}
}
}
printf("%s", A);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, i, j, k, l, m, n, p, q, r, s, t, v, w, x, y, z;
cin >> n;
int arr[n + 1];
for (i = 1; i <= n; i++) {
cin >> arr[i];
}
sort(arr + 1, arr + n + 1);
if (arr[n] == 1) {
arr[n] = 2;
} else
arr[n] = 1;
sort(arr + 1, arr + n + 1);
for (i = 1; i <= n; i++) {
cout << arr[i] << " ";
}
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
char str[200005];
int main() {
int n;
scanf("%d", &n);
if (n > 3) {
str[0] = 'a';
for (int i = 0; i < n - 1; i++) {
if ((i / 2) % 2) {
str[i + 1] = 'a';
} else {
str[i + 1] = 'b';
}
}
printf("%s", str);
} else if (n == 3) {
printf("bba");
} else if (n == 2) {
printf("aa");
} else {
printf("a");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
int main() {
int t;
scanf("%d", &t);
for (int i = 0; i < t; i++) {
int a, b, d;
scanf("%d %d", &a, &b);
d = a - b;
if (d < 0) {
if (d % 2 != 0)
printf("1\n");
else
printf("2\n");
} else if (d > 0) {
if (d % 2 != 0)
printf("2\n");
else
printf("1\n");
} else
printf("0\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200000 + 10;
int n, m, k;
vector<pair<int, int> > g[N], rg[N];
vector<int> vec[N];
int id[12][12], cnt[200];
int mp[200][200];
void build() {
int tot = 0;
for (int i = 1; i <= k; i++) {
for (int j = 1; j <= i; j++) {
id[i][j] = ++tot;
}
}
for (int u = 1; u <= n; u++) {
sort(g[u].begin(), g[u].end());
for (int j = 0; j < g[u].size(); j++) {
int v = g[u][j].second;
vec[v].push_back(id[g[u].size()][j + 1]);
cnt[id[g[u].size()][j + 1]]++;
}
}
for (int i = 1; i <= n; i++) {
sort(vec[i].begin(), vec[i].end());
for (int j = 1; j < vec[i].size(); j++)
if (vec[i][j] == vec[i][j - 1]) mp[vec[i][j]][vec[i][j]] = 1;
vec[i].erase(unique(vec[i].begin(), vec[i].end()), vec[i].end());
for (int x = 0; x < vec[i].size(); x++) {
for (int y = 0; y < vec[i].size(); y++) {
if (x == y) continue;
mp[vec[i][x]][vec[i][y]] = 1;
}
}
}
}
int stk[12], val[12], ans = 0;
void dfs(int now) {
if (now == k + 1) {
for (int i = 1; i <= k; i++) val[i] = id[i][stk[i]];
bool ok = 1;
for (int i = 1; i <= k; i++)
for (int j = 1; j <= k; j++) {
if (mp[val[i]][val[j]] == 1) ok = 0;
}
int sum = 0;
for (int i = 1; i <= k; i++) sum += cnt[val[i]];
if (sum != n) ok = 0;
if (ok) ans++;
return;
}
for (int i = 1; i <= now; i++) {
stk[now] = i;
dfs(now + 1);
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= m; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
g[u].push_back(make_pair(w, v));
rg[v].push_back(make_pair(w, u));
}
build();
dfs(1);
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long int powmod(long long int a, long long int b) {
long long int res = 1;
while (b > 0) {
if (b & 1) res = (res * a) % (long long int)1e9 + 7;
;
a = (a * a) % (long long int)1e9 + 7;
;
b = b >> 1;
}
return res % (long long int)1e9 + 7;
;
}
void solve() {
long long int n;
cin >> n;
vector<long long int> a(n);
for (long long int i = 0; i < n; i++) {
cin >> a[i];
}
for (long long int i = 1; i < n; i++) {
if (a[i] > a[i - 1] + 1) {
cout << "No\n";
return;
}
}
cout << "Yes\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t = 1;
cin >> t;
while (t--) {
solve();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long int mod = 1e9 + 7;
int32_t main() {
long long int t, n;
t = 1;
while (t--) {
cin >> n;
long long int arr[n + 1];
long long int ans = 0;
unordered_map<long long int, long long int> mp;
for (long long int i = 0; i < n; i++) {
cin >> arr[i];
if (arr[i] == i) ans++;
mp[i] = i;
}
bool flag = false;
for (long long int i = 0; i < n; i++) {
if (arr[i] != i) {
flag = true;
long long int pos = mp[arr[i]];
if (pos == arr[i] && i == arr[arr[i]]) {
ans += 2;
flag = false;
break;
}
}
}
if (!flag)
cout << ans;
else if (flag)
cout << ans + 1;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1010;
int n, rt, size;
vector<int> e[N];
int sz[N], mx[N], cnt = 1, t = 1;
void getrt(int u, int ff) {
sz[u] = 1;
for (auto v : e[u])
if (v != ff) {
getrt(v, u), sz[u] += sz[v], mx[u] = max(mx[u], sz[v]);
}
mx[u] = max(mx[u], n - sz[u]);
if (mx[u] < size) size = mx[u], rt = u;
}
void init(int u, int ff) {
sz[u] = 1;
for (auto v : e[u])
if (v != ff) init(v, u), sz[u] += sz[v];
}
inline bool cmp(const int &x, const int &y) { return sz[x] > sz[y]; }
void dfs1(int u, int ff, int w) {
printf("%d %d %d\n", ff, u, cnt - w);
int tw = cnt;
++cnt;
for (auto v : e[u])
if (v != ff) dfs1(v, u, tw);
}
void dfs2(int u, int ff, int w) {
printf("%d %d %d\n", ff, u, cnt * t - w);
int tw = cnt * t;
++t;
for (auto v : e[u])
if (v != ff) dfs2(v, u, tw);
}
int main() {
scanf("%d", &n);
for (int i = (2); i <= (n); i++) {
int x, y;
scanf("%d%d", &x, &y), e[x].push_back(y), e[y].push_back(x);
}
size = n, getrt(1, 0), init(rt, 0);
sort(e[rt].begin(), e[rt].end(), cmp);
for (auto v : e[rt]) {
if (cnt * 3 < n)
dfs1(v, rt, 0);
else
dfs2(v, rt, 0);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAXINT = 0x7fffffff, MAXN = 55, dx[] = {-1, 0, 0, 1},
dy[] = {0, 1, -1, 0};
int m, n, sl;
string s[MAXN];
bool ok(int first, int second) {
return (0 <= first && first < m && 0 <= second && second < n &&
s[first][second] == '#');
}
bool check(int first, int second) {
queue<pair<int, int> > q;
bool avail[MAXN][MAXN];
memset(avail, true, sizeof avail);
avail[first][second] = false;
for (int i = 0; i < 4; ++i) {
pair<int, int> v(first + dx[i], second + dy[i]);
if (ok(v.first, v.second)) {
q.push(v);
avail[v.first][v.second] = false;
break;
}
}
int cnt = 0;
while (q.size()) {
pair<int, int> u = q.front();
q.pop();
++cnt;
for (int i = 0; i < 4; ++i) {
pair<int, int> v(u.first + dx[i], u.second + dy[i]);
if (ok(v.first, v.second) && avail[v.first][v.second]) {
avail[v.first][v.second] = false;
q.push(v);
}
}
}
return cnt < sl - 1;
}
int main() {
scanf("%d %d\n", &m, &n);
for (int i = 0; i < m; ++i) getline(cin, s[i]);
int cnt = 0;
for (int i = 0; i < m; ++i)
for (int j = 0; j < (int)s[i].size(); ++j)
if (s[i][j] == '#') ++cnt;
if (cnt < 3) {
cout << -1 << endl;
exit(0);
}
sl = cnt;
for (int i = 0; i < m; ++i)
for (int j = 0; j < (int)s[i].size(); ++j)
if (s[i][j] == '#')
if (check(i, j)) {
cout << 1 << endl;
exit(0);
}
cout << 2 << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void smax(T &x, T y) {
x = max((x), (y));
}
template <class T>
inline void smin(T &x, T y) {
x = min((x), (y));
}
const int MOD = 1e9 + 7;
const int SIZE = 1e3 + 10;
const int INF = 0x3f3f3f3f;
int a, b;
double getx(int foo) {
return ((double)a + (foo & 1 ? -b : b)) / (2 * (foo / 2 + 1));
}
int main() {
if (0) {
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
}
while (scanf("%d%d", &(a), &(b)) == 2) {
if (a == b) {
printf("%.12f\n", (double)a);
continue;
}
int l = 0, r = INF;
int mid;
while (l < r) {
mid = l + (r - l + 1) / 2;
if (getx(mid) < b)
r = mid - 1;
else
l = mid;
}
if (getx(l) < b) {
printf("-1\n");
continue;
}
printf("%.12f\n", getx(l));
}
return 0;
}
| 4 |
/*BISMILLAH*/
/*Coded by Sheikh Fahad Shaon*/
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define scl(a) scanf("%lld",&a)
#define scll(a,b) scanf("%lld %lld",&a,&b)
#define scf(a) scanf("%lf",&a)
#define sci(a) scanf("%d",&a)
#define scii(a,b) scanf("%d %d",&a,&b)
#define pri(a) printf("%d\n",a)
#define prii(a,b) printf("%d %d\n",a,b)
#define scff(a,b) scanf("%lf %lf",&a,&b)
#define prf(a) printf("%lf",a)
#define prff(a,b) printf("%lf %lf\n",a,b);
#define prl(a) printf("%lld\n",a)
#define prll(a,b) printf("%lld %lld\n",a,b)
#define pb push_back
#define mp make_pair
#define scs(a) scanf("%s",a)
#define prs(a) printf("%s\n",s);
#define test int t;scanf("%d",&t);while(t--)
#define fastio ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define line(s) getline(cin,s)
#define endl '\n'
void solve()
{
int n;
string s;
cin >> n >> s;
for(int i = 0, j = 0; i<n && j<n; i++){
if(s[i] == 'b'){
swap(s[i],s[j++]);
}
}
cout << s << endl;
}
int main()
{
fastio
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
#endif
int t;
cin >> t;
while (t--) solve();
} | 0 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
vector<long long> a(n);
for (long long i = 0; i < n; i++) cin >> a[i];
set<pair<long long, long long> > s1, s2;
long long last = 0;
for (long long i = 0; i < n; i++) {
if (a[i] == a[last])
continue;
else {
s2.insert(pair<long long, long long>(last, i - last));
s1.insert(pair<long long, long long>(last - i, last));
last = i;
}
}
s2.insert(pair<long long, long long>(last, n - last));
s1.insert(pair<long long, long long>(last - n, last));
long long ans = 0;
while ((long long)(s1).size()) {
ans++;
pair<long long, long long> v = *s1.begin();
s1.erase(s1.begin());
s2.erase(pair<long long, long long>(v.second, -v.first));
auto it1 = s2.lower_bound(pair<long long, long long>(v.second, -100));
if (it1 == s2.begin() || it1 == s2.end()) continue;
auto it2 = it1;
it2--;
pair<long long, long long> v2 = *it1, v1 = *it2;
if (a[v2.first] == a[v1.first]) {
s2.erase(v1);
s2.erase(v2);
s1.erase(pair<long long, long long>(-v1.second, v1.first));
s1.erase(pair<long long, long long>(-v2.second, v2.first));
s1.insert(pair<long long, long long>(-(v1.second + v2.second), v1.first));
s2.insert(pair<long long, long long>(v1.first, v1.second + v2.second));
}
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int MX = 2e5 + 5;
const long long INF = 1e18;
const long double PI = acos((long double)-1);
const int xd[4] = {1, 0, -1, 0}, yd[4] = {0, 1, 0, -1};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
vector<int> d(n);
for (int &i : d) {
long long a;
cin >> a;
i = __builtin_popcountll(a);
}
long long ans = 0;
int suf = 0;
vector<vector<int> > cnt(n + 1, vector<int>(2));
cnt[n][0] = 1;
for (int i = n - 1; i >= 0; i--) {
int second = 0, m = 0;
for (int j = i; j < min(n, i + 62); j++) {
second += d[j];
m = max(m, d[j]);
if (second % 2 == 0 && 2 * m > second) ans--;
}
suf += d[i];
ans += cnt[i + 1][suf & 1];
cnt[i][0] = cnt[i + 1][0];
cnt[i][1] = cnt[i + 1][1];
if (suf & 1) {
cnt[i][1]++;
} else {
cnt[i][0]++;
}
}
cout << ans << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1100;
const long long MOD = 998244353;
int N, K;
int arr[MAXN];
int dp[MAXN][MAXN];
int ps[MAXN][MAXN];
long long figure(int k) {
if (k * (K - 1) > arr[N - 1]) return 0;
for (int i = 0; i <= N; i++)
for (int j = 0; j <= K; j++) dp[i][j] = ps[i][j] = 0;
for (int i = 1; i <= N; i++) dp[i][1] = 1;
int cstop = 0;
for (int i = 0; i < N; i++) {
while (cstop < i && arr[i] - arr[cstop] >= k) cstop++;
for (int j = 1; j < K; j++) {
dp[i + 1][j + 1] = ps[cstop][j];
}
for (int j = 0; j <= K; j++) {
ps[i + 1][j] = (ps[i][j] + dp[i + 1][j]) % MOD;
}
}
return ps[N][K];
}
int main() {
ios_base::sync_with_stdio(0);
cin >> N >> K;
for (int i = 0; i < N; i++) cin >> arr[i];
sort(arr, arr + N);
long long ans = 0;
for (int i = 1; i <= 100000; i++) ans = (ans + figure(i)) % MOD;
cout << ans << "\n";
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 120, P2 = 1100000, INF = (int)1e9;
int n, m;
int val[N];
char mode[25];
int turn[25];
int cnt[P2], low[P2], dp[P2];
int main() {
for (int i = 0; i < (1 << 20); i++) {
cnt[i] = 0;
int j = i, pos = 0;
while (j > 0) {
if (j % 2 == 1) low[i] = pos;
cnt[i] += j % 2;
j /= 2;
pos++;
}
}
cin >> n;
for (int i = 0; i < n; i++) cin >> val[i];
sort(val, val + n, greater<int>());
cin >> m;
sort(val, val + m);
for (int i = 0; i < m; i++) {
cin >> mode[i] >> turn[i];
}
for (int i = (1 << m) - 2; i >= 0; i--) {
if (turn[cnt[i]] == 1) {
dp[i] = -INF;
for (int j = 0; j < m; j++) {
if (!(i & (1 << j))) {
if (mode[cnt[i]] == 'b')
dp[i] = max(dp[i], dp[i + (1 << j)]);
else
dp[i] = max(dp[i], dp[i + (1 << j)] + val[j]);
}
}
} else {
dp[i] = INF;
for (int j = 0; j < m; j++) {
if (!(i & (1 << j))) {
if (mode[cnt[i]] == 'b')
dp[i] = min(dp[i], dp[i + (1 << j)]);
else
dp[i] = min(dp[i], dp[i + (1 << j)] - val[j]);
}
}
}
}
cout << dp[0] << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
const int maxn = 500010;
int dx[300], dy[300];
long long ans = 0;
char s[maxn];
int X[maxn], Y[maxn], visx[maxn], visy[maxn];
int main() {
int n, r, c;
cin >> n >> r >> c;
scanf("%s", s);
dy['L'] = -1;
dy['R'] = 1;
dx['U'] = -1;
dx['D'] = 1;
int rmin = 1, cmin = 1, rmax = r, cmax = c;
int x = 0, y = 0;
int bo = 0;
for (int i = 0; i < n; i = i + 1) {
x += dx[s[i]];
y += dy[s[i]];
int tmp = 0;
if (x + rmin <= 0) {
rmin++;
tmp = cmax - cmin + 1;
}
if (x + rmax > r) {
rmax--;
tmp = cmax - cmin + 1;
}
if (y + cmin <= 0) {
cmin++;
tmp = rmax - rmin + 1;
}
if (y + cmax > c) {
cmax--;
tmp = rmax - rmin + 1;
}
visx[i] = x;
visy[i] = y;
ans = (ans + 1LL * tmp * (i + 1) % mod) % mod;
if (rmin > rmax) {
bo = 1;
break;
}
if (cmin > cmax) {
bo = 1;
break;
}
}
if (bo)
cout << ans;
else if (x == 0 && y == 0)
return puts("-1"), 0;
else {
set<pair<int, int> > S;
int px, py;
for (int k = 0; k < n; k++) {
if (1LL * visx[k] * x > 0 && !X[abs(visx[k])])
X[abs(visx[k])] = 1, S.insert(make_pair(k, 0)), px = visx[k];
if (1LL * visy[k] * y > 0 && !Y[abs(visy[k])])
Y[abs(visy[k])] = 1, S.insert(make_pair(k, 1)), py = visy[k];
}
int pos = n - 1, t = n, flag = 0;
for (;;) {
for (auto it : S) {
if (it.second == 0) {
int k;
if (it.first - pos > 0)
k = it.first - pos;
else
k = it.first - pos + n;
t = (t + k) % mod;
pos = it.first;
if (x < 0) {
x--;
if (rmin + x == 0)
ans = (ans + 1LL * t * (cmax - cmin + 1) % mod) % mod, rmin++;
} else {
x++;
if (rmax + x == r + 1)
ans = (ans + 1LL * t * (cmax - cmin + 1) % mod) % mod, rmax--;
}
} else {
int k;
if (it.first - pos > 0)
k = it.first - pos;
else
k = it.first - pos + n;
t = (t + k) % mod;
pos = it.first;
if (y < 0) {
y--;
if (cmin + y == 0)
ans = (ans + 1LL * t * (rmax - rmin + 1) % mod) % mod, cmin++;
} else {
y++;
if (cmax + y == c + 1)
ans = (ans + 1LL * t * (rmax - rmin + 1) % mod) % mod, cmax--;
}
}
if (rmin > rmax) {
flag = 1;
break;
}
if (cmin > cmax) {
flag = 1;
break;
}
}
x += visx[n - 1] - px;
y += visy[n - 1] - py;
if (flag) break;
}
cout << ans;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
int main() {
long long n, s, f = 0, k;
scanf("%I64d", &n);
scanf("%I64d", &s);
k = s;
for (int i = n; i > 0; i--) {
while (k >= i) {
f = f + 1;
k = k - i;
}
}
printf("%d", f);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 100;
tuple<int, int, int> x[MAX], y[MAX];
tuple<int, int> ans[MAX];
int id[MAX];
int n, w, h, xtot, ytot;
void input() {
scanf("%d%d%d", &n, &w, &h);
for (int i = 1; i <= n; i++) {
int g, p, t;
scanf("%d%d%d", &g, &p, &t);
if (g == 1) {
ans[i] = make_tuple(p, h);
x[xtot++] = make_tuple(t - p, p, i);
} else {
ans[i] = make_tuple(w, p);
y[ytot++] = make_tuple(t - p, p, i);
}
id[i] = i;
}
}
bool cmp(tuple<int, int, int> a, tuple<int, int, int> b) {
if (get<0>(a) == get<0>(b)) {
return get<1>(a) < get<1>(b);
}
return get<0>(a) < get<0>(b);
}
void solve() {
sort(x, x + xtot, cmp);
sort(y, y + ytot, cmp);
for (int i = 0, j = 0, ii, jj; i < xtot; i = ii) {
int xx = get<0>(x[i]);
ii = i;
while (ii < xtot && get<0>(x[ii]) == xx) {
ii++;
}
while (j < ytot && get<0>(y[j]) < xx) {
j++;
}
jj = j;
while (jj < ytot && get<0>(y[jj]) == xx) {
jj++;
}
int sx = ii - i;
int sy = jj - j;
if (sy == 0) {
continue;
}
for (int k = i; k < ii; k++) {
if (sy >= ii - k) {
id[get<2>(x[k])] = get<2>(y[j + ii - 1 - k]);
} else {
id[get<2>(x[k])] = get<2>(x[k + sy]);
}
}
for (int k = j; k < jj; k++) {
if (sx >= jj - k) {
id[get<2>(y[k])] = get<2>(x[i + jj - k - 1]);
} else {
id[get<2>(y[k])] = get<2>(y[k + sx]);
}
}
}
for (int i = 1; i <= n; i++) {
printf("%d %d\n", get<0>(ans[id[i]]), get<1>(ans[id[i]]));
}
}
int main() {
input();
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 70005;
unordered_map<string, bool> ok;
unordered_map<string, int> m;
vector<string> subs[MAX];
bool comp(string a, string b) { return a.length() < b.length(); }
char s2[15];
int main() {
int n;
cin >> n;
m.reserve(1024);
m.max_load_factor(0.25);
ok.reserve(1024);
ok.max_load_factor(0.25);
for (int i = 0; i < n; i++) {
scanf("%s", s2);
string second = s2;
int l = 9;
ok.clear();
for (int j = 0; j < l; j++) {
for (int k = 1; k <= l - j; k++) {
string sub = second.substr(j, k);
if (!ok[sub]) {
ok[sub] = true;
subs[i].push_back(second.substr(j, k));
m[second.substr(j, k)] += 1;
}
}
}
}
for (int i = 0; i < n; i++) {
sort(subs[i].begin(), subs[i].end(), comp);
}
for (int i = 0; i < n; i++) {
int minlen = 900;
string ans = "";
bool ok = false;
for (string j : subs[i]) {
if (ok) {
break;
}
if (m[j] == 1) {
for (char i : j) {
printf("%c", i);
}
printf("\n");
ok = true;
}
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 1250005;
bitset<Maxn> f[52][26];
int num[55];
vector<int> ans1, ans2;
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &num[i]);
for (int i = 1; i <= n; i++) scanf("%d", &num[n + i]);
sort(num + 1, num + 2 * n + 1);
f[2 * n + 1][0].flip(0);
int s = 0;
for (int i = 2 * n; i > 2; i--) {
s += num[i];
for (int j = 0; j <= min(2 * n - i + 1, n - 1); j++) {
f[i][j] |= f[i + 1][j];
if (j) f[i][j] |= (f[i + 1][j - 1] << num[i]);
}
}
int id = -1;
for (int i = 0; i <= Maxn; i++)
if (f[3][n - 1][i] && abs(s - 2 * i) < abs(s - 2 * id)) id = i;
ans1.push_back(num[1]);
ans2.push_back(num[2]);
int cnt = n - 1;
for (int i = 3; i <= 2 * n; i++)
if (cnt && f[i + 1][cnt - 1][id - num[i]]) {
ans1.push_back(num[i]);
cnt--;
id -= num[i];
} else
ans2.push_back(num[i]);
reverse(ans2.begin(), ans2.end());
for (int i = 0; i < ans1.size(); i++) printf("%d ", ans1[i]);
printf("\n");
for (int i = 0; i < ans2.size(); i++) printf("%d ", ans2[i]);
printf("\n");
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int kN = 1e6;
int n, P, a[1 + kN], cnt[1 + kN], aib[1 + kN], sol[kN];
vector<int> g[1 + kN];
vector<tuple<int, int, int>> queries[1 + kN];
set<int> freq[1 + kN];
void update(int x, int t) {
for (int i = x; i <= n; i += i & -i) {
aib[i] += t;
}
}
int query(int x) {
int ans = 0;
for (int i = x; i > 0; i = i & (i - 1)) {
ans += aib[i];
}
return ans;
}
void dfs(int u) {
int f = cnt[a[u]];
if (f) {
freq[f].erase(a[u]);
update(f, -1);
}
++f;
cnt[a[u]] = f;
freq[f].emplace(a[u]);
update(f, 1);
for (auto it : queries[u]) {
int l, k, index;
tie(l, k, index) = it;
int erased = query(l - 1);
int rem = query(n) - erased;
if (rem < k) {
continue;
}
int ans = 0, sum = -erased, step = P;
while (step) {
if ((ans | step) < n && sum + aib[ans | step] < k) {
ans |= step;
sum += aib[ans];
}
step /= 2;
}
sol[index] = *freq[ans + 1].begin();
}
for (int v : g[u]) {
dfs(v);
}
freq[f].erase(a[u]);
update(f, -1);
--f;
cnt[a[u]] = f;
if (f) {
freq[f].emplace(a[u]);
update(f, 1);
}
}
void testCase() {
int q;
cin >> n >> q;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
for (int v = 2; v <= n; ++v) {
int u;
cin >> u;
g[u].emplace_back(v);
}
for (int i = 0; i < q; ++i) {
int v, l, k;
cin >> v >> l >> k;
queries[v].emplace_back(l, k, i);
sol[i] = -1;
}
P = 1;
while (P * 2 <= n) {
P *= 2;
}
dfs(1);
for (int i = 1; i <= n; ++i) {
g[i].clear();
queries[i].clear();
}
for (int i = 0; i < q; ++i) {
cout << sol[i] << ' ';
}
cout << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int tests;
cin >> tests;
for (int tc = 0; tc < tests; ++tc) {
testCase();
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC diagnostic ignored "-Wunused-result"
#pragma GCC diagnostic ignored "-Wunused-function"
using namespace std;
namespace {
namespace shik {
template <class T>
void _R(T &x) {
cin >> x;
}
void _R(int &x) { scanf("%d", &x); }
void _R(int64_t &x) { scanf("%" SCNd64, &x); }
void _R(double &x) { scanf("%lf", &x); }
void _R(char &x) { scanf(" %c", &x); }
void _R(char *x) { scanf("%s", x); }
void R() {}
template <class T, class... U>
void R(T &head, U &...tail) {
_R(head);
R(tail...);
}
template <class T>
void _W(const T &x) {
cout << x;
}
void _W(const int &x) { printf("%d", x); }
void _W(const int64_t &x) { printf("%" PRId64, x); }
void _W(const double &x) { printf("%.16f", x); }
void _W(const char &x) { putchar(x); }
void _W(const char *x) { printf("%s", x); }
template <class T>
void _W(const vector<T> &x) {
for (auto i = x.begin(); i != x.end(); _W(*i++))
if (i != x.cbegin()) putchar(' ');
}
void W() {}
template <class T, class... U>
void W(const T &head, const U &...tail) {
_W(head);
putchar(sizeof...(tail) ? ' ' : '\n');
W(tail...);
}
template <class T, class F = less<T>>
void sort_uniq(vector<T> &v, F f = F()) {
sort(begin(v), end(v), f);
v.resize(unique(begin(v), end(v)) - begin(v));
}
template <class T>
inline T bit(T x, int i) {
return (x >> i) & 1;
}
template <class T>
inline bool chkmax(T &a, const T &b) {
return b > a ? a = b, true : false;
}
template <class T>
inline bool chkmin(T &a, const T &b) {
return b < a ? a = b, true : false;
}
template <class T>
using MaxHeap = priority_queue<T>;
template <class T>
using MinHeap = priority_queue<T, vector<T>, greater<T>>;
const int N = 110;
int n;
char s[N];
void main() {
R(n, s);
for (int i = n; i >= 0; i--)
if (i % 2 == 0 && strncmp(s, s + i / 2, i / 2) == 0) {
;
W(i / 2 + n - i + (i != 0));
return;
}
}
} // namespace shik
} // namespace
int main() {
shik::main();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t, k;
long long dp[100005];
dp[0] = 0;
cin >> t >> k;
for (int i = 1; i <= 100000; ++i) {
if (i < k)
dp[i] = 1;
else if (i == k)
dp[i] = 2;
else {
dp[i] = (dp[i - 1] + dp[i - k]) % 1000000007;
}
}
long long pre[100005];
pre[0] = 0;
for (int i = 1; i <= 100000; ++i) {
pre[i] = (pre[i - 1] + dp[i]) % 1000000007;
}
while (t--) {
int a, b;
cin >> a >> b;
long long ans = pre[b] - pre[a - 1];
if (ans < 0) ans += 1000000007;
cout << ans << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<int> ans;
struct Graph {
vector<int> edges[100010];
vector<int> redges[100010];
int d[100010];
bool visited[100010];
int V = 100010;
void add_edge(int from, int to) {
edges[from].push_back(to);
redges[to].push_back(from);
}
void bfs() {
fill(visited, visited + V + 1, 0);
for (int i = 1; i <= V; i++)
if (!visited[i]) bfs(i);
}
void bfs(int s) {
queue<int> q;
q.push(s);
visited[s] = 1;
d[s] = 0;
while (!q.empty()) {
int v = q.front();
q.pop();
for (int next : edges[v]) {
if (!visited[next]) {
visited[next] = 1;
d[next] = d[v] + 1;
q.push(next);
} else {
ans.push_back(abs(d[next] - d[v] - 1));
if (ans.back() == 0) ans.pop_back();
}
}
for (int next : redges[v]) {
if (!visited[next]) {
visited[next] = 1;
d[next] = d[v] - 1;
q.push(next);
} else {
ans.push_back(abs(d[next] - d[v] + 1));
if (ans.back() == 0) ans.pop_back();
}
}
}
}
};
int gcd(int m, int n) {
if (n == 0) return m;
return gcd(n, m % n);
}
Graph g;
int main() {
int n, m;
cin >> n >> m;
g.V = n;
int u, v;
while (m--) {
scanf("%d%d", &u, &v);
g.add_edge(u, v);
}
g.bfs();
if (ans.size() == 0) {
cout << n << endl;
return 0;
}
int sol = ans[0];
for (int i : ans) sol = gcd(sol, i);
cout << sol << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, a, p = 0, b = 0;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a;
if (p + a < m)
p += a;
else if (p + a == m) {
b++;
p = 0;
} else {
b++;
p = a;
}
}
if (p != 0) {
b += p / m;
if (p % m != 0) b++;
}
cout << b;
return 0;
}
| 1 |
#include <bits/stdc++.h>
int main() {
int n, m, p, i, t, ans;
scanf("%d", &t);
while (t--) {
m = 0, p = 0;
scanf("%d", &n);
char s[n + 1];
scanf("%s", s);
if (s[0] == '1' || s[n - 1] == '1')
ans = 2 * n;
else {
for (i = 0; i < n; i++) {
if (s[i] == '0')
m++;
else
break;
}
for (i = n - 1; i >= 0; i--) {
if (s[i] == '0')
p++;
else
break;
}
if (m == n)
ans = n;
else {
ans = 2 * (n - (m < p ? m : p));
}
}
printf("%d\n", ans);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 234567;
int n;
long long a[N];
long long dp[2][N];
bool vis[2][N];
void dfs(int u, bool type) {
int v = u;
if (type)
v += a[u];
else
v -= a[u];
if (v <= 0 || v > n) {
dp[type][u] = a[u];
return;
}
if (!vis[!type][v]) {
vis[!type][v] = 1;
dfs(v, !type);
} else {
if (dp[!type][v] == 0) dp[!type][v] = -1;
if (dp[!type][v] == -1)
dp[type][u] = -1;
else
dp[type][u] = a[u] + dp[!type][v];
return;
}
if (dp[!type][v] == -1)
dp[type][u] = -1;
else
dp[type][u] = a[u] + dp[!type][v];
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 2; i <= n; i++) cin >> a[i];
vis[0][1] = 1, vis[1][1] = 1;
dp[0][1] = -1, dp[1][1] = -1;
for (int type = 0; type <= 1; type++)
for (int u = 2; u <= n; u++)
if (!vis[type][u]) vis[type][u] = 1, dfs(u, type);
for (int u = 2; u <= n; u++)
if (dp[0][u] == -1)
cout << -1 << endl;
else
cout << (u - 1 + dp[0][u]) << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n = 0, m = 0;
cin >> n;
vector<int> buf(n, 0);
for (int i = 0; i < n; i++) {
cin >> buf[i];
}
n--;
for (int i = 1; i < n; i++) {
if ((buf[i] > buf[i - 1] && buf[i] > buf[i + 1]) ||
(buf[i] < buf[i - 1] && buf[i] < buf[i + 1])) {
m++;
}
}
cout << m;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
while (t--) {
long long int n, x, y, d;
cin >> n >> x >> y >> d;
if (abs(x - y) % d == 0) {
cout << (abs(x - y) / d) << endl;
continue;
}
long long int m = LONG_LONG_MAX;
if ((y - 1) % d == 0) m = (x - 1) / d + 1 + (y - 1) / d;
if ((n - y) % d == 0) m = min(m, (n - x) / d + 1 + (n - y) / d);
if (m == LONG_LONG_MAX)
cout << "-1" << endl;
else
cout << m << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (-1u) / 2;
const long long int INF2 = (-1ull) / 2;
int a, b, i, j, k, n, m, timer = 0, x, y, have[300001];
int par[300001], cnt = 0, fl = 0, a2, a3 = -1000000, c[300001] = {0}, ans = 0;
void init(int a) { par[a] = a + 1; }
int find(int v) {
if (have[v] < c[v] || v > n) return (v);
return par[v] = (find(par[v]));
}
void solve(int x, int y) {
if (x > n) return;
have[x] += y;
if (have[x] <= c[x]) return;
y = have[x] - c[x];
have[x] = c[x];
solve(find(x), y);
}
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &c[i]);
init(i);
}
scanf("%d", &m);
for (i = 0; i < m; i++) {
scanf("%d", &a);
if (a == 1) {
scanf("%d%d", &x, &y);
solve(x, y);
} else {
scanf("%d", &x);
printf("%d\n", have[x]);
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int N, M, K, Q, R, S[105], EXP[105], choose[105][105],
dp[105][105 * 105], tmp;
long long int exponentiate(long long int v, long long int p) {
if (p == 1) return v;
if (p & 1ll) return (v * exponentiate(v, p - 1ll)) % 1000000007;
return exponentiate((v * v) % 1000000007, p / 2ll);
}
int main() {
cin >> N >> M >> K;
for (int i = 0; i <= N; ++i)
for (int j = 0; j <= i; ++j) {
if (i == 0 || j == 0 || j == i)
choose[i][j] = 1ll;
else
choose[i][j] = choose[i - 1][j - 1] + choose[i - 1][j];
if (choose[i][j] >= 1000000007) choose[i][j] -= 1000000007;
}
Q = M / N;
R = M % N;
for (int i = 0; i <= N; ++i) {
S[i] = choose[N][i];
EXP[i] = exponentiate(S[i], Q);
}
dp[0][0] = 1;
for (int i = 1; i <= N; ++i) {
dp[i][0] = 1;
for (int j = 1; j <= K; ++j) {
for (int a = 0; a <= N && j - a >= 0; ++a) {
tmp = (EXP[a] * ((i <= R) ? S[a] : 1ll)) % 1000000007;
tmp = (dp[i - 1][j - a] * tmp) % 1000000007;
dp[i][j] += tmp;
if (dp[i][j] >= 1000000007) dp[i][j] -= 1000000007;
}
}
}
cout << dp[N][K] << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, l, r;
cin >> n >> m;
while (m--) cin >> l >> r;
for (int i = 1; i <= n / 2; i++) cout << "01";
if (n % 2) cout << "0" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct item {
int key, prior, cnt, val;
item *l, *r;
item() {}
item(int key, int prior) : key(key), prior(prior), l(NULL), r(NULL), val(1) {}
};
typedef item *pitem;
int cnt(pitem t) { return t ? t->cnt : 0; }
void upd_cnt(pitem t) {
if (t) t->cnt = t->val + cnt(t->l) + cnt(t->r);
}
void split(pitem t, int key, pitem &l, pitem &r) {
if (!t)
l = r = NULL;
else if (key < t->key)
split(t->l, key, l, t->l), r = t;
else
split(t->r, key, t->r, r), l = t;
upd_cnt(t);
}
void insert(pitem &t, pitem it) {
if (!t)
t = it;
else if (t->key == it->key)
t->val += it->val;
else if (it->prior > t->prior)
split(t, it->key, it->l, it->r), t = it;
else
insert(it->key < t->key ? t->l : t->r, it);
upd_cnt(t);
}
const int nm = 200010;
int n, t, a[nm];
pitem root;
int cnt_lte(pitem &t, int x) {
if (!t) {
return 0;
}
if (t->key == x) {
return cnt(t->l) + t->val;
}
if (t->key < x) {
return cnt(t->l) + t->val + cnt_lte(t->r, x);
}
return cnt_lte(t->l, x);
}
int main() {
srand(2512);
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> t;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
int res = 0;
for (int i = 1; i <= n && i < t; ++i) {
insert(root, new item(a[i] - i, rand()));
res = max(res, cnt_lte(root, t - i - 1));
}
cout << res << "\n";
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1012345678;
char S[25];
char T[25];
int p[25];
int n, m, k;
int dpS1[(1 << 20) + 5];
int dpT1[(1 << 20) + 5];
int a[1000005];
int b[1000005];
int conv(int x) {
int ans = 0;
for (int i = 0; i < k; i++) {
if (x & (1 << i)) {
ans |= (1 << (p[i]));
}
}
return ans;
}
int swap1(int x, int a, int b) {
bool val1 = x & (1 << a);
bool val2 = x & (1 << b);
if (val1 == val2) {
return x;
} else {
return x ^ (1 << a) ^ (1 << b);
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
scanf(" %s %s", S, T);
for (int i = 0; i < n; i++) {
scanf("%d%d", &a[i], &b[i]);
a[i]--;
b[i]--;
}
int s = 0;
int t = 0;
for (int i = 0; i < k; i++) {
if (S[i] == '1') {
s |= (1 << i);
}
if (T[i] == '1') {
t |= (1 << i);
}
p[i] = i;
}
int offset = k - __builtin_popcount(s) - __builtin_popcount(t);
for (int i = 0; i < (1 << k); i++) {
dpS1[i] = INF;
dpT1[i] = -INF;
}
int start = 0;
for (int i = 0; i <= n; i++) {
int s2 = conv(s);
int t2 = conv(t);
dpS1[s2] = min(dpS1[s2], i);
dpT1[t2] = max(dpT1[t2], i);
if (i == n) {
break;
}
swap(p[a[i]], p[b[i]]);
}
for (int i = (1 << k) - 1; i >= 0; i--) {
for (int j = 0; j < k; j++) {
if ((i & (1 << j)) == 0) {
dpS1[i] = min(dpS1[i ^ (1 << j)], dpS1[i]);
dpT1[i] = max(dpT1[i ^ (1 << j)], dpT1[i]);
}
}
}
int bestScore = -1;
int l = -1;
int r = -1;
for (int i = 0; i < (1 << k); i++) {
if (dpS1[i] != INF && dpT1[i] != -INF && dpT1[i] - dpS1[i] >= m) {
int score = offset + 2 * __builtin_popcount(i);
if (score > bestScore) {
bestScore = score;
l = dpS1[i];
r = dpT1[i];
}
}
}
printf("%d\n%d %d\n", bestScore, l + 1, r);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> n;
vector<int> vec;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
if (i == 0)
vec.push_back(x);
else {
vec.push_back(x + vec[i - 1]);
}
}
int m;
cin >> m;
while (m--) {
int lower = 0;
int x;
cin >> x;
lower = lower_bound(vec.begin(), vec.end(), x) - vec.begin();
cout << lower + 1 << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const double pi = acos(-1.0);
const double eps = 1e-6;
const int MAX_SIZE = 100;
const int dX[] = {-1, 1, 0, 0, -1, 1, -1, 1};
const int dY[] = {0, 0, -1, 1, 1, -1, -1, 1};
template <class S, class T>
ostream& operator<<(ostream& o, const pair<S, T>& a) {
o << a.first << " " << a.second << " ";
return o;
}
template <class S, class T>
ostream& operator<<(ostream& o, const map<S, T>& a) {
for (auto& it : (a)) o << (it);
return o;
}
template <class S>
ostream& operator<<(ostream& o, const vector<S>& a) {
for (auto& it : (a)) o << (it) << " ";
o << "\n";
return o;
}
template <class S>
ostream& operator<<(ostream& o, const vector<vector<S> >& a) {
for (auto& it : (a)) o << (it);
return o;
}
template <class S>
ostream& operator<<(ostream& o, const set<S>& a) {
for (auto& it : (a)) o << (it) << " ";
o << "\n";
return o;
}
const long long MAX = 4000000;
int find_div(long long x) {
long long i, lim = sqrt(x) + 1;
for (i = (2); (((1) > 0) - ((1) < 0)) * i < (((1) > 0) - ((1) < 0)) * (lim);
i += (1)) {
if (x % i == 0) return i;
}
return 0;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
long long a, b, q;
cin >> q;
a = find_div(q);
if (a == 0)
cout << "1\n0";
else {
b = find_div(q / a);
if (b == 0)
cout << 2;
else
cout << 1 << "\n" << a * b;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
map<pair<int, int>, bool> bridge;
bool isBridge(int u, int v) {
if (u > v) swap(u, v);
return bridge.count(pair<int, int>(u, v));
}
void addBridge(int u, int v) {
if (u > v) swap(u, v);
bridge[pair<int, int>(u, v)] = true;
}
int n, number[100111], low[100111], counter;
vector<int> adj[100111], adj2[100111];
int root[100111], parent[100111], N, P[100111][20], level[100111];
void dfs(int u, int p) {
low[u] = number[u] = ++counter;
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (number[v] == 0) {
dfs(v, u);
if (low[v] > number[u]) addBridge(u, v);
low[u] = min(low[u], low[v]);
} else if (v != p)
low[u] = min(low[u], number[v]);
}
}
void visit(int u, int p) {
root[u] = p;
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (isBridge(u, v)) continue;
if (!root[v]) visit(v, p);
}
}
void buildTree(int u, int p, int lvl) {
parent[u] = p;
level[u] = lvl;
for (int i = 0; i < adj2[u].size(); i++) {
int v = adj2[u][i];
if (!parent[v]) buildTree(v, u, lvl + 1);
}
}
void prepare() {
counter = 0;
for (int i = 1; i <= n; i++) {
low[i] = number[i] = 0;
root[i] = parent[i] = 0;
}
for (int i = 1; i <= n; i++)
if (number[i] == 0) dfs(i, -1);
counter = 0;
for (typeof(bridge.begin()) it = bridge.begin(); it != bridge.end(); it++) {
int u = it->first.first, v = it->first.second;
if (!root[u]) visit(u, ++counter);
if (!root[v]) visit(v, ++counter);
u = root[u];
v = root[v];
adj2[u].push_back(v);
adj2[v].push_back(u);
}
N = counter;
if (N == 0) return;
buildTree(1, -1, 0);
for (int i = 1; i <= N; i++) P[i][0] = parent[i];
for (int j = 1; (1 << (j)) <= N; j++) {
for (int i = 1; i <= N; i++)
if (P[i][j - 1] == -1)
P[i][j] = -1;
else
P[i][j] = P[P[i][j - 1]][j - 1];
}
}
int getLCA(int u, int v) {
if (level[u] < level[v]) swap(u, v);
int m = 0;
while ((1 << (m)) <= level[u]) m++;
for (int i = m; i >= 0; i--)
if (level[u] - (1 << (i)) >= level[v]) u = P[u][i];
if (u == v) return u;
for (int i = m; i >= 0; i--) {
if (P[u][i] != -1 && P[u][i] != P[v][i]) u = P[u][i], v = P[v][i];
}
return parent[u];
}
int solveLCA(int u, int v) {
if (N == 0) return 0;
u = root[u], v = root[v];
int p = getLCA(u, v);
if (p == u || p == v) return abs(level[v] - level[u]);
return level[u] + level[v] - 2 * level[p];
}
int main() {
int m, u, v, k;
scanf("%d %d", &n, &m);
while (m--) {
scanf("%d %d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
prepare();
scanf("%d", &k);
while (k--) {
scanf("%d %d", &u, &v);
printf("%d\n", solveLCA(u, v));
}
return 0;
}
| 4 |
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
const int N = (int)(2e5) + 7;
int _,ans,res,a,b;
char s[N];
int main() {
for (scanf("%d", &_); _; --_) {
res = 0, a = 0, b = 0;
scanf("%s", s );getchar();
int length = (int)strlen(s);
for (int i = 0; i < length; i++) {
if (s[i] == '(')
a++;
if (s[i] == ')' && a != 0) {
a--;
res++;
}
if (s[i] == '[')b++;
if (s[i] == ']' && b != 0) {
b--;
res++;
}
}printf("%d\n", res);
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const long long max_n = 500 + 5;
long long n;
long long a[max_n], b[max_n];
bool are_equal(long long arr1[], long long arr2[], long long sz) {
for (int i = 0; i < sz; ++i) {
if (arr1[i] != arr2[i]) return false;
}
return true;
}
bool same_elements(long long arr1[], long long arr2[], long long sz) {
long long tarr1[sz], tarr2[sz];
for (int i = 0; i < sz; ++i) {
tarr1[i] = arr1[i];
tarr2[i] = arr2[i];
}
sort(tarr1, tarr1 + sz);
sort(tarr2, tarr2 + sz);
return are_equal(tarr1, tarr2, sz);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
cin >> t;
while (t--) {
cin >> n;
for (int z = 0; z < n; ++z) cin >> a[z];
;
for (int z = 0; z < n; ++z) cin >> b[z];
;
if (!same_elements(a, b, n) or (n & 1 and a[n / 2] != b[n / 2])) {
cout << "No\n";
continue;
}
vector<pair<long long, long long> > p;
for (int i = 0; i < (n / 2); ++i) p.push_back({a[i], a[n - 1 - i]});
bool flag = true;
for (int i = 0; i < (n / 2) and flag; ++i) {
long long x;
bool got = false;
pair<long long, long long> temp = {b[i], b[n - 1 - i]};
for (x = 0; x < p.size() and !got; ++x) {
if (p[x] == temp) {
p.erase(p.begin() + x);
got = true;
}
}
temp = {b[n - 1 - i], b[i]};
for (x = 0; x < p.size() and !got; ++x) {
if (p[x] == temp) {
p.erase(p.begin() + x);
got = true;
}
}
flag = got;
}
if (flag)
cout << "Yes\n";
else
cout << "No\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cout << name << " : " << arg1 << "\n";
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
long long int i, j;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m;
cin >> n >> m;
int l[m], r[m], t[m], c[m];
vector<pair<int, int> > v(m + 1);
for (i = 0; i < m; ++i) {
cin >> l[i] >> r[i] >> t[i] >> c[i];
v[i] = make_pair(t[i], c[i]);
}
v[m] = make_pair(0, 0);
int profit = 0;
for (i = 0; i < n; ++i) {
int min = 1002;
int z = m;
for (j = 0; j < m; ++j) {
if (i + 1 >= l[j] and i + 1 <= r[j]) {
if (min > t[j]) {
min = t[j];
z = j;
}
}
}
profit += v[z].second;
}
cout << profit;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int isLess(long long x, long long y, long long a, long long b, long long c) {
if (b == 0) {
long long num = -c;
long long den = a;
if (den < 0) {
den *= -1;
num *= -1;
}
return den * x < num;
}
long long num = -a * x - c;
long long den = b;
if (den < 0) {
den *= -1;
num *= -1;
}
return den * y < num;
}
int main() {
long long a, b, c, d;
scanf("%lld %lld %lld %lld", &a, &b, &c, &d);
int n;
scanf("%d", &n);
int ans = 0;
for (int i = 0; i < n; i++) {
long long x, y, z;
scanf("%lld %lld %lld", &x, &y, &z);
ans += isLess(a, b, x, y, z) ^ isLess(c, d, x, y, z);
}
printf("%d\n", ans);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, a, b;
cin >> t;
int arr[2 * t];
for (int i = 0; i < 2 * t; i++) cin >> arr[i];
for (int p = 0; p < 2 * t; p = p + 2) {
int c = 0, ans = 0;
a = arr[p];
b = arr[p + 1];
if (b > a) {
c = b - a;
ans = c / 10;
if (c % 10 == 0)
cout << ans << "\n";
else
cout << ans + 1 << "\n";
} else if (a > b) {
c = a - b;
ans = c / 10;
if (c % 10 == 0)
cout << ans << "\n";
else
cout << ans + 1 << "\n";
} else
cout << "0"
<< "\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
map<string, int> ZJQ, JSQ, SC, Cnt;
map<string, bool> Used;
vector<string> Teams;
bool Cmp(string &A, string &B) {
if (SC[A] > SC[B]) return 1;
if (SC[A] < SC[B]) return 0;
if (JSQ[A] > JSQ[B]) return 1;
if (JSQ[A] < JSQ[B]) return 0;
if (ZJQ[A] > ZJQ[B]) return 1;
if (ZJQ[A] < ZJQ[B]) return 0;
if (A > B) return 0;
return 1;
}
int main() {
for (int i = 0; i < 5; i++) {
string A, B;
cin >> A >> B;
char _;
int GA, GB;
cin >> GA >> _ >> GB;
if (!Used[A]) {
Teams.push_back(A);
Used[A] = true;
}
if (!Used[B]) {
Teams.push_back(B);
Used[B] = true;
}
ZJQ[A] += GA;
ZJQ[B] += GB;
JSQ[A] -= GB;
JSQ[B] -= GA;
JSQ[A] += GA;
JSQ[B] += GB;
Cnt[A]++;
Cnt[B]++;
if (GA == GB) {
SC[A]++;
SC[B]++;
} else if (GA > GB)
SC[A] += 3;
else
SC[B] += 3;
}
string Enemy;
for (int i = 0; i < 4; i++)
if (Cnt[Teams[i]] == 2 && Teams[i] != "BERLAND") Enemy = Teams[i];
SC["BERLAND"] += 3;
for (int i = 1; i < 100; i++)
for (int j = 0; j < 100; j++) {
JSQ["BERLAND"] += i;
JSQ[Enemy] -= i;
ZJQ["BERLAND"] += i + j;
ZJQ[Enemy] += j;
sort(Teams.begin(), Teams.end(), Cmp);
if (Teams[0] == "BERLAND" || Teams[1] == "BERLAND") {
cout << i + j << ":" << j << endl;
return 0;
}
JSQ["BERLAND"] -= i;
JSQ[Enemy] += i;
ZJQ["BERLAND"] -= i + j;
ZJQ[Enemy] -= j;
}
puts("IMPOSSIBLE");
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
using namespace std;
class Mint {
private:
long long int x;
inline static long long int mod = 1e9 + 9;
long long int fastPow(long long int x, long long int p) const {
if (p == 0)
return 1;
else if (p % 2 == 0) {
auto ans = fastPow(x, p / 2);
return ans * ans % mod;
} else {
auto ans = fastPow(x, p - 1);
return ans * x % mod;
}
}
long long int rev() const { return fastPow(x, mod - 2); }
public:
Mint() : x(0) {}
Mint(long long int x) : x(x % mod) {}
Mint(const Mint& other) {
this->x = other.x;
this->mod = other.mod;
}
Mint(Mint&& other) {
swap(this->x, other.x);
swap(this->mod, other.mod);
}
Mint operator=(const Mint& other) {
this->x = other.x;
return *this;
}
Mint operator=(Mint&& other) {
swap(x, other.x);
return *this;
}
Mint operator+(const Mint& other) const {
long long int nx = (x + other.x + mod) % mod;
return Mint(nx);
}
Mint operator-(const Mint& other) const {
long long int nx = (x - other.x + mod) % mod;
return Mint(nx);
}
Mint operator*(const Mint& other) const {
long long int nx = (x * other.x) % mod;
return Mint(nx);
}
Mint operator/(const Mint& other) const {
long long int nx = (x * other.rev()) % mod;
return Mint(nx);
}
void operator+=(const Mint& other) { *this = *this + other; }
void operator-=(const Mint& other) { *this = *this - other; }
void operator*=(const Mint& other) { *this = *this * other; }
void operator/=(const Mint& other) { *this = *this / other; }
bool operator==(const Mint& other) { return x == other.x; }
bool operator!=(const Mint& other) { return x != other.x; }
friend istream& operator>>(istream& in, Mint& a) {
long long int nx;
in >> nx;
a = nx;
return in;
}
friend ostream& operator<<(ostream& out, Mint& a) { return out << a.x; }
};
Mint fastPow(Mint x, long long int p) {
if (p == 0)
return 1;
else if (p % 2 == 0) {
auto ans = fastPow(x, p / 2);
return ans * ans;
} else {
auto ans = fastPow(x, p - 1);
return ans * x;
}
}
long long int n, k;
Mint a, b;
string s;
vector<long long int> c;
signed main() {
cin >> n >> a >> b >> k >> s;
c.resize(k);
for (long long int i = 0; i < k; ++i) {
if (s[i] == '+')
c[i] = 1;
else
c[i] = -1;
}
Mint S = 0;
Mint nowA = fastPow(a, n), nowB = 1;
for (long long int i = 0; i < k; ++i) {
S += nowA * nowB * c[i];
nowA /= a;
nowB *= b;
}
Mint q = fastPow(b, k) / fastPow(a, k), Sn;
long long int cnt = (n + 1) / k;
if (q == 1)
Sn = cnt;
else
Sn = (fastPow(q, cnt) - 1) / (q - 1);
Mint ans = S * Sn;
cout << ans << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> vec[200005];
set<pair<int, int> > remainingGas;
set<pair<int, int> >::iterator it;
int main() {
int n, d, m, xi, pi;
scanf("%d %d %d", &d, &n, &m);
for (int contador = 0; contador < m; contador++) {
scanf("%d %d", &xi, &pi);
vec[contador] = pair<int, int>(xi, pi);
}
sort(vec, vec + m);
int myp = 0, index = 0;
vec[m] = pair<int, int>(d, 0);
long long custo = 0;
remainingGas.insert(pair<int, int>(0, n));
int capacity = n;
while (index <= m) {
int spent = vec[index].first - myp;
if (spent > capacity) {
printf("-1\n");
return 0;
}
capacity -= spent;
while (spent > 0) {
it = remainingGas.begin();
pair<int, int> rem = *it;
remainingGas.erase(it);
if (spent > rem.second) {
spent -= rem.second;
} else {
rem.second -= spent;
spent = 0;
remainingGas.insert(rem);
}
}
custo += (long long)vec[index].second * n;
remainingGas.insert(pair<int, int>(vec[index].second, n));
while (capacity > 0) {
it = remainingGas.end();
it--;
pair<int, int> rem = *it;
remainingGas.erase(it);
if (capacity > rem.second) {
capacity -= rem.second;
custo -= (long long)rem.first * rem.second;
} else {
rem.second -= capacity;
custo -= (long long)rem.first * capacity;
capacity = 0;
remainingGas.insert(rem);
}
}
capacity = n;
myp = vec[index].first;
index++;
}
printf("%I64d\n", custo);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long n, m;
pair<string, long long> s[1000001];
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (long long i = 0; i < n; i++) {
cin >> s[i].first;
s[i].second = i + 1;
for (long long j = 1; j < m; j += 2)
s[i].first[j] = 'A' + 'Z' - s[i].first[j];
}
sort(s, s + n);
for (long long i = 0; i < n; i++) cout << s[i].second << ' ';
cout << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
cin >> str;
str[0] = toupper(str[0]);
cout << str << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mx = 100010;
int b[mx];
int main() {
int a, m;
while (scanf("%d%d", &a, &m) == 2) {
memset(b, 0, sizeof b);
while (a) {
if (b[a]) break;
b[a] = 1;
a = (a + a) % m;
}
if (a)
printf("No\n");
else
printf("Yes\n");
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline istream& operator>>(istream& in, pair<T, U>& p) {
in >> p.first >> p.second;
return in;
}
template <typename T>
inline istream& operator>>(istream& in, vector<T>& v) {
for (T& x : v) in >> x;
return in;
}
void solve(int& tc) {
long long int n;
cin >> n;
vector<long long int> a(n);
cin >> a;
long long int pos = 0, ans = 0, extra = 0;
for (long long int i = 0; i < n; i++) {
if (a[i] < 0) {
a[i] *= -1;
long long int mn = min(pos, a[i]);
pos -= mn;
a[i] -= mn;
extra += a[i];
} else {
pos += a[i];
}
}
ans += (extra + pos + 1) / 2;
cout << ans << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int tc = 1;
cin >> tc;
for (int i = 1; i <= tc; i++) {
if (0) cerr << "Case #" << i << "\n";
solve(i);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long x, long long y) { return y == 0 ? x : gcd(y, x % y); }
int toInt(char xx) { return xx - '0'; }
char toChar(int xx) { return xx + '0'; }
bool isDigit(char xx) { return ('0' <= xx && xx <= '9'); }
bool isCharacter(char xx) {
return (('a' <= xx && xx <= 'z') || ('A' <= xx && xx <= 'Z'));
}
void swapInt(int &x, int &y) {
x = x ^ y;
y = x ^ y;
x = x ^ y;
}
inline void clear_buffer() {
string tmp;
getline(cin, tmp);
}
const int dx[4] = {-1, 1, 0, 0};
const int dy[4] = {0, 0, -1, 1};
const int Mod = 10;
const int maxn = (1e3) + 10;
bool exitInput = false;
int n;
long long x, y;
void read() { cin >> n >> x >> y; }
void init() {}
void solve() {
long long maxa = y - (n - 1);
if (maxa <= 0) {
cout << -1;
return;
}
long long min_maxa = sqrt(x - (n - 1));
if (min_maxa > maxa) {
cout << -1;
return;
}
long long a = maxa;
if ((a + n - 1) <= y && (a * a + n - 1) >= x) {
cout << a << endl;
for (int i = 1; i <= n - 1; ++i) {
cout << 1 << endl;
}
return;
}
cout << -1;
}
int main() {
int ntest = 1;
int itest = 1;
for (itest = 1; itest <= ntest; ++itest) {
read();
if (exitInput) {
break;
}
init();
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long n, a = 0, b, c = 1;
char d[2009], r[2009];
cin >> n;
cin >> d;
b = n;
for (int i = n; i >= 0; i--) {
if (c % 2 == 1) {
r[b] = d[i];
b--;
} else if (c % 2 == 0) {
r[a] = d[i];
a++;
}
c++;
}
a = 0;
b = n - 1;
for (int i = 0; i < n; i++) {
d[a] = r[b];
a++;
b--;
}
cout << d;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 1 << 17;
map<long long, int> id;
int r[maxn], c[maxn], a[maxn];
int vis[maxn];
int d[maxn];
vector<int> tmp, buf, s;
long long sum[5050], ave;
vector<int> g[maxn];
vector<vector<int> > tot;
int f[maxn], p[maxn];
int q[maxn];
void check(vector<int>& a) {
int state = 0;
for (int x : a) {
int cur = r[x];
if (state & (1 << cur)) return;
state ^= 1 << cur;
}
if (q[state] != -1) return;
q[state] = s.size();
s.push_back(state);
tot.push_back(a);
}
void dfs(int x, int dep, int flag) {
if (vis[x]) {
if (vis[x] == flag) {
buf.clear();
for (int i = d[x]; i < tmp.size(); i++) {
buf.push_back(tmp[i]);
}
check(buf);
}
return;
}
vis[x] = flag;
d[x] = dep;
tmp.push_back(x);
for (int y : g[x]) {
dfs(y, dep + 1, flag);
}
tmp.pop_back();
}
int ans[maxn], place[maxn];
void print(int cur) {
if (cur == 0) return;
int j = p[cur];
for (int i = 0; i < tot[j].size(); i++) {
int x = tot[j][i];
ans[r[x]] = a[x];
if (i > 0)
place[r[x]] = r[tot[j][i - 1]];
else
place[r[x]] = r[tot[j].back()];
}
print(cur ^ s[j]);
}
int main() {
memset(q, -1, sizeof(q));
int n;
cin >> n;
int cur = 0;
for (int i = 0; i < n; i++) {
int ni;
scanf("%d", &ni);
for (int j = 0; j < ni; j++) {
int x;
scanf("%d", &x);
a[++cur] = x;
sum[i] += x;
ave += x;
r[cur] = i;
c[cur] = j;
id[x] = cur;
}
}
if (ave % n) {
puts("No");
return 0;
}
ave /= n;
for (int i = 1; i <= cur; i++) {
long long nex = ave - (sum[r[i]] - a[i]);
if (id.count(nex)) {
g[i].push_back(id[nex]);
}
}
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= cur; i++)
if (!vis[i]) dfs(i, 0, i);
f[0] = 1;
for (int i = 1; i < (1 << n); i++) {
for (int j = i; j; j = (j - 1) & i) {
if (q[j] != -1 && f[i ^ j]) {
f[i] = 1;
p[i] = q[j];
break;
}
}
}
if (f[(1 << n) - 1] == 0) {
puts("No");
return 0;
}
puts("Yes");
print((1 << n) - 1);
for (int i = 0; i < n; i++) printf("%d %d\n", ans[i], place[i] + 1);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
int main() {
int vis[405], n, m, railways = 0;
queue<int> q;
for (int i = 0; i < 405; i++) vis[i] = -1;
vis[1] = 0;
vector<int> v[405];
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
if ((a == 1 && b == n) || (a == n && b == 1)) railways = 1;
}
q.push(1);
while (!q.empty()) {
int curr = q.front();
q.pop();
if (railways != 1) {
for (int i = 0; i < v[curr].size(); i++) {
if (vis[v[curr][i]] == -1) {
vis[v[curr][i]] = vis[curr] + 1;
q.push(v[curr][i]);
}
}
} else {
set<int> s;
for (int i = 1; i <= n; i++) s.insert(i);
for (int i = 0; i < v[curr].size(); i++) s.erase(v[curr][i]);
set<int>::iterator it;
for (it = s.begin(); it != s.end(); it++) {
int y = *(it);
if (vis[y] == -1) {
vis[y] = vis[curr] + 1;
q.push(y);
}
}
}
}
cout << vis[n] << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long a, b, a1, b1, a2, b2;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> a >> b >> a1 >> b1 >> a2 >> b2;
if (a1 + a2 <= a && max(b1, b2) <= b) return cout << "YES", 0;
if (a1 + b2 <= a && max(a2, b1) <= b) return cout << "YES", 0;
if (b1 + a2 <= a && max(b2, a1) <= b) return cout << "YES", 0;
if (b1 + b2 <= a && max(a1, a2) <= b) return cout << "YES", 0;
if (a1 + a2 <= b && max(b1, b2) <= a) return cout << "YES", 0;
if (a1 + b2 <= b && max(b1, a2) <= a) return cout << "YES", 0;
if (b1 + a2 <= b && max(b2, a1) <= a) return cout << "YES", 0;
if (b1 + b2 <= b && max(a1, a2) <= a) return cout << "YES", 0;
cout << "NO";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n;
cin >> n;
long long arr[2 * n];
for (long long i = 0; i < 2 * n; i++) {
cin >> arr[i];
}
vector<long long> odd, even;
for (long long i = 0; i < 2 * n; i++) {
if (arr[i] % 2)
odd.push_back(i + 1);
else
even.push_back(i + 1);
}
vector<pair<long long, long long>> ans;
for (long long i = 0; i + 1 < odd.size(); i += 2) {
ans.push_back({odd[i], odd[i + 1]});
}
for (long long i = 0; i + 1 < even.size(); i += 2) {
ans.push_back({even[i], even[i + 1]});
}
for (long long i = 0; i < n - 1; i++)
cout << ans[i].first << ' ' << ans[i].second << endl;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long t = 1;
cin >> t;
for (long long i = 0; i < t; i++) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const long long inf = numeric_limits<long long>::max() / 2;
const long double eps = 1e-9;
const long double pi = acos(-1);
template <typename T>
inline bool mineq(T& a, T b) {
return (a > b) ? (a = b, 1) : 0;
}
template <typename T>
inline bool maxeq(T& a, T b) {
return (a < b) ? (a = b, 1) : 0;
}
inline void solve(), read();
const string file = "";
signed main() {
if (file != "") {
freopen((file + ".in").c_str(), "r", stdin);
freopen((file + ".out").c_str(), "w", stdout);
}
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
;
read();
solve();
return 0;
}
long long q;
long long n;
long long f(long long k) { return n - k + min(k * (k - 1) / 2, n - k); }
long long tern() {
long long l = 1, r = n + 1;
while (r - l > 2) {
long long d = (r - l + 1) / 3;
long long m1 = l + d, m2 = r - d;
long long f1 = f(m1), f2 = f(m2);
if (f2 > f1) {
l = m1;
} else {
r = m2;
}
}
long long ans = max({f(l), f(l + 1), f(l + 2)});
return ans;
}
inline void solve() {
for (long long i = 0; i < q; i++) {
cin >> n;
long long ans = tern();
cout << ans << "\n";
}
}
inline void read() { cin >> q; }
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1e9 + 7;
const long long int N = 1e7 + 5;
void debugs() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long int lcm(long long int a, long long int b) {
return (a / gcd(a, b)) * b;
}
long long multiply(long long x, long long res[], long long ressize) {
long long carry = 0;
for (long long i = 0; i < ressize; i++) {
long long product = res[i] * x + carry;
res[i] = product % 10;
carry = product / 10;
}
while (carry) {
res[ressize] = carry % 10;
carry = carry / 10;
ressize++;
}
return ressize;
}
void bigfactorial(long long n) {
long long ressize = 1;
long long res[10000];
res[0] = 1;
for (long long i = 2; i <= n; i++) {
ressize = multiply(i, res, ressize);
}
for (long long i = ressize - 1; i >= 0; i--) {
cout << res[i];
}
}
long long int inv(long long i) {
if (i == 1) return 1;
return (mod - ((mod / i) * inv(mod % i)) % mod) % mod;
}
long long int mod_mul(long long a, long long b) {
a = a % mod;
b = b % mod;
return (((a * b) % mod) + mod) % mod;
}
long long int mod_add(long long a, long long b) {
a = a % mod;
b = b % mod;
return (((a + b) % mod) + mod) % mod;
}
void viewvector(vector<long long int> v) {
long long int n = v.size();
for (long long int i = 0; i < n; i++) {
cout << v[i] << " ";
}
cout << endl;
}
void viewarray(long long int a[], long long int n) {
for (long long int i = 0; i < n; i++) {
cout << a[i] << " ";
}
cout << endl;
}
long long int fpow(long long int a, long long int p) {
if (p == 0) return 1;
long long int k = fpow(a, p / 2);
if (p & 1) return (k * k % mod) * a % mod;
return k * k % mod;
}
vector<long long int> phi(10000004);
void euler() {
phi[0] = 0;
phi[1] = 1;
for (long long i = 2; i < 10000004; i++) {
phi[i] = i;
}
for (long long i = 2; i < 10000004; i++) {
if (phi[i] == i) {
for (long long j = i; j < 10000004; j += i) {
phi[j] -= phi[j] / i;
}
}
}
for (long long int i = 0; i < 10000004; i++) {
phi[i] += phi[i - 1];
}
}
long long paindrome(string s, char x) {
long long ans = 0;
long long int n = s.size();
;
long long int i = 0;
long long int j = n - 1;
while (i <= j) {
if (s[i] == s[j]) {
i++;
j--;
} else if (s[i] == x) {
ans++;
i++;
} else if (s[j] == x) {
ans++;
j--;
} else {
ans = n + 1;
break;
}
}
return ans;
}
long long permute(long long a) {
long long int product = 1;
for (long long int i = a; i > a - 2; i--) {
product *= i;
}
product /= 2;
return product;
}
void init_code() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
vector<long long int> alp(26);
vector<long long int> apl2(26);
signed main() {
init_code();
string s, t;
cin >> s >> t;
long long int n = s.size();
long long int m = t.size();
vector<long long int> ans;
if (n > m) {
cout << "-1" << endl;
}
long long int i = n - 1;
long long int j = m - 1;
bool p = true;
i = n - 1;
j = m - 1;
while (j >= i && (j >= 0 && i >= 0)) {
if (s[i] - '0' > t[j] - '0') {
ans.push_back(((t[j - 1] - '0') * 10 + (t[j] - '0')) - (s[i] - '0'));
j -= 2;
i--;
if (t[j + 1] != '1') {
p = false;
}
} else {
ans.push_back((t[j] - '0') - (s[i] - '0'));
j--;
i--;
}
}
if (j < i || !p) {
cout << "-1" << endl;
continue;
}
string y = "";
if (j >= 0) {
for (long long int i1 = 0; i1 <= j; i1++) {
y += t[i1];
}
}
string as = "";
for (long long int i = ans.size() - 1; i >= 0; i--) {
as += to_string(ans[i]);
}
as = y + as;
string ansd = "";
long long int idx = 0;
for (long long int i = 0; i < as.size(); i++) {
if (as[i] != '0') {
idx = i;
break;
}
}
for (long long int i = idx; i < as.size(); i++) {
ansd += as[i];
}
cout << ansd << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<vector<int>> v;
int cnt = 0;
void rec(int ind) {
if (ind == n + 1) {
cnt++;
for (vector<int> curr : v) {
for (int x : curr) cout << x << " ";
cout << "| ";
}
cout << '\n';
return;
}
v.push_back(vector<int>{ind});
rec(ind + 1);
v.pop_back();
for (int i = 0; i < v.size(); i++) {
v[i].push_back(ind);
rec(ind + 1);
v[i].pop_back();
}
}
vector<vector<int>> sol[2];
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
sol[0] = {vector<int>{0}};
for (int i = 1; i < n; i++) {
sol[i % 2].clear();
for (int j = 0; j < sol[(i - 1) % 2].size(); j++) {
int m = 0;
for (int x : sol[(i - 1) % 2][j]) m = max(m, x);
m++;
if (j % 2 == 0) {
sol[i % 2].push_back(sol[(i - 1) % 2][j]);
sol[i % 2].back().push_back(0);
for (int append = m; append > 1; append--) {
sol[i % 2].push_back(sol[(i - 1) % 2][j]);
sol[i % 2].back().push_back(append);
}
sol[i % 2].push_back(sol[(i - 1) % 2][j]);
sol[i % 2].back().push_back(1);
} else {
sol[i % 2].push_back(sol[(i - 1) % 2][j]);
sol[i % 2].back().push_back(1);
for (int append = 2; append <= m; append++) {
sol[i % 2].push_back(sol[(i - 1) % 2][j]);
sol[i % 2].back().push_back(append);
}
sol[i % 2].push_back(sol[(i - 1) % 2][j]);
sol[i % 2].back().push_back(0);
}
}
}
cout << sol[(n - 1) % 2].size() << '\n';
for (vector<int> v : sol[(n - 1) % 2]) {
int m = 0;
for (int x : v) m = max(m, x);
for (int i = 0; i <= m; i++) {
vector<int> elements;
for (int j = 0; j < v.size(); j++) {
if (v[j] == i) elements.push_back(j + 1);
}
cout << "{" << elements[0];
for (int j = 1; j < elements.size(); j++) cout << "," << elements[j];
cout << "}";
if (i != m)
cout << ",";
else
cout << '\n';
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct dot {
int x;
int y;
};
int n, d, k;
dot r;
vector<dot> v(0);
vector<dot> c(0);
void infile(int &n, int &d, int &k, dot &r, vector<dot> &v) {
cin >> n >> d >> k;
for (int i = 0; i < k; i++) {
cin >> r.x >> r.y;
v.push_back(r);
}
}
double S(dot a, dot b, dot c) {
int dx1 = b.x - a.x;
int dx2 = c.x - a.x;
int dy1 = b.y - a.y;
int dy2 = c.y - a.y;
return (double)abs(dx1 * dy2 - dy1 * dx2) / 2.0;
}
int main() {
infile(n, d, k, r, v);
r.x = 0;
r.y = 0;
c.push_back(r);
r.x = 0;
r.y = d;
c.push_back(r);
r.x = d;
r.y = 0;
c.push_back(r);
r.x = n;
r.y = n - d;
c.push_back(r);
r.x = n - d;
r.y = n;
c.push_back(r);
double S_ = S(c[1], c[2], c[3]) + S(c[3], c[4], c[1]);
for (int i = 0; i < k; i++) {
if (S(c[1], c[2], v[i]) + S(c[2], c[3], v[i]) + S(c[3], c[4], v[i]) +
S(c[4], c[1], v[i]) ==
S_)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1010;
int m, n;
int x[MAX], y[MAX];
bool generate(int *x, int p) {
memset(x, 0, sizeof(x));
if (p == 2) {
x[1] = 3;
x[2] = 4;
return true;
}
if (p == 1) {
x[1] = 1;
return true;
}
if (p % 2 == 0) {
for (int i = 1; i <= p - 1; i++) x[i] = 1;
x[p] = p / 2 - 1;
} else {
if (p == 3) {
x[1] = 2;
x[2] = 4;
x[3] = 4;
return true;
}
for (int i = 1; i <= p - 2; i++) x[i] = 5;
x[p - 1] = 3 * (p / 2) - 3;
x[p] = 4 * (p / 2) - 4;
}
return true;
}
int main() {
cin >> m >> n;
if (!generate(x, m)) {
cout << -1 << endl;
return 0;
}
if (!generate(y, n)) {
cout << -1 << endl;
return 0;
}
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) cout << x[i] * y[j] << " ";
cout << endl;
}
}
| 8 |
#include <bits/stdc++.h>
size_t get_steps_count(
size_t subtree_root, int subtree_color, size_t parent,
const int* target_colors,
std::unordered_map<size_t, std::unordered_set<size_t>>& edges) {
size_t steps = 0;
int target_color = target_colors[subtree_root];
if (target_color != subtree_color) {
++steps;
}
for (size_t v : edges[subtree_root]) {
if (v == parent) {
continue;
}
steps +=
get_steps_count(v, target_color, subtree_root, target_colors, edges);
}
return steps;
}
int main(void) {
size_t n = 0;
std::cin >> n;
std::unordered_map<size_t, std::unordered_set<size_t>> edges;
for (size_t i = 1; i < n; ++i) {
size_t vertex;
std::cin >> vertex;
vertex -= 1;
edges[vertex].insert(i);
edges[i].insert(vertex);
}
int target_colors[n];
for (size_t i = 0; i < n; ++i) {
std::cin >> target_colors[i];
}
size_t steps_cout = get_steps_count(0, 0, -1, target_colors, edges);
std::cout << steps_cout << std::endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e7 + 5;
long long spf[N], spf1[N];
void sieve() {
for (int i = 1; i < N; i++) spf[i] = i;
for (int i = 2; i * i < N; i++) {
if (spf[i] == i) {
for (int j = i * i; j < N; j += i) {
if (spf[j] == j) spf[j] = i;
}
}
}
}
long long ncr(long long a, long long b) {
long long k = 1;
if (b > a) swap(a, b);
for (long long i = 1; i <= b; i++) {
k = ((k * (a + i)));
k = k / i;
}
return k;
}
long long power(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long modInverse(long long n, long long p) { return power(n, p - 2, p); }
long long nCrModPFermat(long long n, long long r, long long p) {
if (r == 0) return 1;
long long fac[n + 1];
fac[0] = 1;
for (long long i = 1; i <= n; i++) fac[i] = fac[i - 1] * i % p;
return (fac[n] * modInverse(fac[r], p) % p * modInverse(fac[n - r], p) % p) %
p;
}
void solve() {
long long int n, k = 1, sum = 0, m = -1, l = 0, r = 1, q = 0, x, y, z, lcm,
a1, b1 = 0, i = 0, j = 0, n1, n2, n0, u, m1, e = 0, o = 0,
c1, d1, c;
bool flag = 0, f = 0;
double h, avg1;
cin >> n;
long long a[n + 1], b[21] = {0};
vector<long long> v;
for (i = 0; i < n; i++) cin >> a[i];
for (i = 0; i < n; i++) {
j = 0;
while (a[i] != 0) {
if (a[i] % 2 == 1) b[j]++;
j++;
a[i] /= 2;
}
}
for (i = 0; i < 21; i++) {
if (m < b[i]) m = b[i];
}
for (i = 0; i < m; i++) {
r = 1;
l = 0;
for (j = 0; j < 21; j++) {
if (b[j] > 0) {
l += r;
b[j]--;
}
r *= 2;
}
v.push_back(l);
}
for (i = 0; i < v.size(); i++) {
sum += v[i] * v[i];
}
cout << sum << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
long long int t = 1;
while (t--) {
solve();
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, l, a;
cin >> n >> l;
vector<int> vec(n);
for (int i = 0; i < n; i++) cin >> vec[i];
sort(vec.begin(), vec.end());
float max_dist = 0;
for (int i = 1; i < n; i++)
max_dist = max(max_dist, float(vec[i] - vec[i - 1]));
max_dist = max_dist / 2.0;
max_dist = max(max_dist, float(max(vec[0], l - vec[n - 1])));
printf("%.9f", max_dist);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 * 2 + 10;
const int inf = 1e9 + 10;
int n, m, k, l, cnt;
char c[55][55];
bool u[55][55];
vector<pair<int, pair<int, int> > > v;
void dps(int x, int y) {
if (u[x][y]) return;
u[x][y] = 1;
if (x > 1 && !u[x - 1][y] && c[x - 1][y] == '.') dps(x - 1, y);
if (y > 1 && !u[x][y - 1] && c[x][y - 1] == '.') dps(x, y - 1);
if (x < n && !u[x + 1][y] && c[x + 1][y] == '.') dps(x + 1, y);
if (y < m && !u[x][y + 1] && c[x][y + 1] == '.') dps(x, y + 1);
}
void dfs(int x, int y) {
if (u[x][y]) return;
u[x][y] = 1;
cnt++;
if (x > 1 && !u[x - 1][y] && c[x - 1][y] == '.') dfs(x - 1, y);
if (y > 1 && !u[x][y - 1] && c[x][y - 1] == '.') dfs(x, y - 1);
if (x < n && !u[x + 1][y] && c[x + 1][y] == '.') dfs(x + 1, y);
if (y < m && !u[x][y + 1] && c[x][y + 1] == '.') dfs(x, y + 1);
}
void ghp(int x, int y) {
c[x][y] = '*';
if (x > 1 && c[x - 1][y] == '.') ghp(x - 1, y);
if (y > 1 && c[x][y - 1] == '.') ghp(x, y - 1);
if (x < n && c[x + 1][y] == '.') ghp(x + 1, y);
if (y < m && c[x][y + 1] == '.') ghp(x, y + 1);
}
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> c[i][j];
}
}
for (int i = 1; i <= n; i++) {
if (c[i][1] == '.') dps(i, 1);
if (c[i][m] == '.') dps(i, m);
}
for (int i = 1; i <= m; i++) {
if (c[1][i] == '.') dps(1, i);
if (c[n][i] == '.') dps(n, i);
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (u[i][j] || c[i][j] == '*') continue;
cnt = 0;
dfs(i, j);
v.push_back(make_pair(cnt, make_pair(i, j)));
}
}
sort(v.begin(), v.end());
while (v.size() > k) {
l += v[0].first;
ghp(v[0].second.first, v[0].second.second);
v.erase(v.begin());
}
cout << l << endl;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cout << c[i][j];
}
cout << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char s[1010], t[1000010];
int main() {
scanf("%s%s", s, t);
int n = strlen(t), m = strlen(s);
int j = 0, lst = -1, frnt = -1;
for (int i = 0; i < n; i++) {
if (s[j] == t[i]) {
j++;
if (j == m) {
lst = i;
break;
}
}
}
j = m - 1;
for (int i = n - 1; i > lst; i--) {
if (s[j] == t[i]) {
j--;
if (j < 0) {
frnt = i;
break;
}
}
}
if ((lst == -1) || (frnt == -1))
printf("0");
else
printf("%d", frnt - lst);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 210000, mod = 1e9 + 7;
int a[maxn];
long long int pw(long long int a, int p) {
if (p == 0) return 1;
if (p == 1) return a % mod;
long long int rt = pw(a, p / 2);
rt = (rt * rt) % mod;
if (p % 2) rt = (rt * a) % mod;
return rt;
}
map<int, int> mp;
int main() {
int m = 0;
bool flag = false;
long long int ans = 1;
scanf("%d", &m);
for (int i = 1; i <= m; ++i) {
scanf("%d", &a[i]);
mp[a[i]]++;
ans = (ans * a[i]) % mod;
}
bool dv2 = false;
for (auto p : mp) {
if (p.second % 2) flag = true;
}
if (flag) {
for (auto p : mp) {
if (!dv2 && p.second % 2) {
ans = pw(ans, (p.second + 1) / 2);
dv2 = true;
} else {
ans = pw(ans, (p.second + 1));
}
}
} else {
for (auto p : mp) {
if (!dv2) {
ans = pw(ans, (p.second + 1) / 2);
dv2 = true;
for (auto p : mp) {
ans = (ans * pw(p.first, p.second / 2)) % mod;
}
} else {
ans = pw(ans, (p.second + 1));
}
}
}
cout << ans << endl;
return 0;
}
| 6 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.