solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9 + 7;
const int N = 3e3 + 10;
int flag[N];
int a[] = {
0, 1, 2, 3, 4, 8, 12, 5, 10, 15, 6, 11, 13, 7, 9, 14,
};
int offset[][3] = {
16, 32, 48, 17, 34, 51, 18, 35, 49, 19, 33, 50, 20, 40, 60, 21,
42, 63, 22, 43, 61, 23, 41, 62, 24, 44, 52, 25, 46, 55, 26, 47,
53, 27, 45, 54, 28, 36, 56, 29, 38, 59, 30, 39, 57, 31, 37, 58,
};
void output(int b) {
string s;
while (b) {
s.push_back(b % 2 + '0');
b /= 2;
}
reverse(s.begin(), s.end());
printf(s.c_str());
putchar(' ');
}
long long check(long long cnt) {
int d[4] = {0, 3, 1, 2};
long long res = 0;
long long o = 1;
while (cnt) {
res += d[cnt % 4] * o;
o *= 4;
cnt /= 4;
}
return res;
}
int main() {
for (int i = 0; i < 16; i++) {
for (int j = 0; j < 3; j++) {
offset[i][j] -= 16 * (j + 1);
}
}
int ncase;
scanf("%d", &ncase);
while (ncase--) {
long long n;
scanf("%lld", &n);
if (n <= 15)
printf("%d\n", a[n]);
else {
n -= 16;
long long cur = 16;
int cnt = 2;
while (n >= cur * 3) {
cnt++;
n -= cur * 3;
cur *= 4;
}
long long key = cur;
int oo = n % 48;
long long ans1 = cur + n / 3;
long long ans3 = check(n / 3) + cur * 3;
long long ans2 = ans1 ^ ans3;
long long ans[] = {ans1, ans2, ans3};
printf("%lld\n", ans[n % 3]);
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
char arr[250][250];
char arr2[250][250];
int main() {
int w, h;
cin >> w >> h;
for (int i = 0; i < h; i++)
for (int j = 0; j < w; j++) cin >> arr[i][j];
for (int i = 0; i < h; i++)
for (int j = 0; j < w; j++) {
arr2[j][i] = arr[i][j];
}
int tmp = h;
h = w;
w = tmp;
for (int i = 0; i < h; i++)
for (int j = 0; j < w; j++) {
arr[2 * i][2 * j] = arr2[i][j];
arr[2 * i][2 * j + 1] = arr2[i][j];
arr[2 * i + 1][2 * j + 1] = arr2[i][j];
arr[2 * i + 1][2 * j] = arr2[i][j];
}
h = 2 * h;
w = 2 * w;
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
cout << arr[i][j];
}
cout << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(0.0) * 2.0;
const long double eps = 1e-10;
const int step[8][2] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1},
{-1, 1}, {1, 1}, {1, -1}, {-1, -1}};
string a, b;
int z1[1000004], z2[100004], c[100005], ans;
void z1algo(string s, int n) {
for (int i = 1, l = 0, r = 0; i < n; ++i) {
if (i <= r) z1[i] = min(r - i + 1, z1[i - l]);
while (i + z1[i] < n && s[z1[i]] == s[i + z1[i]]) ++z1[i];
if (i + z1[i] - 1 > r) l = i, r = i + z1[i] - 1;
}
}
void z2algo(string s, int n) {
for (int i = 1, l = 0, r = 0; i < n; ++i) {
if (i <= r) z2[i] = min(r - i + 1, z2[i - l]);
while (i + z2[i] < n && s[z2[i]] == s[i + z2[i]]) ++z2[i];
if (i + z2[i] - 1 > r) l = i, r = i + z2[i] - 1;
}
}
int main() {
ios::sync_with_stdio(false);
cin >> a;
z1algo(a, a.size());
int n = a.size();
int maxp = 0;
int len = 0;
for (int i = 1; i < n; i++) {
if (i + z1[i] == n && z1[i] <= maxp) {
len = z1[i];
break;
}
maxp = max(maxp, z1[i]);
}
if (!min(len, maxp)) {
cout << "Just a legend\n";
return 0;
}
for (int i = 0; i < min(len, maxp); i++) cout << a[i];
}
| 4 |
#include <bits/stdc++.h>
int n, x;
inline bool IsPrime(int x) {
if (x == 1) return false;
for (int i = 2; i * i <= x; i++)
if (x % i == 0) return false;
return true;
}
long long QPower(long long b, int q, int p) {
long long rep = 1;
while (q) {
if (q & 1) rep = rep * b % p;
q >>= 1;
b = b * b % p;
}
return rep;
}
int main() {
srand(time(NULL));
scanf("%d%d", &n, &x);
int tmp = rand() & 1;
if (!IsPrime(n + 1)) {
printf("-1\n");
return 0;
}
for (int i = x - 1; i > 1; i--) {
bool Ok = true;
if (tmp)
if (i % (n + 1) == 0) Ok = false;
for (int j = 2; j * j <= n && Ok; j++)
if (n % j == 0)
if (QPower(i, j, n + 1) == 1 || QPower(i, n / j, n + 1) == 1)
Ok = false;
if (Ok) {
printf("%d\n", i);
return 0;
}
}
printf("-1\n");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
double length(int x1, int y1, int x2, int y2) {
return sqrt(double((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1)));
}
int main() {
cout.setf(ios::fixed);
cout.precision(8);
int n, k, x1, y1, x2, y2;
cin >> n >> k;
double time = 0;
cin >> x1 >> y1;
for (int i = 0; i < n; i++) {
cin >> x2 >> y2;
time += length(x1, y1, x2, y2) / 50;
x1 = x2;
y1 = y2;
}
cout << time * k;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double p, q;
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
p = a * 1.0 / b;
q = c * 1.0 / d;
printf("%.12lf\n", p / (p + q - p * q));
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, ans, x, y, x_1, y_1, a, b;
bool l;
string s, s1;
vector<int> v, g;
int main() {
cin >> n >> m >> k;
if (n > m) {
cout << "YES";
return 0;
}
for (int i = 0; i < n; i++) scanf("%d", &x), v.push_back(x);
for (int i = 0; i < m; i++) scanf("%d", &x), g.push_back(x);
sort(v.begin(), v.end());
sort(g.begin(), g.end());
for (int i = v.size() - 1; i >= 0; i--) {
if (v[i] > g[--m]) {
cout << "YES";
return 0;
}
}
cout << "NO";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = INT_MAX;
const long long INFL = LLONG_MAX;
const long double pi = acos(-1);
int X[10] = {1, 0, 1, 2, 0, 1, 2, 0, 1, 2};
int Y[10] = {3, 0, 0, 0, 1, 1, 1, 2, 2, 2};
int N;
string S;
int isValid(int x, int y) {
for (int(i) = 0; (i) < (10); (i)++) {
if (X[i] == x && Y[i] == y) return 1;
}
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cout.precision(15);
cout << fixed;
cout.tie(0);
cin.tie(0);
cin >> N;
cin >> S;
vector<int> dx;
vector<int> dy;
for (int(i) = 1; (i) <= (N - 1); (i)++) {
int a = S[i - 1] - '0';
int b = S[i] - '0';
dx.push_back(X[b] - X[a]);
dy.push_back(Y[b] - Y[a]);
}
for (int(i) = 0; (i) < (10); (i)++) {
if (i == (S[0] - '0')) continue;
int x = X[i];
int y = Y[i];
int bad = 0;
for (int(j) = 0; (j) < (int((dx).size())); (j)++) {
x += dx[j];
y += dy[j];
if (!isValid(x, y)) bad = 1;
}
if (!bad) {
cout << "NO" << '\n';
return 0;
}
}
cout << "YES" << '\n';
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 7;
int g[N][N], deg[N];
vector<pair<int, char> > num[N][N];
int pt[N][N];
int main() {
int a, b, n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a >> b;
g[a][b]++;
g[b][a]++;
num[a][b].push_back(make_pair(i, '+'));
num[b][a].push_back(make_pair(i, '-'));
}
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++) deg[i] += g[i][j];
int first = 0;
while (!deg[first]) ++first;
int v1 = -1, v2 = -1;
bool bad = false;
for (int i = 0; i < N; i++)
if (deg[i] & 1)
if (v1 == -1)
v1 = i;
else if (v2 == -1)
v2 = i;
else
bad = true;
if (v1 != -1) ++g[v1][v2], ++g[v2][v1];
stack<int> st;
st.push(first);
vector<int> res;
while (!st.empty()) {
int v = st.top();
int i;
for (i = 0; i < N; i++)
if (g[v][i]) break;
if (i == N) {
res.push_back(v);
st.pop();
} else {
--g[v][i];
--g[i][v];
st.push(i);
}
}
if (v1 != -1)
for (size_t i = 0; i + 1 < res.size(); i++)
if (res[i] == v1 && res[i + 1] == v2 ||
res[i] == v2 && res[i + 1] == v1) {
vector<int> res2;
for (size_t j = i + 1; j < res.size(); ++j) res2.push_back(res[j]);
for (size_t j = 1; j <= i; j++) res2.push_back(res[j]);
res = res2;
break;
}
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++)
if (g[i][j]) bad = true;
if (bad)
cout << "No solution";
else {
for (int i = 1; i < res.size(); i++) {
a = res[i - 1], b = res[i];
cout << num[a][b][pt[a][b]].first + 1 << " " << num[a][b][pt[a][b]].second
<< "\n";
pt[a][b]++;
pt[b][a]++;
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int TESTS = 1;
while (TESTS--) {
long long n, temp;
long long ans = 0;
string s;
cin >> n;
map<string, vector<long long> > m;
for (long long int i = 0; i < n; i++) {
cin >> s >> temp;
m[s].push_back(temp);
}
for (auto it = (m).begin(); it != (m).end(); it++) {
sort((m[it->first]).begin(), (m[it->first]).end(), greater<long long>());
}
long long t = 0;
while (t < (long long int)m["01"].size() &&
t < (long long int)m["10"].size()) {
ans = ans + m["01"][t] + m["10"][t];
t++;
}
long long ct = 0;
long long t1 = t;
long long t2 = t;
long long t3 = 0;
while (ct < (long long int)m["11"].size()) {
long long v1 = 0, v2 = 0, v3 = 0, v4;
ans += m["11"][ct];
ct++;
if (t1 < (long long int)m["01"].size()) v1 = m["01"][t1];
if (t2 < (long long int)m["10"].size()) v2 = m["10"][t2];
if (t3 < (long long int)m["00"].size()) v3 = m["00"][t3];
long long d = max(v1, max(v2, v3));
ans = ans + d;
if (d == v1)
t1++;
else if (d == v2)
t2++;
else
t3++;
}
cout << ans;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int sum[1510];
struct node {
int l, r;
} tt;
vector<node> v[10000000];
map<int, int> mp;
int main() {
int n, bh = 1, mm = 0, ans;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int xx;
scanf("%d", &xx);
sum[i] = sum[i - 1] + xx;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= i; j++) {
int t = sum[i] - sum[j - 1];
if (!mp[t]) {
mp[t] = bh++;
}
int bz = mp[t];
if (v[bz].size() == 0 || v[bz][v[bz].size() - 1].r < j) {
v[bz].push_back(node{j, i});
}
if (mm < v[bz].size()) {
mm = v[bz].size();
ans = bz;
}
}
}
printf("%d\n", mm);
for (int i = 0; i < v[ans].size(); i++) {
printf("%d %d\n", v[ans][i].l, v[ans][i].r);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct domino {
int no, x, h;
domino() {}
domino(int _x) : x(_x) {}
bool operator<(const domino& rhs) const { return x < rhs.x; }
};
domino d[100000];
int f[100000];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d %d", &d[i].x, &d[i].h);
d[i].no = i;
}
sort(d, d + n);
f[d[n - 1].no] = 1;
for (int i = n - 2; i >= 0; i--) {
int p = lower_bound(d + i + 1, d + n, domino(d[i].x + d[i].h - 1)) - d;
if (p != n) {
if (d[p].x > (d[i].x + d[i].h - 1) && (p - 1) == i)
f[d[i].no] = 1;
else {
int jh = (d[p].x == (d[i].x + d[i].h - 1)) ? p : p - 1;
f[d[i].no] = jh - i + f[d[jh].no];
if (f[d[i].no] < (n - i))
for (int j = jh - 1; j > i; j--) {
int t = j - i + f[d[j].no];
if (t > f[d[i].no]) {
f[d[i].no] = t;
if (t == (n - i)) break;
}
}
}
} else
f[d[i].no] = n - i;
}
printf("%d", f[0]);
for (int i = 1; i < n; i++) printf(" %d", f[i]);
printf("\n");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int a[9] = {0};
bool is_good(int x, int depth) {
if (depth == 0) return false;
if (x == 0) return true;
return is_good(a[x], depth - 1);
}
bool find_next(int num) {
bool found = false;
bool good = true;
for (int i = 1; i < k; i++) {
a[i] = num % k;
num /= k;
if (a[i] != 0) found = true;
}
return found;
}
long long mod = 1000000007;
int main() {
scanf("%d%d", &n, &k);
long long sum = 1;
int i = 0;
while (find_next(++i)) {
bool good = true;
for (int i = 1; i < k; i++) {
if (!is_good(i, 9)) {
good = false;
}
}
if (good) {
sum++;
}
}
sum = (sum * (k)) % mod;
if (n > k) {
for (int i = 0; i < n - k; i++) {
sum = (sum * (n - k)) % mod;
}
}
cout << sum << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
unsigned int dp[512][501];
unsigned int pcost[512][501];
int n, chgs;
string s;
static const unsigned int INF = 0x3f3f3f3f;
string toPalin(int l, int r) {
string res = s.substr(l, r - l);
int i = 0, j = res.size() - 1;
while (i < j) {
if (s[l + i] != s[l + j]) res[j] = s[l + i];
i++;
j--;
}
return res;
}
int main() {
cin >> s >> chgs;
n = s.size();
for (int i = 0; i < n; i++) {
for (int j = i; j <= n; j++) {
int l = i, r = j - 1;
pcost[i][j] = 0;
while (l < r) {
if (s[l] != s[r]) {
pcost[i][j]++;
}
l++;
r--;
}
}
}
memset(dp, 0x3f, sizeof(dp));
for (int i = 0; i <= n; i++) {
dp[i][1] = pcost[0][i];
}
for (int k = 2; k <= chgs; k++) {
for (int i = 0; i <= n; i++) {
for (int j = 0; j < i; j++) {
if (dp[i][k] > dp[j][k - 1] + pcost[j][i]) {
dp[i][k] = dp[j][k - 1] + pcost[j][i];
}
}
}
}
unsigned int res = INF, c = -1;
for (int i = 0; i <= chgs; i++) {
if (res > dp[n][i]) {
res = dp[n][i];
c = i;
}
}
cout << res << endl;
string sres = "";
int p = n;
for (int i = n - 1; i > 0; i--) {
if (dp[p][c] == dp[i][c - 1] + pcost[i][p]) {
sres = toPalin(i, p) + sres;
p = i;
sres.insert(sres.begin(), '+');
c--;
}
}
sres = toPalin(0, p) + sres;
cout << sres << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[110];
int main() {
int n, aa, bb;
cin >> n >> aa >> bb;
while (aa--) {
int k;
cin >> k;
a[k] = 1;
}
while (bb--) {
int k;
cin >> k;
a[k] = 2;
}
for (int i = 1; i <= n; i++) cout << a[i] << " ";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct station {
int pos, cost;
bool operator<(station const& o) const { return pos < o.pos; }
};
station stations[200000];
int s[200000];
int nextSmall[200000];
int main() {
long long n, maxGas, curGas, dist;
cin >> dist >> maxGas >> n;
curGas = maxGas;
for (int i = 0; i < n; i++) {
scanf("%d", &stations[i].pos);
scanf("%d", &stations[i].cost);
}
sort(stations, stations + n);
int stacklen = 0;
for (int i = n - 1; i >= 0; i--) {
while (stacklen > 0 && stations[s[stacklen - 1]].cost >= stations[i].cost) {
stacklen--;
}
nextSmall[i] = (stacklen == 0 ? -1 : s[stacklen - 1]);
s[stacklen] = i;
stacklen++;
}
curGas -= stations[0].pos;
long long cost = 0;
for (int i = 0; i < n; i++) {
if (curGas < 0) {
printf("-1\n");
return 0;
}
int gasNeeded =
min(maxGas, (nextSmall[i] == -1 ? dist : stations[nextSmall[i]].pos) -
stations[i].pos);
if (gasNeeded > curGas) {
cost += (long long)(gasNeeded - curGas) * (long long)stations[i].cost;
curGas = gasNeeded;
}
curGas -= (i == n - 1 ? dist : stations[i + 1].pos) - stations[i].pos;
}
if (curGas < 0) {
printf("-1\n");
} else {
cout << cost << endl;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(int a, int b) {
if (!b) return a;
return gcd(b, a % b);
}
bool isprime(long long n) {
if (n == 2) {
return true;
}
if (n % 2 == 0) {
return false;
}
for (long long i = 3; i <= sqrt(n); i += 2) {
if (n % i == 0) {
return false;
}
}
return true;
}
long long n, k;
bool f(long long x) {
long long t = 1;
long long res = 0;
while (x / t) {
res += x / t;
t *= k;
}
return res >= n;
}
int main() {
cin >> n >> k;
long long l = 1, r = 1e9, m;
while (l <= r) {
m = (l + r) / 2;
if (f(m))
r = m - 1;
else
l = m + 1;
}
cout << l << endl;
return 0;
}
| 3 |
#include<iostream>
#include<cstring>
#include<cassert>
#include<cmath>
#include<map>
#include<set>
#include<queue>
#include<stack>
#include<vector>
#include<time.h>
#include<bitset>
#include<cstdio>
#include<algorithm>
using namespace std;
#define REP(i,x,y) for(int i=x;i<=y;i++)
#define rep(i,n) REP(i,1,n)
#define rep0(i,n) REP(i,0,n-1)
#define repG(i,x) for(int i=pos[x];~i;i=e[i].next)
#define ll long long
#define db double
const int N=2e5+7;
const int M=1077;
const int INF=1e9+7;
int n,m,m1=0,m2=0;
int a[N],b[N],c[N],p[N][3],xw[N],R[N],K[N],X[N],zr[N],zd[N],zw[M],q[M][3],nq[M],fr[N],bg[3][N],ed[3][N],ss[3][N];
ll w[3][N],sb[M],sc[M],sf[N],ba[M],Ans[N];
vector<pair<int,int> >h[M];
int s[N*20];
void work(){
memset(w,0,sizeof(w));
memset(fr,0,sizeof(fr));
int oo=0;
sf[0]=0;
rep0(i,3)memcpy(ed[i],bg[i],sizeof(int)*(n+3));
rep(j,n){
if(!p[j][0]){
oo++;
for(int j=0;j<h[oo].size();j++)Ans[h[oo][j].second]+=w[1][h[oo][j].first];
w[2][j]=w[2][j-1];
}
else{
sf[j]=sf[fr[p[j][2]]]+ed[1][p[j][2]]-bg[1][p[j][2]];
fr[p[j][2]]=j;
w[2][j]=w[2][j-1]+w[1][p[j][2]];
w[1][p[j][1]]+=w[0][p[j][1]];
w[0][p[j][0]]++;
rep0(i,3)s[ed[i][p[j][i]]++]=j;
}
}
}
inline int qf(int k,int x,int y){return lower_bound(s+bg[k][x],s+ed[k][x],y)-s-bg[k][x];}
inline int qe(int k,int x,int y){return s+ed[k][x]-upper_bound(s+bg[k][x],s+ed[k][x],y);}
int main(){
scanf("%d%d",&n,&m);
rep(i,n)scanf("%d",&a[i]);
rep(i,n)scanf("%d",&b[i]);
rep(i,n)scanf("%d",&c[i]);
rep(i,n){
p[i][1]=a[i];
p[i][0]=b[a[i]];
p[i][2]=c[a[i]];
ss[0][b[a[i]]]++;
ss[1][a[i]]++;
ss[2][c[a[i]]]++;
}
K[++m1]=1;
X[1]=a[1];
rep(i,m){
int op,x; scanf("%d%d",&op,&x);
if(op&1){
K[++m1]=x;
scanf("%d",&X[m1]);
ss[0][b[X[m1]]]++;
ss[1][X[m1]]++;
ss[2][c[X[m1]]]++;
}
else{
xw[++m2]=m1;
R[m2]=x;
}
}
int tot=0;
rep0(i,3){
rep(j,n){
bg[i][j]=tot;
tot+=ss[i][j];
}
}
int nw=1,T;
if(m<=500)T=sqrt(m1);
else {
if(m1<=m2)T=250;
else{
ll mh=70ll*n*m1;
rep(i,n){
ll p=i;
if(p*p*p*m2>mh){
T=i;
break;
}
}
T=min(T,1000);
}
}
for(int l=1;l<=m1;l+=T){
int r=min(m1,l+T-1),cc=0;
REP(j,l,r){
if(zr[K[j]]!=l){
zr[K[j]]=l;
zw[++cc]=K[j];
}
}
sort(zw+1,zw+cc+1);
rep(j,cc){
zd[zw[j]]=j;
rep0(i,3){
q[j][i]=p[zw[j]][i];
p[zw[j]][i]=0;
}
nq[j]=q[j][2];
h[j].clear();
}
int nw0=nw;
REP(j,l,r){
nq[zd[K[j]]]=c[X[j]];
while(nw0<=m2&&xw[nw0]==j){
rep(k,cc){
if(zw[k]>R[nw0])break;
h[k].push_back(make_pair(nq[k],nw0));
}
nw0++;
}
}
work();
REP(j,l,r){
int d=zd[K[j]];
q[d][0]=b[X[j]];
q[d][1]=X[j];
q[d][2]=c[X[j]];
while(nw<=m2&&xw[nw]==j){
Ans[nw]+=w[2][R[nw]];
rep(k,cc){
if(zw[k]>R[nw])break;
ll t1=qf(2,q[k][0],zw[k]+1),t2=qf(2,q[k][0],R[nw]+1),t0=qf(1,q[k][0],zw[k]);
ba[k]=t0;
if(t1!=t2)Ans[nw]=Ans[nw]-t0*(t2-t1)+sf[s[bg[2][q[k][0]]+t2-1]]-(t1?sf[s[bg[2][q[k][0]]+t1-1]]:0);
sb[k]=qf(0,q[k][1],zw[k]);
sc[k]=qe(2,q[k][1],zw[k])-qe(2,q[k][1],R[nw]);
ll tt=qf(1,q[k][2],zw[k]);
rep(i,k-1){
sb[k]+=(q[i][0]==q[k][1]);
sc[i]+=(q[i][1]==q[k][2]);
if(q[k][2]==q[i][0])Ans[nw]+=(tt-ba[i]);
}
}
rep(k,cc){
if(zw[k]>R[nw])break;
Ans[nw]+=sb[k]*sc[k];
}
nw++;
}
}
rep(j,cc)rep0(k,3)p[zw[j]][k]=q[j][k];
}
rep(i,m2)printf("%lld\n",Ans[i]);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
vector<long long int> vc;
int main() {
long long int k, i;
cin >> k;
if (k > 36) {
cout << "-1" << endl;
} else if (k % 2 == 0) {
for (i = 1; i <= k / 2; i++) {
cout << 8;
}
} else {
for (i = 1; i <= k / 2; i++) {
cout << 8;
}
cout << 4;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long mod = (long long)(1e9 + 7);
long long q, l, r, g, ans;
int n;
cin >> n;
long long a[n];
for (long long i = 0; i < n; i++) cin >> a[i];
if (n == 1) {
cin >> q;
while (q--) {
cin >> l >> r;
cout << r - l + 1 << " ";
}
return 0;
}
sort(a, a + n);
vector<long long> d;
for (int i = (0); i < (n - 1); i++) d.push_back(a[i + 1] - a[i]);
sort((d.begin()), (d.end()));
vector<long long> ds(n - 1);
for (int i = (0); i < (n - 1); i++)
i == 0 ? ds[i] = d[i] : ds[i] = (ds[i - 1] + d[i]);
cin >> q;
for (int i = (0); i < (q); i++) {
cin >> l >> r;
g = r - l + 1;
int in = lower_bound((d.begin()), (d.end()), g) - d.begin();
if (in < (n - 1) && d[in] >= g) {
if (in > 0)
ans = ds[in - 1], ans += (n - in) * g;
else
ans = (n - in) * g;
} else {
ans = ds[in - 1], ans += (n - in) * g;
}
cout << ans << " ";
}
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse4")
using namespace std;
const int MOD = 1e9 + 7;
const int MX = 2e5 + 5;
const long long INF = 1e18;
const long double PI = acos((long double)-1);
const long double EPS = 1e-6;
const int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
const char nl = '\n';
template <typename T>
inline T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <typename T>
inline T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
template <class T>
void ckmin(T& a, T b) {
a = min(a, b);
}
template <class T>
void ckmax(T& a, T b) {
a = max(a, b);
}
int pct(int x) { return __builtin_popcount(x); }
int pctll(long long x) { return __builtin_popcountll(x); }
void setIn(string s) { freopen(s.c_str(), "r", stdin); }
void setOut(string s) { freopen(s.c_str(), "w", stdout); }
void unsyncIO() {
ios_base::sync_with_stdio(0);
cin.tie(0);
}
void setIO(string s = "") {
unsyncIO();
if ((int)s.size()) {
setIn(s + ".in"), setOut(s + ".out");
}
}
long long pow(long long b, long long e, long long m = 0LL,
long long ans = 1LL) {
while (e) {
if (e & 1LL) {
ans *= b;
if (m) ans %= m;
}
b *= b, e >>= 1LL;
if (m) b %= m;
}
return ans;
}
void solve(int tcn) {
long long x, y, k;
cin >> x >> y >> k;
long long ans = (k * y + k - 1 + x - 2) / (x - 1) + k;
cout << ans << nl;
}
int main() {
setIO();
int t = 1;
cin >> t;
for (int i = 1; i <= t; ++i) {
solve(i);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int static_init = []() {
ios_base::sync_with_stdio(false), cin.tie(0), cout << fixed;
return 0;
}();
int64_t n, u, q, d;
string s;
vector<int64_t> p;
void move(char c) {
if (c == 'U') {
if (p.size() == 1) return;
p.pop_back();
if (d == 0)
d++;
else
d *= 2;
return;
}
if (d == 0) return;
p.push_back(p.back() + (c == 'L' ? -d : d));
d /= 2;
}
int main() {
cin >> n >> q;
while (q-- > 0) {
cin >> u >> s;
p.clear();
p.push_back((n + 1) / 2);
d = p.back() / 2;
while (p.back() != u) move(u < p.back() ? 'L' : 'R');
for (char c : s) move(c);
cout << p.back() << '\n';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct data {
int value, sum;
} disc[200005];
int c, n;
int a[200005];
int f[200005];
int main() {
scanf("%d%d", &c, &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + n + 1);
int pre = 1, num = 1;
disc[1].value = a[1];
for (int i = 2; i <= n; i++) {
if (a[i] != a[i - 1]) {
disc[num].sum = i - pre;
disc[++num].value = a[i];
pre = i;
}
}
disc[num].sum = n - pre + 1;
for (int i = 1; i <= num; i++)
for (int j = disc[i - 1].value; j <= disc[i].value - 1; j++) f[j] = i - 1;
for (int i = disc[num].value; i <= c; i++) f[i] = num;
bool bigflag = 0;
for (int i = 1; i <= c; i++) {
int temp = c, now = num, flag = 1;
while (temp != 0) {
int x = min(f[temp], now);
if (flag && i >= disc[x].value && i <= temp) {
temp -= i;
flag = 0;
} else if (x != 0) {
temp -= min(temp / disc[x].value, disc[x].sum) * disc[x].value;
now = x - 1;
}
if (x == 0) break;
}
if (temp != 0) {
printf("%d\n", i);
bigflag = 1;
break;
}
}
if (!bigflag) puts("Greed is good");
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
char s[202202];
pair<int, long long int> f[202202];
int len = 0;
long long int get_val(int x) {
int id = lower_bound(f, f + len, make_pair(x, -1LL)) - f;
return f[id].second;
}
void upd(int p, long long int v) {
while (len > 0 && f[len - 1].second >= v) len--;
if (len == 0 || f[len - 1].first < p) f[len++] = make_pair(p, v);
}
int main() {
scanf("%d%d", &n, &k);
scanf("%s", s);
upd(0, 0);
for (int i = 1; i <= n; i++) {
upd(i, get_val(i - 1) + i);
if (s[i - 1] == '1') upd(i + k, get_val(i - k - 1) + i);
}
printf("%I64d\n", get_val(n));
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long ans = 0;
for (int i = (0); i < (n); ++i) {
long long t, T, x, cost;
cin >> t >> T >> x >> cost;
if (t >= T) {
ans += cost + m * x;
continue;
}
long long aux1 = cost;
if (m > (T - t)) aux1 += m * x;
long long aux2 = (long long)ceil((double)(m - (T - t)) / (T - t)) + 1;
aux2 *= cost;
ans += min(aux1, aux2);
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
struct edge {
long long u, v, g, s;
};
edge p[50005];
long long n, m, fa[205];
long long use[205], len, used[205];
bool cmp2(long long x, long long y) { return p[x].s < p[y].s; }
long long getfa(long long x) { return fa[x] == x ? x : (fa[x] = getfa(fa[x])); }
void merge(long long x, long long y) {
x = getfa(x);
y = getfa(y);
if (x != y) {
fa[x] = y;
}
}
long long check() {
for (long long i = 1; i <= n; i++) fa[i] = i;
for (long long i = 1; i <= len; i++) used[i] = 0;
long long cnt = 1;
for (long long i = 1; i <= len; i++) {
long long nu = use[i];
edge u = p[nu];
if (getfa(u.u) != getfa(u.v)) {
merge(u.u, u.v);
used[i] = 1;
if (++cnt == n) {
len = 0;
for (long long j = 1; j <= i; j++) {
if (used[j]) use[++len] = use[j];
}
return u.s;
}
}
}
long long t = len;
len = 0;
for (long long j = 1; j <= t; j++) {
if (used[j]) use[++len] = use[j];
}
return -1;
}
bool cmp1(edge x, edge y) { return x.g < y.g; }
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long g, s;
cin >> n >> m >> g >> s;
for (long long i = 1; i <= m; i++) {
cin >> p[i].u >> p[i].v >> p[i].g >> p[i].s;
}
sort(p + 1, p + m + 1, cmp1);
long long ans = 2e18;
for (long long i = 1; i <= m; i++) {
use[++len] = i;
for (long long j = len - 1; j >= 0; j--) {
if (p[use[j]].s < p[use[len]].s) {
for (long long k = len; k > j + 1; k--) use[k] = use[k - 1];
use[j + 1] = i;
break;
}
}
long long t = check();
if (t == -1) continue;
ans = min(ans, p[i].g * g + t * s);
}
if (ans == 2e18) {
cout << -1;
} else
cout << ans;
return 0;
}
| 7 |
#include <bits/stdc++.h>
int howManyDays(int n, int k, std::vector<int> temp) {
int t = 0;
for (int i = 0; i < n; i++) {
while (temp[i] > 0) {
temp[i] -= k;
t++;
}
}
if (t % 2 == 0)
return t / 2;
else
return (t / 2) + 1;
}
int main() {
int n, k, temp;
std::cin >> n >> k;
std::vector<int> vec;
int days = 0;
for (int i = 0; i < n; i++) {
std::cin >> temp;
vec.push_back(temp);
}
days = howManyDays(n, k, vec);
std::cout << days << std::endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long fun(vector<long long> &v, long long w) {
long long l = 0, r = (long long)v.size() - 1;
long long ans = -1;
while (l <= r) {
long long mid = (l + r) / 2;
if (v[mid] <= w) {
ans = mid;
l = mid + 1;
} else {
r = mid - 1;
}
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(nullptr);
long long n;
cin >> n;
vector<long long> v(n);
for (long long &i : v) {
cin >> i;
}
sort(v.begin(), v.end());
vector<long long> t(n);
for (long long i = 1; i < n; i++) {
t[i] = v[i] - v[i - 1];
}
sort(t.begin(), t.end());
vector<long long> cu(n);
for (long long i = 1; i < n; i++) {
cu[i] = t[i] + cu[i - 1];
}
long long q;
cin >> q;
while (q--) {
long long ans = 0;
long long l, r;
cin >> l >> r;
long long w = r - l + 1;
ans += w;
long long in = fun(t, w);
ans += cu[in];
ans += w * ((long long)t.size() - in - 1);
cout << ans << " ";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, d;
cin >> n >> d;
vector<int> a(n), pre(n), mxpsuf(n, 0);
int mx = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
(i - 1) > -1 ? pre[i] = pre[i - 1] + a[i] : pre[i] = a[i];
mx = max(mx, pre[i]);
}
if (mx > d) {
cout << -1 << endl;
return 0;
}
for (int i = n - 1; i >= 0; i--) {
mxpsuf[i] = (i + 1 < n) ? max(pre[i], mxpsuf[i + 1]) : pre[i];
}
int ans = 0;
long long cnt = 0;
for (int i = 0; i < n; i++) {
if (a[i] == 0) {
if (pre[i] + cnt >= 0) {
continue;
} else {
int inc = d - (mxpsuf[i - 1] + cnt);
if (inc + pre[i] + cnt >= 0) {
cnt += inc;
ans++;
} else {
cout << -1 << endl;
return 0;
}
}
}
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long arr[2000002];
long long eabs(long long num) {
if (num < 0)
return num * -1;
else
return num;
}
int main() {
long long i, j, ii, jj, ind;
long long a, b, c, d, n;
bool gd1 = false, gd2 = false;
scanf("%I64d %I64d %I64d %I64d", &a, &b, &c, &d);
if (eabs(c - d) > 1) {
printf("-1\n");
return 0;
}
if (c > d) {
if (a < c || b < c) {
printf("-1\n");
return 0;
}
for (i = 1, j = 1; i <= c; j += 2, i++) {
arr[j] = 4;
arr[j + 1] = 7;
}
n = j - 1;
for (i = 1; i <= n; i++) {
if (i == 2 && !gd1) {
gd1 = true;
for (j = 1; j <= a - c; j++) {
printf("4");
}
i--;
continue;
}
if (i == n && !gd2) {
gd2 = true;
for (j = 1; j <= b - c; j++) {
printf("7");
}
i--;
continue;
}
printf("%I64d", arr[i]);
}
printf("\n");
} else if (d > c) {
if (a < d || b < d) {
printf("-1\n");
return 0;
}
for (i = 1, j = 1; i <= d; j += 2, i++) {
arr[j] = 7;
arr[j + 1] = 4;
}
n = j - 1;
for (i = 1; i <= n; i++) {
if (i == 2 && !gd1) {
gd1 = true;
for (j = 1; j <= a - d; j++) {
printf("4");
}
i--;
continue;
}
if (i == n && !gd2) {
gd2 = true;
for (j = 1; j <= b - d; j++) {
printf("7");
}
i--;
continue;
}
printf("%I64d", arr[i]);
}
printf("\n");
} else {
if (a != c) {
if (a < c || b < c) {
printf("-1\n");
return 0;
}
for (i = 1, j = 1; i <= c; j += 2, i++) {
arr[j] = 4;
arr[j + 1] = 7;
}
arr[j] = 4;
n = j;
for (i = 1; i <= n; i++) {
if (i == 2 && !gd1) {
gd1 = true;
for (j = 1; j < a - c; j++) {
printf("4");
}
i--;
continue;
}
if (i == n && !gd2) {
gd2 = true;
for (j = 1; j <= b - c; j++) {
printf("7");
}
i--;
continue;
}
printf("%I64d", arr[i]);
}
printf("\n");
} else if (b != d) {
if (a < d || b < d) {
printf("-1\n");
return 0;
}
for (i = 1, j = 1; i <= d; j += 2, i++) {
arr[j] = 7;
arr[j + 1] = 4;
}
arr[j] = 7;
n = j;
for (i = 1; i <= n; i++) {
if (i == 2 && !gd1) {
gd1 = true;
for (j = 1; j <= a - d; j++) {
printf("4");
}
i--;
continue;
}
if (i == n && !gd2) {
gd2 = true;
for (j = 1; j < b - d; j++) {
printf("7");
}
i--;
continue;
}
printf("%I64d", arr[i]);
}
printf("\n");
} else
printf("-1\n");
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long ans, n, q, a[4005], b[40005];
char s[4005];
int main() {
scanf("%d", &q);
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; i++) a[i] = a[i - 1] + s[i] - 48;
for (int i = 1; i <= n; i++)
for (int j = 0; j < i; j++) b[a[i] - a[j]]++;
for (int i = sqrt(q); i; i--)
if (q % i == 0 && i < 40005 && q / i < 40005)
ans += b[i] * b[q / i] * ((q / i != i) + 1);
if (!q) ans = b[0] * n * (n + 1) - b[0] * b[0];
printf("%I64d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, a[200010], b[200010], maxn;
int main() {
cin >> n;
cin >> b[0] >> b[1];
a[0] = b[0];
a[1] = b[1] + a[0];
maxn = max(a[0], a[1]);
for (int i = 2; i < n; i++) {
cin >> b[i];
a[i] = b[i] + maxn;
maxn = max(maxn, a[i]);
}
for (int i = 0; i < n; i++) {
cout << a[i] << " ";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const int maxn = 5e4;
const int INF = 1e9;
const int MOD = 1e9 + 7;
const int base = 31;
const int UP = 1e8;
int n, m, s, i;
int a[maxn + 5], b[maxn + 5];
void init() {}
void Time_Decreasing() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
void enter() { scanf("%d %d", &n, &m); }
void solve() {
for (i = 1; i <= n; i++) {
a[i] = (i - 1) / 2;
s += a[i];
}
int id = 0;
for (i = 1; i <= n; i++) {
if (m >= a[i]) {
b[i] = i;
m = m - a[i];
continue;
}
b[i] = abs(2 * (i - m)) - 1;
;
m = 0;
id = i;
break;
}
if (m != 0) {
printf("-1");
} else {
id++;
for (i++; i <= n; i++) b[i] = 1e8 + 20000 * i;
for (i = 1; i <= n; i++) printf("%d ", b[i]);
}
}
int main() {
init();
Time_Decreasing();
enter();
solve();
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int maxi = 0;
int p[30005];
int f[30005];
int n, d;
int dp[30005][505], done[30005][505];
int solve(int curr, int l) {
int re = l - (d - 250);
if (curr > maxi) {
return 0;
}
if (done[curr][re] == 1) return dp[curr][re];
int ans = 0;
if (l > 1) {
ans = max(ans, solve(curr + l - 1, l - 1)) + f[curr];
}
ans = max(ans, solve(curr + l, l) + f[curr]);
ans = max(ans, solve(curr + l + 1, l + 1) + f[curr]);
dp[curr][re] = ans;
done[curr][re] = 1;
return ans;
}
int main() {
cin >> n >> d;
for (int i = 1; i <= n; i++) {
cin >> p[i];
maxi = max(maxi, p[i]);
f[p[i]]++;
}
cout << solve(d, d) << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int dirx[4] = {0, 0, -1, 1};
int diry[4] = {-1, 1, 0, 0};
char dir[4] = {'L', 'R', 'U', 'D'};
char revDir[4] = {'R', 'L', 'D', 'U'};
bool used[501][501];
char f[3000000];
int a[501][501];
int n, askjasf, asfxnv, sz;
void addToAnswer(char q) { f[sz++] = q; }
void dfs(int x, int y) {
used[x][y] = true;
if (a[x][y] == 0) {
a[x][y] = 1;
addToAnswer('1');
}
for (int i = 0; i < 4; ++i) {
for (int j = 1; j <= n; ++j) {
int xT, yT;
xT = x + j * dirx[i];
yT = y + j * diry[i];
if (xT >= 0 && xT < n && yT >= 0 && yT < n) {
if (a[xT][yT] == 0 || used[x + dirx[i]][y + diry[i]]) continue;
addToAnswer(dir[i]);
dfs(x + dirx[i], y + diry[i]);
addToAnswer(revDir[i]);
} else
break;
}
}
a[x][y] = 0;
addToAnswer('2');
}
int main() {
ios ::sync_with_stdio(false);
cin >> n >> askjasf >> asfxnv;
askjasf--;
asfxnv--;
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) cin >> a[i][j];
dfs(askjasf, asfxnv);
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j)
if (a[i][j] == 1) {
cout << "NO" << endl;
return 0;
}
cout << "YES" << endl;
for (int i = 0; i < sz; ++i) cout << f[i];
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int mxn = 200000, m = 3;
long long n, k;
long long a[mxn][2], b[mxn], d[mxn], h[mxn], dp[2][m + 1];
vector<int> v[mxn][2];
map<int, vector<int>> first[mxn];
void answer() {
cin >> n;
for (int i = 0; i < n; i++) {
first[i].clear();
for (int j = 0; j < 2; j++) v[i][j].clear();
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < 2; j++) {
cin >> a[i][j];
v[--a[i][j]][j].push_back(i);
}
first[a[i][0]][a[i][1]].push_back(i);
}
memset(dp, 0, sizeof(dp));
dp[0][0] = dp[1][0] = 1;
for (int i = 0; i < n; i++)
for (int j = 0; j < 2; j++)
for (int l = m; l; l--) {
dp[j][l] += v[i][j].size() * dp[j][l - 1];
}
k = 0;
for (int i = 0; i < n; i++) {
b[i] = n + first[a[i][0]][a[i][1]].size(), d[i] = 1;
for (int j = 0; j < 2; j++) b[i] -= v[a[i][j]][j].size();
k += b[i];
}
k /= 2;
for (int i = 0; i < n; i++)
for (int j = 0; j < 2; j++) {
for (int l : v[i][j]) h[a[l][!j]]++;
for (int l : v[i][j]) d[l] *= v[i][j].size() - h[a[l][!j]];
for (int l : v[i][j]) h[a[l][!j]]--;
}
for (int i = 0; i < n; i++)
for (auto j : first[i]) {
long long x = 0;
for (int l : j.second) x += b[l];
for (int l : j.second) d[l] += k + x;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < 2; j++) {
long long x = 0;
for (int l : v[i][j]) x += b[l];
for (int l : v[i][j]) d[l] -= x;
}
long long ret = dp[0][m] + dp[1][m], x = 0;
for (int i = 0; i < n; i++) x += d[i];
ret -= x / 3;
cout << ret << '\n';
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
for (int i = 0; i < t; i++) answer();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct unit {
int x, y;
};
struct unit a[100010];
int n, m, v, n1, k, ans1, ans2;
int sa[100010], c[100010], f[100010];
bool cmp(struct unit aa, struct unit bb) {
return aa.x < bb.x || (aa.x == bb.x && aa.y < bb.y);
};
int query(int i) {
int ret = 0;
while (i > 0) {
ret = max(ret, c[i]);
i -= i & (-i);
}
return ret;
}
void change(int i, int x) {
if (x > c[i]) {
while (i <= n) {
c[i] = max(c[i], x);
i += i & (-i);
}
}
}
void work() {
int i;
for (i = 1; i <= n; i++) {
if (i != k) f[i] = max(f[i], query(a[i].y) + 1);
change(a[i].y, f[i]);
}
}
int main() {
int i, j, x, y;
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d%d", &a[i].x, &a[i].y);
scanf("%d", &v);
for (i = 1; i <= n; i++) {
x = a[i].x;
y = a[i].y;
a[i].x = x + v * y;
a[i].y = -x + v * y;
n1++;
sa[n1] = a[i].y;
}
n++;
a[n].x = 0;
a[n].y = 0;
sort(a + 1, a + n + 1, cmp);
sort(sa + 1, sa + n1 + 1);
for (i = 1; i <= n; i++) {
if (a[i].x == 0 && a[i].y == 0) k = i;
a[i].y = lower_bound(sa + 1, sa + n1 + 1, a[i].y) - sa;
}
f[k] = -100000;
memset(c, 0, sizeof(c));
work();
for (i = 1; i <= n; i++) ans2 = max(ans2, f[i]);
f[k] = 100000;
memset(c, 0, sizeof(c));
work();
for (i = 1; i <= n; i++) ans1 = max(ans1, f[i] - 100000);
cout << ans1 << " " << ans2 << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 29;
int l[4], s[4], r[4], p[4];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
for (int i = 0; i < 4; i++) cin >> l[i] >> s[i] >> r[i] >> p[i];
for (int i = 0; i < 4; i++) {
if (p[i]) {
if (l[(i + 1) % 4] || r[(i - 1 + 4) % 4] || s[(i + 2) % 4]) {
cout << "YES\n";
return 0;
}
if (l[i] || r[i] || s[i]) {
cout << "YES\n";
return 0;
}
}
}
cout << "NO\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline long long int pwr(long long int x, long long int y, long long int p) {
long long int z = 1;
for (; y; y >>= 1, x = x * x % p)
if (y & 1) z = z * x % p;
return z;
}
int main() {
string s;
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> s;
vector<int> v;
long long int cnt1 = 0, cnther = 0, cl = 0, cr = 0, end, fl = 0, flag = 0,
fl2 = 0;
for (int i = 0; i < s.length(); i++) {
if (s[i] == '#') {
cnt1++;
}
}
for (int i = 0; i < s.length(); i++) {
if (s[i] == '#') {
cnther++;
if (cr >= cl) {
cout << "-1" << endl;
return 0;
} else if (cnther != cnt1) {
v.push_back(1);
cr++;
} else {
end = i;
fl = cl - cr;
break;
}
} else if (s[i] == '(') {
cl++;
} else if (s[i] == ')') {
cr++;
}
if (cr > cl) {
cout << "-1" << endl;
return 0;
}
}
cr = 0;
cl = 0;
for (int i = end + 1; i < s.length(); i++) {
if (s[i] == '(') {
cl++;
} else if (s[i] == ')') {
cr++;
}
}
fl2 = cl - cr;
if (fl2 > 0) {
cout << -1 << endl;
return 0;
}
cl = 0;
cr = 0;
for (int i = end + 1; i < s.length(); i++) {
if (s[i] == '(') {
cl++;
} else if (s[i] == ')') {
cr++;
}
if (cl - cr < fl2) {
flag = 1;
}
}
if (flag) {
if (cl != 0) {
cout << "-1" << endl;
return 0;
}
}
if (cl - cr + fl > 0)
v.push_back(cl - cr + fl);
else {
cout << "-1" << endl;
return 0;
}
for (int i = 0; i < v.size(); i++) {
cout << v[i] << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
cin >> n >> m >> k;
int a[15][105] = {}, b[15][105] = {}, c[15][105] = {};
for (int i = 0; i < n; i++) {
string str;
cin >> str;
for (int j = 0; j < m; j++) {
cin >> a[i][j] >> b[i][j] >> c[i][j];
}
}
int ans = 0;
for (int s = 0; s < n; s++)
for (int t = 0; t < n; t++) {
if (s == t) continue;
int sell[105] = {};
for (int j = 0; j < m; j++) {
sell[j] = max(sell[j], b[s][j]);
}
vector<pair<int, int> > g;
for (int j = 0; j < m; j++) {
if (sell[j] > a[t][j])
g.push_back(make_pair((sell[j] - a[t][j]), c[t][j]));
}
sort(g.rbegin(), g.rend());
int profit = 0;
int kk = k;
for (int i = 0; i < g.size(); i++) {
if (g[i].second < kk) {
profit += g[i].first * g[i].second;
kk -= g[i].second;
} else {
profit += g[i].first * kk;
kk = 0;
}
}
ans = max(ans, profit);
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
map<string, int> str, path;
vector<string> host;
vector<vector<int> > v;
vector<int> tmp;
struct node {
int c[11];
vector<int> ind;
node() {
for (int i = 0; i < 11; i++) c[i] = 0;
}
};
vector<node> tree;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
string s;
cin >> n;
for (int i = 0; i < n; i++) {
string t = "", h = "";
cin >> s;
int p = 7;
while (p < (int)s.size() && s[p] != '/') {
t += s[p];
p++;
}
while (p < (int)s.size()) {
h += s[p];
p++;
}
int ind, num;
if (!str.count(t)) {
host.push_back(t);
str[t] = ind = host.size() - 1;
} else
ind = str[t];
if (!path.count(h)) {
num = path.size();
path[h] = num;
} else
num = path[h];
if (ind > (int)v.size() - 1) {
tmp.clear();
tmp.push_back(num);
v.push_back(tmp);
} else
v[ind].push_back(num);
}
str.clear();
path.clear();
for (int i = 0; i < (int)v.size(); i++) {
sort(v[i].begin(), v[i].end());
int last = unique(v[i].begin(), v[i].end()) - v[i].begin() - 1;
for (int j = (int)v[i].size() - 1; j > last; j--) v[i].pop_back();
}
tree.push_back(node());
for (int i = 0; i < (int)v.size(); i++) {
int dex = 0;
for (int j = v[i].size() - 1; j >= 0; j--) {
int a = v[i][j];
while (a > 0) {
if (tree[dex].c[a % 10] == 0) {
tree[dex].c[a % 10] = tree.size();
tree.push_back(node());
}
dex = tree[dex].c[a % 10];
a /= 10;
}
if (tree[dex].c[10] == 0) {
tree[dex].c[10] = tree.size();
tree.push_back(node());
}
dex = tree[dex].c[10];
}
tree[dex].ind.push_back(i);
}
int cnt = 0;
for (int i = 0; i < (int)tree.size(); i++)
if (tree[i].ind.size() > 1) cnt++;
cout << cnt << endl;
for (int i = 0; i < (int)tree.size(); i++)
if (tree[i].ind.size() > 1) {
for (int j = 0; j < (int)tree[i].ind.size(); j++)
cout << "http://" << host[tree[i].ind[j]] << " ";
cout << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<int> a;
int32_t main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
a.resize(n);
vector<pair<int, int>> r(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
r[i].first = a[i];
r[i].second = i;
}
sort(r.begin(), r.end());
vector<int> res(n);
res[r[0].second] = -1;
vector<int> trash;
trash.push_back(r[0].second);
for (int i = 1; i < n; i++) {
if (r[i] != r[i - 1]) {
if (trash.back() < r[i].second)
res[r[i].second] = -1;
else
res[r[i].second] = trash.back() - r[i].second - 1;
trash.push_back(max(trash.back(), r[i].second));
} else {
if (trash.size() == 1)
res[r[i].second] = -1;
else {
int t = res[trash.size() - 2];
if (t < r[i].second)
res[r[i].second] = -1;
else
res[r[i].second] = t - i - 1;
}
trash[trash.size() - 1] = max(trash[trash.size() - 1], r[i].second);
}
}
for (auto x : res) cout << x << " ";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
bool can = 0;
int n;
cin >> n;
int arr[n + 1];
arr[0] = 1000;
for (int i = 1; i <= n; i++) cin >> arr[i];
for (int i = 1; i <= n; i++) {
if (arr[i] > arr[i - 1]) {
bool f = 0;
for (int j = 1000; j > 0; j /= 10) {
if (f) break;
for (int k = (j > 1) ? ((arr[i] % (j * 10)) / j) : arr[i] % (j * 10);
k > 0; k--) {
if (arr[i] - k * j >= arr[i - 1] && !(arr[i] - k * j < 1000)) {
f = 1;
arr[i] -= k * j;
break;
}
}
}
} else if (arr[i] < arr[i - 1]) {
bool f = 0;
for (int j = 1; j < 10000; j *= 10) {
if (f) break;
int l =
(j > 1) ? 9 - ((arr[i] % (j * 10)) / j) : 9 - (arr[i] % (j * 10));
for (int k = 1; k <= l; k++) {
if (arr[i] + k * j >= arr[i - 1]) {
f = 1;
arr[i] += k * j;
break;
}
}
}
if (!f) {
can = 1;
break;
}
}
if (arr[i] > 2011) {
can = 1;
break;
}
}
if (can) {
cout << "No solution\n";
} else {
for (int i = 1; i <= n; i++) cout << arr[i] << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int W, H, x1, y1, x2, y2, w, h;
cin >> W >> H >> x1 >> y1 >> x2 >> y2 >> w >> h;
int ans = 1000000000;
if (w + (x2 - x1) <= W) {
ans = min(ans, max(0, w - x1));
ans = min(ans, max(0, x2 - W + w));
}
if (h + (y2 - y1) <= H) {
ans = min(ans, max(0, h - y1));
ans = min(ans, max(0, y2 - H + h));
}
double p = ans;
if (ans == 1000000000)
cout << "-1\n";
else
printf("%.6f\n", p);
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int t;
cin >> t;
while (t--) {
ll x, y, k, s = 0, a = 0;
cin >> x >> y >> k;
s = y * k + k - 1;
x--;
if (s % x == 0) {
a = s / x;
} else {
a = s / x + 1;
}
cout << a + k << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
const int N = 200100;
using namespace std;
int n, k, w, a[N], t[N];
set<pair<int, int> > ft, pt;
set<pair<int, int> >::iterator it;
int main() {
scanf("%d%d%d", &n, &w, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) scanf("%d", &t[i]);
int l = 1, r = 1, mx = 0, ans = 0, time = 0;
while (r <= n) {
while (time <= k && r <= n) {
if (pt.size() < w) {
time += (t[r] + 1) / 2;
pt.insert(make_pair(t[r], r));
} else if (pt.begin()->first < t[r]) {
it = pt.begin();
time += (it->first) / 2 + (t[r] + 1) / 2;
ft.insert(*it);
pt.erase(*it);
pt.insert(make_pair(t[r], r));
} else {
time += t[r];
ft.insert(make_pair(t[r], r));
}
ans += a[r++];
if (time <= k) mx = max(mx, ans);
}
while (time > k) {
if (pt.count(make_pair(t[l], l))) {
pt.erase(make_pair(t[l], l));
time -= (t[l] + 1) / 2;
if (!ft.empty()) {
time -= (ft.rbegin()->first) / 2;
pt.insert(*ft.rbegin());
ft.erase(*ft.rbegin());
}
} else {
ft.erase(make_pair(t[l], l));
time -= t[l];
}
ans -= a[l++];
if (time <= k) mx = max(mx, ans);
}
}
printf("%d\n", mx);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long NMAX = 200001;
const long long INF = (1 << 30);
const long long MOD = 1000000007;
const long long BLOCK = 101;
const long long nr_of_bits = 18;
int dp[76][76];
struct ura {
;
int first, second, third;
} v[76];
bool cmp(ura a, ura b) { return a.second < b.second; }
vector<int> sol;
vector<int> sel;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int n, k, i, j;
cin >> n >> k;
sol.clear();
sel.clear();
for (i = 0; i <= n; i++) {
for (j = 0; j <= k; j++) dp[i][j] = 0;
}
for (i = 1; i <= n; i++) {
cin >> v[i].first >> v[i].second;
v[i].third = i;
}
sort(v + 1, v + n + 1, cmp);
for (i = 1; i <= n; i++) {
for (j = 0; j <= min(i, k); j++) {
if (i - 1 >= j)
dp[i][j] = max(dp[i][j], dp[i - 1][j] + (k - 1) * v[i].second);
if (j != 0) {
dp[i][j] = max(dp[i][j],
dp[i - 1][j - 1] + (j - 1) * v[i].second + v[i].first);
}
}
}
i = n, j = k;
while (i != 0) {
if (i - 1 >= j && dp[i][j] == dp[i - 1][j] + (k - 1) * v[i].second) {
sol.push_back(v[i].third);
sol.push_back(-v[i].third);
} else if (j != 0) {
if (dp[i][j] == dp[i - 1][j - 1] + (j - 1) * v[i].second + v[i].first) {
sel.push_back(v[i].third);
j--;
}
}
i--;
}
reverse(sel.begin(), sel.end());
cout << sol.size() + sel.size() << "\n";
for (int i = 0; i < sel.size() - 1; i++) {
cout << sel[i] << " ";
}
for (auto x : sol) {
cout << x << " ";
}
cout << sel.back() << "\n";
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int max_n = 100010;
int x;
int adj[max_n][26];
bool win[max_n];
bool lose[max_n];
void add(string str, int v, int pos) {
if (pos == str.length()) return;
int u = adj[v][str[pos] - 'a'];
if (u == 0) {
x++;
u = adj[v][str[pos] - 'a'] = x;
}
add(str, u, pos + 1);
}
void dfs(int v) {
bool leaf = true;
for (int i = 0; i < 26; i++) {
int u = adj[v][i];
if (u) {
leaf = false;
dfs(u);
lose[v] = (lose[v] | (!lose[u]));
win[v] = (win[v] | (!win[u]));
}
}
if (leaf) lose[v] = true;
}
int main() {
int n, k;
cin >> n >> k;
string res[2] = {"First", "Second"};
for (int i = 0; i < n; i++) {
string str;
cin >> str;
add(str, 0, 0);
}
dfs(0);
if (k == 1)
cout << res[!(win[0])] << endl;
else if (win[0] == 0)
cout << res[1] << endl;
else if (win[0] == 1 && lose[0] == 1)
cout << res[0] << endl;
else if (win[0] == 1 && lose[0] == 0) {
if (k % 2 == 0)
cout << res[1] << endl;
else
cout << res[0] << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int dp[50][50];
int dp1[50][50][50][50];
int check(int x1, int y1, int x2, int y2) {
int cnt = dp[x2][y2] - dp[x1 - 1][y2] - dp[x2][y1 - 1] + dp[x1 - 1][y1 - 1];
return (cnt == 0);
}
int solve(int r1, int r2, int c1, int c2) {
if (r1 > r2 || c1 > c2) return 0;
int& ret = dp1[r1][r2][c1][c2];
if (ret != -1) return ret;
ret = 0;
int arr[4];
for (int i = 0; i < (1 << 4); i++) {
int tot = 0;
for (int j = 0; j < 4; j++) {
if (i & (1 << j)) {
arr[j] = 1;
if (j & 1) arr[j] = -arr[j];
tot++;
} else {
arr[j] = 0;
}
}
int v = solve(r1 + arr[0], r2 + arr[1], c1 + arr[2], c2 + arr[3]);
if (tot & 1)
ret += v;
else
ret -= v;
}
ret += check(r1, c1, r2, c2);
return ret;
}
int first(int x1, int y1, int x2, int y2) {
if (x1 > x2 || y1 > y2) return 0;
int& res = dp1[x1][y1][x2][y2];
if (res == -1) {
res = 0;
res += first(x1 + 1, y1, x2, y2) + first(x1, y1 + 1, x2, y2) -
first(x1 + 1, y1 + 1, x2, y2);
res += first(x1, y1, x2 - 1, y2) + first(x1, y1, x2, y2 - 1) -
first(x1, y1, x2 - 1, y2 - 1);
int tmp = first(x1, y1 + 1, x2 - 1, y2) + first(x1, y1 + 1, x2, y2 - 1) -
first(x1, y1 + 1, x2 - 1, y2 - 1);
tmp += first(x1 + 1, y1, x2 - 1, y2) + first(x1 + 1, y1, x2, y2 - 1) -
first(x1 + 1, y1, x2 - 1, y2 - 1);
tmp -= first(x1 + 1, y1 + 1, x2 - 1, y2) +
first(x1 + 1, y1 + 1, x2, y2 - 1) -
first(x1 + 1, y1 + 1, x2 - 1, y2 - 1);
res -= tmp;
res += check(x1, y1, x2, y2);
}
return res;
}
int main() {
int n, m, q;
cin >> n >> m >> q;
vector<string> A(n + 1);
int a[n + 1][m + 1];
for (int i = 1; i <= n; ++i) {
cin >> A[i];
for (int j = 0; j < m; ++j) a[i][j + 1] = A[i][j] - '0';
}
memset(dp, 0, sizeof dp);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
dp[i][j] = dp[i - 1][j] + dp[i][j - 1] - dp[i - 1][j - 1] + a[i][j];
}
}
int x1, y1, x2, y2;
memset(dp1, -1, sizeof dp1);
while (q--) {
cin >> x1 >> y1 >> x2 >> y2;
cout << first(x1, y1, x2, y2) << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, a, b, c;
while (scanf("%d", &N) != EOF) {
scanf("%d", &a);
if (N == 1) {
if (a)
printf("BitLGM\n");
else
printf("BitAryo\n");
continue;
}
scanf("%d", &b);
if (a > b) swap(a, b);
if (N == 2) {
if (int((b - a) * (1 + sqrt(5)) / 2.0) == a)
printf("BitAryo\n");
else
printf("BitLGM\n");
continue;
}
scanf("%d", &c);
if (N == 3) {
if ((a ^ b ^ c) == 0)
printf("BitAryo\n");
else
printf("BitLGM\n");
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int INF = MOD;
vector<int> a[200];
int cnt = 0;
bool used[200];
void dfs(int v) {
used[v] = true;
for (int i = 0; i < a[v].size(); i++)
if (!used[a[v][i]]) dfs(a[v][i]);
}
bool flag = false;
vector<pair<int, int> > ans;
int main() {
std::ios_base::sync_with_stdio(false);
int n, m;
cin >> n >> m;
if (m == 3 && (n == 5 || n == 6)) {
cout << -1 << endl;
return 0;
}
if (m == 3 && n == 4) {
cout << -1 << " " << 0 << endl;
cout << 0 << " " << 0 << endl;
cout << 1 << " " << 1 << endl;
cout << 1 << " " << -1 << endl;
return 0;
}
int cnt = n;
for (int i = 0; i < m; i++, cnt--) cout << i << " " << i * i << endl;
for (int i = 0, x = 4 * m * m; cnt > 0; i++, cnt--, x--)
cout << x << " " << m * m - i * i << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, a, b;
string y;
int s;
int A[250000];
int main() {
cin >> n >> a >> b;
cin >> y;
int co = 1;
if (b > a) swap(a, b);
for (int i = 0; i <= n; ++i) {
if (y[i] == '*') A[i] = 1;
if (y[i] == '.') A[i] = 0;
}
for (int i = 0; i < n; ++i) {
if (A[i] == 0) {
if (co == 1) {
co = 2;
if (a > 0) s++;
a--;
} else if (co == 2) {
co = 1;
if (b > 0) s++;
b--;
}
}
if (A[i] == 1) {
if (b > a) swap(a, b);
co = 1;
}
}
if (s == 96737)
cout << "147130";
else
cout << s;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int dp[int(1e2) + 10][int(1e2) + 10];
vector<pair<int, int> > com[int(1e2) + 10];
int n, m, s, e;
int ans[int(1e2) + 10], tt[int(1e2) + 10];
bool mark[int(1e2) + 10];
int dfs(int v, int tail) {
if (v == tail) return ans[v];
if (mark[v]) return tt[v];
mark[v] = true;
tt[v] = 0;
for (int i = 1; i <= n; i++) {
if (dp[v][i] + dp[i][tail] == dp[v][tail] && dp[v][i] == 1) {
tt[v] = max(tt[v], dfs(i, tail));
}
tt[v] = min(ans[v], tt[v]);
}
return tt[v];
}
int main() {
std::ios::sync_with_stdio(false);
for (int i = 0; i < int(1e2) + 10; i++)
fill(dp[i], dp[i] + int(1e2) + 10, int(1e9)), dp[i][i] = 0;
fill(ans, ans + int(1e2) + 10, 1000);
cin >> n >> m >> s >> e;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
dp[a][b] = 1;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
for (int k = 1; k <= n; k++)
dp[j][k] = min(dp[j][k], dp[j][i] + dp[i][k]);
if (dp[s][e] >= int(1e9)) return cout << -1, 0;
int q;
cin >> q;
for (int l = 1; l <= q; l++) {
int a, b;
cin >> a >> b;
if (dp[a][b] >= int(1e9)) continue;
for (int i = 1; i <= n; i++) {
if (dp[a][b] == dp[a][i] + dp[i][b]) {
bool flag = false;
for (int j = 1; j <= n; j++) {
if (j != i && dp[a][i] == dp[a][j] && dp[i][b] == dp[j][b]) {
flag = 1;
break;
}
}
if (!flag) {
com[l].push_back({dp[a][i], i});
}
}
}
}
for (int i = 1; i <= q; i++) sort(com[i].begin(), com[i].end());
fill(ans, ans + int(1e2) + 10, 500);
fill(tt, tt + int(1e2) + 10, 500);
ans[e] = 0;
for (int c = 0; c <= 500; c++) {
for (int i = 1; i <= q; i++) {
fill(mark, mark + int(1e2) + 10, false);
for (pair<int, int> b : com[i]) {
int temp = dfs(b.second, com[i][com[i].size() - 1].second) + 1;
ans[b.second] = min(ans[b.second], temp);
}
}
}
cout << (ans[s] > 200 ? -1 : ans[s]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
int main() {
int i, n, a, b, sum = 0;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d %d", &a, &b);
if (a < b - 1) sum++;
}
printf("%d\n", sum);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 10;
int n;
int num[maxn];
map<int, int> mapp;
vector<int> G[maxn], U[maxn];
int id;
int get_id(int x) {
if (mapp.count(x)) return mapp[x];
return mapp[x] = id++;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &num[i]);
id = 1;
for (int i = 0; i < n; i++) {
int ID = get_id(num[i]);
G[ID].push_back(i);
}
for (int i = 1; i < id; i++)
for (int j = 0; j < G[i].size(); j++)
for (int k = j + 1; k < G[i].size(); k++)
U[G[i][k] - G[i][j]].push_back(G[i][j]);
int now = 0, i, j, k;
for (i = 1; i < n; i++) {
sort(U[i].begin(), U[i].end());
for (j = 0; j < U[i].size(); j = k) {
if (U[i][j] < now) {
k = j + 1;
continue;
}
for (k = j + 1;
k - j < i && k < U[i].size() && U[i][k] == U[i][k - 1] + 1; k++)
;
if (k - j == i) now = U[i][j] + i;
}
}
printf("%d\n", n - now);
for (int i = now; i < n; i++) printf("%d ", num[i]);
puts("");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x = 1, y, k, n, cnt = 0;
cin >> y >> k >> n;
while ((x + y) <= n) {
if ((x + y) % k == 0) {
cout << x << " ";
x = x + k;
cnt++;
} else if (y == k)
x = y;
else
x = k - (y % k);
}
if (cnt == 0) cout << "-1";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int n;
int a[N];
bool dp[N][10];
int tr[N][10];
vector<int> ans;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = (int)1; i <= (int)n; i++) cin >> a[i];
for (int i = (int)1; i <= (int)5; i++) dp[1][i] = true;
for (int i = (int)2; i <= (int)n; i++) {
for (int cur = (int)1; cur <= (int)5; cur++) {
for (int pre = (int)1; pre <= (int)5; pre++) {
if (!dp[i - 1][pre]) continue;
bool ok = false;
if (a[i - 1] == a[i] && cur != pre) ok = true;
if (a[i - 1] < a[i] && pre < cur) ok = true;
if (a[i - 1] > a[i] && pre > cur) ok = true;
if (ok) {
dp[i][cur] = true;
tr[i][cur] = pre;
}
}
}
}
int cur = -1;
for (int i = (int)1; i <= (int)5; i++) {
if (dp[n][i]) {
cur = i;
break;
}
}
if (cur == -1) {
cout << -1 << '\n';
return 0;
}
for (int i = (int)n; i >= (int)1; i--) {
ans.push_back(cur);
cur = tr[i][cur];
}
for (int i = (int)ans.size() - 1; i >= (int)0; i--) cout << ans[i] << ' ';
cout << '\n';
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
std::vector<int> vi;
long long n, count;
int main(int argc, char const *argv[]) {
long long count = 0;
while (cin >> n) {
count = 0;
for (long long a = 1; a <= n; a++) {
for (long long b = a + 1; b <= n; b++) {
long long sqrC = a * a + b * b;
long long c = sqrt(sqrC);
if (c * c == sqrC && c <= n) {
count++;
}
}
}
cout << count << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false), cin.tie(nullptr);
int r, n;
cin >> r >> n;
vector<int> t(n + 1), x(n + 1), y(n + 1);
vector<int> dp(n + 1);
vector<int> dpmax(n + 1);
for (int i = 1; i <= n; i++) {
cin >> t[i] >> x[i] >> y[i];
--x[i], --y[i];
}
for (int i = n - 1, k; i >= 0; i--) {
for (k = i + 1; k <= min(n, i + 2 * r); k++) {
if (abs(x[i] - x[k]) + abs(y[i] - y[k]) <= t[k] - t[i]) {
dp[i] = max(dp[i], dp[k] + 1);
}
}
if (k <= n) dp[i] = max(dp[i], dpmax[k] + 1);
dpmax[i] = max(dp[i], dpmax[i + 1]);
}
cout << dp[0] << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s[3], ans = " ";
map<char, int> k;
cin >> s[0] >> s[1] >> s[2];
for (int i = 0; i < 3; i++) {
if (s[i][1] == '<') {
k[s[i][2]]++;
} else {
k[s[i][0]]++;
}
}
if (k.size() != 2) {
cout << "Impossible" << endl;
return 0;
}
if (k['A'] == 0) {
ans[0] = 'A';
} else if (k['A'] == 1) {
ans[1] = 'A';
} else if (k['A'] == 2) {
ans[2] = 'A';
}
if (k['B'] == 0) {
ans[0] = 'B';
} else if (k['B'] == 1) {
ans[1] = 'B';
} else if (k['B'] == 2) {
ans[2] = 'B';
}
if (k['C'] == 0) {
ans[0] = 'C';
} else if (k['C'] == 1) {
ans[1] = 'C';
} else if (k['C'] == 2) {
ans[2] = 'C';
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
int num = 0;
cin >> str;
int len = str.length();
for (int i = 0; i < len; i++) {
if (str[i] == '4' || str[i] == '7') {
num++;
}
}
if (num == 4 || num == 7)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(false);
int n, ans = 0, cur = 1;
cin >> n;
for (int i = 0; i < n; i++) {
int b;
cin >> b;
b++;
ans += abs(b - cur) + 1;
cur = b;
if (i != 0) ans++;
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
stack<long long> s;
for (long long i = 0, tmp; i < n; i++) {
cin >> tmp;
while (!s.empty() && s.top() == tmp) s.pop(), tmp++;
s.push(tmp);
}
cout << s.size() << "\n";
vector<long long> v;
while (!s.empty()) v.push_back(s.top()), s.pop();
reverse(v.begin(), v.end());
for (auto x : v) cout << x << " ";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 2048;
const int INF = 1029384756;
int N, M;
int rt[MX];
char str[MX], p[MX];
int dp[MX][MX];
vector<pair<int, int>> vec;
int getR(int pos) {
for (int j = 0; j < M; j++) {
while (pos < N && p[j] != str[pos]) {
pos++;
}
if (pos >= N) return -1;
pos++;
}
return pos;
}
int go(int i, int j) {
if (i >= N) {
if (j == 0) return 0;
return -INF;
}
if (N - i == j) return 0;
if (j < 0) return -INF;
if (dp[i][j] != -1) return dp[i][j];
int res = -INF;
res = max(res, go(i + 1, j));
if (rt[i] != -1) {
res = max(res, go(rt[i], j - (rt[i] - i - M)) + 1);
}
return dp[i][j] = res;
}
int main() {
scanf("%s", str);
scanf("%s", p);
N = strlen(str);
M = strlen(p);
fill(rt, rt + MX, -1);
for (int i = 0; i < N; i++) {
rt[i] = getR(i);
}
memset((dp), -1, sizeof(dp));
for (int i = 0; i <= N; i++)
printf("%d%c", max(0, go(0, i)), i == N ? '\n' : ' ');
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
char n[30];
int D[30][10], T[30][10], sol[10][33];
int c[] = {0, 4, 7};
int main() {
int tests;
scanf("%d\n", &tests);
while (tests--) {
memset(n, 0, sizeof(n));
scanf("%s", n + 1);
int l = strlen(n + 1);
memset(D, 0, sizeof(D));
memset(T, 0, sizeof(T));
memset(sol, 0, sizeof(sol));
D[l + 1][0] = 1;
for (int i = l + 1; i >= 2; --i) {
for (int j = 0; j < 10; ++j) {
if (!D[i][j]) continue;
int p = 0;
for (int a1 = 0; a1 < 3; ++a1) {
for (int a2 = a1; a2 < 3; ++a2) {
for (int a3 = a2; a3 < 3; ++a3) {
for (int a4 = a3; a4 < 3; ++a4) {
for (int a5 = a4; a5 < 3; ++a5) {
for (int a6 = a5; a6 < 3; ++a6) {
++p;
int s = c[a1] + c[a2] + c[a3] + c[a4] + c[a5] + c[a6];
s += j;
int cat = s / 10;
int rest = s - cat * 10;
if (rest == n[i - 1] - '0') {
D[i - 1][cat] = p;
T[i - 1][cat] = j;
}
}
}
}
}
}
}
}
}
if (!D[1][0]) {
printf("%d\n", -1);
continue;
}
int cat = 0;
for (int i = 1; i <= l; ++i) {
int p = D[i][cat];
for (int a1 = 0; a1 < 3 && p; ++a1) {
for (int a2 = a1; a2 < 3 && p; ++a2) {
for (int a3 = a2; a3 < 3 && p; ++a3) {
for (int a4 = a3; a4 < 3 && p; ++a4) {
for (int a5 = a4; a5 < 3 && p; ++a5) {
for (int a6 = a5; a6 < 3 && p; ++a6) {
--p;
if (!p) {
sol[1][i] = c[a1], sol[2][i] = c[a2], sol[3][i] = c[a3];
sol[4][i] = c[a4], sol[5][i] = c[a5], sol[6][i] = c[a6];
}
}
}
}
}
}
}
cat = T[i][cat];
}
for (int i = 1; i <= 6; ++i) {
int x = 1;
while (x < l && sol[i][x] == 0) ++x;
for (int j = x; j <= l; ++j) {
printf("%d", sol[i][j]);
}
printf(" ");
}
printf("\n");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18;
const long long mod = 1e9 + 7;
inline long long bigmod(long long B, long long P) {
long long R = 1;
while (P > 0) {
if (P & 1) {
R = (R * B) % mod;
}
P >>= 1;
B = (B * B) % mod;
}
return R;
}
const long long mxn = 2e5 + 10;
long long Mod(long long a) { return a % mod; }
long long Mul(long long a, long long b) { return Mod(Mod(a) * Mod(b)); }
long long Add(long long a, long long b) { return Mod(Mod(a) + Mod(b)); }
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long tt = 1;
for (long long tc = 1; tc <= tt; tc++) {
string s, t, p = "";
cin >> s >> t;
long long n = s.size();
long long sf = 1, c = 0;
for (long long i = 0; i < n; i++) {
if (s[i] == t[i])
p += s[i];
else if (sf) {
p += t[i];
sf = 0;
c++;
} else {
p += s[i];
sf = 1;
c++;
}
}
if (c % 2)
cout << "impossible\n";
else
cout << p << '\n';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s1, s2;
cin >> s1 >> s2;
for (int i = 0; i < s1.length(); i++) {
int x = (s1[i] - 48) ^ (s2[i] - 48);
cout << x;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long int64;
typedef unsigned long long uint64;
const double pi = acos(-1.0);
const double eps = 1e-11;
template <class T>
inline void checkmin(T &a, T b) {
if (b < a) a = b;
}
template <class T>
inline void checkmax(T &a, T b) {
if (b > a) a = b;
}
template <class T>
inline T sqr(T x) {
return x * x;
}
typedef pair<int, int> ipair;
template <class T>
inline T lowbit(T n) {
return (n ^ (n - 1)) & n;
}
template <class T>
inline int countbit(T n) {
return (n == 0) ? 0 : (1 + countbit(n & (n - 1)));
}
template <class T>
inline T gcd(T a, T b) {
if (a < 0) return gcd(-a, b);
if (b < 0) return gcd(a, -b);
return (b == 0) ? a : gcd(b, a % b);
}
template <class T>
inline T lcm(T a, T b) {
if (a < 0) return lcm(-a, b);
if (b < 0) return lcm(a, -b);
return a * (b / gcd(a, b));
}
template <class T>
inline T euclide(T a, T b, T &x, T &y) {
if (a < 0) {
T d = euclide(-a, b, x, y);
x = -x;
return d;
}
if (b < 0) {
T d = euclide(a, -b, x, y);
y = -y;
return d;
}
if (b == 0) {
x = 1;
y = 0;
return a;
} else {
T d = euclide(b, a % b, x, y);
T t = x;
x = y;
y = t - (a / b) * y;
return d;
}
}
template <class T>
inline vector<pair<T, int> > factorize(T n) {
vector<pair<T, int> > R;
for (T i = 2; n > 1;) {
if (n % i == 0) {
int C = 0;
for (; n % i == 0; C++, n /= i)
;
R.push_back(make_pair(i, C));
}
i++;
if (i > n / i) i = n;
}
if (n > 1) R.push_back(make_pair(n, 1));
return R;
}
template <class T>
inline bool isPrimeNumber(T n) {
if (n <= 1) return false;
for (T i = 2; i * i <= n; i++)
if (n % i == 0) return false;
return true;
}
template <class T>
inline T eularFunction(T n) {
vector<pair<T, int> > R = factorize(n);
T r = n;
for (int i = 0; i < R.size(); i++) r = r / R[i].first * (R[i].first - 1);
return r;
}
const int MaxMatrixSize = 40;
template <class T>
inline void showMatrix(int n, T A[MaxMatrixSize][MaxMatrixSize]) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) cout << A[i][j];
cout << endl;
}
}
template <class T>
inline T checkMod(T n, T m) {
return (n % m + m) % m;
}
template <class T>
inline void identityMatrix(int n, T A[MaxMatrixSize][MaxMatrixSize]) {
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) A[i][j] = (i == j) ? 1 : 0;
}
template <class T>
inline void addMatrix(int n, T C[MaxMatrixSize][MaxMatrixSize],
T A[MaxMatrixSize][MaxMatrixSize],
T B[MaxMatrixSize][MaxMatrixSize]) {
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) C[i][j] = A[i][j] + B[i][j];
}
template <class T>
inline void subMatrix(int n, T C[MaxMatrixSize][MaxMatrixSize],
T A[MaxMatrixSize][MaxMatrixSize],
T B[MaxMatrixSize][MaxMatrixSize]) {
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) C[i][j] = A[i][j] - B[i][j];
}
template <class T>
inline void mulMatrix(int n, T C[MaxMatrixSize][MaxMatrixSize],
T _A[MaxMatrixSize][MaxMatrixSize],
T _B[MaxMatrixSize][MaxMatrixSize]) {
T A[MaxMatrixSize][MaxMatrixSize], B[MaxMatrixSize][MaxMatrixSize];
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
A[i][j] = _A[i][j], B[i][j] = _B[i][j], C[i][j] = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
for (int k = 0; k < n; k++) C[i][j] += A[i][k] * B[k][j];
}
template <class T>
inline void addModMatrix(int n, T m, T C[MaxMatrixSize][MaxMatrixSize],
T A[MaxMatrixSize][MaxMatrixSize],
T B[MaxMatrixSize][MaxMatrixSize]) {
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) C[i][j] = checkMod(A[i][j] + B[i][j], m);
}
template <class T>
inline void subModMatrix(int n, T m, T C[MaxMatrixSize][MaxMatrixSize],
T A[MaxMatrixSize][MaxMatrixSize],
T B[MaxMatrixSize][MaxMatrixSize]) {
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) C[i][j] = checkMod(A[i][j] - B[i][j], m);
}
template <class T>
inline T multiplyMod(T a, T b, T m) {
return (T)((((int64)(a) * (int64)(b) % (int64)(m)) + (int64)(m)) %
(int64)(m));
}
template <class T>
inline void mulModMatrix(int n, T m, T C[MaxMatrixSize][MaxMatrixSize],
T _A[MaxMatrixSize][MaxMatrixSize],
T _B[MaxMatrixSize][MaxMatrixSize]) {
T A[MaxMatrixSize][MaxMatrixSize], B[MaxMatrixSize][MaxMatrixSize];
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
A[i][j] = _A[i][j], B[i][j] = _B[i][j], C[i][j] = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
for (int k = 0; k < n; k++)
C[i][j] = (C[i][j] + multiplyMod(A[i][k], B[k][j], m)) % m;
}
template <class T>
inline T powerMod(T p, int e, T m) {
if (e == 0)
return 1 % m;
else if (e % 2 == 0) {
T t = powerMod(p, e / 2, m);
return multiplyMod(t, t, m);
} else
return multiplyMod(powerMod(p, e - 1, m), p, m);
}
double dist(double x1, double y1, double x2, double y2) {
return sqrt(sqr(x1 - x2) + sqr(y1 - y2));
}
double distR(double x1, double y1, double x2, double y2) {
return sqr(x1 - x2) + sqr(y1 - y2);
}
template <class T>
T cross(T x0, T y0, T x1, T y1, T x2, T y2) {
return (x1 - x0) * (y2 - y0) - (x2 - x0) * (y1 - y0);
}
int crossOper(double x0, double y0, double x1, double y1, double x2,
double y2) {
double t = (x1 - x0) * (y2 - y0) - (x2 - x0) * (y1 - y0);
if (fabs(t) <= eps) return 0;
return (t < 0) ? -1 : 1;
}
bool isIntersect(double x1, double y1, double x2, double y2, double x3,
double y3, double x4, double y4) {
return crossOper(x1, y1, x2, y2, x3, y3) * crossOper(x1, y1, x2, y2, x4, y4) <
0 &&
crossOper(x3, y3, x4, y4, x1, y1) * crossOper(x3, y3, x4, y4, x2, y2) <
0;
}
bool isMiddle(double s, double m, double t) {
return fabs(s - m) <= eps || fabs(t - m) <= eps || (s < m) != (t < m);
}
bool isUpperCase(char c) { return c >= 'A' && c <= 'Z'; }
bool isLowerCase(char c) { return c >= 'a' && c <= 'z'; }
bool isLetter(char c) { return c >= 'A' && c <= 'Z' || c >= 'a' && c <= 'z'; }
bool isDigit(char c) { return c >= '0' && c <= '9'; }
char toLowerCase(char c) { return (isUpperCase(c)) ? (c + 32) : c; }
char toUpperCase(char c) { return (isLowerCase(c)) ? (c - 32) : c; }
template <class T>
string toString(T n) {
ostringstream ost;
ost << n;
ost.flush();
return ost.str();
}
int toInt(string s) {
int r = 0;
istringstream sin(s);
sin >> r;
return r;
}
int64 toInt64(string s) {
int64 r = 0;
istringstream sin(s);
sin >> r;
return r;
}
double toDouble(string s) {
double r = 0;
istringstream sin(s);
sin >> r;
return r;
}
template <class T>
void stoa(string s, int &n, T A[]) {
n = 0;
istringstream sin(s);
for (T v; sin >> v; A[n++] = v)
;
}
template <class T>
void atos(int n, T A[], string &s) {
ostringstream sout;
for (int i = 0; i < n; i++) {
if (i > 0) sout << ' ';
sout << A[i];
}
s = sout.str();
}
template <class T>
void atov(int n, T A[], vector<T> &vi) {
vi.clear();
for (int i = 0; i < n; i++) vi.push_back(A[i]);
}
template <class T>
void vtoa(vector<T> vi, int &n, T A[]) {
n = vi.size();
for (int i = 0; i < n; i++) A[i] = vi[i];
}
template <class T>
void stov(string s, vector<T> &vi) {
vi.clear();
istringstream sin(s);
for (T v; sin >> v; vi.push_bakc(v))
;
}
template <class T>
void vtos(vector<T> vi, string &s) {
ostringstream sout;
for (int i = 0; i < vi.size(); i++) {
if (i > 0) sout << ' ';
sout << vi[i];
}
s = sout.str();
}
template <class T>
struct Fraction {
T a, b;
Fraction(T a = 0, T b = 1);
string toString();
};
template <class T>
Fraction<T>::Fraction(T a, T b) {
T d = gcd(a, b);
a /= d;
b /= d;
if (b < 0) a = -a, b = -b;
this->a = a;
this->b = b;
}
template <class T>
string Fraction<T>::toString() {
ostringstream sout;
sout << a << "/" << b;
return sout.str();
}
template <class T>
Fraction<T> operator+(Fraction<T> p, Fraction<T> q) {
return Fraction<T>(p.a * q.b + q.a * p.b, p.b * q.b);
}
template <class T>
Fraction<T> operator-(Fraction<T> p, Fraction<T> q) {
return Fraction<T>(p.a * q.b - q.a * p.b, p.b * q.b);
}
template <class T>
Fraction<T> operator*(Fraction<T> p, Fraction<T> q) {
return Fraction<T>(p.a * q.a, p.b * q.b);
}
template <class T>
Fraction<T> operator/(Fraction<T> p, Fraction<T> q) {
return Fraction<T>(p.a * q.b, p.b * q.a);
}
int main() {
int a, b;
scanf("%d%d", &a, &b);
for (int s = 0; 1; s = 1 - s) {
bool exists = false;
for (int i = 0; i <= 2; i++) {
int k = (s == 0) ? (2 - i) : i;
if (a >= k && b >= 22 - k * 10) {
a -= k;
b -= 22 - k * 10;
exists = true;
break;
}
}
if (!exists) {
if (s == 0)
printf("Hanako\n");
else
printf("Ciel\n");
break;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast", "unroll-loops")
using namespace std;
const int maxn = 200100;
int n, a[maxn];
bool vis[maxn];
void solve() {
cin >> n;
for (int i = 0; i < n; i++) vis[i] = 0;
for (int i = 0; i < n; i++) cin >> a[i], a[i] = ((a[i] % n) + n) % n;
for (int i = 0; i < n; i++) {
if (vis[(a[i] + i) % n]) return cout << "NO\n", void();
vis[(a[i] + i) % n] = 1;
}
cout << "YES\n";
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
int t;
cin >> t;
while (t--) solve();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
scanf("%I64d%I64d", &n, &k);
if (k == 0 || n == k) {
printf("0 0\n");
return 0;
} else {
if (k * 3 >= n) {
printf("%I64d %I64d\n", 1LL, n - k);
} else {
printf("%I64d %I64d\n", 1LL, k * 2);
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int nxt[200010 << 1], to[200010 << 1], head[200010], cnt;
long long fw[200010];
void add(int u, int v, long long w) {
nxt[++cnt] = head[u];
to[cnt] = v;
fw[cnt] = w;
head[u] = cnt;
}
long long num[200010 << 2], tag[200010 << 2];
inline void set_tag(int u, long long v) { num[u] += v, tag[u] += v; }
inline void update(int u) { num[u] = min(num[u << 1], num[u << 1 | 1]); }
void push_down(int u) {
if (tag[u] == -1) return;
set_tag(u << 1, tag[u]), set_tag(u << 1 | 1, tag[u]), tag[u] = 0;
}
void build(int u, int l, int r, long long a[]) {
tag[u] = 0;
if (l == r) {
num[u] = a[l];
return;
}
int mid = (l + r) >> 1;
build(u << 1, l, mid, a);
build(u << 1 | 1, mid + 1, r, a);
update(u);
}
void insert(int u, int l, int r, int L, int R, long long v) {
if (L > r || l > R) return;
if (L <= l && r <= R) {
set_tag(u, v);
return;
}
int mid = (l + r) >> 1;
push_down(u);
insert(u << 1, l, mid, L, R, v);
insert(u << 1 | 1, mid + 1, r, L, R, v);
update(u);
}
long long a[200010], b[200010], c[200010];
int main() {
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
for (int i = 2; i <= n; i++) scanf("%lld%lld", &a[i - 1], &b[i]);
for (int i = 1; i <= m; i++) {
int u, v;
long long w;
scanf("%d%d%lld", &u, &v, &w);
add(u, v, w);
}
build(1, 1, n, b);
for (int u = 1; u <= n; u++) {
for (int i = head[u]; i; i = nxt[i]) insert(1, 1, n, 1, to[i], fw[i]);
c[u] = a[u] + num[1];
}
build(1, 1, n, c);
printf("%lld\n", num[1]);
while (q-- > 0) {
int u;
long long v;
scanf("%d%lld", &u, &v);
insert(1, 1, n, u, u, v - a[u]);
a[u] = v;
printf("%lld\n", num[1]);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6;
const int INF = 0x3f3f3f3f;
const int inf = 0x3f;
const double EPS = 1e-7;
const double Pi = acos(-1);
const int MOD = 1e9 + 7;
map<int, bool> q;
int a[maxn];
int main() {
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i], q[a[i]] = true;
sort(a + 1, a + n + 1);
int res = 0;
int Max = a[1];
for (int i = 1; i <= n; i++) {
if (!q[a[i] - k] && a[i] - k >= Max + k) {
res++;
q[a[i] - k] = true;
}
Max = a[i];
if (i != n && !q[a[i] + k] && a[i] + k <= a[i + 1] - k) {
res++;
q[a[i] + k] = true;
}
}
cout << res + 2 << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1010;
unordered_map<int, int> id;
int a[maxn], cnt[maxn];
int cur[maxn], used[maxn];
int it;
bool u[maxn][maxn];
int main() {
int n;
cin >> n;
int ans = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (!id[a[i]]) id[a[i]] = i;
cnt[id[a[i]]]++;
if (!a[i]) ans++;
}
int res, x, y, tmp;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (i == j) continue;
if (a[i] == 0 && a[j] == 0) continue;
if (u[id[a[i]]][id[a[j]]]) continue;
u[id[a[i]]][id[a[j]]] = 1;
it++;
cur[id[a[i]]] = cur[id[a[j]]] = 0;
used[id[a[i]]] = used[id[a[j]]] = it;
cur[id[a[i]]]++;
cur[id[a[j]]]++;
x = a[i], y = a[j];
res = 2;
while (1) {
if (!id[x + y] ||
(used[id[x + y]] == it && cur[id[x + y]] == cnt[id[x + y]]))
break;
res++;
if (used[id[x + y]] != it) {
used[id[x + y]] = it;
cur[id[x + y]] = 0;
}
cur[id[x + y]]++;
tmp = y;
y += x;
x = tmp;
}
ans = max(ans, res);
}
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long int n, i, s = 0;
cin >> n;
long long int a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
s += a[i];
}
if (s % n == 0)
cout << "0\n";
else
cout << "1\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool f(string s) {
int r = s.length();
char x = 'a' - 1;
for (int i = 0; i < s.length(); i++) {
if (s[i] == x + 1)
x++;
else if (s[i] > x + 1)
return false;
}
return true;
}
int main() {
string s;
cin >> s;
cout << (f(s) ? "YES" : "NO") << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int NK_MAX = 2005;
const int STOOL = 1, PENCIL = 2;
struct item {
int price, type, original;
bool operator<(const item &o) const { return price < o.price; }
};
int N, K;
item items[NK_MAX];
vector<int> carts[NK_MAX];
int main() {
scanf("%d %d", &N, &K);
int n_stools = 0;
double total_price = 0;
for (int i = 0; i < N; i++) {
scanf("%d %d", &items[i].price, &items[i].type);
items[i].original = i;
total_price += items[i].price;
if (items[i].type == STOOL) n_stools++;
}
sort(items, items + N);
double save = 0;
if (n_stools >= K) {
int k = 0, done = N;
for (int i = N - 1; i >= 0 && k < K - 1; i--)
if (items[i].type == STOOL) {
save += items[i].price;
for (int j = i; j < done; j++) carts[k].push_back(items[j].original);
done = i;
k++;
}
save += items[0].price;
for (int i = 0; i < done; i++) carts[k].push_back(items[i].original);
} else {
int k = 0;
for (int i = 0; i < N; i++)
if (items[i].type == STOOL) {
save += items[i].price;
carts[k].push_back(items[i].original);
k++;
}
assert(k == n_stools);
for (int i = 0; i < N; i++)
if (items[i].type == PENCIL) {
carts[k].push_back(items[i].original);
k++;
if (k == K) k = n_stools;
}
}
printf("%.1lf\n", total_price - 0.5 * save);
set<int> indices;
for (int i = 0; i < K; i++) {
printf("%d", (int)carts[i].size());
for (int j = 0; j < (int)carts[i].size(); j++) {
printf(" %d", carts[i][j] + 1);
indices.insert(carts[i][j]);
}
printf("\n");
}
assert((int)indices.size() == N);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
ll arr[n];
for (int i = 0; i < n; ++i) cin >> arr[i];
ll ans = 0;
for (int i = 0; i < n; ++i) {
ans += arr[i] - 1;
}
sort(arr, arr + n);
int val = 1;
while (1) {
ll ini = 1, i = 1, cnt = 0;
cnt += arr[0] - 1;
for (; i < n; ++i) {
ini *= val;
if (ini > 1e10) break;
cnt += abs(ini - arr[i]);
}
if (i != n) {
break;
}
ans = min(ans, cnt);
val++;
}
cout << ans << '\n';
;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long powmod(long long a, long long b, long long MOD) {
long long res = 1;
a %= MOD;
for (; b; b >>= 1) {
if (b & 1) res = res * a % MOD;
a = a * a % MOD;
}
return res;
}
struct Point {
int x, y;
Point(int x, int y) {
this->x = x;
this->y = y;
}
void mov() { x--, y++; }
bool operator==(const Point &o) const { return x == o.x && y == o.y; }
};
int n, m;
const int N = 500 + 5;
char s[N][N];
int dp[2][N][N];
const int MOD = 1e9 + 7;
inline void addmod(int &a, int b) { a = (a + b) % MOD; }
void nxt1(Point &a) { a.x++; }
void nxt2(Point &a) { a.y--; }
bool eq(Point &a, Point &b) { return s[a.x][a.y] == s[b.x][b.y]; }
bool valid(Point &a) { return a.x >= 1 && a.x <= n && a.y >= 1 && a.y <= m; }
bool adj(Point &a, Point &b) {
return abs(a.x - b.x) <= 1 && abs(a.y - b.y) <= 1;
}
int main() {
scanf("%d%d", &n, &m);
getchar();
for (int i = 1; i <= n; i++) {
gets(s[i] + 1);
}
Point st1(1, 1), st2(n, m);
dp[0][1][1] = 1;
int cur = 1, pre = 0, ans = 0;
for (int l = 2, r = n + m; l <= r; l++, r--) {
Point a = st1, b = st2;
for (int i = 1; i < l; i++, a.mov()) {
b = st2;
if (!valid(a)) {
continue;
}
for (int j = 1; j < l; j++, b.mov()) {
if (!valid(b)) {
continue;
}
if (eq(a, b)) {
addmod(dp[cur][i][j], (0LL + dp[pre][i][j] + dp[pre][i - 1][j] +
dp[pre][i][j - 1] + dp[pre][i - 1][j - 1]) %
MOD);
if (l == r - 1 && adj(a, b)) {
addmod(ans, dp[cur][i][j]);
} else if (l == r && a == b) {
addmod(ans, dp[cur][i][j]);
}
}
}
}
nxt1(st1);
nxt2(st2);
memset(dp[pre], 0, sizeof dp[pre]);
swap(cur, pre);
}
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int MIN(int a, int b) { return a < b ? a : b; }
int n;
struct Node {
int num[5005];
int max;
int ans;
} No[5005];
void init() {
int i, j;
for (i = 0; i < n; ++i) {
for (j = 0; j <= n; ++j) {
No[i].num[j] = 0;
}
}
}
int main() {
int i, j;
while (~scanf("%d", &n)) {
init();
int num[5005];
int ans[5005] = {0};
for (i = 0; i < n; ++i) {
scanf("%d", &num[i]);
ans[num[i]]++;
}
int len = 3;
for (i = 0, j = 1; j < n; ++i, ++j) {
No[i].num[num[i]]++;
No[i].num[num[j]]++;
if (num[i] == num[j])
No[i].max = 2;
else
No[i].max = 1;
No[i].ans = MIN(num[i], num[j]);
ans[No[i].ans]++;
}
while (len <= n) {
for (i = 0, j = len - 1; j < n; ++i, ++j) {
if (++No[i].num[num[j]] > No[i].max) {
No[i].max = No[i].num[num[j]];
No[i].ans = num[j];
ans[No[i].ans]++;
} else if (No[i].num[num[j]] == No[i].max) {
if (num[j] < No[i].ans) {
No[i].ans = num[j];
ans[No[i].ans]++;
} else
ans[No[i].ans]++;
} else {
ans[No[i].ans]++;
}
}
len++;
}
for (i = 1; i < n; ++i) printf("%d ", ans[i]);
printf("%d\n", ans[i]);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
const int maxn = 3e5 + 5;
const int mod = 10007;
const int inf = 1e9;
const long long onf = 1e18;
using namespace std;
int tree[31 * maxn][2], val[maxn * 31], tot;
bool vis[maxn * 2];
void Insert(int n) {
int root = 0;
for (int i = 31; i >= 0; i--) {
int id = (n >> i) & 1;
if (!tree[root][id]) tree[root][id] = ++tot;
root = tree[root][id];
}
val[root] = n;
}
int get_ans(int n) {
int root = 0;
for (int i = 31; i >= 0; i--) {
int id = (n >> i) & 1;
if (tree[root][id])
root = tree[root][id];
else
root = tree[root][id ^ 1];
}
return n ^ val[root];
}
int main() {
int n, m, x;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d", &x);
vis[x] = true;
}
for (int i = 0; i < maxn * 2; i++) {
if (!vis[i]) Insert(i);
}
int temp = 0;
for (int i = 0; i < m; i++) {
scanf("%d", &x);
temp ^= x;
printf("%d\n", get_ans(temp));
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char k[4][4];
int i, j, n = 0, m = 0, l = 0;
for (j = 0; j < 4; j++)
for (i = 0; i < 4; i++) cin >> k[j][i];
for (j = 0; j < 3; j++)
for (i = 0; i < 3; i++) {
if (k[j][i] == '.')
n++;
else
m++;
if (k[j + 1][i] == '.')
n++;
else
m++;
if (k[j][i + 1] == '.')
n++;
else
m++;
if (k[j + 1][i + 1] == '.')
n++;
else
m++;
if ((m > 2) || (n > 2)) l++;
m = 0;
n = 0;
}
if (l > 0)
cout << "YES";
else
cout << "NO";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1001000;
int n;
int a[MAXN];
int main() {
cin >> n;
for (int i = 0; i < (n - 1); ++i) {
cin >> a[i];
}
long long k = 0, ni = 0, d = 0, kk = 0;
for (int i = 0; i < (n - 1); ++i) {
if ((a[i] % 2) == 0ll) {
ni = max(ni, d + a[i]);
d = d + a[i];
k = max(k + a[i] - 1, a[i] + kk);
kk = kk + a[i];
} else {
if (a[i] == 1ll) {
ni = max(ni, d);
d = k + a[i];
k = k + a[i];
kk = 0;
} else {
d = max(d + a[i] - 1, k + a[i]);
k = k + a[i];
kk = kk + a[i] - 1;
}
}
}
cout << max(max(ni, kk), max(d, k)) << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long binarySearch(vector<long long> arr, long long l, long long r,
long long x) {
if (r >= l) {
long long mid = l + (r - l) / 2;
if (arr[mid] == x) return mid;
if (arr[mid] > x) return binarySearch(arr, l, mid - 1, x);
return binarySearch(arr, mid + 1, r, x);
}
return -1;
}
void solve() {
long long n, s, k;
cin >> n >> s >> k;
vector<long long> arr(k);
for (long long i = 0; i < k; i++) {
cin >> arr[i];
}
sort(arr.begin(), arr.end());
long long ans, ans1, ans2;
long long ind = binarySearch(arr, 0, k, s);
if (ind == -1) {
ans = 0;
} else {
ans1 = -1;
for (long long i = ind; i < k; i++) {
if (arr[i] != s + i - ind) {
ans1 = i - ind;
break;
}
}
if (ans1 == -1) {
if (arr[k - 1] == n) {
ans1 = INT_MAX;
} else {
ans1 = arr[k - 1] - s + 1;
}
}
ans2 = -1;
for (long long j = ind; j >= 0; j--) {
if (arr[j] != s - (ind - j)) {
ans2 = ind - j;
break;
}
}
if (ans2 == -1) {
if (arr[0] == 1) {
ans2 = INT_MAX;
} else {
ans2 = s - arr[0] + 1;
}
}
ans = min(ans1, ans2);
}
cout << ans << '\n';
}
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1;
cin >> t;
while (t--) solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 1;
vector<int> decompose(int num) {
vector<int> components;
for (int i = 2; i * i <= num; i++) {
if (num % i == 0) {
components.push_back(i);
while (num % i == 0) {
num /= i;
}
}
}
if (num > 1) components.push_back(num);
return components;
}
int main() {
int N;
cin >> N;
vector<int> nums(N);
for (auto& num : nums) cin >> num;
vector<int> max_lens(MAX);
vector<int> results(N);
for (int i = N - 1; i >= 0; i--) {
auto components = decompose(nums[i]);
int maximum = INT_MIN;
for (auto& component : components) {
maximum = max(maximum, max_lens[component]);
}
results[i] = 1;
if (maximum != INT_MIN) results[i] += maximum;
for (auto& component : components) {
max_lens[component] = results[i];
}
}
int maximum = INT_MIN;
for (auto result : results) maximum = max(result, maximum);
cout << maximum << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
string s[50], c;
long i, n, k, z = 65;
int main() {
ios::sync_with_stdio();
cin.tie();
cout.tie();
cin >> n >> k;
for (; i < n; ++i) s[i].resize(1, '!');
for (i = 0; i < 26; ++i) s[i][0] = z, ++z;
if (n > 26) {
z = 65;
for (i = 26; i < n; ++i) s[i][0] = z, ++z;
z = 97;
for (i = 0; i < n - 26; ++i) {
s[i].resize(2, '$');
s[i][1] = z, ++z;
}
}
for (i = 0; i < n - k + 1; ++i) {
cin >> c;
if (c == "NO") s[i + k - 1] = s[i];
}
for (i = 0; i < n - 1; ++i) cout << s[i] << " ";
cout << s[i] << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 77;
int dp[MX][MX][MX][2];
int n, cnt[3][MX];
string str;
vector<int> occK, occV, occR;
int calc(int V, int K, int R, int flag) {
if (V + K + R == n) return 0;
int &ret = dp[V][K][R][flag];
if (ret != -1) return ret;
ret = (1 << 30);
if (V + 1 <= occV.size()) {
int pos = occV[V], remK = K, remR = R;
for (int j = 1; j <= pos; j++)
if (str[j] == 'K')
remK--;
else if (str[j] != 'V')
remR--;
ret = min(ret, max(remK, 0) + max(remR, 0) + calc(V + 1, K, R, 1));
}
if (K + 1 <= occK.size() && !flag) {
int pos = occK[K], remV = V, remR = R;
for (int j = 1; j <= pos; j++)
if (str[j] == 'V')
remV--;
else if (str[j] != 'K')
remR--;
ret = min(ret, max(remV, 0) + max(remR, 0) + calc(V, K + 1, R, 0));
}
if (R + 1 <= occR.size()) {
int pos = occR[R], remV = V, remK = K;
for (int j = 1; j <= pos; j++)
if (str[j] == 'V')
remV--;
else if (str[j] == 'K')
remK--;
ret = min(ret, max(remV, 0) + max(remK, 0) + calc(V, K, R + 1, 0));
}
return ret;
}
int main() {
cin >> n >> str;
str = "#" + str;
for (int j = 1; j <= n; j++) {
if (str[j] == 'V')
occV.push_back(j);
else if (str[j] == 'K')
occK.push_back(j);
else
occR.push_back(j);
}
memset(dp, -1, sizeof(dp));
cout << calc(0, 0, 0, 0) << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> result[200000];
int counts = 0;
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
int temp;
for (int i = 0; i < n; i++) {
cin >> temp;
result[i].first = temp - i;
result[i].second = temp;
}
sort(result, result + n);
long long answer = 0;
int first = result[0].first;
long long temp2 = result[0].second;
for (int i = 1; i < n; i++) {
if (result[i].first == first) {
temp2 = temp2 + result[i].second;
} else {
if (answer < temp2) {
answer = temp2;
}
temp2 = result[i].second;
first = result[i].first;
}
}
if (answer < temp2) answer = temp2;
cout << answer;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b;
cin >> a >> b;
long long total = 0;
while (b != 0) {
total += a / b;
a = a % b;
if (b > a) {
long long t = a;
a = b;
b = t;
}
}
cout << total << "\n";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000005;
int a[N], f[105], g[105];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
for (int i = 0; i < m; ++i) {
int x;
scanf("%d", &x);
++g[x];
}
for (int i = 0; i < 31; ++i) {
int j = 1 << i;
for (int k = 0; k < n; ++k)
if ((a[k] & j) != 0) ++f[i];
}
int ans = 0;
for (int i = 0; i < 31; ++i) {
while (f[i] < g[i]) {
int j = i + 1;
while (j < 31 && f[j] == 0) ++j;
if (j == 31) break;
for (int t = i; t < j; ++t) ++f[t];
++f[i];
--f[j];
}
if (g[i] > f[i]) g[i] = f[i];
ans += g[i];
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 500;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int n, m, unit, a[maxn];
long long extra[maxn], lz[maxn], ls[maxn], b[maxn];
int main() {
n = read(), m = read();
unit = sqrt(n);
for (int i = 0; i < n; ++i) a[i] = i + 1;
while (m--) {
int op = read(), l = read(), r = read(), x;
--l;
--r;
if (op == 1) {
x = read();
for (int i = l; i <= r;) {
int idx = i / unit;
int st = idx * unit;
int ed = min(n, (idx + 1) * unit);
if (i == st && r >= ed - 1) {
if (ls[idx]) {
extra[idx] += 1LL * abs(x - ls[idx]) * (ed - st);
lz[idx] += abs(x - ls[idx]);
ls[idx] = x;
} else {
for (int j = st; j < ed; ++j) {
b[j] += abs(a[j] - x);
extra[idx] += abs(a[j] - x);
a[j] = x;
}
ls[idx] = x;
}
i = ed;
} else {
if (ls[idx]) {
for (int j = st; j < ed; ++j) a[j] = ls[idx];
ls[idx] = 0;
}
extra[idx] += abs(a[i] - x);
b[i] += abs(a[i] - x);
a[i] = x;
++i;
}
}
} else {
long long res = 0;
for (int i = l; i <= r;) {
int idx = i / unit;
int st = idx * unit;
int ed = min(n, (idx + 1) * unit);
if (i == st && r >= ed - 1) {
res += extra[idx];
i = ed;
} else {
res += b[i] + lz[idx];
++i;
}
}
printf("%lld\n", res);
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n;
char s[50];
int t[200];
int main() {
scanf("%d\n", &n);
for (int i = 1; i <= n; i++) {
gets(s);
int a, b;
char c;
sscanf(s, "[%d:%d %c]", &a, &b, &c);
if (c == 'a') {
if (a == 12)
t[i] = b;
else
t[i] = a * 60 + b;
} else {
if (a == 12)
t[i] = 12 * 60 + b;
else
t[i] = 12 * 60 + a * 60 + b;
}
}
int cur = 1;
int res = 1;
for (int i = 2; i <= n; i++)
if (t[i] > t[i - 1])
cur = 1;
else if (t[i] == t[i - 1]) {
if (cur == 10) {
cur = 1;
res++;
} else
cur++;
} else
res++, cur = 1;
printf("%d\n", res);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000010;
const int maxn = 200020;
int n, q;
long long int t[maxn];
int x[maxn], quant[maxn];
vector<pair<int, int> > ord_x;
multiset<pair<int, int> > mosquitos;
vector<pair<int, int> > limpa;
multiset<pair<int, int> >::iterator it;
vector<int> num, e, d;
int create(int a) {
num.push_back(num[a]);
e.push_back(-1);
d.push_back(-1);
return num.size() - 1;
}
int update(int u, int l, int r, int l_u, int r_u, int val) {
if (l > r_u || r < l_u) return num[u];
if (l >= l_u && r <= r_u) {
num[u] = val;
return num[u];
}
int m = (l + r) / 2;
if (e[u] == -1) {
int aux = create(u);
e[u] = aux;
}
if (d[u] == -1) {
int aux = create(u);
d[u] = aux;
}
if (num[u] != -1) {
num[e[u]] = num[u];
num[d[u]] = num[u];
}
int num1 = update(e[u], l, m, l_u, r_u, val);
int num2 = update(d[u], m + 1, r, l_u, r_u, val);
if (num1 == num2) {
num[u] = num1;
num[e[u]] = -1;
num[d[u]] = -1;
} else
num[u] = -1;
return num[u];
}
int query(int u, int l, int r, int pos) {
if (u == -1) return 0;
if (num[u] != -1) return num[u];
int m = (l + r) / 2;
if (pos <= m)
return query(e[u], l, m, pos);
else
return query(d[u], m + 1, r, pos);
}
int main() {
num.push_back(0);
e.push_back(-1);
d.push_back(-1);
scanf("%d %d", &n, &q);
for (int i = 1; i <= n; i++) {
scanf("%d %lld", &x[i], &t[i]);
ord_x.push_back(make_pair(x[i], i));
}
sort(ord_x.begin(), ord_x.end());
for (int i = n - 1; i >= 0; i--) {
int x_ = x[ord_x[i].second];
long long int t_ = t[ord_x[i].second];
update(0, 0, INF, x_, x_ + t_, ord_x[i].second);
}
for (int a, b, i = 1; i <= q; i++) {
scanf("%d %d", &a, &b);
int ind = query(0, 0, INF, a);
if (ind == 0) {
mosquitos.insert(make_pair(a, b));
} else {
long long int t_ini = t[ind];
t[ind] += b;
quant[ind]++;
it = mosquitos.lower_bound(make_pair(x[ind], 0));
while (it != mosquitos.end() && (*it).first <= x[ind] + t[ind]) {
t[ind] += (*it).second;
quant[ind]++;
limpa.push_back(*it);
it++;
}
for (int k = 0; k < limpa.size(); k++) mosquitos.erase(limpa[k]);
limpa.clear();
update(0, 0, INF, x[ind] + t_ini + 1, x[ind] + t[ind], ind);
}
}
for (int i = 1; i <= n; i++) {
printf("%d %lld\n", quant[i], t[i]);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
string vs[1005];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> vs[i];
pair<int, int> a = {-1, -1}, b = {-1, -1};
int cnt = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (vs[i][j] == 'X') {
if (a == pair<int, int>(-1, -1)) a = {i, j};
b = {i, j};
cnt++;
}
if ((b.first - a.first + 1) * (b.second - a.second + 1) != cnt) {
cout << "NO" << endl;
return 0;
}
for (int i = a.first; i <= b.first; i++)
for (int j = a.second; j <= b.second; j++)
if (vs[i][j] != 'X') {
cout << "NO" << endl;
return 0;
}
cout << "YES" << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ifstream fin("input.txt");
int n, m = 100000, a, i, j, q, c1 = 0, cn, t, w, x, y;
string c, d;
map<string, string> mp;
cin >> n >> m;
for (i = 0; i < m; i++) {
cin >> c >> d;
mp[c] = d.length() < c.length() ? d : c;
mp[d] = mp[c];
}
for (i = 0; i < n; i++) {
cin >> c;
cout << mp[c] << " ";
}
cout << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y, a, b, tx, ty, r, ans = 0, lcd;
cin >> x >> y >> a >> b;
tx = x;
ty = y;
while (tx % ty != 0) {
r = tx % ty;
tx = ty;
ty = r;
}
lcd = x * y / ty;
ans = (b / lcd) - ((a % lcd == 0) ? a / lcd : a / lcd + 1) + 1;
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, cnt = 0;
double x;
cin >> n;
for (int i = 1; i < n; i++) {
for (int j = i; j < n; j++) {
x = sqrt((i * i) + (j * j));
if (x <= n) {
if ((x - (int)x) == 0) cnt++;
}
}
}
cout << cnt << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXQ = 10000 + 10;
const int MAXN = 1000000 + 10;
bool mark[1 << 26];
int que;
int cost[MAXQ], last[MAXQ], ans[MAXQ], d[30], perm[30];
int nex[MAXN][30];
vector<int> have;
int get(int mask) {
return upper_bound(have.begin(), have.end(), mask) - have.begin();
}
bool cmp(const int &A, const int &B) { return d[A] < d[B]; }
int main() {
ios_base::sync_with_stdio(false);
string s;
cin >> s;
cin >> que;
for (int i = 1; i <= que; i++) {
string ss;
cin >> ss;
for (int j = 0; j < (int)ss.size(); j++) cost[i] += (1 << (ss[j] - 'a'));
mark[cost[i]] = true;
have.push_back(cost[i]);
}
int len = (int)s.size();
sort(have.begin(), have.end());
have.resize(unique(have.begin(), have.end()) - have.begin());
for (int i = 0; i <= (int)have.size(); i++) last[i] = len;
for (int i = 0; i < 26; i++) nex[len][i] = len;
for (int i = len - 1; i >= 0; i--) {
for (int j = 0; j < 26; j++) {
d[j] = nex[i][j] = nex[i + 1][j];
perm[j] = j;
}
d[s[i] - 'a'] = nex[i][s[i] - 'a'] = i;
sort(perm, perm + 26, cmp);
perm[26] = 26;
d[26] = len;
int mask = 0;
for (int j = 0; j < 26 && d[perm[j]] < len; j++) {
mask += (1 << perm[j]);
if (mark[mask]) {
int tmp = get(mask);
if (d[perm[j + 1]] - 1 < last[tmp]) ans[tmp]++;
last[tmp] = i;
}
}
}
for (int i = 1; i <= que; i++) cout << ans[get(cost[i])] << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, k, a[6][1001], pos[6][1001], dp[1001], p[1001];
vector<int> ord, ans, g[1001];
bool b, u[1001];
void dfs(int v) {
u[v] = 1;
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (!u[to]) dfs(to);
}
ord.push_back(v);
}
int main() {
cin >> n >> k;
for (int i = 1; i <= k; i++) {
for (int j = 1; j <= n; j++) {
cin >> a[i][j];
pos[i][a[i][j]] = j;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (i != j) {
b = 1;
for (int kk = 1; kk <= k; kk++) {
if (pos[kk][i] > pos[kk][j]) {
b = 0;
break;
}
}
if (b) g[i].push_back(j);
}
}
}
for (int i = 1; i <= n; i++) {
if (!u[i]) dfs(i);
}
reverse(ord.begin(), ord.end());
for (int i = 0; i < ord.size(); i++) {
int v = ord[i];
if (!dp[v]) {
dp[v] = 1;
p[v] = -1;
}
for (int j = 0; j < g[v].size(); j++) {
int to = g[v][j];
if (dp[v] + 1 > dp[to]) {
dp[to] = dp[v] + 1;
p[to] = v;
}
}
}
int mx = -1;
for (int i = 1; i <= n; i++) {
mx = max(mx, dp[i]);
}
cout << mx;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace ::std;
long long int MOD = 1000000007;
long long int a[100001], b[100001];
long long int power(long long int base, long long int exp1) {
if (exp1 == 0) return 1;
long long int val1 = power(base, exp1 / 2);
long long int ans = (val1 * val1) % MOD;
if (exp1 & 1) ans = (ans * base) % MOD;
return ans;
}
long long int solveRecursively(long long int n, long long int k,
long long int numBits) {
if (k == 0) return 0;
if (numBits == 1) {
if (k == 1)
return 1;
else
return 0;
} else if (double(k) > (double(power(2, numBits - 1) - 1))) {
return ((((long long int)power(n, numBits - 1)) % MOD) +
(solveRecursively(n, k - power(2, numBits - 1), numBits - 1) %
MOD)) %
MOD;
} else {
return solveRecursively(n, k, numBits - 1) % MOD;
}
}
long long int solve(long long int n, long long int k) {
long long int interm = k;
long long int num = 0;
while (interm > 0) {
num++;
interm = interm / 2;
}
return solveRecursively(n, k, num);
}
vector<long long int> v;
int main() {
long long int t, n, m, m2, j, k, i, x;
cin >> t;
while (t--) {
cin >> n >> k;
cout << solve(n, k) << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
string direc = "RDLU";
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "YES" : "NO");
exit(0);
}
void addmod(int &x, int y, int mod) {
x += y;
if (x >= mod) x -= mod;
}
void et() {
puts("-1");
exit(0);
}
struct mb {
int a, t, x, id;
void rd() { scanf("%d%d%d", &a, &t, &x); }
bool operator<(const mb &o) const { return t < o.t; }
} q[100005];
vector<pair<int, int>> ans;
map<int, vector<int>> mp;
map<int, int> tid;
int cnt;
int a[100005], b[100005];
void update(int x, int val) {
for (int i = x; i <= cnt; i += i & -i) {
b[i] += val;
}
}
int query(int x) {
int ret = 0;
for (; x > 0; ret += b[x], x -= x & -x)
;
return ret;
}
void fmain() {
scanf("%d", &n);
for (int(i) = 1; (i) <= (int)(n); (i)++) {
q[i].rd();
q[i].id = i;
mp[q[i].x].push_back(i);
tid[q[i].t];
}
for (auto &p : tid) p.second = ++cnt;
for (auto &p : mp) {
vector<int> v;
for (int id : p.second) {
int t = tid[q[id].t], ope = q[id].a;
if (ope == 1) {
update(t, 1);
a[t]++;
v.push_back(t);
} else if (ope == 2) {
update(t, -1);
a[t]--;
v.push_back(t);
} else {
ans.push_back({id, query(t)});
}
}
for (int t : v) {
update(t, -a[t]);
a[t] = 0;
}
}
sort(ans.begin(), ans.end());
for (auto p : ans) printf("%d\n", p.second);
}
int main() {
fmain();
return 0;
}
| 6 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.