solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 110;
int main() {
int n;
scanf("%d", &n);
vector<int> v(n);
for (int i = 0; i < n; i++) {
scanf("%d", &v[i]);
}
sort(v.begin(), v.end());
n = unique(v.begin(), v.end()) - v.begin();
if (n > 3) {
printf("-1\n");
} else {
if (n == 1)
printf("0\n");
else if (n == 2)
printf("%d\n", (v[1] - v[0]) % 2 == 0 ? (v[1] - v[0]) / 2 : v[1] - v[0]);
else if (v[1] - v[0] == v[2] - v[1])
printf("%d\n", v[1] - v[0]);
else
printf("-1\n");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
long long dx[4] = {0, -1, 0, 1};
long long dy[4] = {1, 0, -1, 0};
using namespace std;
class pa3 {
public:
long long x, y, z;
pa3(long long x = 0, long long y = 0, long long z = 0) : x(x), y(y), z(z) {}
bool operator<(const pa3 &p) const {
if (x != p.x) return x < p.x;
if (y != p.y) return y < p.y;
return z < p.z;
}
bool operator>(const pa3 &p) const {
if (x != p.x) return x > p.x;
if (y != p.y) return y > p.y;
return z > p.z;
}
bool operator==(const pa3 &p) const {
return x == p.x && y == p.y && z == p.z;
}
bool operator!=(const pa3 &p) const {
return !(x == p.x && y == p.y && z == p.z);
}
};
class pa4 {
public:
long long x;
long long y, z, w;
pa4(long long x = 0, long long y = 0, long long z = 0, long long w = 0)
: x(x), y(y), z(z), w(w) {}
bool operator<(const pa4 &p) const {
if (x != p.x) return x < p.x;
if (y != p.y) return y < p.y;
if (z != p.z) return z < p.z;
return w < p.w;
}
bool operator>(const pa4 &p) const {
if (x != p.x) return x > p.x;
if (y != p.y) return y > p.y;
if (z != p.z) return z > p.z;
return w > p.w;
}
bool operator==(const pa4 &p) const {
return x == p.x && y == p.y && z == p.z && w == p.w;
}
};
class pa2 {
public:
long long x, y;
pa2(long long x = 0, long long y = 0) : x(x), y(y) {}
pa2 operator+(pa2 p) { return pa2(x + p.x, y + p.y); }
pa2 operator-(pa2 p) { return pa2(x - p.x, y - p.y); }
bool operator<(const pa2 &p) const { return x != p.x ? x < p.x : y < p.y; }
bool operator>(const pa2 &p) const { return x != p.x ? x > p.x : y > p.y; }
bool operator==(const pa2 &p) const {
return abs(x - p.x) == 0 && abs(y - p.y) == 0;
}
bool operator!=(const pa2 &p) const {
return !(abs(x - p.x) == 0 && abs(y - p.y) == 0);
}
};
class Point {
public:
double x, y;
Point(double x = 0, double y = 0) : x(x), y(y) {}
Point operator+(Point p) { return Point(x + p.x, y + p.y); }
Point operator-(Point p) { return Point(x - p.x, y - p.y); }
Point operator*(double a) { return Point(x * a, y * a); }
Point operator/(double a) { return Point(x / a, y / a); }
double absv() { return sqrt(norm()); }
double norm() { return x * x + y * y; }
bool operator<(const Point &p) const { return x != p.x ? x < p.x : y < p.y; }
bool operator==(const Point &p) const {
return fabs(x - p.x) < (1e-7) && fabs(y - p.y) < (1e-7);
}
};
struct Segment {
Point p1, p2;
};
double dot(Point a, Point b) { return a.x * b.x + a.y * b.y; }
double cross(Point a, Point b) { return a.x * b.y - a.y * b.x; }
bool parareru(Point a, Point b, Point c, Point d) {
return abs(cross(a - b, d - c)) < (1e-7);
}
double distance_ls_p(Point a, Point b, Point c) {
if (dot(b - a, c - a) < (1e-7)) return (c - a).absv();
if (dot(a - b, c - b) < (1e-7)) return (c - b).absv();
return abs(cross(b - a, c - a)) / (b - a).absv();
}
bool is_intersected_ls(Segment a, Segment b) {
if (a.p1 == b.p1 || a.p2 == b.p1 || a.p1 == b.p2 || a.p2 == b.p2)
return false;
if (parareru((a.p2), (a.p1), (a.p1), (b.p2)) &&
parareru((a.p2), (a.p1), (a.p1), (b.p1))) {
if (dot(a.p1 - b.p1, a.p1 - b.p2) < (1e-7)) return true;
if (dot(a.p2 - b.p1, a.p2 - b.p2) < (1e-7)) return true;
if (dot(a.p1 - b.p1, a.p2 - b.p1) < (1e-7)) return true;
if (dot(a.p1 - b.p2, a.p2 - b.p2) < (1e-7)) return true;
return false;
} else
return (cross(a.p2 - a.p1, b.p1 - a.p1) * cross(a.p2 - a.p1, b.p2 - a.p1) <
(1e-7)) &&
(cross(b.p2 - b.p1, a.p1 - b.p1) * cross(b.p2 - b.p1, a.p2 - b.p1) <
(1e-7));
}
double segment_dis(Segment a, Segment b) {
if (is_intersected_ls(a, b)) return 0;
double r = distance_ls_p(a.p1, a.p2, b.p1);
r = min(r, distance_ls_p(a.p1, a.p2, b.p2));
r = min(r, distance_ls_p(b.p1, b.p2, a.p2));
r = min(r, distance_ls_p(b.p1, b.p2, a.p1));
return r;
}
Point intersection_ls(Segment a, Segment b) {
Point ba = b.p2 - b.p1;
double d1 = abs(cross(ba, a.p1 - b.p1));
double d2 = abs(cross(ba, a.p2 - b.p1));
double t = d1 / (d1 + d2);
return a.p1 + (a.p2 - a.p1) * t;
}
string itos(long long i) {
ostringstream s;
s << i;
return s.str();
}
long long gcd(long long v, long long b) {
if (v > b) return gcd(b, v);
if (v == b) return b;
if (b % v == 0) return v;
return gcd(v, b % v);
}
double distans(double x1, double y1, double x2, double y2) {
double rr = (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);
return sqrt(rr);
}
long long beki(long long wa, long long rr, long long warukazu) {
if (rr == 0) return 1ll;
if (rr == 1) return wa % warukazu;
if (rr % 2 == 1) return (beki(wa, rr - 1, warukazu) * wa) % warukazu;
long long zx = beki(wa, rr / 2, warukazu);
return (zx * zx) % warukazu;
}
unsigned long long randxor() {
static unsigned long long x = 123456789, y = 362436069, z = 521288629,
w = 88675123;
unsigned long long t;
t = (x ^ (x << 11));
x = y;
y = z;
z = w;
return (w = (w ^ (w >> 19)) ^ (t ^ (t >> 8)));
}
long long n, k, p;
vector<long long> iti, kagi;
vector<pair<long long, long long>> ve;
priority_queue<long long, vector<long long>, greater<long long>> pq;
bool ch(long long r) {
while (pq.size()) pq.pop();
ve.clear();
for (long long i = 0; i < n; i++) {
if (abs(p - iti[i]) > r) {
return 0;
}
long long noko = -abs(p - iti[i]) + r;
long long si = min(p, iti[i]) - noko / 2;
long long ue = max(p, iti[i]) + noko / 2;
long long ur = upper_bound(kagi.begin(), kagi.end(), ue) - kagi.begin();
long long sr = lower_bound(kagi.begin(), kagi.end(), si) - kagi.begin();
if (sr >= ur) return 0;
ve.push_back(make_pair(sr, ur));
}
sort(ve.begin(), ve.end());
ve.push_back(make_pair(1000000007, 1000000007));
long long it = 0;
for (long long i = 0; i < k; i++) {
while (ve[it].first == i) {
pq.push(ve[it].second);
it++;
}
if (pq.size()) {
long long z = pq.top();
pq.pop();
if (z <= i) return 0;
}
}
return pq.size() == 0;
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> k >> p;
for (long long i = 0; i < n; i++) {
long long y;
cin >> y;
iti.push_back(y);
}
for (long long i = 0; i < k; i++) {
long long y;
cin >> y;
kagi.push_back(y);
}
sort(kagi.begin(), kagi.end());
if (ch(0)) {
cout << 0 << endl;
return 0;
}
long long si = 0, ue = 100ll * 1000000007, me;
while (ue - si > 1) {
me = (ue + si) / 2;
if (ch(me))
ue = me;
else
si = me;
}
cout << ue << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2e9;
const long long INFL = 2e18;
string s;
int p, v;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> s;
s = '~' + s;
for (int i = (1), _b = (26); i <= _b; ++i)
for (int j = (i + 1), _b = (27); j <= _b; ++j)
if (s[i] == s[j]) {
p = i;
v = j;
}
if (v - p == 1) return cout << "Impossible" << '\n', 0;
string t = "";
for (int i = (1), _b = (p + (v - p - 1) / 2); i <= _b; ++i) t = s[i] + t;
s.erase(v, 1);
string l = s.substr(p + (v - p - 1) / 2 + 1, 26);
while (((int)(l).size()) > 13) {
t += l[((int)(l).size()) - 1];
l.erase(((int)(l).size()) - 1, 1);
}
while (((int)(t).size()) > 13) {
l += t[((int)(t).size()) - 1];
t.erase(((int)(t).size()) - 1, 1);
}
cout << t << '\n';
cout << l << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1000005;
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
long long a[n];
for (long long i = 0; i < n; i++) cin >> a[i];
long long l = 0, r = 0, ans = INT_MAX;
set<long long> s;
while (l < n && r < n) {
s.insert(a[r]);
if (s.size() < (r - l + 1)) {
ans = min(ans, r - l + 1);
s.erase(a[l]);
l++;
} else {
r++;
}
}
ans = (ans == INT_MAX) ? -1 : ans;
cout << ans << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int bi_search(int high, int low, long long a[], long long req) {
int mid, ans = -1;
while (high >= low) {
mid = (high + low) / 2;
if (a[mid] <= req) {
low = mid + 1;
ans = mid;
} else {
high = mid - 1;
}
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
unsigned long long c = 0;
int n, d;
double x, y;
long long a[100005];
cin >> n >> d;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n - 2; i++) {
if (bi_search(n - 1, i + 2, a, a[i] + d) != -1) {
x = double(bi_search(n - 1, i + 2, a, a[i] + d) - i - 1) / 2.0;
c += x * (1 + (bi_search(n - 1, i + 2, a, a[i] + d) - i - 1));
}
}
cout << c;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 50005;
const int MAXE = 100005;
struct Node* null;
struct Node {
Node* c[2];
Node* f;
long long cnt;
long long sum;
int val;
int siz;
int lazy;
int tree_siz;
inline void new_node() {
sum = val = 0;
c[0] = c[1] = f = null;
lazy = 0;
}
inline void add_siz(int SIZE) {
if (this == null) return;
tree_siz += SIZE;
cnt += 2LL * siz * SIZE;
lazy += SIZE;
}
inline void push_up() { sum = c[0]->sum + (long long)siz * val + c[1]->sum; }
inline void push_down() {
if (lazy) {
c[0]->add_siz(lazy);
c[1]->add_siz(lazy);
lazy = 0;
}
}
inline bool is_root() {
return f == null || f->c[0] != this && f->c[1] != this;
}
inline void sign_down() {
if (!is_root()) f->sign_down();
push_down();
}
inline void setc(Node* o, bool d) {
c[d] = o;
o->f = this;
}
inline void rot(bool d) {
Node* p = f;
Node* g = f->f;
p->setc(c[d], !d);
if (!p->is_root())
g->setc(this, p == g->c[1]);
else
f = g;
setc(p, d);
p->push_up();
}
inline void splay() {
sign_down();
while (!is_root()) {
if (f->is_root())
rot(this == f->c[0]);
else {
if (f == f->f->c[0]) {
if (this == f->c[0])
f->rot(1), rot(1);
else
rot(0), rot(1);
} else {
if (this == f->c[1])
f->rot(0), rot(0);
else
rot(1), rot(0);
}
}
}
push_up();
}
inline void access() {
Node* o = this;
Node* x = null;
while (o != null) {
if (x != null) {
while (x->c[0] != null) x = x->c[0];
x->splay();
}
o->splay();
o->siz = o->tree_siz - x->tree_siz;
o->setc(x, 1);
o->push_up();
x = o;
o = o->f;
}
splay();
}
};
struct Edge {
int v;
Edge* next;
};
Node pool[MAXN];
Node* node[MAXN];
Node* curN;
Edge edge[MAXE];
Edge* H[MAXN];
Edge* curE;
long long ans;
int n, m;
void clear() {
ans = 0;
curE = edge;
curN = pool;
null = curN++;
null->new_node();
null->cnt = null->tree_siz = null->siz = 0;
memset(H, 0, sizeof H);
}
void addedge(int u, int v) {
curE->v = v;
curE->next = H[u];
H[u] = curE++;
}
void dfs(int u) {
node[u]->cnt = node[u]->tree_siz = 1;
for (Edge* e = H[u]; e; e = e->next) {
int v = e->v;
dfs(v);
node[u]->cnt += 2LL * node[u]->tree_siz * node[v]->tree_siz;
node[u]->tree_siz += node[v]->tree_siz;
}
ans += node[u]->cnt * node[u]->val;
node[u]->siz = node[u]->tree_siz;
}
void solve() {
int x, y;
char op[2];
double tot = (double)n * n;
clear();
for (int i = (1); i <= (n); ++i) {
node[i] = curN++;
node[i]->new_node();
}
for (int i = (2); i <= (n); ++i) {
scanf("%d", &x);
addedge(x, i);
node[i]->f = node[x];
}
for (int i = (1); i <= (n); ++i) scanf("%d", &node[i]->val);
dfs(1);
printf("%.10f\n", ans / tot);
scanf("%d", &m);
while (m--) {
scanf("%s%d%d", op, &x, &y);
if (op[0] == 'P') {
node[y]->access();
node[x]->splay();
if (node[x]->f == null) swap(x, y);
node[x]->access();
Node* o = node[x]->c[0];
ans -= 2LL * o->sum * node[x]->tree_siz;
o->add_siz(-node[x]->tree_siz);
node[x]->c[0]->f = null;
node[x]->c[0] = null;
node[x]->push_up();
o->push_up();
node[y]->access();
ans += 2LL * node[y]->sum * node[x]->tree_siz;
node[y]->add_siz(node[x]->tree_siz);
node[y]->push_up();
node[x]->f = node[y];
} else {
node[x]->access();
ans += node[x]->cnt * (y - node[x]->val);
node[x]->val = y;
}
printf("%.10f\n", ans / tot);
}
}
int main() {
while (~scanf("%d", &n)) solve();
return 0;
}
| 5 |
#include <iostream>
#include <algorithm>
#include <string>
#include <set>
using namespace std;
int main() {
int n;
while(cin >> n) {
cin.ignore();
for(int I=0; I<n; I++) {
string Arr;
getline(cin, Arr);
unsigned sz = Arr.size();
set<string> s;
string tr1, tr2, ntr1, ntr2;
// divide loop
for(unsigned i=1; i<=sz-1; i++) {
// reverse
for(int j=0; j<2; j++) {
for(int k=0; k<2; k++) {
tr1 = Arr.substr(0,i);
tr2 = Arr.substr(i);
if(j) reverse(tr1.begin(), tr1.end());
if(k) reverse(tr2.begin(), tr2.end());
// merge
ntr1 = tr1 + tr2;
ntr2 = tr2 + tr1;
// set
s.insert(ntr1);
s.insert(ntr2);
}
}
}
cout << s.size() << endl;
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, mins, maxs, forward;
int dis[200001];
int stops[400001];
int pos[400002];
int main(int argc, char** argv) {
long long int length, curlen;
int k, *path, leftm, dn, diff;
cin >> n;
for (int i = 0; i < (n); i++) scanf("%d", &(dis[i]));
cin >> m;
for (int i = 0; i < (m); i++) {
scanf("%d", &k);
stops[k - 1]++;
}
for (int i = 0; i < (n); i++) pos[i] = i;
for (int i = 0; i < (n - 1); i++) pos[n + i] = n - 2 - i;
length = -1;
path = new int[n];
dn = 2 * n - 2;
for (int q = 1; q >= -1; q -= 2) {
memset(path, 0, n * sizeof(int));
int start, end;
if (q == 1)
start = 0, end = n - 1;
else
start = n - 1, end = 0;
path[start]++;
int num = start, nnum = 0;
curlen = 0;
for (int i = 0; i < (m - 1); i++) {
nnum = (num + q + dn) % dn;
curlen += abs(dis[pos[nnum]] - dis[pos[num]]);
path[pos[nnum]]++;
num = nnum;
}
diff = 0;
for (int i = 0; i < (n); i++) diff += (stops[i] != path[i]);
if (diff == 0) length = curlen;
for (int i = start + q; (q == 1) ? (i <= end) : (i >= end); i += q) {
nnum = (num + q + dn) % dn;
curlen -= abs(dis[i] - dis[i - q]);
curlen += abs(dis[pos[nnum]] - dis[pos[num]]);
diff -= (path[i - q] != stops[i - q]);
diff -= (path[pos[nnum]] != stops[pos[nnum]]);
path[i - q]--;
path[pos[nnum]]++;
diff += (path[i - q] != stops[i - q]);
diff += (path[pos[nnum]] != stops[pos[nnum]]);
num = nnum;
if (diff == 0) {
if (length == -1)
length = curlen;
else if (length != curlen) {
cout << -1;
delete[] path;
return 0;
}
}
}
}
cout << length;
delete[] path;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
#define F first
#define S second
typedef pair<int,int> P;
typedef pair<P,int> P2;
int main() {
int n,m;
while(cin >> n >> m && n) {
vector<P2> a;
a.push_back(P2(P(0,0),-1));
a.push_back(P2(P(n,n),-1));
while(m--) {
char c;
int x,y;
cin >> c;
if(c=='s') {
cin >> x >> y;
int z=-1;
for(int i=0; i<a.size()-1; i++) {
if(a[i+1].F.F-a[i].F.S>=y) {
z=a[i].F.S;
a.push_back(P2(P(z,z+y),x));
sort(a.begin(),a.end());
break;
}
}
if(z!=-1) cout << z << endl;
else cout << "impossible" << endl;
} else {
cin >> x;
for(int i=0; i<a.size(); i++) {
if(a[i].S==x) a.erase(a.begin()+i);
}
}
}
cout << "END" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> V[300];
int parent[300] = {-1};
int capacity[300][300] = {0};
void BFS(int current_number, int goal_number, bool is_visited[]) {
queue<int> Queue;
Queue.push(current_number);
is_visited[current_number] = true;
while (!Queue.empty()) {
current_number = Queue.front();
Queue.pop();
if (current_number == goal_number) {
is_visited[current_number] = true;
return;
}
is_visited[current_number] = true;
for (std::vector<int>::iterator iter = V[current_number].begin();
iter != V[current_number].end(); iter++) {
if (is_visited[*iter] == false && capacity[current_number][*iter] == 1 &&
*iter != 0) {
parent[*iter] = current_number;
Queue.push(*iter);
}
}
}
return;
}
bool find_a_path(int goal_number) {
bool s[300] = {false};
BFS(0, goal_number, s);
return s[goal_number];
}
void heapify(int arr[], int n, int i) {
int largest = i;
int l = 2 * i + 1;
int r = 2 * i + 2;
if (l < n && arr[l] > arr[largest]) largest = l;
if (r < n && arr[r] > arr[largest]) largest = r;
if (largest != i) {
swap(arr[i], arr[largest]);
heapify(arr, n, largest);
}
}
void heapSort(int arr[], int n) {
for (int i = n / 2 - 1; i >= 0; i--) heapify(arr, n, i);
for (int i = n - 1; i >= 0; i--) {
swap(arr[0], arr[i]);
heapify(arr, i, 0);
}
}
void test(bool d[]) { d[0] = true; }
int main() {
int m, n;
cin >> m;
int boys[m];
for (int i = 0; i < m; i++) {
cin >> boys[i];
}
cin >> n;
int girls[n];
for (int i = 0; i < n; i++) {
cin >> girls[i];
V[m + i + 1].push_back(m + n + 1);
capacity[m + i + 1][m + n + 1] = 1;
}
heapSort(boys, m);
heapSort(girls, n);
int cap;
for (int i = 0; i < m; i++) {
V[0].push_back(i + 1);
V[i + 1].push_back(0);
capacity[0][i + 1] = 1;
capacity[i + 1][0] = 0;
cap = boys[i];
for (int j = 0; j < n; j++) {
if (girls[j] - cap > 1) {
break;
} else if (std::abs(girls[j] - cap) <= 1) {
V[i + 1].push_back(j + m + 1);
capacity[i + 1][j + m + 1] = 1;
V[j + m + 1].push_back(i + 1);
}
}
}
int total_pair = 0;
while (true) {
if (find_a_path(m + n + 1) == true) {
total_pair++;
int u = m + n + 1;
while (parent[u] != -1) {
int v = parent[u];
capacity[v][u] = 0;
capacity[u][v] = 1;
u = v;
}
} else {
break;
}
for (int i = 0; i < 300; i++) {
parent[i] = -1;
}
}
cout << total_pair;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k, sum = 0;
cin >> n >> m >> k;
int a[m];
for (int j = 0; j < m; j++) {
a[j] = -1;
}
for (int k = 0; k < n; k++) {
int d, c;
cin >> d >> c;
if (a[d - 1] >= c) {
sum = sum - a[d - 1] + c;
a[d - 1] = c;
}
if (a[d - 1] == -1) {
sum = sum + c;
a[d - 1] = c;
}
}
if (sum < k)
cout << sum;
else
cout << k;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int w, h;
cin>>w>>h;
long long p[w], q[h];
for (int i=0; i<w; i++) cin>>p[i];
for (int i=0; i<h; i++) cin>>q[i];
sort(p, p + w);
sort(q, q + h);
int i = 0, j = 0;
long long cost = 0;
while (i < w && j < h) {
if (p[i] < q[j]) {
cost += p[i] * (h + 1 - j);
++i;
} else {
cost += q[j] * (w + 1 - i);
++j;
}
}
while (i < w) {
cost += p[i] * (h + 1 - j);
++i;
}
while (j < h) {
cost += q[j] * (w + 1 - i);
++j;
}
cout<<cost<<endl;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
const int N=20;
#define ll long long
#define oo 1000000000000
ll n,a[N];
ll dp(int l,int r,int x,int y){
if(r-l<=1)return 0;
ll ans=oo;
for(int m=l+1;m<=r-1;++m){
ans=min(ans,dp(l,m,x,x+y)+dp(m,r,x+y,y)+(x+y)*a[m]);
}
return ans;
}
int main(){
cin>>n;
for(int i=1;i<=n;++i)cin>>a[i];
cout<<a[1]+a[n]+dp(1,n,1,1);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return x * f;
}
inline void write(ll x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
const int N = 2e5 + 10;
int n, m, np, nq, fa[N << 1], res[N << 1];
ll s[N << 3], sum[N << 1], Ref[N << 1], ans, tmp;
struct Line {
int l, r, x;
} p[N], q[N << 1];
set<int> st;
set<int>::iterator it;
inline bool cmp(const Line& a, const Line& b) {
return (a.x == b.x) ? (a.r > b.r) : (a.x < b.x);
}
inline int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
inline void update(int l, int r, int x, int a, int b) {
s[x] += b;
if (l == r) return;
int mid = l + r >> 1;
if (a <= mid)
update(l, mid, x << 1, a, b);
else
update(mid + 1, r, x << 1 | 1, a, b);
}
inline int count(int l, int r, int x, int a, int b) {
if (a > b) return 0;
if (a <= l && r <= b) return s[x];
int mid = l + r >> 1;
if (b <= mid) return count(l, mid, x << 1, a, b);
if (a > mid) return count(mid + 1, r, x << 1 | 1, a, b);
return count(l, mid, x << 1, a, b) + count(mid + 1, r, x << 1 | 1, a, b);
}
inline int find(int l, int r, int x, int a) {
if (l == r) return l;
int mid = l + r >> 1;
if (a <= s[x << 1]) return find(l, mid, x << 1, a);
return find(mid + 1, r, x << 1 | 1, a - s[x << 1]);
}
inline int pre(int x) {
int t = count(1, m, 1, 1, x);
if (t == 1) return -1;
return find(1, m, 1, t - 1);
}
inline int Next(int x) {
int t = count(1, m, 1, 1, x);
if (t == s[1]) return -1;
return find(1, m, 1, t + 1);
}
int main() {
n = read();
for (int i = 1; i <= n; i++) {
int a = read(), b = read(), c = read(), d = read();
if (b == d) {
q[++nq].x = a;
q[nq].l = b;
q[nq].r = c - a + 1;
q[++nq].x = c;
q[nq].l = b;
q[nq].r = 0;
Ref[++m] = b;
} else {
p[++np].x = a;
p[np].l = b;
p[np].r = d;
Ref[++m] = b;
Ref[++m] = d;
ans = ((ans) > ((ll)(d - b)) ? (ans) : ((ll)(d - b)));
}
}
sort(Ref + 1, Ref + m + 1);
int Count = 0;
Ref[0] = -(1 << 30);
for (int i = 1, j = 0; i <= m; i++)
if (Ref[i] != Ref[j]) Ref[Count = ++j] = Ref[i];
m = Count;
for (int i = 1; i <= nq; i++) {
q[i].l = lower_bound(Ref + 1, Ref + m + 1, q[i].l) - Ref;
fa[i] = i;
}
for (int i = 1; i <= np; i++) {
p[i].l = lower_bound(Ref + 1, Ref + m + 1, p[i].l) - Ref;
p[i].r = lower_bound(Ref + 1, Ref + m + 1, p[i].r) - Ref;
}
sort(p + 1, p + np + 1, cmp);
sort(q + 1, q + nq + 1, cmp);
for (int i = 1, j = 1; i <= np; i++) {
int a, b, c, d;
while (j <= nq && (q[j].x < p[i].x || (q[j].x == p[i].x && q[j].r))) {
a = q[j].l;
b = q[j].r;
if (b) {
res[a] = j;
sum[j] = b;
st.insert(a);
update(1, m, 1, a, 1);
c = pre(a);
if (c != -1) st.insert(c);
} else {
it = st.find(a);
if (it != st.end()) st.erase(it);
c = pre(a);
if (c != -1) st.insert(c);
update(1, m, 1, a, -1);
}
j++;
}
tmp = Ref[p[i].r] - Ref[p[i].l] + 1 - count(1, m, 1, p[i].l, p[i].r);
a = p[i].l - 1;
c = Next(a);
if (c <= p[i].r) {
sum[find(res[c])] += tmp;
while (233) {
it = st.lower_bound(p[i].l);
if (it == st.end() || (*it) > p[i].r) break;
a = *it;
c = Next(a);
if (c == -1 || c > p[i].r) break;
st.erase(it);
b = find(res[a]);
d = find(res[c]);
if (b != d) {
sum[d] += sum[b];
fa[b] = d;
}
}
}
}
for (int i = 1; i <= nq; i++)
ans = ((ans) > (sum[i] - 1) ? (ans) : (sum[i] - 1));
write(ans);
puts("");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 5;
bool S[100];
int main() {
unsigned long long cur = 1;
int n;
unsigned long long m;
cin >> n >> m;
for (int i = 0; i < n - 2; i++) cur *= 2;
vector<int> all;
unsigned long long x = cur;
int id = 1;
while (m > 0) {
if (id > n) break;
while (m > x) {
id++;
m -= x;
if (x != 1) x /= 2;
}
all.push_back(id);
S[id] = true;
id++;
if (x != 1) x /= 2;
if (all.size() == n) break;
}
for (int i = n; i >= 1; i--)
if (!S[i]) all.push_back(i);
for (int i = 0; i < n; i++) cout << all[i] << " ";
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool check(long long n, long long pos) { return n & (1LL << pos); }
long long Set(long long n, long long pos) { return n = n | (1LL << pos); }
long long dist[503][503];
vector<long long> edge;
long long ans[503];
bool vis[503];
void solve(long long n) {
long long idx = n;
for (auto k : edge) {
vis[k] = 1;
long long sum = 0;
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= n; j++) {
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
if (vis[i] == 0 || vis[j] == 0) continue;
sum += dist[i][j];
}
}
ans[idx--] = sum;
}
return;
}
int main() {
long long i, j, k, l, m, n, o, r, q;
long long testcase;
long long input, flag, tag;
while (cin >> n) {
edge.clear();
memset(vis, 0, sizeof vis);
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
scanf("%lld", &dist[i][j]);
}
}
for (i = 0; i < n; i++) {
scanf("%lld", &input);
edge.push_back(input);
}
reverse(edge.begin(), edge.end());
solve(n);
for (i = 1; i <= n; i++) {
cout << ans[i] << " ";
}
cout << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void solve();
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int in;
cin >> in;
for (int i = 0; i < in; i++) solve();
return 0;
}
void solve() {
long long n;
cin >> n;
if (n < 7)
cout << 15;
else
n ^ 2 ? cout << (++n / 2) * 5 : cout << (n / 2) * 5;
cout << '\n';
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
ifstream in("input.txt");
ofstream out("output.txt");
vector<vector<int> > g;
const int MAXN = 100000;
bool used[MAXN];
int timer, tin[MAXN], fup[MAXN];
int n;
map<pair<int, int>, bool> A;
void dfs(int v, int p = -1) {
used[v] = true;
tin[v] = fup[v] = timer++;
for (size_t i = 0; i < g[v].size(); ++i) {
int to = g[v][i];
if (to == p) continue;
if (used[to])
fup[v] = min(fup[v], tin[to]);
else {
dfs(to, v);
fup[v] = min(fup[v], fup[to]);
if (fup[to] > tin[v]) A[make_pair(to, v)] = A[make_pair(v, to)] = true;
}
}
}
void find_bridges() {
timer = 0;
for (int i = 0; i < n; ++i) used[i] = false;
for (int i = 0; i < n; ++i)
if (!used[i]) dfs(i);
}
vector<int> path;
void bfs(int s, int end) {
queue<int> q;
q.push(s);
memset(used, 0, 100000);
vector<int> d(n), p(n);
used[s] = true;
p[s] = -1;
while (!q.empty()) {
int v = q.front();
q.pop();
for (size_t i = 0; i < g[v].size(); ++i) {
int to = g[v][i];
if (!used[to]) {
used[to] = true;
q.push(to);
d[to] = d[v] + 1;
p[to] = v;
}
}
}
for (int v = end; v != -1; v = p[v]) path.push_back(v);
}
int main() {
int t, m;
cin >> n >> t;
g.assign(n, vector<int>());
for (int i = 0; i < t; i++) {
int u, v;
cin >> u >> v;
g[u - 1].push_back(v - 1);
g[v - 1].push_back(u - 1);
}
cin >> m;
find_bridges();
for (int i = 0; i < m; i++) {
path.assign(0, 0);
int u, v, ans = 0;
cin >> u >> v;
u--;
v--;
bfs(u, v);
for (int j = 0; j < path.size(); j++) {
if (j < path.size() - 1) {
if (A.find(make_pair(path[j], path[j + 1])) != A.end()) ans++;
}
}
cout << ans << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long n, i, j = 0, l = 0, d = 1, t = 0, a[1];
int main() {
cin >> n;
if (n < 10) {
cout << 9;
return 0;
}
for (i = 1; i >= 0; i++) {
n = n + 1;
while (n % 10 == 0) {
n = n / 10;
}
if (n == 1) a[1]++;
if (t == 0)
if (n < 10) {
t = 1;
l = n;
}
if (a[1] == 2) break;
d++;
if (n + 1 == l) break;
}
cout << d;
return 0;
}
| 1 |
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
const int dx[] = {1, 0};
const int dy[] = {0, 1};
vector<string> board(80);
string memo[80][80];
int W, H;
inline bool isDigit(int x, int y)
{
if ('0' <= board[y][x] && board[y][x] <= '9')
return true;
else
return false;
}
string Rec(int x, int y)
{
if (memo[y][x].size() != 0)
return memo[y][x];
string s, tmp;
for (int d = 0; d < 2; ++d) {
int nx = x + dx[d];
int ny = y + dy[d];
if (nx < 0 || nx >= W || ny < 0 || ny >= H || !isDigit(nx, ny))
continue;
tmp = Rec(nx, ny);
if (tmp.size() > s.size() || (tmp.size() == s.size() && tmp > s))
s = tmp;
}
return memo[y][x] = board[y][x] + s;
}
int main()
{
while (cin >> W >> H, W || H) {
// Input
for (int i = 0; i < H; ++i)
cin >> board[i];
// Init
for (int i = 0; i < H; ++i)
for (int j = 0; j < W; ++j)
memo[i][j] = "";
// Solve
string tmp, ans;
for (int i = 0; i < H; ++i)
for (int j = 0; j < W; ++j)
if (isDigit(j, i)) {
tmp = Rec(j, i);
int index = 0;
while (tmp[index] == '0')
index++;
tmp = tmp.substr(index);
if (tmp.size() > ans.size() || (tmp.size() == ans.size() && tmp > ans))
ans = tmp;
}
// Output
cout << ans << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, h, t, r, x, y, dis[210][210], h1[210], t1[210], h2[210], t2[210],
bfs[210 * 210][2], L, R;
void renew(int x, int y, int v) {
if (x + y > r) return;
if (dis[x][y] == -1) {
dis[x][y] = v;
bfs[++R][0] = x;
bfs[R][1] = y;
}
}
int dfs(int x, int y) {
if (x + y > r) return 0;
int i, p = 1;
if (dis[x][y] == -1) {
printf("Draw\n");
exit(0);
}
if (dis[x][y]) return dis[x][y];
dis[x][y] = -1;
for (i = 1; i <= n && i <= x; ++i)
p = max(p, dfs(x - i + h1[i], y + t1[i]) + 1);
for (i = 1; i <= m && i <= y; ++i)
p = max(p, dfs(x + h2[i], y - i + t2[i]) + 1);
dis[x][y] = p;
return p;
}
int main() {
int i;
scanf("%d%d%d", &h, &t, &r);
scanf("%d", &n);
for (i = 1; i <= n; ++i) scanf("%d%d", &h1[i], &t1[i]);
scanf("%d", &m);
for (i = 1; i <= m; ++i) scanf("%d%d", &h2[i], &t2[i]);
memset(dis, -1, sizeof(dis));
dis[h][t] = 0;
bfs[L = R = 1][0] = h;
bfs[1][1] = t;
while (L <= R) {
x = bfs[L][0];
y = bfs[L++][1];
for (i = 1; i <= n && i <= x; ++i)
renew(x - i + h1[i], y + t1[i], dis[x][y] + 1);
for (i = 1; i <= m && i <= y; ++i)
renew(x + h2[i], y - i + t2[i], dis[x][y] + 1);
}
if (dis[0][0] != -1) return printf("Ivan\n%d\n", dis[0][0]), 0;
memset(dis, 0, sizeof(dis));
printf("Zmey\n%d\n", dfs(h, t));
}
| 5 |
#include <cstdio>
using namespace std;
int main() {
const int MAX_H = 10;
int H, board[MAX_H][5];
int res;
bool updated;
bool zeroseq;
int seq;
while(true){
scanf("%d", &H);
if (H == 0) {
break;
}
for (int i = 0;i < H;i++) {
for (int j = 0;j < 5;j++) {
scanf("%d", &board[i][j]);
}
}
updated = true;
res = 0;
while (updated) {
updated = false;
for (int i = 0;i < H;i++) {
seq = 1;
for (int j = 0;j < 5;j++) {
if (j == 4 || board[i][j] != board[i][j + 1]) {
if (seq >= 3) {
updated = true;
res += board[i][j] * seq;
for (int k = 0;k < seq;k++) {
board[i][j - k] = 0;
}
}
seq = 1;
}
else if (j + 1 < 5 && board[i][j] == board[i][j + 1] && board[i][j] != 0) {
seq++;
}
}
}
for (int j = 0;j < 5;j++) {
zeroseq = true;
for (int i = 0;i < H;i++) {
if (board[i][j] == 0 && !zeroseq) {
for (int k = i;k > 0;k--) {
board[k][j] = board[k - 1][j];
}
board[0][j] = 0;
}
else {
zeroseq = false;
}
}
}
}
printf("%d\n", res);
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t, n;
cin >> t;
for (long long i = 0; i < t; i++) {
cin >> n;
vector<long long> v(n, 0);
long long count = 0, m = 1, h = 0, ma = 0;
for (long long j = 0; j < n; j++) {
cin >> v[j];
}
for (long long j = 0; j < n - 1; j++) {
if ((v[j + 1] - v[j]) < 0) {
count = v[j] - v[j + 1];
ma = max(ma, count);
v[j + 1] = count + v[j + 1];
}
}
for (long long j = 0;; j++) {
if (h >= ma) {
cout << j << "\n";
break;
}
h += m;
m = m * 2;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
int n;
cin >> n;
vector<long long> ar(n), br(n);
for (int i = 0; i < n; i++) cin >> ar[i];
sort(ar.begin(), ar.end());
if (n == 1)
cout << ar[0] << endl;
else if (n == 2)
cout << max(ar[1] - ar[0], ar[0] - ar[1]) << endl;
else {
long long ans = 0;
if (ar[0] >= 0) {
for (int i = 1; i < n; i++) ans += ar[i];
ans = ans - ar[0];
} else if (ar[n - 1] < 0) {
for (int i = 0; i < n - 1; i++) ans = ans - ar[i];
ans = ans + ar[n - 1];
} else {
for (int i = 0; i < n; i++) {
if (ar[i] < 0)
ans = ans - ar[i];
else
ans += ar[i];
}
}
cout << ans << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
using minheap = priority_queue<T, vector<T>, greater<T>>;
template <typename T>
void setmax(T& a, T b) {
a = max(a, b);
};
template <typename T>
void setmin(T& a, T b) {
a = min(a, b);
};
template <typename T>
bool in(T lo, T v, T hi) {
return lo <= v && v <= hi;
};
const int M = 5e5 + 10;
const int N = 1e7 + 10;
int small[N];
int u[M], v[M];
void solve(int i) {
int n;
cin >> n;
int copy = n;
int p = small[n];
while (n % p == 0) n /= p;
if (n == 1) {
u[i] = v[i] = -1;
} else {
u[i] = n;
v[i] = copy / n;
}
}
int main() {
for (int i = 2; i < N; i++) {
if (small[i] == 0) {
for (int j = i; j < N; j += i) {
if (small[j] == 0) small[j] = i;
}
}
}
int t;
cin >> t;
for (int i = 0; i < t; i++) {
solve(i);
}
for (int i = 0; i < t; i++) cout << u[i] << " ";
cout << '\n';
for (int i = 0; i < t; i++) cout << v[i] << " ";
cout << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int te;
cin >> te;
long long int cg = 3;
long long int ans = 1;
while (cg < te) {
if (te % cg != 0) {
ans = te / cg;
ans++;
break;
} else
cg *= 3;
}
cout << ans << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >>N;
int ans=0;
for(int i=1;i<=N;i+=2){
int c=0;
for(int j=1;j<=sqrt(i-1);j++){
if(i%j==0)c++;
}
if(c==4)ans++;
}
cout <<ans;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
int nxt[maxn], beg[maxn], num[maxn];
int n, k, x;
int st;
int fa[maxn];
int main() {
cin >> n >> k;
st = -1;
memset(beg, -1, sizeof(beg));
memset(num, 0, sizeof(num));
for (int i = 1; i <= n; i++) {
cin >> x;
nxt[i] = beg[x];
beg[x] = i;
num[x]++;
}
if (num[0] != 1) {
cout << -1;
return 0;
}
if (num[1] > k) {
cout << -1;
return 0;
}
for (int i = 2; i < n; i++)
if (num[i - 1] * (k - 1LL) < num[i]) {
cout << -1;
return 0;
}
st = beg[0];
int u, v;
for (int i = 1; i < n; i++) {
v = beg[i];
for (u = beg[i - 1]; u != -1; u = nxt[u])
for (int j = (i == 1) ? 0 : 1; j < k && v != -1; j++, v = nxt[v])
fa[v] = u;
}
fa[st] = -1;
cout << n - 1 << endl;
for (int i = 1; i <= n; i++)
if (i != st) cout << fa[i] << " " << i << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n = 0;
cin >> n;
vector<pair<int, int> > array(n);
for (int i = 0; i < n; ++i) {
cin >> array[i].first;
--array[i].first;
}
for (int i = 0; i < n; ++i) {
cin >> array[i].second;
--array[i].second;
}
sort(array.begin(), array.end());
for (int i = 0; i < n; ++i) {
cout << (array[i].second + 1) << " ";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int n, m, i, j, k = 0, T, t = 0, u, v, c = 0, d = 0, q = 0, c1, c2;
long long int a[100010], df[100010];
class node {
public:
vector<int> near;
};
node p[100010];
void bfs(int j, int c);
int main() {
cin >> m >> n;
for (i = 0; i < n; i++) {
scanf("%d %d", &u, &v);
p[u].near.push_back(v);
p[v].near.push_back(u);
}
if (n == 0) {
cout << 3 << " " << (m * (m - 1) * (m - 2)) / 6;
return 0;
}
for (i = 1; i <= n; i++) {
u = p[i].near.size();
if (u > 1) {
t = 1;
}
}
if (t == 0) {
cout << 2 << " " << (n * (m - 2));
return 0;
}
for (i = 1; i <= m; i++) {
c = 1;
c1 = 0;
c2 = 0;
if (df[i] == 0) {
bfs(i, c);
d += ((c1 * (c1 - 1)) / 2) + ((c2 * (c2 - 1)) / 2);
}
}
if (k == 1) {
cout << 0 << " " << 1;
return 0;
}
cout << 1 << " " << d;
return 0;
}
void bfs(int j, int c) {
if (df[j] == 0) {
df[j] = c;
if (c % 2 == 0) {
c1++;
} else {
c2++;
}
c++;
vector<int> v = p[j].near;
for (int k = 0; k < v.size(); k++) {
bfs(v[k], c);
}
} else if ((df[j] - c) % 2 != 0) {
k = 1;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline void read(int &x) {
char c = getchar();
int p = 1;
x = 0;
while (!isdigit(c)) {
if (c == '-') p = -1;
c = getchar();
}
while (isdigit(c)) {
x = (x << 1) + (x << 3) + (c ^ '0');
c = getchar();
}
x *= p;
}
int main() {
char str[20005];
scanf("%s", str + 1);
int n = strlen(str + 1);
for (register int i = 1; i <= 2 * n; ++i) {
if (i <= n)
printf("%c", str[i]);
else
printf("%c", str[2 * n - i + 1]);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC push_options
#pragma GCC optimize("unroll-loops")
vector<vector<int>> edges;
vector<long long> val;
vector<long long> cost;
vector<int> vis;
pair<long long, pair<int, int>> dfs(long long cur, long long ashu) {
if (vis[cur]) return {0, {0, 0}};
vis[cur] = 1;
pair<long long, pair<int, int>> res;
ashu = min(ashu, cost[cur]);
for (int i : edges[cur]) {
auto temp = dfs(i, ashu);
res.first += temp.first;
res.second.first += temp.second.first;
res.second.second += temp.second.second;
}
if (val[cur] == -1) {
res.second.second++;
}
if (val[cur] == 1) {
res.second.first++;
}
int resolve = min(res.second.first, res.second.second);
res.first += ashu * resolve * 2;
res.second.first -= resolve;
res.second.second -= resolve;
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
edges.resize(n + 1);
val.resize(n + 1);
vis.resize(n + 1);
cost.resize(n + 1);
for (int i = 1; i <= n; i++) {
int a, b, c;
cin >> a >> b >> c;
cost[i] = a;
if (b > c)
val[i] = 1;
else if (c > b)
val[i] = -1;
else
val[i] = 0;
}
for (int i = 1; i <= n - 1; i++) {
int one, two;
cin >> one >> two;
edges[one].emplace_back(two);
edges[two].emplace_back(one);
}
auto res = dfs(1, cost[1]);
if (res.second.second != 0 || res.second.first != 0) {
cout << -1;
return 0;
}
cout << res.first << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, r[17], m[17];
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; ++i) cin >> m[i];
for (int i = 0; i < n; ++i) cin >> r[i];
int cnt = 0;
for (int i = 1; i <= 100000; ++i) {
for (int j = 0; j < n; ++j) {
if (i % m[j] == r[j]) {
cnt++;
break;
}
}
}
cout.precision(6);
cout << fixed << cnt / 100000.0;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
int a, x, b, y, n;
int next_x(int x) {
if (x == n)
return 1;
else
return x + 1;
}
int next_y(int x) {
if (x == 1)
return n;
else
return x - 1;
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> a >> x >> b >> y;
while (a != x && b != y) {
if (a == b) {
puts("YES");
return 0;
}
a = next_x(a);
b = next_y(b);
if (a == b) {
puts("YES");
return 0;
}
}
puts("NO");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int M = 2e5 + 5;
int n;
vector<pair<int, int> > A, res;
int dep[M], id[M], dfn, pre;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
A.push_back(make_pair(x, i * 2 - 1));
}
sort(A.begin(), A.end());
reverse(A.begin(), A.end());
for (auto tp : A) {
dep[tp.second] = ++dfn;
id[dfn] = tp.second;
if (pre) res.push_back(make_pair(pre, tp.second));
pre = tp.second;
}
for (auto tp : A) {
int u = tp.second, v = tp.second + 1, dis = dep[u] + tp.first - 1;
if (id[dis]) {
res.push_back(make_pair(id[dis], v));
dep[v] = dis;
if (!id[dis + 1]) {
id[dis + 1] = v;
}
} else {
dis = dep[u] - tp.first + 1;
res.push_back(make_pair(id[dis], v));
dep[v] = dis;
if (!id[dis + 1]) {
id[dis + 1] = v;
}
}
}
for (auto x : res) {
printf("%d %d\n", x.first, x.second);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 10;
int vis1[N], vis2[N];
vector<int> g1[N], g2[N];
set<int> s;
void dfs2(int u, int p) {
if (vis2[u]) return;
s.insert(p);
vis2[u] = p;
for (int v : g2[u])
if (!vis2[v]) dfs2(v, p);
}
void dfs1(int u) {
vis1[u] = 1;
dfs2(u, u);
for (int v : g1[u])
if (!vis1[v]) dfs1(v);
}
int par[N];
int find(int x) {
if (x == par[x]) return x;
return par[x] = find(par[x]);
}
int main() {
ios::sync_with_stdio(0);
int n, m1, m2;
cin >> n >> m1 >> m2;
for (int i = 1; i <= n; i++) par[i] = i;
while (m1--) {
int u, v;
cin >> u >> v;
g1[u].push_back(v);
g1[v].push_back(u);
}
while (m2--) {
int u, v;
cin >> u >> v;
g2[u].push_back(v);
g2[v].push_back(u);
}
dfs1(1);
vector<array<int, 2>> e;
for (int t = 0; t < 2; t++) {
for (int i = 1; i <= n; i++)
if (!vis1[i]) {
if (!vis2[i]) dfs2(i, i);
if (s.size() == 1) continue;
s.erase(find(vis2[i]));
e.push_back({find(*s.begin()), i});
par[find(vis2[i])] = find(*s.begin());
dfs1(i);
}
}
cout << e.size() << endl;
for (auto [u, v] : e) {
cout << u << ' ' << v << endl;
}
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const long long maxn = 1e6 + 100;
const long long maxc = 20;
long long n, m, k, t;
vector<long long> V[maxc];
vector<long long> V1[maxc];
long long used[maxc];
long long st2[maxn];
long long ans = 0;
void dfs(long long v) {
used[v] = 2;
for (auto v1 : V1[v]) {
if (!used[v1]) {
dfs(v1);
}
}
}
void solve(long long v) {
dfs(v);
long long q, w, e;
vector<long long> nw;
for (q = 0; q < maxc; q++) {
if (used[q] == 2) {
nw.push_back(q);
}
}
vector<long long> I(maxc);
for (q = 0; q < nw.size(); q++) {
I[nw[q]] = q;
}
vector<bool> dp(st2[nw.size()]);
dp[0] = 1;
long long mxsz = 0;
for (q = 1; q < st2[nw.size()]; q++) {
for (w = 0; w < nw.size(); w++) {
if ((st2[w] & q) != 0) {
if (dp[q - st2[w]] == 0) {
continue;
}
bool fail = 0;
for (auto v1 : V[nw[w]]) {
if ((st2[I[v1]] & q) != 0) {
fail = 1;
break;
}
}
if (fail) {
continue;
}
dp[q] = 1;
mxsz = max(mxsz, (long long)__builtin_popcount(q));
break;
}
}
}
ans += 2 * nw.size() - mxsz - 1;
for (q = 0; q < maxc; q++) {
if (used[q] == 2) {
used[q] = 1;
}
}
}
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long q, w, e, a, b, c;
st2[0] = 1;
for (q = 1; q < 63; q++) {
st2[q] = st2[q - 1] * 2;
}
cin >> t;
for (long long it = 0; it < t; it++) {
string s1, s2;
for (q = 0; q < maxc; q++) {
V[q].clear();
used[q] = 0;
V1[q].clear();
}
set<pair<long long, long long> > S;
cin >> n;
cin >> s1 >> s2;
for (q = 0; q < n; q++) {
if (s1[q] != s2[q]) {
if (S.find(make_pair(s1[q], s2[q])) == S.end()) {
S.insert(make_pair(s1[q], s2[q]));
long long v1 = s1[q] - 'a', v2 = s2[q] - 'a';
V[v1].push_back(v2);
V1[v2].push_back(v1);
V1[v1].push_back(v2);
}
}
}
for (q = 0; q < maxc; q++) {
if (!used[q]) {
solve(q);
}
}
cout << ans << '\n';
ans = 0;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 110000;
const int MAXQ = 500;
struct Query {
int l, r, t, id;
bool operator<(const Query &a) const { return t < a.t; }
} q[MAXN];
int n, m, Q;
int lb[MAXN], rb[MAXN], bl[MAXN];
struct P {
int a, b, id;
bool operator<(const P &x) const {
if (b != x.b) return b < x.b;
if (a != x.a) return a > x.a;
return 0;
}
} p[MAXN];
double calv(P x, int t) { return double(x.a) + double(x.b) * t; }
bool cmp(P x, P y, int t) {
if (calv(x, t) != calv(y, t))
return calv(x, t) > calv(y, t);
else
return x.b > y.b;
}
double calj(P x, P y) {
if (x.b == y.b) return 1e18;
return double(x.a - y.a) / (y.b - x.b);
}
void init() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d %d", &p[i].a, &p[i].b);
p[i].id = i;
}
for (int i = 1; i <= m; i++) {
scanf("%d %d %d", &q[i].l, &q[i].r, &q[i].t);
q[i].id = i;
}
sort(q + 1, q + m + 1);
}
vector<P> V[MAXQ];
vector<P> tmp;
void build() {
Q = sqrt(n);
for (int i = 1; i <= n; i++) {
bl[i] = (i - 1) / Q + 1;
if (bl[i] != bl[i - 1]) lb[bl[i]] = i, rb[bl[i - 1]] = i - 1;
}
rb[bl[n]] = n;
for (int x = 1; x <= bl[n]; x++) {
int L = lb[x], R = rb[x];
for (int i = L; i <= R; i++) V[x].push_back(p[i]);
sort(V[x].begin(), V[x].end());
tmp.clear();
tmp.push_back(V[x][0]);
for (int i = 1; i < int(V[x].size()); i++) {
if (V[x][i].b != V[x][i - 1].b) tmp.push_back(V[x][i]);
}
V[x].clear();
V[x].push_back(tmp[0]);
for (int i = 0; i < int(tmp.size()) - 1;) {
int t = i;
for (int j = i + 1; j < int(tmp.size()); j++)
if (calj(tmp[i], tmp[j]) < calj(tmp[i], tmp[t])) t = j;
V[x].push_back(tmp[i = t]);
}
V[x].push_back(tmp.back());
}
}
int now[MAXQ];
int ans[MAXN];
void solve() {
for (int i = 1; i <= m; i++) {
int L = q[i].l, R = q[i].r, t = q[i].t;
int BL = bl[L], BR = bl[R], tmp = 0;
if (BL == BR) {
for (int i = L; i <= R; i++)
if (cmp(p[i], p[tmp], t)) tmp = i;
ans[q[i].id] = tmp;
continue;
}
for (int i = BL + 1; i <= BR - 1; i++) {
while (now[i] + 1 < int(V[i].size()) &&
calv(V[i][now[i]], t) <= calv(V[i][now[i] + 1], t))
now[i]++;
if (cmp(V[i][now[i]], p[tmp], t)) tmp = V[i][now[i]].id;
}
for (int i = L; i <= rb[BL]; i++)
if (cmp(p[i], p[tmp], t)) tmp = i;
for (int i = lb[BR]; i <= R; i++)
if (cmp(p[i], p[tmp], t)) tmp = i;
ans[q[i].id] = tmp;
}
for (int i = 1; i <= m; i++) {
printf("%d\n", ans[i]);
}
}
int main() {
init();
build();
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long L, R, n;
int c[10], a[19], b[19];
int ret;
bool check(int step, int lim) {
if (step < 0) return 1;
if (lim == 3) {
int l = b[step], u = a[step];
if (l == u) {
if (!c[l]) return 0;
--c[l];
int res = check(step - 1, 3);
++c[l];
return res;
}
for (int j = l + 1; j < u; ++j)
if (c[j]) return 1;
if (c[l]) {
--c[l];
if (check(step - 1, 1)) {
++c[l];
return 1;
}
++c[l];
}
if (c[u]) {
--c[u];
if (check(step - 1, 2)) {
++c[u];
return 1;
}
++c[u];
}
return 0;
}
int l = 0, u = 10, x = -1;
if (lim == 1)
l = b[step] + 1, x = b[step];
else
u = a[step], x = a[step];
for (int j = l; j < u; ++j)
if (c[j]) return 1;
if (!c[x]) return 0;
--c[x];
int res = check(step - 1, lim);
++c[x];
return res;
}
void get(int step, int cnt) {
if (step == 10) {
c[0] = n - cnt;
if (check(n - 1, 3)) ++ret;
return;
}
for (int i = 0; i < n - cnt + 1; ++i) {
c[step] = i;
get(step + 1, cnt + i);
c[step] = 0;
}
}
void calc() {
while (R) a[n++] = R % 10, R /= 10;
for (int i = 0; i < n; ++i) b[i] = L % 10, L /= 10;
get(1, 0);
}
int main() {
cin >> L >> R;
calc();
cout << ret << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char opposite(char x) {
if (x == 'N') return 'S';
if (x == 'S') return 'N';
if (x == 'W') return 'E';
if (x == 'E') return 'W';
}
const int N = 1e6 + 5;
char s[2 * N];
int p[2 * N];
int main() {
int n;
scanf("%d", &n);
--n;
scanf("%s\n%s", s + 1, s + n + 1);
for (int i = 1; i < n + 1 - i; ++i) swap(s[i], s[n + 1 - i]);
for (int i = 1; i <= n; ++i) s[i] = opposite(s[i]);
p[1] = p[0] = 0;
int t = p[1];
for (int i = 2; i <= 2 * n; ++i) {
while (t != 0 && s[t + 1] != s[i]) t = p[t];
if (s[t + 1] == s[i]) ++t;
p[i] = t;
}
printf(p[2 * n] == 0 ? "YES\n" : "NO\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
const int maxn = 1000010, maxp = 1000000000, lim = 100000000;
int n, p[2], h[1000010][2], pw[1000010][2];
char s[1000010];
bool com(int x) {
for (int i = 2; i * i <= x; i++)
if (x % i == 0) return 1;
return 0;
}
bool chk(int i, int j) {
if (i > 0 && i < j && j < n && (i == 1 || s[0] != 0) &&
(j == i + 1 || s[i] != 0) && (n == j + 1 || s[j] != '0')) {
for (int t = 0; t < 2; t++)
if ((h[i][t] * (1ll - pw[j - i][t]) + h[j][t] * (1ll + pw[n - j][t]) -
h[n][t]) %
p[t])
return 0;
return 1;
} else
return 0;
}
void op(int i, int j) {
for (int k = 0; k < i; k++) putchar(s[k]);
putchar('+');
for (int k = i; k < j; k++) putchar(s[k]);
putchar('=');
puts(s + j);
}
int main() {
srand(time(0));
scanf("%s", s);
do *p = maxp - (rand() << 15 | rand()) % lim;
while (com(*p));
do p[1] = maxp - (rand() << 15 | rand()) % lim;
while (p[1] == *p || com(p[1]));
for (pw[0][0] = pw[0][1] = 1; s[n]; n++)
for (int t = 0; t < 2; t++)
h[n + 1][t] = (h[n][t] * 10ll + s[n] - '0') % p[t],
pw[n + 1][t] = pw[n][t] * 10ll % p[t];
for (int i = n / 2; i < n; i++) {
if (chk(i * 2 - n, i)) return op(i * 2 - n, i), 0;
if (chk(i * 2 - n + 1, i)) return op(i * 2 - n + 1, i), 0;
if (chk(n - i, i)) return op(n - i, i), 0;
if (chk(n - i - 1, i)) return op(n - i - 1, i), 0;
}
}
| 6 |
#include <iostream>
int findText(std::string text, std::string oldText){
int times = 0, pos = 0;
while(pos = text.find(oldText, pos), pos != std::string::npos){
pos++, times++;
}
return times;
}
int main(){
std::string s;
while(std::cin >> s, !std::cin.eof()){
std::cout << findText(s, "JOI") << std::endl;
std::cout << findText(s, "IOI") << std::endl;
}
} | 0 |
#include <bits/stdc++.h>
#pragma GCC optimize(3)
using namespace std;
int n, m, A, B, bb, tt, first[80], fa[80], num[80], sz[80], ans[80],
dp[80][150000];
struct Bn {
int to, next, quan;
} bn[410];
struct Zt {
int u, v, d;
bool operator<(const Zt &u) const { return d > u.d; }
};
priority_queue<Zt> pq;
int ff(int u) { return fa[u] == u ? u : fa[u] = ff(fa[u]); }
inline int get(int u) { return num[u] == -1 ? 0 : (1 << num[u]); }
inline void add(int u, int v, int w) {
bb++;
bn[bb].to = v;
bn[bb].quan = w;
bn[bb].next = first[u];
first[u] = bb;
}
int main() {
memset(first, -1, sizeof(first));
memset(num, -1, sizeof(num));
memset(dp, 0x3f, sizeof(dp));
memset(ans, 0x3f, sizeof(ans));
int i, j, p, q, o;
cin >> n >> m >> A >> B;
for (i = 1; i <= n; i++) fa[i] = i;
for (i = 1; i <= m; i++) {
scanf("%d%d%d", &p, &q, &o);
add(p, q, o), add(q, p, o);
if (o == A) fa[ff(p)] = ff(q);
}
for (i = 1; i <= n; i++) sz[ff(i)]++;
for (i = 1; i <= n; i++)
if (i == ff(i) && sz[i] > 3) num[i] = ++tt;
for (i = 1; i <= n; i++) num[i] = num[ff(i)];
dp[1][get(1)] = 0;
pq.push((Zt){1, get(1), 0});
for (; !pq.empty();) {
Zt now = pq.top();
pq.pop();
if (dp[now.u][now.v] < now.d) continue;
ans[now.u] = min(ans[now.u], now.d);
for (p = first[now.u]; p != -1; p = bn[p].next) {
q = bn[p].to;
if (bn[p].quan == B && num[q] != -1 && ((1 << num[q]) & now.v)) continue;
if (bn[p].quan == B && ff(now.u) == ff(q)) continue;
int t = bn[p].quan + now.d;
if (t >= dp[q][get(q) | now.v]) continue;
dp[q][get(q) | now.v] = t;
pq.push((Zt){q, get(q) | now.v, t});
}
}
for (i = 1; i <= n; i++) printf("%d ", ans[i]);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int a[n];
bool b[n];
int one = 0, zero = 0;
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < n; ++i) {
cin >> b[i];
if (b[i])
++one;
else
++zero;
}
if (one && zero)
cout << "Yes\n";
else {
bool f = true;
for (int i = 0; i < n - 1; ++i) {
if (a[i] > a[i + 1]) {
f = false;
break;
}
}
if (f)
cout << "Yes\n";
else
cout << "No\n";
}
}
return 0;
}
| 2 |
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <sstream>
#include <cmath>
#include <queue>
using namespace std;
vector<int> tree[200];
int cost[200];
int min_cost(int index){
if(tree[index].size() == 0){
return cost[index];
}
int sum = 0;
int siz = tree[index].size();
for(int i = 0; i < siz; i++){
sum += min_cost(tree[index].at(i));
}
return min(sum, cost[index]);
}
int main(){
string name[200];
int n, m;
while(true){
cin >> n;
if(n == 0){
break;
}
for(int i = 0; i < n; i++){
cin >> name[i] >> cost[i];
tree[i].erase(tree[i].begin(), tree[i].end());
}
cin >> m;
for(int i = 0; i < m; i++){
string str;
int num;
cin >> str >> num;
int index = 0;
for(int j = 0; j < n; j++){
if(str == name[j]){
index = j;
break;
}
}
for(int j = 0; j < num; j++){
string str2;
cin >> str2;
for(int k = 0; k < n; k++){
if(str2 == name[k]){
tree[index].push_back(k);
break;
}
}
}
}
string str;
cin >> str;
int index;
for(int i = 0; i < n; i++){
if(str == name[i]){
index = i;
break;
}
}
cout << min_cost(index) << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
short w1, w2, r;
cin >> w1 >> w2;
for (r = 0; w1 <= w2; r++) {
w1 *= 3;
w2 *= 2;
}
cout << r;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool loop(int x) { return (x % 100 != 0 && x % 4 == 0) || (x % 400 == 0); }
int main() {
int y;
cin >> y;
bool org = loop(y);
int mod = 0;
do {
mod = (mod + 365 + loop(y)) % 7;
y++;
} while (mod || loop(y) != org);
cout << y << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string s;
int n;
int main() {
cin >> n >> s;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < s.length(); j++)
if (j + i * 4 < s.length())
if ((s[j] == '*') && (s[j + i] == '*') && (s[j + i * 2] == '*') &&
(s[j + i * 3] == '*') && (s[j + i * 4] == '*')) {
cout << "yes";
return 0;
}
}
cout << "no";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin >> s;
string ans = "";
int i = 0, j = s.length() - 1;
while (j - i >= 3) {
if (s[i] == s[j])
ans += s[i];
else if (s[i + 1] == s[j])
ans += s[i + 1];
else
ans += s[j - 1];
i += 2;
j -= 2;
}
string t = ans;
reverse(t.begin(), t.end());
if (j >= i)
cout << ans + s[i] + t;
else
cout << ans + t;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long pd[100010];
long long tot[100010];
long long inv[100010];
int main() {
long long n;
scanf("%I64d", &n);
pd[1] = 20;
tot[1] = 3 * 3 * 3;
inv[1] = tot[1] - pd[1];
long long i;
for (i = 2; i <= n; i++) {
pd[i] = pd[i - 1] * 3 * 3 * 3;
pd[i] %= 1000000007;
pd[i] += inv[i - 1] * 20;
pd[i] %= 1000000007;
tot[i] = tot[i - 1] * 3 * 3 * 3;
tot[i] %= 1000000007;
inv[i] = tot[i] - pd[i];
inv[i] += 1000000007;
inv[i] %= 1000000007;
}
printf("%I64d\n", pd[n]);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
signed main(){
int n;cin>>n;
if(n==1){
cout<<1<<endl<<0<<endl;return 0;
}
if(n==2){
cout<<2<<endl<<0<<endl<<11<<endl;return 0;
}
cout<<n-1<<endl;
for(int i=1;i<n;i++){
cout<<1;for(int j=1;j<i;j++)cout<<0;cout<<1<<endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long GCD(long long a, long long b) {
long long r;
while (b != 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
long long NOK(long long a, long long b) {
long long ret = 1, v;
while (v != 1) {
v = GCD(a, b);
ret *= v;
if (a % v == 0) a /= v;
if (b % v == 0) b /= v;
}
ret *= a;
ret *= b;
return ret;
}
int main() {
long long i, j, ii, jj, ind;
long long x, y, a, b;
long long nk;
cin >> x >> y >> a >> b;
nk = NOK(x, y);
long long l, r, mid;
long long lastbeg = -1, lastend = -1;
l = 1;
r = 2000000000 / nk + 1;
while (l <= r) {
mid = (l + r) / 2;
if (mid * nk < a) {
l = mid + 1;
} else {
lastbeg = mid;
r = mid - 1;
}
}
l = 1;
r = 2000000000 / nk + 1;
while (l <= r) {
mid = (l + r) / 2;
if (mid * nk > b) {
r = mid - 1;
} else {
lastend = mid;
l = mid + 1;
}
}
if (lastbeg == -1 || lastend == -1 || lastbeg > lastend) {
cout << 0 << endl;
return 0;
}
cout << lastend - lastbeg + 1 << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
const int N = 51;
int A[4][N];
vector<pair<int, pair<int, int>>> ans;
int main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < 4; i++)
for (int j = 0; j < n; j++) {
cin >> A[i][j];
if ((i == 0 || i == 3) && A[i][j] == 0) A[i][j] = -1;
}
int fl = 0;
while (1) {
int st = 0;
for (int i = 0; i < n; i++)
if (A[0][i] == A[1][i]) {
ans.push_back(make_pair(A[1][i], make_pair(1, i + 1)));
A[1][i] = 0;
st = 1;
}
for (int i = 0; i < n; i++)
if (A[2][i] == A[3][i]) {
ans.push_back(make_pair(A[2][i], make_pair(4, i + 1)));
A[2][i] = 0;
st = 1;
}
if (st == 1) continue;
for (int i = 0; i < n - 1; i++)
if (A[1][i + 1] == 0 && A[1][i] != 0) {
ans.push_back(make_pair(A[1][i], make_pair(2, i + 2)));
swap(A[1][i], A[1][i + 1]);
st = 1;
break;
}
if (st == 1) continue;
if (A[1][n - 1] != 0 && A[2][n - 1] == 0) {
ans.push_back(make_pair(A[1][n - 1], make_pair(3, n)));
swap(A[1][n - 1], A[2][n - 1]);
st = 1;
}
if (st == 1) continue;
for (int i = n - 1; i > 0; i--) {
if (A[2][i] != 0 && A[2][i - 1] == 0) {
ans.push_back(make_pair(A[2][i], make_pair(3, i)));
swap(A[2][i], A[2][i - 1]);
st = 1;
break;
}
}
if (st == 1) continue;
if (A[2][0] != 0 && A[1][0] == 0) {
ans.push_back(make_pair(A[2][0], make_pair(2, 1)));
swap(A[2][0], A[1][0]);
st = 1;
}
if (st == 1) continue;
if (st == 0) {
for (int i = 1; i < 3; i++)
for (int j = 0; j < n; j++)
if (A[i][j] != 0) fl = 1;
break;
}
}
if (fl == 1)
cout << "-1\n";
else {
cout << (int)(ans.size()) << "\n";
for (int i = 0; i < (int)(ans.size()); i++)
cout << ans[i].first << " " << ans[i].second.first << " "
<< ans[i].second.second << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<long long int> dp(100001, 0);
vector<long long int> a(100001, 0);
while (n--) {
int x;
cin >> x;
a[x]++;
}
dp[0] = a[0];
dp[1] = a[1];
for (int i = 2; i < 100001; i++) {
dp[i] = max(dp[i - 1], dp[i - 2] + i * a[i]);
}
cout << dp[100000];
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[2][2][200047];
struct pmin {
int x;
deque<int> d;
deque<int> v;
pmin(int x) : x(x) {}
int query(int a) {
v.push_back(a);
while (!d.empty() && d.back() > a) d.pop_back();
d.push_back(a);
if (v.size() > x + 1) {
if (d.front() == v.front()) d.pop_front();
v.pop_front();
}
return d.front();
}
};
int main(void) {
for (int i = 0; i < 2; ++i)
for (int j = 0; j < 2; ++j)
for (int k = 0; k < 200047; ++k) a[i][j][k] = 1ll << 20;
int n, k;
scanf("%d%d", &n, &k);
vector<pair<int, int> > q;
int x = 0;
for (int i = 0; i < k; ++i) {
int a, b;
scanf("%d%d", &a, &b);
q.push_back({x, a});
q.push_back({a, b});
x = b;
}
q.push_back({x, 2 * n});
a[0][0][0] = 0;
a[0][1][0] = 0;
for (int ii = 1; ii <= q.size(); ++ii) {
int i = ii % 2;
for (int j = 0; j < 2; ++j)
for (int t = 0; t < 200047; ++t) a[i][j][t] = 1ll << 20;
auto& interval = q[ii - 1];
int dur = interval.second - interval.first;
for (int j = 0; j < 2; ++j)
for (int t = 0; t < n + 1; ++t) {
if (j == 0)
a[i][j][t + dur] = min(a[i][j][t + dur], a[1 - i][j][t]);
else
a[i][j][t] = min(a[i][j][t], a[1 - i][j][t]);
}
if (i == 0) {
pmin Q[2] = {pmin(dur), pmin(dur)};
int A[2];
for (int t = 0; t < n + 1; ++t) {
for (int j = 0; j < 2; ++j) A[j] = Q[j].query(a[1 - i][j][t]);
for (int j = 0; j < 2; ++j) {
a[i][j][t] = min(a[i][j][t], A[1 - j] + 1);
a[i][j][t] = min(a[i][j][t], A[j] + 2);
}
}
}
}
if (a[q.size() % 2][0][n] != (1ll << 20))
printf("Full\n%d\n", a[q.size() % 2][0][n]);
else
puts("Hungry");
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long INFLL = 1e18;
const int MOD = 1e9 + 7;
const int MAXN = 1e3 + 5;
int n, m, p;
int s[10];
char g[MAXN][MAXN];
queue<pair<int, int> > nxt[10];
vector<pair<int, int> > temp;
int ans[10];
int d[MAXN][MAXN];
int dr[4] = {0, 0, 1, -1};
int dc[4] = {1, -1, 0, 0};
bool valid(int r, int c) { return 0 <= r && r < n && 0 <= c && c < m; }
void bfs() {
memset(d, -1, sizeof(d));
memset(ans, 0, sizeof(ans));
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
char c = g[i][j];
if (c != '.') {
d[i][j] = 0;
if (isdigit(c)) {
nxt[c - '1'].push({i, j});
ans[c - '1']++;
}
}
}
bool f = 1;
while (f) {
for (int k = 0; k < p; k++) {
temp.clear();
while (!nxt[k].empty()) {
pair<int, int> pp = nxt[k].front();
nxt[k].pop();
int cr = pp.first;
int cc = pp.second;
for (int i = 0; i < 4; i++) {
int r = cr + dr[i];
int c = cc + dc[i];
if (valid(r, c) && d[r][c] == -1) {
ans[k]++;
if (d[cr][cc] + 1 == s[k]) {
d[r][c] = 0;
temp.push_back({r, c});
continue;
}
d[r][c] = d[cr][cc] + 1;
nxt[k].push({r, c});
}
}
}
for (pair<int, int> pp : temp) nxt[k].push(pp);
}
f = 0;
for (int i = 0; i < p; i++) f |= !nxt[i].empty();
}
}
int main() {
scanf("%d %d %d", &n, &m, &p);
for (int i = 0; i < p; i++) scanf("%d", &s[i]);
for (int i = 0; i < n; i++) scanf("%s", g[i]);
bfs();
for (int i = 0; i < p; i++) printf("%d ", ans[i]);
printf("\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int arr[100000 + 10];
int main() {
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
vector<string> b1, b2;
if (n % 2) {
cout << n << endl;
return 0;
} else {
string tmp;
char ch;
int ans = n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> ch;
tmp.push_back(ch);
}
b1.push_back(tmp);
tmp.clear();
}
while (1) {
int z = b1.size() / 2, t = b1.size() - 1;
for (int i = t; i >= z; i--) {
b2.push_back(b1[i]);
b1.pop_back();
}
if (b1 == b2)
ans = min(ans, (int)b1.size());
else
break;
b2.clear();
}
cout << ans << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int powm(long long int a, int b, int n) {
long long int rm = 1;
while (b) {
if (b % 2) {
rm = (rm * a) % n;
}
a = (a * a) % n;
b /= 2;
}
return rm;
}
int bestresult[160][160], fulldest[160][160], pali[160][160][160], n, a[160];
string s;
bool isPali(int l, int r) {
while (r >= l) {
if (s[l] != s[r]) return false;
r--, l++;
}
return true;
}
void go(int l, int r) {
int len = r - l + 1;
bool isPal = isPali(l, r);
if (a[len] > -1 && isPal) fulldest[l][r] = a[len];
for (int i = l; i < r; ++i)
fulldest[l][r] = max(fulldest[l][r], fulldest[l][i] + fulldest[i + 1][r]);
if (s[l] == s[r] && len > 2) {
for (int i = 0; i <= r - l - 1; ++i) {
if (a[i + 2] > -1)
fulldest[l][r] = max(fulldest[l][r], pali[l + 1][r - 1][i] + a[i + 2]);
}
}
int to1, from2;
for (int i = l; i < r; ++i) {
to1 = i, from2 = i + 1;
for (int j = 0; j <= i - l + 1; ++j) {
pali[l][r][j] = max(pali[l][r][j], pali[l][to1][j] + fulldest[i + 1][r]);
}
for (int j = 0; j <= r - i; ++j) {
pali[l][r][j] = max(pali[l][r][j], fulldest[l][i] + pali[i + 1][r][j]);
}
}
if (s[l] == s[r]) {
int l2 = l + 1, r2 = r - 1;
if (r - l == 1) {
if (a[2] > -1) pali[l][r][0] = max(pali[l][r][0], a[2]);
pali[l][r][2] = 0;
} else {
for (int j = 0; j <= r2 - l2 + 1; ++j) {
pali[l][r][j + 2] = max(pali[l][r][j + 2], pali[l2][r2][j]);
if (a[j + 2] > -1) {
pali[l][r][0] = max(pali[l][r][0], a[j + 2] + pali[l2][r2][j]);
}
}
}
}
for (int i = l; i < r; ++i) {
bestresult[l][r] =
max(bestresult[l][r], bestresult[l][i] + bestresult[i + 1][r]);
}
if (s[l] == s[r]) {
for (int j = 0; j <= len - 2 && len > 2; ++j) {
bestresult[l][r] = max(bestresult[l][r], pali[l + 1][r - 1][j] +
max(0, max(a[j], a[j + 2])));
}
}
bestresult[l][r] = max(bestresult[l][r], fulldest[l][r]);
}
int main() {
string locals;
cin >> n;
for (int i = int(1); i <= (int)n; i++) cin >> a[i];
cin >> locals;
s = '#' + locals;
for (int i = 0; i < 153; ++i) {
for (int j = 0; j < 153; ++j) {
bestresult[i][j] = -5e7;
fulldest[i][j] = -5e7;
for (int k = 0; k < 153; ++k) {
pali[i][j][k] = -5e7;
}
}
}
memset(bestresult, 0, sizeof(bestresult));
;
if (a[1] > -1) {
for (int i = int(1); i <= (int)n; i++) {
bestresult[i][i] = a[1];
fulldest[i][i] = a[1];
pali[i][i][0] = a[1];
}
}
for (int i = int(1); i <= (int)n; i++) pali[i][i][1] = 0;
for (int len = 2; len <= n; ++len) {
for (int l = 1; l <= n - len + 1; ++l) {
int r = l + len - 1;
go(l, r);
}
}
cout << max(0, bestresult[1][n]) << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
int main() {
long long n, k, sum = 0, way = 1, old = -1;
cin >> n >> k;
for (int i = 0, a; i < n; i++) {
cin >> a;
if (a >= n - k + 1) {
sum += a;
if (old == -1)
old = i;
else {
long long x = (i - old) % mod;
way *= x;
way %= mod;
old = i;
}
}
}
cout << sum << " " << way;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline long long in() {
long long x = 0, flag = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') flag = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
x = (x << 3) + (x << 1) + (ch ^ 48), ch = getchar();
return x * flag;
}
int n;
double sqr(double x) { return x * x; }
struct Poi {
double x, y;
double ang, dis;
bool operator<(const Poi& b) const {
return ang == b.ang ? dis < b.dis : ang < b.ang;
}
} ori, a[4];
double cdis(Poi a, Poi b) { return sqrt(sqr(a.x - b.x) + sqr(a.y - b.y)); }
void read(Poi& now) {
now.x = in();
now.y = in();
now.ang = atan2(now.y - ori.y, now.x - ori.x);
now.dis = cdis(now, ori);
}
long long cross(Poi pre, Poi now, Poi nex) {
return (nex.x - now.x) * (pre.y - now.y) - (nex.y - now.y) * (pre.x - now.x);
}
set<Poi> S;
set<Poi>::iterator ne(set<Poi>::iterator it) {
it++;
if (it == S.end()) it = S.begin();
return it;
}
set<Poi>::iterator pr(set<Poi>::iterator it) {
if (it == S.begin()) it = S.end();
it--;
return it;
}
void printall() {
for (set<Poi>::iterator it = S.begin(); it != S.end(); it++) {
Poi now = *it;
printf("%.4lf %.4lf %.4lf\n", now.x, now.y, now.ang);
}
printf("\n");
}
int main() {
n = in();
for (int i = 1; i <= 3; i++) {
int opt = in();
a[i].x = in(), a[i].y = in();
ori.x += a[i].x, ori.y += a[i].y;
}
ori.x /= 3.0, ori.y /= 3.0;
for (int i = 1; i <= 3; i++) {
Poi now = a[i];
now.ang = atan2(now.y - ori.y, now.x - ori.x);
now.dis = cdis(now, ori);
S.insert(now);
}
n -= 3;
while (n--) {
int opt = in();
Poi now;
read(now);
set<Poi>::iterator pos = S.lower_bound(now);
if (pos == S.end()) pos = S.begin();
set<Poi>::iterator l = pr(pos), r = pos;
if (opt == 1) {
if (cross(*l, now, *r) <= 0) continue;
while (cross(*pr(l), *l, now) <= 0) {
l = pr(l);
S.erase(ne(l));
}
while (cross(now, *r, *ne(r)) <= 0) {
r = ne(r);
S.erase(pr(r));
}
S.insert(now);
} else if (opt == 2) {
if (cross(*l, now, *r) <= 0)
printf("YES\n");
else
printf("NO\n");
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long tests;
string s;
long long n, m;
void solve() {
cin >> n;
m = n / 2 + (n % 2);
cout << m << " ";
for (int i = 1; i <= m; i++) {
if (m + i <= n) cout << m + i << " ";
if (m - i > 0) cout << m - i << " ";
}
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
solve();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long int n, m, i, j, k, l, a[1000009], b[1000009], p[1000009], ans, cn, t,
x, y, z, mx, mn, s, lo, hi, mid;
char c[1000009], d[1000009], ch;
long long int isP(long long int flor) {
long long int num = n;
long long int pos = 0;
while (2 + pos * 3 <= num) {
num -= (2 + pos * 3);
pos++;
if ((pos == flor) && (num % 3 == 0)) {
return 1;
}
}
return 0;
}
int main() {
while (scanf("%I64d", &n) != EOF) {
x = n % 3;
if (x == 0) {
x = 3;
} else if (x == 2) {
x = 1;
} else {
x = 2;
}
ans = 0;
lo = 0;
hi = 1000000000000LL;
while (lo <= hi) {
mid = (lo + hi) / 2;
if (isP(mid * 3 + x) == 1) {
ans = mid + 1;
lo = mid + 1;
} else {
hi = mid - 1;
}
}
printf("%I64d\n", ans);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
namespace Sakurajima_Mai {
const int infi = 2e9;
const long long infl = 4e18;
inline int qi() {
int f = 0, fu = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') fu = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
f = (f << 3) + (f << 1) + c - 48;
c = getchar();
}
return f * fu;
}
inline long long ql() {
long long f = 0;
int fu = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') fu = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
f = (f << 3) + (f << 1) + c - 48;
c = getchar();
}
return f * fu;
}
inline double qd() {
char c = getchar();
int flag = 1;
double ans = 0;
while ((!(c >= '0' && c <= '9')) && c != '-') c = getchar();
if (c == '-') flag = -1, c = getchar();
while (c >= '0' && c <= '9') ans = ans * 10 + (c ^ 48), c = getchar();
if (c == '.') {
c = getchar();
for (register int Bit = 10; c >= '0' && c <= '9';
Bit = (Bit << 3) + (Bit << 1))
ans += (double)(c ^ 48) * 1.0 / Bit, c = getchar();
}
return ans * flag;
}
inline long long ceil_div(long long a, long long b) { return (a + b - 1) / b; }
} // namespace Sakurajima_Mai
using namespace Sakurajima_Mai;
const int MAX_N = 6e5 + 5;
long long ans = 0;
struct node {
int x, y, rnk, sizx, sizy;
};
struct Union_Find {
int fa[MAX_N], sizx[MAX_N], sizy[MAX_N], rnk[MAX_N];
node s[MAX_N];
int top;
void init(int n) {
for (register int i = 1, bbb = n; i <= bbb; ++i)
fa[i] = i, rnk[i] = 1, sizx[i] = 1, sizy[i] = 0;
for (register int i = n + 1, bbb = 2 * n; i <= bbb; ++i)
fa[i] = i, rnk[i] = 1, sizx[i] = 0, sizy[i] = 1;
top = 0;
}
int find(int x) { return fa[x] == x ? x : find(fa[x]); }
void unit_2(int x, int y) {
if ((x = find(x)) == (y = find(y))) return;
if (rnk[x] < rnk[y]) swap(x, y);
fa[y] = x;
ans -= 1ll * sizx[x] * sizy[x], ans -= 1ll * sizx[y] * sizy[y];
s[++top] = node{x, y, rnk[x], sizx[x], sizy[x]};
if (rnk[x] == rnk[y]) rnk[x]++;
sizx[x] += sizx[y], sizy[x] += sizy[y];
ans += 1ll * sizx[x] * sizy[x];
}
void cancel() {
node now = s[top--];
ans -= 1ll * sizx[now.x] * sizy[now.x];
fa[now.y] = now.y, rnk[now.x] = now.rnk, sizx[now.x] = now.sizx,
sizy[now.x] = now.sizy;
ans += 1ll * sizx[now.x] * sizy[now.x],
ans += 1ll * sizx[now.y] * sizy[now.y];
}
bool same(int x, int y) { return find(x) == find(y); }
} uf;
pair<int, int> e[MAX_N];
vector<int> tr[MAX_N << 2];
void update(int k, int l, int r, int L, int R, int id) {
if (R < l || r < L) return;
if (L <= l && r <= R) {
tr[k].push_back(id);
return;
}
int mid = (l + r) >> 1;
update(k << 1, l, mid, L, R, id), update(k << 1 | 1, mid + 1, r, L, R, id);
}
void solve(int k, int l, int r) {
int cntop = 0;
for (auto x : tr[k]) {
int u = e[x].first, v = e[x].second + 300000;
if (uf.same(u, v)) continue;
uf.unit_2(u, v), cntop++;
}
if (l == r)
printf("%lld\n", ans);
else {
int mid = (l + r) >> 1;
solve(k << 1, l, mid), solve(k << 1 | 1, mid + 1, r);
}
while (cntop--) uf.cancel();
}
map<pair<int, int>, int> mp;
int main() {
int q = qi();
for (register int i = 1, bbb = q; i <= bbb; ++i) {
e[i].first = qi(), e[i].second = qi();
if (!mp[e[i]])
mp[e[i]] = i;
else
update(1, 1, q, mp[e[i]], i - 1, i), mp.erase(e[i]);
}
for (auto x : mp) update(1, 1, q, x.second, q, x.second);
uf.init(300000);
solve(1, 1, q);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void readline(char *s) {
int len = 0;
char c;
for (c = ((char)fgetc(stdin)); c != '\n';
s[len++] = c, c = ((char)fgetc(stdin)))
;
s[len] = 0;
}
void readstr(char *s) {
int len = 0;
char c;
for (c = ((char)fgetc(stdin)); c != ' ' && c != '\n';
s[len++] = c, c = ((char)fgetc(stdin)))
;
s[len] = 0;
}
void printstr(const char *s) {
int len = strlen(s);
for (int(i) = (0); (i) <= (len - 1); i++) fputc((s[i]), stdout);
}
void to_lower(char *s, int L, int R) {
for (int(i) = (L); (i) <= (R); i++)
if (((s[i]) >= 'A' && (s[i]) <= 'Z')) s[i] = s[i] - 'A' + 'a';
}
void to_upper(char *s, int L, int R) {
for (int(i) = (L); (i) <= (R); i++)
if (((s[i]) >= 'a' && (s[i]) <= 'z')) s[i] = s[i] - 'a' + 'A';
}
long long readll() {
char c;
long long ans = 0, x = 1;
for (c = ((char)fgetc(stdin)); !((c) >= '0' && (c) <= '9') && c != '-';
c = ((char)fgetc(stdin)))
;
if (c == '-') x = -1, c = ((char)fgetc(stdin));
for (; ((c) >= '0' && (c) <= '9');
ans = ans * 10 + c - '0', c = ((char)fgetc(stdin)))
;
return ans * x;
}
void printll(long long x) {
int a[25], cnt = 0;
if (x == 0) {
fputc(('0'), stdout);
return;
}
if (x < 0) fputc(('-'), stdout), x = -x;
for (; x; a[cnt++] = x - x / 10 * 10, x /= 10)
;
for (int(i) = (cnt - 1); (i) >= (0); i--) fputc((a[i] + '0'), stdout);
}
long long calc(int x, int y) {
return (1ll * x * (x + 1) / 2) * (y + 1) * 1ll +
(1ll * y * (y + 1) / 2) * (x + 1) * 1ll;
}
int m, b;
long long ans = 0;
int main() {
m = ((int)readll());
b = ((int)readll());
for (int(j) = (0); (j) <= (b); j++) {
int i = (b - j) * m;
ans = max(ans, calc(i, j));
}
printll(ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int b = 30; b >= 0; b--) {
int cnt = 0;
for (int i = 0; i < n; i++) {
cnt += (a[i] & (1 << b)) > 0;
}
if (cnt % 2 == 0) continue;
if (cnt % 4 == 1) {
cout << "WIN" << '\n';
return;
}
int z = n - cnt;
if (z % 2 == 0) {
cout << "LOSE" << '\n';
return;
} else {
cout << "WIN" << '\n';
return;
}
}
cout << "DRAW" << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int t = 1;
cin >> t;
for (int i = 1; i <= t; i++) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300100;
int n, q;
struct point {
int x, idx;
point(int _x = 0, int _idx = 0) {
x = _x;
idx = _idx;
}
} M[N * 5];
int global;
struct interval {
int a, b, idx;
interval(int _a = 0, int _b = 0, int _idx = 0) {
a = _a;
b = _b;
idx = _idx;
}
} IN[N];
struct fenwick {
int tree[1000005];
int n;
fenwick() {
memset(tree, 0, sizeof(tree));
n = 1000004;
}
inline void add(int x, int val) {
for (; x < n; x += x & -x) tree[x] += val;
}
inline int get(int x) {
int ans = 0;
for (; x; x -= x & -x) ans += tree[x];
return ans;
}
} F;
inline bool cmp1(const interval &A, const interval &B) { return A.b < B.b; }
inline bool cmp2(const point &A, const point &B) { return A.x < B.x; }
vector<int> V[N];
inline void load() {
scanf("%d %d", &n, &q);
for (int i = 0; i < n; i++) scanf("%d %d", &IN[i].a, &IN[i].b);
for (int i = 0; i < q; i++) {
int k;
scanf("%d", &k);
V[i].push_back(0);
M[global].x = 0;
M[global++].idx = i;
while (k--) {
scanf("%d", &M[global].x);
V[i].push_back(M[global].x);
M[global++].idx = i;
}
V[i].push_back(1000001);
M[global].x = 1000001;
M[global++].idx = i;
}
}
int GLOBAL[N];
int ANS[N];
inline void solve() {
sort(IN, IN + n, cmp1);
sort(M, M + global, cmp2);
int index = 0;
for (int i = 0; i < global; i++) {
while (index < n && IN[index].b < M[i].x) {
F.add(IN[index].a, 1);
index++;
}
if (GLOBAL[M[i].idx] == 0)
ANS[M[i].idx] += F.get(M[i].x), GLOBAL[M[i].idx]++;
else {
int tocka = V[M[i].idx][GLOBAL[M[i].idx] - 1];
int how_much = F.get(M[i].x - 1) - F.get(tocka);
ANS[M[i].idx] += how_much;
GLOBAL[M[i].idx]++;
}
}
for (int i = 0; i < q; i++) printf("%d\n", n - ANS[i]);
}
int main(void) {
load();
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long MOD = 1e9 + 7;
vector<int> isPrime(20, 1);
void seive(int range) {
isPrime[0] = isPrime[1] = 0;
for (int i = 2; i * i <= range; i++)
if (isPrime[i])
for (int j = i * i; j <= range; j += i) isPrime[j] = i;
}
long long mod_expo(long long n, long long exp, long long p = MOD) {
long long res = 1;
while (exp > 0) {
if (exp & 1) {
res = ((res % p) * (n % p)) % p;
exp--;
};
n = ((n % p) * (n % p)) % p;
exp >>= 1;
}
return res;
}
int checkPrime(int n) {
if (n == 1 or n == 0) return -1;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) {
return -1;
}
}
return 1;
}
void solve() {
int l, r, d;
cin >> l >> r >> d;
if (d < l || d > r) {
cout << (d) << '\n';
} else {
cout << ((r / d) * d + d) << '\n';
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int ts = 1;
cin >> ts;
std::chrono::time_point<std::chrono::system_clock> start, end;
start = std::chrono::system_clock::now();
while (ts--) {
solve();
}
end = std::chrono::system_clock::now();
std::chrono::duration<double> elapsed_seconds = end - start;
std::time_t end_time = std::chrono::system_clock::to_time_t(end);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long int N = 1e6 + 5;
const int BL = 1;
const int WH = -1;
long long int dfs_num[N];
vector<pair<long long int, long long int> > adj[N];
long long int dfs_low[N];
long long int dfs_counter;
stack<long long int> dfs_scc;
set<long long int> in_stack;
long long int cnt = 0;
long long int A[N];
vector<long long int> pos[N], val[N];
void SCC(long long int u) {
dfs_low[u] = dfs_num[u] = dfs_counter++;
dfs_scc.push(u);
in_stack.insert(u);
for (vector<pair<long long int, long long int> >::iterator v = adj[u].begin();
v != adj[u].end(); ++v) {
if (dfs_num[v->first] == WH) SCC(v->first);
if (in_stack.find(v->first) != in_stack.end())
dfs_low[u] = min(dfs_low[u], dfs_num[v->first]);
}
if (dfs_num[u] == dfs_low[u]) {
while (!dfs_scc.empty()) {
val[cnt].push_back(A[dfs_scc.top()]);
pos[cnt].push_back(dfs_scc.top());
in_stack.erase(dfs_scc.top());
dfs_scc.pop();
}
cnt++;
}
}
bool cmpr1(long long int p, long long int q) { return (p < q); }
bool cmpr2(long long int p, long long int q) { return (p > q); }
int main() {
long long int m, n;
ios::sync_with_stdio(false);
cin >> n >> m;
for (long long int i = 0; i < n; i++) cin >> A[i];
for (long long int i = 0; i < m; i++) {
long long int ai, bi;
cin >> ai >> bi;
ai--;
bi--;
adj[ai].push_back(make_pair(bi, 1));
adj[bi].push_back(make_pair(ai, 1));
}
memset(dfs_num, WH, sizeof(dfs_num));
dfs_counter = 0;
for (long long int i = 0; i < n; i++) {
if (dfs_num[i] == WH) SCC(i);
}
long long int B[N];
for (long long int i = 0; i < cnt; i++) {
sort(pos[i].begin(), pos[i].end(), cmpr1);
sort(val[i].begin(), val[i].end(), cmpr2);
for (vector<long long int>::iterator it = pos[i].begin(),
ti = val[i].begin();
it != pos[i].end() && ti != val[i].end(); ++it, ++ti)
B[*it] = *ti;
}
for (long long int i = 0; i < n; i++) cout << B[i] << " ";
cout << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int t, a[12], x, ans;
string s;
int main() {
cin >> t;
for (int i = 0; i < t; i++) {
cin >> s;
ans = 0;
x = 0;
for (int j = 0; j < 12; j++)
if (s[j] == 'X') {
a[j] = 1;
x++;
} else
a[j] = 0;
if (x) ans++;
if (a[0] * a[6] + a[1] * a[7] + a[2] * a[8] + a[3] * a[9] + a[4] * a[10] +
a[5] * a[11])
ans++;
if (a[0] * a[4] * a[8] + a[1] * a[5] * a[9] + a[2] * a[6] * a[10] +
a[3] * a[7] * a[11])
ans++;
if (a[0] * a[3] * a[6] * a[9] + a[1] * a[4] * a[7] * a[10] +
a[2] * a[5] * a[8] * a[11])
ans++;
if (a[0] * a[2] * a[4] * a[6] * a[8] * a[10] +
a[1] * a[3] * a[5] * a[7] * a[9] * a[11])
ans++;
if (x == 12) ans++;
cout << ans << " ";
if (x) cout << "1x12 ";
if (a[0] * a[6] + a[1] * a[7] + a[2] * a[8] + a[3] * a[9] + a[4] * a[10] +
a[5] * a[11])
cout << "2x6 ";
if (a[0] * a[4] * a[8] + a[1] * a[5] * a[9] + a[2] * a[6] * a[10] +
a[3] * a[7] * a[11])
cout << "3x4 ";
if (a[0] * a[3] * a[6] * a[9] + a[1] * a[4] * a[7] * a[10] +
a[2] * a[5] * a[8] * a[11])
cout << "4x3 ";
if (a[0] * a[2] * a[4] * a[6] * a[8] * a[10] +
a[1] * a[3] * a[5] * a[7] * a[9] * a[11])
cout << "6x2 ";
if (x == 12) cout << "12x1";
cout << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
map<long long, int> M;
vector<vector<long long> > v;
int main() {
int n;
cin >> n;
multiset<long long> m;
for (int i = 0; i < n; i++) {
long long x;
cin >> x;
m.insert(x);
}
while (1) {
if (m.find(1) == m.end()) {
break;
}
vector<long long> v2;
for (long long i = 1;; i *= 2) {
if (m.find(i) != m.end()) {
v2.push_back(i);
m.erase(m.find(i));
} else {
break;
}
}
v.push_back(v2);
}
int lo = 0, hi = (int)v.size() + 1, mi;
while (hi - lo > 1) {
mi = (lo + hi) >> 1;
bool ok = 1;
int cnt = (int)m.size();
multiset<long long> m2 = m;
for (int i = mi; i < (int)v.size(); i++) {
cnt += (int)v[i].size();
for (int j = 0; j < (int)v[i].size(); j++) {
m2.insert(v[i][j]);
}
}
if (cnt > mi) ok = 0;
int pos = 0;
if ((int)m2.size() && ok) {
multiset<long long>::iterator it = m2.end();
it--;
for (;; it--) {
if (v[pos][(int)v[pos].size() - 1] * 2 < *it) {
ok = 0;
}
if (it == m2.begin()) break;
pos++;
}
}
if (ok) {
hi = mi;
} else
lo = mi;
}
if (hi == (int)v.size() + 1) {
cout << -1 << endl;
} else {
for (int i = 0; i < (int)v.size() - hi + 1; i++) {
if (i) cout << " ";
cout << (hi + i);
}
cout << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << "\n";
err(++it, args...);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin.tie(NULL);
long long int n, m, i, j, k, ans = 0;
cin >> n;
vector<long long int> a(n), dp2(n, 1000000007);
vector<vector<long long int> > dp(n, vector<long long int>(n, -1));
for (i = 0; i < n; i++) cin >> a[i], dp[i][i] = a[i];
for (j = 1; j < n; j++) {
for (i = 0; i + j < n; i++) {
for (k = i; k < i + j and k < n; k++) {
if (dp[i][k] == dp[k + 1][i + j] and ~dp[k + 1][i + j]) {
dp[i][i + j] = 1 + dp[i][k];
break;
}
}
}
}
dp2[0] = 1;
for (i = 1; i < n; i++) {
if (~dp[0][i])
dp2[i] = 1;
else {
for (j = 0; j < i; j++) {
if (~dp[j + 1][i]) dp2[i] = min(dp2[i], dp2[j] + 1);
}
}
}
cout << dp2[n - 1] << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
struct Node {
int lmax, rmax, mmax, sum;
Node() : lmax(0), rmax(0), mmax(INT_MIN), sum(INT_MIN) {}
};
int main() {
int n, m;
std::cin >> n >> m;
std::vector<std::vector<int> > arrays(n + 1);
for (int i = 1; i <= n; ++i) {
int l;
std::cin >> l;
arrays[i] = std::vector<int>(l);
for (int j = 0; j < l; ++j) {
std::cin >> arrays[i][j];
}
}
std::vector<Node> nodes(n + 1);
for (int i = 1; i <= n; ++i) {
Node node;
int sum = 0;
for (int j = 0; j < (int)arrays[i].size(); ++j) {
sum += arrays[i][j];
node.lmax = std::max(node.lmax, sum);
int msum = 0;
for (int k = j; k < (int)arrays[i].size(); ++k) {
msum += arrays[i][k];
node.mmax = std::max(node.mmax, msum);
}
node.rmax = std::max(node.rmax, msum);
}
node.sum = sum;
nodes[i] = node;
}
long long res = INT_MIN;
long long csum = 0;
for (int i = 0; i < m; ++i) {
int idx;
std::cin >> idx;
if (nodes[idx].lmax > 0) {
res = std::max(res, csum + nodes[idx].lmax);
}
res = std::max(res, (long long)nodes[idx].mmax);
res = std::max(res, csum + nodes[idx].sum);
csum = std::max(csum + nodes[idx].sum, (long long)nodes[idx].rmax);
csum = std::max(csum, 0LL);
}
std::cout << res << std::endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, up(0), co(0);
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
up += arr[0];
for (int i = 1; i < n; i++) {
if (arr[i] >= up) {
up += arr[i];
co++;
}
}
cout << ++co << "\n";
return 0;
}
| 4 |
#include <iostream>
#include <queue>
#include <algorithm>
#include <vector>
using namespace std;
const int INF = 1e9;
//<最小コスト, 町番号>
typedef pair<int, int> P;
struct edge{int to, cost;};
int c, n, m, s, dist;
vector<edge> G[100];
//割引券が残りiの時のj地点における最小コスト
int d[10][100];
void dijkstra(int s, int a){
priority_queue<P, vector<P>, greater<P> > Q;
for(int i = 0; i < n; i++) d[a][i] = INF;
d[a][s] = 0;
Q.push(P(0, s));
while(!Q.empty()){
P p = Q.top(); Q.pop();
int v = p.second;
if(d[a][v] < p.first) continue;
for(int i = 0; i < G[v].size(); i++){
edge e = G[v][i];
//割引券を使った時と使ってない時でよりコストが小さい時をdmに代入
int dm;
if(a == 0) dm = d[a][v] + e.cost;
else dm = min(d[a][v] + e.cost, d[a-1][v] + e.cost / 2);
if(d[a][e.to] > dm){
d[a][e.to] = dm;
Q.push(P(d[a][e.to], e.to));
}
}
}
}
int main(void){
while(true){
cin >> c >> n >> m >> s >> dist;
s--; dist--;
if(!c) break;
edge e;
for(int i = 0; i < m; i++){
int a, b, f;
cin >> a >> b >> f;
a--; b--;
e.to = b; e.cost = f;
G[a].push_back(e);
e.to = a;
G[b].push_back(e);
}
int ans = INF;
for(int i = 0; i <= c; i++){
dijkstra(s, i);
}
cout << d[c][dist] << endl;
for(int i = 0; i < 100; i++) G[i].clear();
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
void solve(int n) {
int cnt = 0;
for (int i = 0; i <= 1000; i++) {
for (int j = 0; j <= 1000; j++) {
if (n - i - j >= 0) {
if (n - i - j <= 1000) {
cnt += n - i - j + 1;
} else if (n - i - j <= 2000) {
cnt += 2000 - (n - i - j) + 1;
}
}
}
}
cout << cnt << endl;
}
int main() {
int n;
while (cin >> n) {
solve(n);
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vll = vector<ll>;
const ll MOD = 1000000007ll;
const ll INF = 0x3f3f3f3f3f3f3f3f;
inline ll SUB(ll a, ll b) { return a - b >= 0ll ? a - b : a - b + MOD; }
inline ll ADD(ll a, ll b) { return a + b >= MOD ? a + b - MOD : a + b; }
inline ll MUL(ll a, ll b) { return a * b % MOD; }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
map<char, set<int>> aid, bid;
for (int i = (0), _for = ((n)); i < _for; i++) {
char first;
cin >> first;
aid[first].insert(i);
}
for (int i = (0), _for = ((n)); i < _for; i++) {
char first;
cin >> first;
bid[first].insert(i);
}
vector<pii> pairs;
for (auto& [k, as] : aid) {
if (k == '?') continue;
auto& bs = bid[k];
while (!bs.empty() && !as.empty()) {
pairs.push_back({*begin(as), *begin(bs)});
as.erase(begin(as));
bs.erase(begin(bs));
}
}
auto& a = aid['?'];
auto& b = bid['?'];
for (auto& [k, as] : aid) {
if (b.empty()) break;
if (k == '?') continue;
while (!as.empty() && !b.empty()) {
pairs.push_back({*begin(as), *begin(b)});
b.erase(begin(b));
as.erase(begin(as));
}
}
for (auto& [k, bs] : bid) {
if (k == '?') continue;
if (a.empty()) break;
while (!bs.empty() && !a.empty()) {
pairs.push_back({*begin(a), *begin(bs)});
a.erase(begin(a));
bs.erase(begin(bs));
}
}
while (!a.empty() && !b.empty()) {
pairs.push_back({*begin(a), *begin(b)});
a.erase(begin(a));
b.erase(begin(b));
}
sort((pairs).begin(), (pairs).end());
cout << (int)(pairs).size() << endl;
for (auto [first, second] : pairs) {
cout << (first + 1) << " " << (second + 1) << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
priority_queue<int, vector<int>, greater<int> > a;
long long ans = 0;
for (int i = 1; i <= n; i++) {
long long x;
scanf("%lld", &x);
ans -= x;
a.push(x);
a.push(x);
ans += a.top();
a.pop();
}
printf("%lld", -1 * ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char s[101][3];
int main() {
int n, i, k = 0, c1 = 0, c2 = 0;
cin.get(s[0], 3);
cin >> n;
for (i = 1; i <= n; i++) {
cin.get();
cin.get(s[i], 3);
}
for (i = 1; i <= n && k < 2; i++) {
if (s[0][0] == s[i][1] && c1 == 0) {
k++;
c1 = 1;
}
if (s[0][1] == s[i][0] && c2 == 0) {
k++;
c2 = 1;
}
if (strcmp(s[0], s[i]) == NULL) k = 2;
}
if (k == 2)
cout << "YES";
else
cout << "NO";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
char num[120];
scanf("%d", &n);
scanf("%s", num);
if (n == 4) {
printf("%c%c%c%c%c", num[0], num[1], '-', num[2], num[3]);
return 0;
}
for (int i = 0, j = 0; i < n; i++, j++) {
printf("%c", num[i]);
if (j == 2 && i < n - 1 && n % 2 != 0) {
printf("-");
j = 0;
} else if (j == 2 && i < n - 2 && n % 2 == 0) {
printf("-");
j = 0;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = int(2e5) + 99;
const int INF = int(1e9) + 99;
int tc;
string s, t;
int nxt[N][26];
int main() {
cin >> tc;
while (tc--) {
cin >> s >> t;
for (int i = 0; i < s.size() + 5; ++i)
for (int j = 0; j < 26; ++j) nxt[i][j] = INF;
for (int i = int(s.size()) - 1; i >= 0; --i) {
for (int j = 0; j < 26; ++j) nxt[i][j] = nxt[i + 1][j];
nxt[i][s[i] - 'a'] = i;
}
int res = 1, pos = 0;
for (int i = 0; i < t.size(); ++i) {
if (pos == s.size()) {
pos = 0;
++res;
}
if (nxt[pos][t[i] - 'a'] == INF) {
pos = 0;
++res;
}
if (nxt[pos][t[i] - 'a'] == INF && pos == 0) {
res = INF;
break;
}
pos = nxt[pos][t[i] - 'a'] + 1;
}
if (res >= INF)
cout << -1 << endl;
else
cout << res << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using lint = long long int;
using P = pair<int, int>;
using PL = pair<lint, lint>;
constexpr int MOD = 1000000007;
constexpr lint B1 = 1532834020;
constexpr lint M1 = 2147482409;
constexpr lint B2 = 1388622299;
constexpr lint M2 = 2147478017;
constexpr int INF = 2147483647;
void yes(bool expr) { cout << (expr ? "Yes" : "No") << "\n"; }
template <class T>
void chmax(T &a, const T &b) {
if (a < b) a = b;
}
template <class T>
void chmin(T &a, const T &b) {
if (b < a) a = b;
}
struct op {
lint a, b;
int type;
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
lint x;
cin >> x;
vector<op> ans;
if (x >> 1 & 1) {
ans.push_back(op{x, x, 0});
ans.push_back(op{2 * x, x, 1});
x = (x * 2) ^ x;
}
while (x != 1) {
lint k = 0;
for (int i = (60) - 1, i_begin_ = (0); i >= i_begin_; i--)
if (x >> i & 1) {
k = i;
break;
}
lint y = x;
for (int i = (0), i_end_ = (k); i < i_end_; i++) {
ans.push_back(op{y, y, 0});
y *= 2;
}
ans.push_back(op{x, y, 0});
ans.push_back(op{x, y, 1});
ans.push_back(op{x + y, x ^ y, 1});
lint z = (x + y) ^ (x ^ y);
k++;
while (true) {
if (y >> k & 1) {
ans.push_back(op{y, z, 1});
y ^= z;
}
int bit = 0;
for (int i = (0), i_end_ = (60); i < i_end_; i++)
if (y >> i & 1) bit++;
if (bit <= 1) break;
ans.push_back(op{z, z, 0});
z *= 2;
k++;
}
ans.push_back(op{x, y, 1});
x ^= y;
}
cout << ans.size() << endl;
for (int i = (0), i_end_ = (ans.size()); i < i_end_; i++) {
if (ans[i].type == 0)
cout << ans[i].a << " + " << ans[i].b << endl;
else
cout << ans[i].a << " ^ " << ans[i].b << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
const int M = 1e9 + 7;
const int INF = 0x3f3f3f3f;
int n, m;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long ans = 0;
long long phi(long long n) {
long long res = n;
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) res = res / i * (i - 1);
while (n % i == 0) n /= i;
}
if (n > 1) res = res / n * (n - 1);
return res;
}
void solve() {
long long a, m, d;
scanf("%lld%lld", &a, &m);
d = gcd(a, m);
a /= d;
m /= d;
ans = phi(m);
cout << ans << endl;
}
int main() {
int T;
scanf("%d", &T);
for (int i = 1; i <= T; i++) solve();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long expo(long long a, long long b, long long m) {
long long result = 1;
while (b) {
if (b & 1) {
result = (result * a) % m;
}
b = (b >> 1) % m;
a = (a * a) % m;
}
return result;
}
double expof(double a, int b) {
double result = 1;
while (b) {
if (b & 1) {
result = (result * a);
}
b = (b >> 1);
a = (a * a);
}
return result;
}
int main() {
int a[5];
for (int i = 0; i < 5; ++i) {
cin >> a[i];
}
sort(a, a + 5);
int mxsum1 = INT_MIN;
for (int i = 0; i < 4; ++i) {
if (a[i] == a[i + 1]) {
mxsum1 = max(mxsum1, a[i] + a[i + 1]);
}
}
int mxsum2 = INT_MIN;
for (int i = 0; i < 3; ++i) {
if (a[i] == a[i + 1] && a[i + 1] == a[i + 2]) {
mxsum2 = max(mxsum2, a[i] + a[i + 1] + a[i + 2]);
}
}
int sum = 0;
for (int i = 0; i < 5; ++i) {
sum += a[i];
}
if (mxsum1 == INT_MIN && mxsum2 == INT_MIN) {
cout << sum << endl;
} else if (mxsum1 > mxsum2) {
cout << sum - mxsum1 << endl;
} else if (mxsum1 < mxsum2) {
cout << sum - mxsum2 << endl;
} else if (mxsum1 == mxsum2)
cout << sum - mxsum2 << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18 + 5;
void solve() {
string s;
cin >> s;
long long diff = 0;
for (long long i = 1; i < (long long)s.size(); i++) {
if (s[i] != s[i - 1]) diff = 1;
}
sort((s).begin(), (s).end());
if (diff)
cout << s << endl;
else
cout << -1 << endl;
}
signed main() {
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
cin.tie(0);
cout.tie(0);
long long t = 1;
cin >> t;
while (t--) {
solve();
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char str[200086];
bool vi[200086];
int main() {
vector<char> s;
char ch;
while ((ch = getchar()) != EOF) {
if (s.empty() || s.back() != ch) {
s.push_back(ch);
} else {
s.pop_back();
}
}
for (int i = 0; i < s.size(); i++) {
putchar(s[i]);
}
puts("");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 10;
int a[MAXN];
map<int, int> mp;
int main() {
int T;
cin >> T;
while (T--) {
mp.clear();
int n;
cin >> n;
for (int i = 1; i <= 2 * n; i++) cin >> a[i];
int res = 0;
mp[0] = 0;
for (int i = 1; i <= n; i++) {
if (a[i] == 1)
res++;
else
res--;
mp[res] = i;
}
int now = 0;
for (int i = 2 * n; i > n; i--) {
if (a[i] == 1)
now++;
else
now--;
}
if (now + res == 0) {
cout << "0" << endl;
continue;
}
int ans = 2 * n;
for (int i = n + 1; i <= 2 * n; i++) {
if (a[i] == 1)
now--;
else
now++;
if (mp[-now] != 0) {
ans = min(i - mp[-now], ans);
}
}
mp.clear();
res = 0;
mp[0] = 0;
for (int i = 2 * n; i > n; i--) {
if (a[i] == 1)
res++;
else
res--;
mp[res] = i;
}
now = 0;
for (int i = 1; i <= n; i++) {
if (a[i] == 1)
now++;
else
now--;
}
if (now + res == 0) {
cout << "0" << endl;
continue;
}
for (int i = n; i > 0; i--) {
if (a[i] == 1)
now--;
else
now++;
if (mp[-now] != 0) {
ans = min(mp[-now] - i, ans);
}
}
cout << ans << endl;
}
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
char a[105];
int main(){
long long n,cnt=0;
cin>>n;
while(n){
n--;
a[cnt++]=n%26+'a';
n/=26;
}
for(int i=cnt-1;i>=0;i--)
cout<<a[i];
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e5 + 50;
int n, k;
int psum[2][N], ssum[2][N];
string str;
string res[3] = {"quailty", "once again", "tokitsukaze"};
void ans(int type) {
cout << res[type + 1] << endl;
exit(0);
}
bool one_win(string str) {
static int psum[2][N], ssum[2][N];
for (int i = 1; i <= n; i++) {
psum[0][i] = psum[0][i - 1] + (str[i] == '0');
psum[1][i] = psum[1][i - 1] + (str[i] == '1');
}
for (int i = n; i >= 1; i--) {
ssum[0][i] = ssum[0][i + 1] + (str[i] == '0');
ssum[1][i] = ssum[1][i + 1] + (str[i] == '1');
}
for (int i = 1; i + k - 1 <= n; i++) {
if ((psum[0][i - 1] == 0 && ssum[0][i + k] == 0) ||
(psum[1][i - 1] == 0 && ssum[1][i + k] == 0))
return true;
}
return false;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> k;
cin >> str;
str = " " + str;
for (int i = 1; i <= n; i++) {
psum[0][i] = psum[0][i - 1] + (str[i] == '0');
psum[1][i] = psum[1][i - 1] + (str[i] == '1');
}
for (int i = n; i >= 1; i--) {
ssum[0][i] = ssum[0][i + 1] + (str[i] == '0');
ssum[1][i] = ssum[1][i + 1] + (str[i] == '1');
}
for (int i = 1; i + k - 1 <= n; i++) {
if ((psum[0][i - 1] == 0 && ssum[0][i + k] == 0) ||
(psum[1][i - 1] == 0 && ssum[1][i + k] == 0))
ans(1);
}
int have = 0;
for (int i = 1; i + k - 1 <= n; i++) {
if (i == 1) {
bool win[2] = {false, false};
string str1 = str;
for (int j = 1; j <= k; j++) str1[j] = '0';
if (one_win(str1)) win[0] = true;
for (int j = 1; j <= k; j++) str1[j] = '1';
if (one_win(str1)) win[1] = true;
if (!win[0] || !win[1]) have = 1;
continue;
}
if (i + k - 1 == n) {
bool win[2] = {false, false};
string str1 = str;
for (int j = n - k + 1; j <= n; j++) str1[j] = '0';
if (one_win(str1)) win[0] = true;
for (int j = n - k + 1; j <= n; j++) str1[j] = '1';
if (one_win(str1)) win[1] = true;
if (!win[0] || !win[1]) have = 1;
continue;
}
if (i - 1 > k || n - (i + k) + 1 > k) continue;
if ((psum[0][i - 1] == 0 && ssum[1][i + k] == 0) ||
(psum[1][i - 1] == 0 && ssum[0][i + k] == 0))
continue;
have = 1;
}
if (!have) ans(-1);
ans(0);
}
| 3 |
#include <iostream>
using namespace std;
int main()
{
int A[5][2],i,min=10,ans =0;
for(i=0;i<5;i++){
cin >>A[i][0];
A[i][1]=A[i][0]%10;
if((A[i][1]<min) && (A[i][1]>0)){
min = A[i][1];
}else if (A[i][1]==0){
A[i][0]-=10;
}
ans+=A[i][0]-A[i][1]+10;
}
cout << ans-10+min;
return 0;
}
| 0 |
#include <cstdio>
int main()
{
int h,w,k;
scanf("%d%d%d",&h,&w,&k);
static char s[400][400];
static int c[400];
for(int i=0;i<h;i++){
scanf("%s",s[i]);
c[i]=0;
for(int j=0;j<w;j++){
c[i]+=(s[i][j]=='#'?1:0);
}
}
static int a[400][400];
int b=1;
for(int i=0;i<h;){
int k=i;
while(k<h&&c[k]==0){
k++;
}
if(k==h){
for(int x=i;x<k;x++){
for(int j=0;j<w;j++){
a[x][j]=a[x-1][j];
}
}
i=k;
}
else{
for(int j=0;j<w;){
int l=j;
while(l<w&&s[k][l]!='#'){
l++;
}
if(l==w){
for(int x=i;x<=k;x++){
for(int y=j;y<w;y++){
a[x][y]=a[x][y-1];
}
}
j=l;
}
else{
for(int x=i;x<=k;x++){
for(int y=j;y<=l;y++){
a[x][y]=b;
}
}
b++;
j=l+1;
}
}
i=k+1;
}
}
for(int i=0;i<h;i++){
for(int j=0;j<w;j++){
printf("%d%c",a[i][j],j==w-1?'\n':' ');
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline bool comp(int A, int B) { return A > B; }
int x[100010], y[100010];
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
if (n > m) {
printf("YES");
return 0;
}
for (int i = 1; i <= n; ++i) scanf("%d", &x[i]);
for (int i = 1; i <= m; ++i) scanf("%d", &y[i]);
sort(x + 1, x + n + 1, comp);
sort(y + 1, y + m + 1, comp);
for (int i = 1; i <= n; ++i)
if (x[i] > y[i]) {
printf("YES");
return 0;
}
printf("NO");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c, d, ans = -1;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a >> b;
if (i == 0) {
c = a;
d = b;
}
if (c > a) {
c = a;
ans = -1;
}
if (d < b) {
d = b;
ans = -1;
}
if ((a == c) && (b == d)) ans = i + 1;
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
const int INF = 1000000000;
const long long LINF = 1000000000000000000;
const long long MOD = 1000000007;
const double PI = acos(-1.0);
const double EPS = 1e-10;
template <class T>
inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T>
inline void add(T& a, T b) {
a = ((a + b) % MOD + MOD) % MOD;
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
long long N, H;
cin >> N >> H;
vector<long long> L(N), R(N), D(N);
for (int i = 0; i < N; i++) cin >> L[i] >> R[i];
for (int i = 0; i < N - 1; i++) D[i] = L[i + 1] - R[i];
long long ans = 0, sum = 0, r = 0;
for (int l = 0; l < N; l++) {
while (r < N - 1 && sum + D[r] < H) {
sum += D[r];
r++;
}
chmax(ans, R[r] - L[l] + H - sum);
sum -= D[l];
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int arr[n], lookup[n], visited[100001];
for (int i = 0; i < n; i++) visited[i] = 0;
for (int i = 0; i < n; i++) cin >> arr[i];
lookup[n - 1] = 1;
visited[arr[n - 1]] = 1;
for (int i = n - 2; i >= 0; i--) {
int temp = arr[i];
if (visited[temp] == 1)
lookup[i] = lookup[i + 1];
else {
lookup[i] = 1 + lookup[i + 1];
visited[temp] = 1;
}
}
for (int i = 0; i < m; i++) {
int l;
cin >> l;
int answer = lookup[l - 1];
cout << answer << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize 2
using namespace std;
vector<pair<int, int> > e[200005];
bitset<200005> s[10][10];
int D[200005];
int pd[10][10][10][10];
int ans = 0, p[10], k;
inline void dfs(int x) {
if (x == k + 1) {
++ans;
return;
}
for (int i = 1; i <= x; i++) {
int flag = 1;
if (s[x][i][200001]) continue;
for (int j = 1; j < x; j++) {
if (!pd[x][i][j][p[j]]) {
flag = 0;
break;
}
}
if (flag) p[x] = i, dfs(x + 1);
}
}
int main(int argc, char** argv) {
int n, m;
cin >> n >> m >> k;
for (int i = 1; i <= m; i++) {
int u, v, w;
cin >> u >> v >> w;
e[u].push_back({w, v});
++D[u];
}
for (int i = 1; i <= n; i++) {
sort(e[i].begin(), e[i].end());
for (int j = 0; j < e[i].size(); j++) {
if (s[D[i]][j + 1][e[i][j].second] && !s[D[i]][j + 1][200001])
s[D[i]][j + 1][200001] = 1;
s[D[i]][j + 1][e[i][j].second] = 1;
}
}
for (int i = 1; i <= k; i++) {
for (int j = 1; j <= i; j++) {
for (int x = 1; x < i; x++) {
for (int y = 1; y <= x; y++) {
if ((s[i][j] & s[x][y]).none()) {
pd[i][j][x][y] = 1;
}
}
}
}
}
dfs(1);
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool st(const pair<int, string>& i, const pair<int, string>& j) {
return (i.first < j.first);
}
int main() {
int n;
cin >> n;
vector<pair<int, string>> v(n);
string stat;
for (int i = 0; i < n; i++) {
cin >> v[i].second >> stat;
if (stat == "rat") v[i].first = 0;
if (stat == "child") v[i].first = 1;
if (stat == "woman") v[i].first = 1;
if (stat == "man") v[i].first = 2;
if (stat == "captain") v[i].first = 3;
}
stable_sort(v.begin(), v.end(), st);
for (int i = 0; i < n; i++) cout << v[i].second << '\n';
return (0);
}
| 1 |
#include <bits/stdc++.h>
const int inf = int(1e9) + 7;
const long long INF = 1e18;
const double eps = 1e-9;
using namespace std;
const int maxn = int(1e5 + 10);
int c[maxn];
vector<set<int>> colors(maxn);
int main() {
ios_base::sync_with_stdio(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; ++i) {
cin >> c[i];
}
for (int i = 1; i <= m; ++i) {
int a, b;
cin >> a >> b;
if (c[a] == c[b]) {
continue;
}
colors[c[a]].insert(c[b]);
colors[c[b]].insert(c[a]);
}
int res = inf, cnt = 0;
for (int i = 1; i <= n; ++i) {
if (cnt < colors[c[i]].size()) {
cnt = colors[c[i]].size();
res = c[i];
} else if (cnt == colors[c[i]].size()) {
res = min(res, c[i]);
}
}
cout << res;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, i, j;
cin >> n;
vector<long long> a(100005), d(100005);
map<long long, long long> mp;
for (i = 0; i < n; i++) {
cin >> a[i];
}
d[n - 1] = 1;
mp[a[n - 1]]++;
for (i = n - 2; i >= 0; i--) {
mp[a[i]]++;
if (mp[a[i]] == 1) {
d[i] = d[i + 1] + 1;
} else {
d[i] = d[i + 1];
}
}
vector<long long> mark(100005, 0);
long long ans = 0;
for (i = 0; i < n - 1; i++) {
long long x = a[i];
if (mark[x] == 0) {
ans += d[i + 1];
mark[x] = 1;
}
}
cout << ans << endl;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
void z_algorithm(int *s,int *z,int n){
int c=0;
for(int i=1;i<n;i++){
if(i+z[i-c]<c+z[c]){
z[i]=z[i-c];
}else{
int j=max(0,c+z[c]-i);
while(i+j<n&&s[j]==s[i+j])j++;
z[i]=j;
c=i;
}
}
z[0]=n;
}
int n;
int a[200005];
int b[200005];
int s[600005];
int z[600005];
int main(){
scanf("%d",&n);
for(int i=0;i<n;i++)scanf("%d",a+i);
for(int i=0;i<n;i++)scanf("%d",b+i);
a[n]=a[0];
b[n]=b[0];
for(int i=0;i<n;i++){
s[i]=b[i]^b[i+1];
s[i+n]=s[i+(n<<1)]=a[i]^a[i+1];
}
z_algorithm(s,z,n*3);
for(int i=n;i<n<<1;i++){
if(z[i]>=n)printf("%d %d\n",i-n,a[i-n]^b[0]);
}
return 0;
} | 0 |
#include<iostream>
#include<math.h>
#include<stdio.h>
using namespace std;
int main(){
int n;
cin>>n;
while(n!=0){
double s[1000]={},sum=0,a=0;
for(int i=0; i<n; i++){
cin>>s[i];
sum+=s[i];
}
for(int i=0; i<n; i++){
a+=((sum/n)-s[i])*((sum/n)-s[i])/n;
}
printf("%.5f\n",sqrt(a));
cin >> n;
}
return 0;
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.