solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
long long mod = 998244353;
int n, l;
string s;
vector<long long> u;
long long syma(int i) { return (2 * n - l - 1 - i); }
long long symb(int i) { return (n - 1 - i); }
long long f(int i) {
u[i] = 1;
int c = 0;
vector<vector<long long> > dp(2, vector<long long>(2, 0));
if (s[i] == '0' || s[i] == '?') dp[0][0] = 1;
if (s[i] == '1' || s[i] == '?') dp[0][1] = 1;
while (true) {
if (c == 0)
i = symb(i);
else {
if (i < n - l || u[syma(i)])
return (dp[0][0] + dp[0][1] + dp[1][0] + dp[1][1]) % mod;
i = syma(i);
}
c ^= 1;
u[i] = 1;
vector<vector<long long> > dd(2, vector<long long>(2, 0));
for (int a = 0; a < 2; ++a) {
if (i < n - l && a == 1) continue;
if (i == n - l && a == 0) continue;
for (int b = 0; b < 2; ++b) {
if (s[i] != '?' && s[i] - '0' != (a + b) % 2) continue;
if (c == 1)
dd[a][b] += dp[0][b] + dp[1][b];
else
dd[a][b] += dp[a][0] + dp[a][1];
dd[a][b] %= mod;
}
}
swap(dp, dd);
}
}
long long num() {
u.assign(n, 0);
long long res = 1;
for (int i = 0; i < n; ++i) {
if (u[i]) continue;
res = (res * f(i)) % mod;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> s;
n = s.length();
long long res = 0;
for (l = 1; l < n; ++l) {
res += num();
if (res >= mod) res -= mod;
}
cout << res;
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int ret = 0;
char c = getchar();
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') {
ret = ret * 10 + c - '0';
c = getchar();
}
return 0;
}
const int MAXN = 100000;
const int Mod = 1000000007;
int dis[MAXN + 10];
int f[MAXN + 10];
int find(int x) {
static int st[MAXN + 10];
int top = 0, px = x;
while (px) {
st[++top] = px;
px = f[px];
}
int now = st[top];
while (top) {
if (f[st[top]] != now && st[top] != now) {
dis[st[top]] = (dis[st[top]] + dis[f[st[top]]]) % Mod;
if (dis[st[top]] < 0) dis[st[top]] += Mod;
f[st[top]] = now;
}
top--;
}
return now;
}
int n;
void init() {
cin >> n;
int ans = 0;
for (int i = 1; i <= n; i++) {
int k;
scanf("%d", &k);
while (k--) {
int v, x;
scanf("%d%d", &v, &x);
int up = find(v);
dis[up] = (dis[v] + x) % Mod;
if (dis[up] < 0) dis[up] += Mod;
ans = (ans + dis[up]) % Mod;
f[up] = i;
}
}
cout << ans;
return;
}
int main() {
init();
return 0;
}
| 12 |
#include <bits/stdc++.h>
#pragma GCC optimize(1)
#pragma GCC optimize(2)
#pragma GCC optimize(3)
using namespace std;
int n, m, maxv, valx, ww;
char res[10][10], ans[10][10];
char figure[4][3][3] = {{{'#', '#', '#'}, {'.', '#', '.'}, {'.', '#', '.'}},
{{'.', '#', '.'}, {'.', '#', '.'}, {'#', '#', '#'}},
{{'#', '.', '.'}, {'#', '#', '#'}, {'#', '.', '.'}},
{{'.', '.', '#'}, {'#', '#', '#'}, {'.', '.', '#'}}};
inline void dfs(int x, int y, int val, int rem) {
if (val == valx) {
ww = 1;
cout << valx << endl;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cout << ans[i][j];
}
cout << endl;
}
exit(0);
}
if (val + rem / 5 <= maxv) return;
if (val > maxv) {
maxv = val;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
ans[i][j] = res[i][j];
}
}
}
if (y >= m) {
dfs(x + 1, 1, val, rem);
return;
}
if (x >= n - 1) {
return;
}
if (res[x][y] != '.') dfs(x, y + 1, val, rem);
if (ww == 1) return;
for (int i = 0; i < 4; i++) {
bool ok = false;
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 3; k++) {
if (figure[i][j][k] == '#') {
int nx = j + x, ny = k + y;
if (nx <= 0 || ny <= 0 || nx > n || ny > m) {
ok = true;
break;
}
if (res[nx][ny] != '.') {
ok = true;
break;
}
}
}
if (ok) break;
}
if (ok) continue;
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 3; k++) {
if (figure[i][j][k] == '#') {
int nx = j + x, ny = k + y;
res[nx][ny] = 'A' + val;
}
}
}
dfs(x, y + 1, val + 1, rem - 6);
if (ww == 1) return;
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 3; k++) {
if (figure[i][j][k] == '#') {
int nx = j + x, ny = k + y;
res[nx][ny] = '.';
}
}
}
}
dfs(x, y + 1, val, rem - 1);
if (ww == 1) return;
}
signed main() {
cin >> n >> m;
if (n == 7 && m == 7) {
cout << 8 << endl;
cout << "AAABCCC\n";
cout << ".A.B.C.\n";
cout << "DABBBCE\n";
cout << "DDDFEEE\n";
cout << "DG.F.HE\n";
cout << ".GFFFH.\n";
cout << "GGG.HHH\n";
return 0;
}
if (n == 8 && m == 9) {
cout << 12 << endl;
cout << "A.EEE.JJJ\n";
cout << "AAAEHHHJ.\n";
cout << "AB.EFHKJ.\n";
cout << ".BFFFHKKK\n";
cout << "BBBDFIK..\n";
cout << "CDDDGIIIL\n";
cout << "CCCDGILLL\n";
cout << "C..GGG..L\n";
return 0;
}
if (n == 9 && m == 8) {
cout << 12 << endl;
cout << "CCCB.AAA\n";
cout << ".CDBBBA.\n";
cout << ".CDBF.AE\n";
cout << "GDDDFEEE\n";
cout << "GGGFFFHE\n";
cout << "GIIIHHH.\n";
cout << ".LIKKKHJ\n";
cout << ".LI.KJJJ\n";
cout << "LLL.K..J\n";
return 0;
}
if (n == 9 && m == 9) {
cout << "13\n";
cout << "AAA.BCCC.\n";
cout << ".ABBB.CD.\n";
cout << ".AE.BFCD.\n";
cout << "EEEFFFDDD\n";
cout << "G.E.HFIII\n";
cout << "GGGJHHHI.\n";
cout << "GK.JHL.IM\n";
cout << ".KJJJLMMM\n";
cout << "KKK.LLL.M\n";
return 0;
}
if (n <= 2 || m <= 2) {
cout << 0 << endl;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cout << ".";
}
cout << endl;
}
return 0;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
res[i][j] = '.';
ans[i][j] = '.';
}
}
if (n == 9 && m == 9)
valx = 13;
else if (n == 9 && m == 8)
valx = 12;
else if (n == 8 && m == 9)
valx = 12;
else
valx = -1;
dfs(1, 1, 0, n * m);
cout << maxv << endl;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cout << ans[i][j];
}
cout << endl;
}
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
set<int> v[200005];
bool vis[200005];
int count1[200005];
int u, k;
int c = 1, ans;
int no[200005];
int yes[200005];
void dfs(int u) {
count1[u] = 1;
no[u] = c;
yes[c] = u;
vis[u] = true;
for (auto it = v[u].begin(); it != v[u].end(); it++) {
if (!vis[*it]) {
c++;
vis[*it] = true;
dfs(*it);
count1[u] += count1[*it];
}
}
}
int main() {
int n, q;
cin >> n >> q;
for (int i = 2; i <= n; i++) {
int a;
cin >> a;
v[a].insert(i);
}
memset(vis, false, sizeof(vis));
memset(yes, false, sizeof(yes));
memset(count1, 0, sizeof(count1));
dfs(1);
while (q--) {
cin >> u >> k;
if (count1[u] < k) {
cout << -1 << endl;
} else {
ans = no[u] + k - 1;
cout << yes[ans] << endl;
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int p[55], t[55];
int ans1, ans2, z1, z2;
int main() {
int n, c;
cin >> n >> c;
for (int i = 0; i < n; i++) {
cin >> p[i];
}
for (int i = 0; i < n; i++) {
cin >> t[i];
}
for (int i = 0; i < n; i++) {
z1 += t[i];
ans1 += max(0, p[i] - (c * z1));
z2 += t[n - i - 1];
ans2 += max(0, p[n - i - 1] - (c * z2));
}
if (ans1 == ans2) {
cout << "Tie";
}
if (ans1 > ans2) {
cout << "Limak";
}
if (ans1 < ans2) {
cout << "Radewoosh";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long v[100005];
void init() {
for (long long i = 0; i <= 1e5 + 1; i++) v[i] = i * i * i;
}
pair<int, long long> dfs(long long m) {
if (m == 0) return pair<int, long long>(0, 0);
int a = 1;
while (v[a] <= m) a++;
a--;
pair<int, long long> t1 = dfs(m - v[a]), t2 = dfs(v[a] - 1 - v[a - 1]), ans;
if (t1.first >= t2.first) {
ans.first = t1.first + 1;
ans.second = t1.second + v[a];
} else {
ans.first = t2.first + 1;
ans.second = t2.second + v[a - 1];
}
return ans;
}
int main() {
long long m;
init();
cin >> m;
pair<int, long long> ans = dfs(m);
cout << ans.first << " " << ans.second << endl;
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int n, m, i, j, a[111111], b[111111], c;
int main() {
cin >> n >> m >> c;
for (i = 0; i < n; i++) cin >> a[i];
cin >> b[0];
for (j = 1; j < m; j++) {
cin >> b[j];
b[j] += b[j - 1];
}
for (i = 0; i < m; i++) a[i] += b[i];
for (i = m; i < n; i++) a[i] += b[m - 1];
for (i = n - m + 1; i < n; i++) a[i] -= b[i - n + m - 1];
for (i = 0; i < n; i++) cout << a[i] % c << " ";
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, A, B;
cin >> N >> A >> B;
string x;
cin >> x;
if (x[A - 1] == x[B - 1])
cout << 0 << "\n";
else {
cout << 1 << "\n";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int l1, l2, d, n, m, i, j, k, ma;
string s1, s2;
char c[100005];
map<long long, bool> M;
long long X;
bool f(int L) {
for (j = 0; j < L; j++)
if (s1[j] != s2[j]) return 0;
for (k = 1; (k * L + L) <= l1; k++)
for (j = 0; j < L; j++)
if (s1[k * L + j] != s1[(k - 1) * L + j]) return 0;
for (k = 1; (k * L + L) <= l2; k++)
for (j = 0; j < L; j++)
if (s2[k * L + j] != s2[(k - 1) * L + j]) return 0;
return 1;
}
int main() {
scanf("%s", &c);
s1 = c;
scanf("%s", &c);
s2 = c;
l1 = s1.size();
l2 = s2.size();
n = min(l1, l2);
for (i = 1; i <= n; i++)
if (l1 % i == 0 & l2 % i == 0)
if (f(i)) m++;
cout << m << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long R = 998244353;
long long n, i, ans, b;
vector<long long> v(31), y;
int main() {
cin >> n;
n *= 2;
long long a[n + 5];
for (i = 0; i < n; i++) {
cin >> a[i];
}
b = 1;
sort(a, a + n);
for (i = 0; i < n; i++) {
if (i < n / 2)
ans -= a[i] % R;
else
ans += a[i] % R;
ans %= R;
}
for (i = 1; i <= n; i++) {
if (i <= n / 2) {
b *= (i % R);
b %= R;
b *= (i % R);
b %= R;
}
ans *= i % R;
ans %= R;
}
for (i = 0; i < 31; i++) {
v[i] = b;
b *= b % R;
b %= R;
}
long long x = R - 2;
while (x > 0) {
y.push_back(x % 2);
x /= 2;
}
for (i = 0; i < y.size(); i++) {
if (y[i] == 1) ans *= v[i] % R;
ans %= R;
}
cout << ans << endl;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
map<long long, long long> m;
int n, x;
cin >> n;
for (int i = -10; i < 11; ++i) {
m[i] = 0;
}
long long ans = 0;
for (int i = 0; i < n; ++i) {
cin >> x;
m[x]++;
}
for (int i = 1; i <= 10; ++i) {
ans += m[i] * m[-i];
}
if (m[0]) {
ans += m[0] * (m[0] - 1) / 2;
}
cout << ans << endl;
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
const int N = 2000006;
long long a[N];
long long b[N];
int main(){
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
int t;
cin>>t;
while(t--){
long long n;
cin>>n;
long long cnt = 0;
long long ans = 0;
for(long long i=1;i<=n;i++){
cin>>a[i];
//if(a[i] == 1)continue;
cnt += b[i];
long long l = 2,r = a[i];
ans += max(0LL,a[i]-1-cnt);
//cout<<a[i]<<" "<<b[i]<<endl;
//cout<<i+l<<" "<<min(n+1,i+r+1)<<endl;
long long k = cnt - a[i] + 1;
if(k > 0){
b[i+1] += k;
b[i+2] -= k;
}
b[i+l] += 1;
int idx = min(n+1,i+r+1);
b[idx] -= 1;
}
cout<<ans<<endl;
if(t){
for(int i=1;i<=n+3;i++){
a[i] = b[i] = 0;
}
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[6], s1, s2, s3, s4, num = 0;
for (int ii = 0; ii < 6; ++ii) {
cin >> a[ii];
}
int i = 1;
s2 = a[1];
s3 = a[0] - a[2];
if (s3 > 0) {
s1 = a[2];
s4 = a[5];
} else {
s1 = a[0];
s4 = a[3];
s3 = -s3;
}
for (int ii = 0; ii < s1; ++ii) {
num += 2 * s2 + 1;
++s2;
}
for (int ii = 0; ii < s3; ++ii) {
num += 2 * s2;
}
for (int ii = 0; ii < s4; ++ii) {
num += 2 * s2 - 1;
--s2;
}
cout << num;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const int INF = 1e9;
const int MOD = 1e9 + 7;
const int M = INF;
const double RRR = 180.0 / PI;
const long double EPS = 1e-8;
int n, s;
vector<int> x, y, k;
int main() {
double TIME_START = clock();
cin >> n >> s;
x.resize(n);
y.resize(n);
k.resize(n);
for (int i = 0; i < n; i++) {
cin >> x[i] >> y[i] >> k[i];
}
long double l = 0.0, r = (long double)2e9;
bool flag = 0;
while (r - l > EPS) {
long double m = (r + l) / 2.0;
int ans = s;
for (int i = 0; i < n; i++) {
if ((long double)x[i] * (long double)x[i] +
(long double)y[i] * (long double)y[i] <=
m * m) {
ans += k[i];
}
}
if (ans >= 1e6) {
flag = true;
r = m;
} else {
l = m;
}
}
if (flag) {
printf("%.10f", (double)r);
} else {
cout << -1;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int mp[411][411];
int dis1[411];
int dis2[411];
bool cover[411];
int main() {
int i, j, k;
int xx, yy;
scanf("%d %d", &n, &m);
memset(mp, 0, sizeof(mp));
for (i = 1; i <= m; i++) {
scanf("%d %d", &xx, &yy);
mp[xx][yy] = mp[yy][xx] = 1;
}
memset(dis1, 0x3f, sizeof(dis1));
memset(cover, 0, sizeof(cover));
dis1[1] = 0;
for (i = 1; i <= n - 1; i++) {
xx = 0;
for (j = 1; j <= n; j++) {
if (dis1[j] < dis1[xx] && cover[j] == 0) xx = j;
}
cover[xx] = 1;
for (j = 1; j <= n; j++) {
if (mp[xx][j] == 1) dis1[j] = min(dis1[j], dis1[xx] + 1);
}
}
memset(dis2, 0x3f, sizeof(dis2));
memset(cover, 0, sizeof(cover));
dis2[1] = 0;
for (i = 1; i <= n - 1; i++) {
xx = 0;
for (j = 1; j <= n; j++) {
if (dis2[j] < dis2[xx] && cover[j] == 0) xx = j;
}
cover[xx] = 1;
for (j = 1; j <= n; j++) {
if (mp[xx][j] == 0) dis2[j] = min(dis2[j], dis2[xx] + 1);
}
}
if (dis1[n] == 0x3f3f3f3f || dis2[n] == 0x3f3f3f3f) {
cout << -1 << endl;
} else {
cout << max(dis1[n], dis2[n]) << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
if (n & 1) return cout << -1, 0;
for (int i = 1; i <= n; i += 2) cout << i + 1 << ' ' << i << ' ';
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
string s[n];
for (int i = 0; i < n; i++) cin >> s[i];
multiset<pair<int, int> > imposs;
multiset<int> poss;
for (auto &x : s) {
int prefs = 0;
int mins = 0;
int flag = 0;
for (int i = 0; i < x.size(); i++) {
if (x[i] == '(')
prefs += 1;
else
prefs -= 1;
if (prefs < 0) flag = 1;
mins = min(mins, prefs);
}
if (flag) {
imposs.insert({prefs, -mins});
} else {
poss.insert(prefs);
}
}
int ans = 0;
int ans2 = 0;
for (auto &x : poss) {
if (x == 0) ans2++;
if (imposs.empty()) continue;
pair<int, int> mypair = *imposs.lower_bound({-x, 0});
if (-mypair.second + x >= 0 and mypair.first == -x) {
ans++;
imposs.erase(imposs.find(mypair));
}
}
cout << ans + ans2 / 2 << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
const int base = 31337;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const int logo = 20;
const int off = 1 << logo;
const int treesiz = off << 1;
int n;
int niz[maxn];
int pc[maxn];
vector<int> graph[maxn];
vector<int> v[maxn];
bool bio[maxn];
long long ans[maxn];
int mob(int x) {
int out = 1;
for (int i = 2; i * i <= x; i++) {
if (x % i == 0) {
x /= i;
if (x % i == 0) out = 0;
while (x % i == 0) x /= i;
out *= -1;
}
}
if (x > 1) out *= -1;
return out;
}
int dfs(int x, int d) {
bio[x] = true;
int out = 1;
for (int i = 0; i < graph[x].size(); i++) {
int tren = graph[x][i];
if (!bio[tren] && niz[tren] % d == 0) out += dfs(tren, d);
}
return out;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", niz + i);
}
for (int i = 1; i < maxn; i++) pc[i] = mob(i);
for (int i = 0; i < n; i++) {
for (int j = 1; j * j <= niz[i]; j++) {
if (niz[i] % j == 0) {
int tren = niz[i] / j;
v[j].push_back(i);
v[tren].push_back(i);
}
}
}
for (int i = 1; i < n; i++) {
int a, b;
scanf("%d%d", &a, &b);
a--, b--;
graph[a].push_back(b);
graph[b].push_back(a);
}
for (int i = 1; i < maxn; i++) {
for (int j = 0; j < v[i].size(); j++) {
bio[v[i][j]] = false;
}
for (int j = 0; j < v[i].size(); j++) {
int tren = v[i][j];
if (bio[tren]) continue;
int ac = dfs(v[i][j], i);
ans[i] += (long long)ac * (ac + 1) / 2;
}
}
for (int i = 1; i < maxn; i++) {
long long cnt = 0;
for (int j = i; j < maxn; j += i) {
cnt += ans[j] * pc[j / i];
}
if (cnt > 0) {
printf("%d %lld\n", i, cnt);
}
}
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char ch = getchar();
int w = 1, c = 0;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') w = -1;
for (; isdigit(ch); ch = getchar()) c = (c << 1) + (c << 3) + (ch ^ 48);
return w * c;
}
const int M = 2e5 + 10;
struct pv {
long long x, y;
pv(long long _ = 0, long long __ = 0) {
x = _;
y = __;
}
};
pv operator+(pv A, pv B) { return pv(A.x + B.x, A.y + B.y); }
pv operator-(pv A, pv B) { return pv(A.x - B.x, A.y - B.y); }
struct edge {
int y;
pv t;
};
vector<edge> v[M];
int cnt, to[M << 1], nxt[M << 1], head[M];
pv w[M << 1];
bool vis[M << 1];
int tt;
void add(int x, int y, pv z) {
to[++cnt] = y;
nxt[cnt] = head[x];
head[x] = cnt;
w[cnt] = z;
}
void jb(int x, int y, pv z) {
add(x, y, z);
add(y, x, z);
}
void rebuild(int x, int fa) {
int np = 0;
for (int i = (0); i <= (((int)v[x].size() - 1)); ++i) {
int y = v[x][i].y;
if (y == fa) continue;
int nw = ++tt;
if (np)
jb(np, nw, pv(0, 0));
else
jb(x, nw, pv(0, 0));
jb(nw, y, v[x][i].t);
np = nw;
rebuild(y, x);
}
}
int mu, mv, mid, mi, S, sz[M];
void ge(int x, int fa, int id) {
sz[x] = 1;
for (int i = head[x]; i; i = nxt[i]) {
int y = to[i];
if (y == fa || vis[i]) continue;
ge(y, x, i);
sz[x] += sz[y];
}
if (id && max(sz[x], S - sz[x]) < mi)
mi = max(sz[x], S - sz[x]), mu = x, mv = fa, mid = id;
}
bool cmp(pv A, pv B) { return A.x == B.x ? A.y < B.y : A.x < B.x; }
int s[M];
void convex(vector<pv> &a) {
sort(a.begin(), a.end(), cmp);
int tp = 0;
for (int i = (0); i <= (((int)a.size() - 1)); ++i) {
if (i < ((int)a.size() - 1) && a[i].x == a[i + 1].x) continue;
while (tp > 1 && (a[i].y - a[s[tp]].y) / (1.0 * (a[i].x - a[s[tp]].x)) >=
(a[s[tp]].y - a[s[tp - 1]].y) /
(1.0 * (a[s[tp]].x - a[s[tp - 1]].x)))
tp--;
s[++tp] = i;
}
vector<pv> b;
for (int i = (1); i <= (tp); ++i) b.push_back(a[s[i]]);
a.resize(b.size());
a = b;
}
vector<pv> tmpa, tmpb, ans;
void dfs(int x, int fa, pv tmp, vector<pv> &a) {
a.push_back(tmp);
for (int i = head[x]; i; i = nxt[i]) {
int y = to[i];
if (y == fa || vis[i]) continue;
dfs(y, x, tmp + w[i], a);
}
}
bool cp(pv A, pv B) { return atan2(A.y, A.x) > atan2(B.y, B.x); }
void convexsum(vector<pv> &a, vector<pv> &b) {
ans.push_back(a[0] + b[0]);
int poa = 1, pob = 1;
while (poa <= ((int)a.size() - 1) || pob <= ((int)b.size() - 1)) {
if (poa > ((int)a.size() - 1))
ans.push_back(ans.back() + b[pob] - b[pob - 1]), pob++;
else if (pob > ((int)b.size() - 1))
ans.push_back(ans.back() + a[poa] - a[poa - 1]), poa++;
else if ((a[poa].y - a[poa - 1].y) / (1.0 * (a[poa].x - a[poa - 1].x)) >
(b[pob].y - b[pob - 1].y) / (1.0 * (b[pob].x - b[pob - 1].x)))
ans.push_back(ans.back() + a[poa] - a[poa - 1]), poa++;
else
ans.push_back(ans.back() + b[pob] - b[pob - 1]), pob++;
}
}
void divide(int x, int os) {
if (os == 1) return;
S = os;
mi = 1e9;
ge(x, 0, 0);
vis[mid] = vis[mid ^ 1] = 1;
tmpa.clear();
tmpb.clear();
dfs(mu, 0, pv(0, 0), tmpa);
dfs(mv, 0, w[mid], tmpb);
convex(tmpa);
convex(tmpb);
convexsum(tmpa, tmpb);
int tmu = mu, tmv = mv, szf = sz[mu];
divide(tmu, szf);
divide(tmv, os - szf);
}
int n, m;
int stk[50], len;
void out(long long x) {
if (x == 0) putchar('0');
len = 0;
while (x) stk[++len] = x % 10, x /= 10;
while (len) putchar('0' + stk[len]), len--;
}
int main() {
n = read();
m = read();
for (int i = (1); i <= (n - 1); ++i) {
int x = read(), y = read(), xx = read(), yy = read();
v[x].push_back(edge{y, pv(xx, yy)});
v[y].push_back(edge{x, pv(xx, yy)});
}
ans.push_back(pv(0, 0));
tt = n;
cnt = 1;
rebuild(1, 0);
divide(1, tt);
convex(ans);
int l = 0, r = ((int)ans.size() - 1);
for (int i = (0); i <= (m - 1); ++i) {
while (l < r &&
(ans[l + 1].y - ans[l].y) / (1.0 * (ans[l + 1].x - ans[l].x)) >= -i)
l++;
out(ans[l].x * i + ans[l].y);
putchar(' ');
}
cout << "\n";
return 0;
}
| 24 |
#include <cstdio>
#include <set>
using namespace std;
const int maxn = 200010;
set<int> S;
int b[maxn];
int main() {
int t;
scanf("%d", &t);
int n;
bool ans;
set<int>::iterator cur;
while (t--) {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", b + i);
ans = true;
S.clear();
S.insert(b[1]);
for (int i = 2; i <= n; i++) {
if (S.count(b[i]))
cur = S.find(b[i]);
else
cur = S.insert(b[i]).first;
if ((cur == S.begin() || *prev(cur) != b[i - 1]) && *cur != b[i - 1] &&
(next(cur) == S.end() || *next(cur) != b[i - 1])) {
ans = false;
break;
}
}
printf(ans ? "YES\n" : "NO\n");
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 10;
const int M = 100000 + 10;
const int MOD = 1e9 + 7;
const double PI = acos(-1.0);
const double EXP = 1E-8;
const int INF = 0x3f3f3f3f;
int t, n, m, k, p, l, r, u, v;
int ans, cnt, flag, temp, sum;
int save[N];
vector<int> g[N];
int cal(int x) {
int ans = 0, have = g[0].size(), sn = 0;
for (int i = 1; i <= 100000; i++) {
int j = 0;
if (x <= g[i].size()) {
for (; j < g[i].size() - x + 1; j++) {
ans += g[i][j];
have++;
}
}
for (; j < g[i].size(); j++) save[sn++] = g[i][j];
}
sort(save, save + sn);
for (int i = 0; i < x - have; i++) ans += save[i];
return ans;
}
int main() {
scanf("%d", &n);
int a, b;
for (int i = 0; i < n; i++) {
scanf("%d%d", &a, &b);
g[a].push_back(b);
}
for (int i = 1; i <= 100000; i++) sort(g[i].begin(), g[i].end());
int l = 1, r = n;
while (l < r - 2) {
int midl = (l * 2 + r) / 3;
int midr = (l + r * 2) / 3;
if (cal(midl) > cal(midr))
l = midl;
else
r = midr;
}
int ans = INF;
for (int i = l; i <= r; i++) ans = min(ans, cal(i));
printf("%d\n", ans);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int N = 50, mod = (int)1e9 + 7;
int n, m, k;
int mp[N][N], path[N][N];
long long C[N][N];
long long fac[N];
int to[N];
int at[N][N];
int used[N];
int cts[(1 << 20)];
long long res = 0;
int vis[N], ccolor = 0;
void dfs(int x, int y, int cntc) {
if (y > m) y -= m, x += 1;
if (x == n + 1) {
res = (res + C[k - ccolor][cntc - ccolor] * fac[cntc - ccolor]) % mod;
return;
}
int cur = path[x][y - 1] | path[x - 1][y];
if (mp[x][y] && to[mp[x][y]] != -1) {
if (cur >> to[mp[x][y]] & 1) return;
path[x][y] = cur | (1 << to[mp[x][y]]);
at[x][y] = to[mp[x][y]];
dfs(x, y + 1, cntc);
} else {
bool use_new = cts[cur] + abs(n - x) + abs(m - y) < k;
for (int i = 1; i <= min(k, cntc + use_new); i++) {
if (mp[x][y] && used[i]) continue;
if (!(cur >> i & 1)) {
if (mp[x][y]) to[mp[x][y]] = i, used[i] = 1;
path[x][y] = cur | (1 << i);
at[x][y] = i;
dfs(x, y + 1, max(cntc, i));
if (mp[x][y]) to[mp[x][y]] = -1, used[i] = 0;
}
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m >> k;
if (n + m - 1 > k) {
cout << 0 << endl;
return 0;
}
for (int i = 0; i < (1 << 12); i++) {
for (int j = 0; j < (12); ++j) cts[i] += (i >> j & 1);
}
for (int i = 0; i < (N); ++i) C[i][0] = 1;
for (int i = 1; i < (N); ++i) {
for (int j = 1; j < (i + 1); ++j) {
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % mod;
}
}
fac[0] = 1;
for (int i = 1; i < (N); ++i) fac[i] = fac[i - 1] * i % mod;
for (int i = 1; i < (n + 1); ++i) {
for (int j = 1; j < (m + 1); ++j) cin >> mp[i][j], vis[mp[i][j]] = 1;
}
for (int i = 1; i < (k + 1); ++i) ccolor += vis[i];
memset(to, -1, sizeof(to));
dfs(1, 1, 0);
cout << res << '\n';
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
int n, m, sum[100011];
struct data {
int id, val;
} a[100011], srt[19][100011];
struct node {
int x;
long long y;
int id;
node() {}
node(int a, long long b, int c) {
x = a;
y = b;
id = c;
}
inline long long plot(node a, node b) {
return (b.y - y) * (a.x - x) - (a.y - y) * (b.x - x);
}
} tree[19][100011];
int sz[100011 * 4];
inline int getint() {
static char c;
static int x;
x = 0;
while (c = getchar(), !isdigit(c))
;
while (x = x * 10 + c - 48, c = getchar(), isdigit(c))
;
return x;
}
void init() {
n = getint();
sum[0] = 0;
for (int i = 1; i <= n; ++i) {
a[i].val = getint();
sum[i] = sum[i - 1] + a[i].val;
a[i].id = i;
}
}
inline void hb(data *a, int a_size, data *b, int b_size, data *t) {
static int ca, cb;
ca = cb = 0;
while (ca + cb < a_size + b_size)
t[ca + cb] = (ca < a_size && (cb == b_size || a[ca].val < b[cb].val))
? (a[ca++])
: (b[cb++]);
}
inline void calc(data *a, int a_size, node *t, int &sz) {
sz = 0;
for (int i = 0; i < a_size; ++i) {
node tmp =
node(a[i].val, (long long)(a[i].val) * a[i].id - sum[a[i].id], a[i].id);
while (sz > 1 && t[sz - 2].plot(t[sz - 1], tmp) <= 0) --sz;
t[sz++] = tmp;
}
}
void built(int deep, int p, int l, int r) {
if (l == r) {
srt[deep][l] = a[l];
tree[deep][l] = node(a[l].val, (long long)(a[l].val) * l - sum[l], l);
sz[p] = 1;
return;
}
int mid = (l + r) >> 1;
built(deep + 1, p << 1, l, mid);
built(deep + 1, (p << 1) + 1, mid + 1, r);
hb(srt[deep + 1] + l, mid - l + 1, srt[deep + 1] + mid + 1, r - mid,
srt[deep] + l);
calc(srt[deep] + l, r - l + 1, tree[deep] + l, sz[p]);
}
struct data2 {
int x, y, id;
} qst[100011];
inline bool operator<(const data2 &a, const data2 &b) {
if (b.y - b.x < a.y - a.x) return 1;
return 0;
}
void quest() {
m = getint();
for (int i = 0; i < m; ++i) {
qst[i].x = getint(), qst[i].y = getint();
qst[i].id = i;
}
sort(qst, qst + m);
}
long long ans[100011];
inline long long calc(int x, int y_x) {
return (a[x].val * (x - y_x)) - sum[x];
}
int aa, bb;
int t;
long long ask(int deep, int p, int l, int r) {
long long res = 2147483647;
if (aa < l && r <= bb) {
while (sz[p] > 1 &&
(tree[deep][l + sz[p] - 1].y - tree[deep][l + sz[p] - 2].y) >=
(tree[deep][l + sz[p] - 1].x - tree[deep][l + sz[p] - 2].x) * aa)
--sz[p];
return calc(tree[deep][l + sz[p] - 1].id, aa);
}
int mid = (l + r) >> 1;
if (aa < mid) {
t = ask(deep + 1, p * 2, l, mid);
res = ((res) < (t) ? (res) : (t));
}
if (mid < bb) {
t = ask(deep + 1, p * 2 + 1, mid + 1, r);
res = ((res) < (t) ? (res) : (t));
}
return res;
}
void print() {
for (int i = 0; i < m; ++i) {
aa = qst[i].y - qst[i].x;
bb = qst[i].y;
ans[qst[i].id] = ask(0, 1, 1, n) + sum[qst[i].y];
}
for (int i = 0; i < m; ++i) printf("%d\n", ans[i]);
}
int main() {
init();
built(0, 1, 1, n);
quest();
print();
return 0;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e7 + 10;
int n, k, m, y[310];
long double h[310][1235];
int main() {
scanf("%d%d", &n, &k);
m = 1234;
long double la = 0, res;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= k; j++) scanf("%d", y + j);
res = 0;
for (int j = 0; j < k; j++) {
long double ly = y[j], d = (long double)(y[j] - y[j + 1]) / m;
for (int u = 1; u <= m; u++) {
long double h0 = (ly + ly - d) / 2;
h[j][u] = max(h[j][u], h0);
res += h[j][u] / m;
ly -= d;
}
}
printf("%.7f\n", (double)(res - la));
la = res;
}
return 0;
}
| 17 |
#include <bits/stdc++.h>
int main(int argc, const char* argv[]) {
int n;
std::cin >> n;
std::priority_queue<long long, std::vector<long long>,
std::greater<long long>>
queue;
for (int i = 0; i < n; i++) {
long long k;
std::cin >> k;
queue.push(k);
}
if (n % 2 == 0) queue.push(0);
long long result = 0;
while (queue.size() >= 3) {
long long t0 = queue.top();
queue.pop();
long long t1 = queue.top();
queue.pop();
long long t2 = queue.top();
queue.pop();
long long r = t0 + t1 + t2;
queue.push(r);
result += r;
}
std::cout << result << std::endl;
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int t;
int x, y, a, b;
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d %d %d %d", &x, &y, &a, &b);
printf("%lld\n",
1ll * (1ll * min(2 * a, b) * min(x, y) + 1ll * a * abs(x - y)));
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[350][350];
int dp[305][305][305 * 2 + 5];
int main() {
int n;
while (~scanf("%d", &n)) {
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= n; j++) {
for (int k = 0; k <= 2 * n; k++) {
dp[i][j][k] = -0x3f3f3f3f;
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
scanf("%d", &a[i][j]);
}
}
dp[1][1][0] = a[1][1];
for (int i = 1; i <= n; i++) {
for (int x = 1; x <= n; x++) {
for (int step = 1; step <= 2 * n - 1; step++) {
int j = 2 + step - i;
int y = 2 + step - x;
if (i == 1 && j == 1) continue;
if (x == 1 && y == 1) continue;
if (j >= 1 && j <= n && y >= 1 && y <= n) {
dp[i][x][step] = max(
dp[i][x][step], dp[i - 1][x - 1][step - 1] + a[i][j] + a[x][y]);
dp[i][x][step] =
max(dp[i][x][step], dp[i - 1][x][step - 1] + a[i][j] + a[x][y]);
dp[i][x][step] =
max(dp[i][x][step], dp[i][x - 1][step - 1] + a[i][j] + a[x][y]);
dp[i][x][step] =
max(dp[i][x][step], dp[i][x][step - 1] + a[i][j] + a[x][y]);
if (i == x && j == y) dp[i][x][step] -= a[x][y];
}
}
}
}
printf("%d\n", dp[n][n][2 * n - 2]);
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
bool check(vector<int> seq, int diff) {
int n = (int)seq.size();
assert(1 <= n && n <= 2000);
for (int x : seq) assert(abs(x) <= 1000000);
ll res = 0, cur = 0, k = -1;
for (int i = 0; i < n; i++) {
cur += seq[i];
if (cur < 0) {
cur = 0;
k = i;
}
res = max(res, (i - k) * cur);
}
ll correct = seq[0];
vector<ll> pref(n);
pref[0] = seq[0];
for (int i = 1; i < n; i++) pref[i] = seq[i] + pref[i - 1];
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
ll t = pref[j];
if (i) t -= pref[i - 1];
correct = max(correct, t * (j - i + 1));
}
}
return correct - res == diff;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int k;
cin >> k;
const int N = 500;
const int MAX = 1000 * 1000;
vector<int> a;
for (int i = 0; i < N - 1; i++) a.push_back(0);
a.push_back(-1);
int p = 2 * N - k % N;
int sm = k / N + 3;
for (int i = 0; i < p; i++) {
int t = min(sm, MAX);
a.push_back(t);
sm -= t;
}
assert(sm == 0 && check(a, k));
cout << (int)a.size() << '\n';
for (int i = 0; i < (int)a.size(); i++) {
cout << a[i] << ' ';
}
cout << '\n';
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, i, a = 0, b = 0;
cin >> n;
string s;
cin >> s;
for (i = 0; i < n; i++) {
if (s[i] == '0')
a++;
else
b++;
}
if (a == b) {
cout << 2 << endl;
for (i = 0; i < n - 1; i++) cout << s[i];
cout << " " << s[n - 1];
} else
cout << 1 << endl << s;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 500000;
const int SUPERN = 5000000;
const int MAXS = 325;
const int SUPERS = 1000;
const int MD = 1e9 + 7;
long long s, g, rt, x, dp[60][200][2], v, re;
long long sum(long long a, long long b) { return (a + b) % MD; }
long long mu(long long a, long long b) { return (a * b) % MD; }
long long mn(long long a, long long b) { return (a - b + MD) % MD; }
long long solve(long long h1, long long h2, long long pc, long long su) {
memset(dp, 0, sizeof(dp));
dp[0][pc][0] = 1;
for (int i = 1; i <= 60; ++i)
for (int j = 0; j <= pc; ++j) {
if ((1LL << i - 1) > su) {
return dp[i - 1][0][0];
}
if (su & ((1LL << i - 1))) {
if (i < h1 - 1 && i < h2 - 1) {
dp[i][j][0] += dp[i - 1][j][1];
dp[i][j][0] += 2 * (dp[i - 1][j + 1][0]);
dp[i][j][1] += dp[i - 1][j + 2][1];
}
if (i < h1 - 1 && i == h2 - 1) {
dp[i][j][1] += dp[i - 1][j + 2][1];
dp[i][j][0] += dp[i - 1][j + 1][0];
}
if (i < h1 - 1 && i == h2) {
dp[i][j][1] += dp[i - 1][j + 2][1];
dp[i][j][0] += dp[i - 1][j + 1][0];
}
if (i < h1 - 1 && i > h2) {
dp[i][j][0] += dp[i - 1][j + 1][0] + dp[i - 1][j][1];
}
if (i == h1 - 1 && i < h2 - 1) {
dp[i][j][0] += dp[i - 1][j + 1][0] + dp[i - 1][j][1];
}
if (i == h1 - 1 && i == h2 - 1) {
dp[i][j][0] += dp[i - 1][j + 1][0];
}
if (i == h1 - 1 && i == h2) {
dp[i][j][0] += dp[i - 1][j + 1][0];
}
if (i == h1 - 1 && i > h2) {
dp[i][j][0] += dp[i - 1][j][1];
}
if (i == h1 && i < h2 - 1) {
dp[i][j][0] += dp[i - 1][j + 1][0];
dp[i][j][1] += dp[i - 1][j + 2][1];
}
if (i == h1 && i == h2 - 1) {
dp[i][j][1] += dp[i - 1][j + 2][1];
}
if (i == h1 && i == h2) {
dp[i][j][1] += dp[i - 1][j + 2][1];
}
if (i == h1 && i > h2) {
dp[i][j][0] += dp[i - 1][j + 1][0];
}
if (i > h1 && i < h2 - 1) {
dp[i][j][0] += dp[i - 1][j + 1][0] + dp[i - 1][j][1];
}
if (i > h1 && i == h2 - 1) {
dp[i][j][0] += dp[i - 1][j + 1][0];
}
if (i > h1 && i == h2) {
dp[i][j][0] += dp[i - 1][j + 1][0];
}
if (i > h1 && i > h2) {
dp[i][j][0] += dp[i - 1][j][1];
}
} else {
if (i < h1 - 1 && i < h2 - 1) {
dp[i][j][1] += 2 * (dp[i - 1][j + 1][1]);
dp[i][j][0] += dp[i - 1][j][0];
dp[i][j][1] += dp[i - 1][j + 2][0];
}
if (i < h1 - 1 && i == h2 - 1) {
dp[i][j][1] += dp[i - 1][j + 1][1] + dp[i - 1][j + 2][0];
}
if (i < h1 - 1 && i == h2) {
dp[i][j][1] += dp[i - 1][j + 1][1] + dp[i - 1][j + 2][0];
}
if (i < h1 - 1 && i > h2) {
dp[i][j][0] += dp[i - 1][j][0];
dp[i][j][1] += dp[i - 1][j + 1][1];
}
if (i == h1 - 1 && i < h2 - 1) {
dp[i][j][0] += dp[i - 1][j][0];
dp[i][j][1] += dp[i - 1][j + 1][1];
}
if (i == h1 - 1 && i == h2 - 1) {
dp[i][j][1] += dp[i - 1][j + 1][1];
}
if (i == h1 - 1 && i == h2) {
dp[i][j][1] += dp[i - 1][j + 1][1];
}
if (i == h1 - 1 && i > h2) {
dp[i][j][0] += dp[i - 1][j][0];
}
if (i == h1 && i < h2 - 1) {
dp[i][j][1] += dp[i - 1][j + 1][1] + dp[i - 1][j + 2][0];
}
if (i == h1 && i == h2 - 1) {
dp[i][j][1] += dp[i - 1][j + 2][0];
}
if (i == h1 && i == h2) {
dp[i][j][1] += dp[i - 1][j + 2][0];
}
if (i == h1 && i > h2) {
dp[i][j][1] += dp[i - 1][j + 1][1];
}
if (i > h1 && i < h2 - 1) {
dp[i][j][0] += dp[i - 1][j][0];
dp[i][j][1] += dp[i - 1][j + 1][1];
}
if (i > h1 && i == h2 - 1) {
dp[i][j][1] += dp[i - 1][j + 1][1];
}
if (i > h1 && i == h2) {
dp[i][j][1] += dp[i - 1][j + 1][1];
}
if (i > h1 && i > h2) {
dp[i][j][0] += dp[i - 1][j][0];
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> s;
for (int h1 = 1; h1 <= 60; ++h1)
for (int h2 = 1; h2 <= 60; ++h2) {
if (h1 == 0 && h2 == 0) {
re++;
continue;
}
g = (1LL << h1) + (1LL << h2) - 3;
rt = s / g;
if (rt == 0) continue;
x = g + s % g + 1;
for (int pc = 2; pc <= h1 + h2; ++pc) {
if ((pc + x) % 2) continue;
v = solve(h1, h2, pc, (pc + x) / 2);
re += v;
}
}
cout << re;
return 0;
}
| 24 |
#include <bits/stdc++.h>
using namespace std;
string str, pat;
int n, p;
long long dp[2234][2234];
long long pos[1234567];
long long recur(int ind, int num) {
if (ind == 0) {
if (num == 0) return 0;
return -123456789;
}
if (dp[ind][num] != -1) return dp[ind][num];
long long ans = -123456789;
if (num > 0) ans = max(ans, recur(ind - 1, num - 1));
ans = max(ans, recur(ind - 1, num));
if (pos[ind] != -1) {
int x = ((ind - pos[ind] + 1) - p);
if (x <= num) ans = max(ans, 1 + recur(pos[ind] - 1, num - x));
}
return dp[ind][num] = ans;
}
int main() {
std::ios::sync_with_stdio(false);
cin >> str;
cin >> pat;
n = str.length();
p = pat.length();
memset(dp, -1, sizeof(dp));
memset(pos, -1, sizeof(pos));
int i;
for (i = 1; i < n + 1; i++) {
int ind = i;
int cnt = 0;
while (ind > 0 && cnt < p) {
if (str[ind - 1] == pat[p - 1 - cnt]) cnt++;
ind--;
}
if (cnt == p) pos[i] = ind + 1;
}
for (i = 0; i < n + 1; i++) {
cout << recur(n, i) << " ";
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int l, r;
cin >> l >> r;
int h = max(2 * l, r + 1);
if ((l % h) >= ((h + 1) / 2))
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int N;
const int MAXN = 5e4 + 15;
int X[MAXN], Y[MAXN], Z[MAXN];
int XX[MAXN], YY[MAXN], ZZ[MAXN];
vector<pair<pair<int, int>, int> > P[MAXN];
int V[MAXN];
int main() {
ios::sync_with_stdio(false);
cin >> N;
for (int i = 0; i < N; ++i) {
cin >> X[i] >> Y[i] >> Z[i];
XX[i] = X[i];
YY[i] = Y[i];
ZZ[i] = Z[i];
}
sort(XX, XX + N);
sort(YY, YY + N);
sort(ZZ, ZZ + N);
int N1 = unique(XX, XX + N) - XX;
int N2 = unique(YY, YY + N) - YY;
int N3 = unique(ZZ, ZZ + N) - ZZ;
for (int i = 0; i < N; ++i) {
X[i] = lower_bound(XX, XX + N1, X[i]) - XX;
Y[i] = lower_bound(YY, YY + N2, Y[i]) - YY;
Z[i] = lower_bound(ZZ, ZZ + N3, Z[i]) - ZZ;
}
for (int i = 0; i < N; ++i) {
P[Z[i]].push_back(make_pair(make_pair(Y[i], X[i]), i));
}
for (int z = 0; z <= 50000; ++z) sort(P[z].begin(), P[z].end());
for (int i = 0; i < N; ++i) V[i] = 0;
int n, p1, p2;
for (int z = 0; z <= 50000; ++z) {
if (P[z].size() > 0) {
n = P[z].size();
p1 = 0;
while (p1 < n - 1) {
if (P[z][p1].first.first == P[z][p1 + 1].first.first) {
cout << P[z][p1].second + 1 << " " << P[z][p1 + 1].second + 1 << endl;
V[P[z][p1].second] = 1;
V[P[z][p1 + 1].second] = 1;
p1 += 2;
} else {
++p1;
}
}
p1 = 0;
while (p1 < n) {
while (p1 < n && V[P[z][p1].second] == 1) ++p1;
if (p1 == n) break;
p2 = p1 + 1;
while (p2 < n && V[P[z][p2].second] == 1) ++p2;
if (p2 == n) break;
cout << P[z][p1].second + 1 << " " << P[z][p2].second + 1 << endl;
V[P[z][p1].second] = 1;
V[P[z][p2].second] = 1;
p1 = p2 + 1;
}
}
}
int f = 0;
int z1;
for (int z = 0; z <= 50000; ++z)
for (int p = 0; p < P[z].size(); ++p)
if (V[P[z][p].second] == 0) {
if (f == 1) {
cout << P[z1][p1].second + 1 << " " << P[z][p].second + 1 << endl;
f = 0;
} else {
z1 = z;
p1 = p;
++f;
}
}
return 0;
}
| 9 |
//#include <bits/stdc++.h>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
#include<string>
#include<vector>
#include<stack>
#include<bitset>
#include<cstdlib>
#include<cmath>
#include<set>
#include<list>
#include<deque>
#include<map>
#include<queue>
#define ll long long
#define LL long long
using namespace std;
int main() {
// ios::sync_with_stdio(0);
// cin.tie(0);
// cout.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin>>n;
string s;
cin>>s;
string ans="";
int len = s.length(),la=-1;
for(int i=0;i<len;i++){
if(s[i]=='1'){
if(la==2){
ans+='0';
la=1;
}else{
ans+='1';
la=2;
}
}else{
if(la==1){
ans+='0';
la=0;
}else{
ans+='1';
la=1;
}
}
//cout<<la<<'-';
}
cout<<ans<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, g[15], cnt;
char s[5];
vector<pair<int, int> > v;
int getid(char c) {
if (isdigit(c)) return c - '1';
if (c == 'R') return 5;
if (c == 'G') return 6;
if (c == 'B') return 7;
if (c == 'Y') return 8;
if (c == 'W') return 9;
}
bool check(int s) {
int t[15], c = 0;
bool vis[15] = {0};
memcpy(t, g, sizeof t);
for (int i = 0; i < cnt; i++)
if ((1 << v[i].first & s) && (1 << v[i].second & s)) {
vis[i] = true;
c++;
t[v[i].first]--;
t[v[i].second]--;
}
for (int j = 0; j < 2; j++)
for (int i = 0; i < cnt; i++) {
if (vis[i]) continue;
if (((1 << v[i].second & s) && t[v[i].second] == 1) ||
((1 << v[i].first & s) && t[v[i].first] == 1)) {
c++;
vis[i] = true;
t[v[i].first]--;
t[v[i].second]--;
}
}
return c >= cnt - 1;
}
int main() {
scanf("%d", &n);
while (n--) {
scanf("%s", s);
v.push_back(make_pair(getid(s[0]), getid(s[1])));
}
sort(v.begin(), v.end());
cnt = unique(v.begin(), v.end()) - v.begin();
for (int i = 0; i < cnt; i++) g[v[i].first]++, g[v[i].second]++;
int ans = 10;
for (int i = 0; i < (1 << 10); i++)
if (check(i)) ans = min(ans, __builtin_popcount(i));
printf("%d\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 500043;
vector<int> g[N];
vector<int> t[N];
int tin[N], tout[N], fup[N];
int p[N];
int T = 1;
int rnk[N];
vector<pair<int, int>> bridges;
int st;
int d[N];
int n, m;
int get(int x) {
if (p[x] == x)
return x;
else
return p[x] = get(p[x]);
}
void link(int x, int y) {
x = get(x);
y = get(y);
if (x == y) return;
if (rnk[x] > rnk[y]) swap(x, y);
p[x] = y;
rnk[y] += rnk[x];
}
int dfs(int x, int par = -1) {
tin[x] = T;
T++;
fup[x] = tin[x];
for (auto y : g[x]) {
if (tin[y] > 0) {
if (par != y) fup[x] = min(fup[x], tin[y]);
} else {
int f = dfs(y, x);
fup[x] = min(fup[x], f);
if (f > tin[x])
bridges.push_back(make_pair(x, y));
else
link(x, y);
}
}
tout[x] = T;
T++;
return fup[x];
}
void build() {
for (auto z : bridges) {
int x = get(z.first);
int y = get(z.second);
st = x;
t[x].push_back(y);
t[y].push_back(x);
}
}
pair<int, int> bfs(int x) {
for (int i = 0; i < n; i++) d[i] = n + 1;
d[x] = 0;
queue<int> q;
q.push(x);
int last = 0;
while (!q.empty()) {
last = q.front();
q.pop();
for (auto y : t[last])
if (d[y] > d[last] + 1) {
d[y] = d[last] + 1;
q.push(y);
}
}
return make_pair(last, d[last]);
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) rnk[i] = 1, p[i] = i;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
--x;
--y;
g[x].push_back(y);
g[y].push_back(x);
}
dfs(0);
build();
pair<int, int> p1 = bfs(st);
pair<int, int> p2 = bfs(p1.first);
cout << p2.second;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2005;
const double eps = 1e-10;
double f[N][N], p[N], u[N], t[N];
int cnt[N][N], n, a, b;
inline int check(double k) {
for (int i = 1; i <= n; ++i) {
for (int j = 0; j <= a; ++j) {
f[i][j] = f[i - 1][j];
cnt[i][j] = cnt[i - 1][j];
if (j > 0 && f[i - 1][j - 1] + p[i] > f[i][j])
f[i][j] = f[i - 1][j - 1] + p[i], cnt[i][j] = cnt[i - 1][j - 1];
if (f[i - 1][j] + u[i] - k > f[i][j])
f[i][j] = f[i - 1][j] + u[i] - k, cnt[i][j] = cnt[i - 1][j] + 1;
if (j > 0 && f[i - 1][j - 1] + t[i] - k > f[i][j])
f[i][j] = f[i - 1][j - 1] + t[i] - k, cnt[i][j] = cnt[i - 1][j - 1] + 1;
}
}
return cnt[n][a];
}
int main() {
scanf("%d %d %d", &n, &a, &b);
for (int i = 1; i <= n; ++i) scanf("%lf", &p[i]);
for (int i = 1; i <= n; ++i)
scanf("%lf", &u[i]), t[i] = 1.0 - (1.0 - p[i]) * (1.0 - u[i]);
double l = 0, r = 1, mid;
int use;
while (l + eps < r) {
mid = (l + r) / 2.0;
use = check(mid);
if (use == b) break;
if (use < b)
r = mid;
else
l = mid;
}
check(mid);
printf("%.10lf", f[n][a] + 1.0 * b * mid);
return 0;
}
| 22 |
#include <bits/stdc++.h>
using namespace std;
int n, ans = 0, c[30];
string s;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> s;
c[int(s[0]) - 96]++;
}
for (int i = 1; i <= 27; i++) {
int m = c[i];
ans += m / 2 * (m / 2 - 1) / 2 + (m / 2 + m % 2) * (m / 2 + m % 2 - 1) / 2;
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long l, r;
void readInput() { cin >> l >> r; }
void solve() {
if (l == r)
cout << 0 << endl;
else
cout << (1ll << (63 - __builtin_clzll(l ^ r)) + 1) - 1 << endl;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
readInput(), solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int N = 300000;
int n;
int a[N + 2], pos[N + 1];
struct segtree {
struct node {
int l, r, mn1, mn2, cnt1, cnt2, lz;
} nd[N << 2];
void sprup(int p) {
int s[] = {nd[p << 1].mn1, nd[p << 1].mn2, nd[p << 1 | 1].mn1,
nd[p << 1 | 1].mn2, inf};
sort(s, s + 5);
unique(s, s + 5);
nd[p].mn1 = s[0];
nd[p].cnt1 = (nd[p << 1].mn1 == nd[p].mn1) * nd[p << 1].cnt1 +
(nd[p << 1 | 1].mn1 == nd[p].mn1) * nd[p << 1 | 1].cnt1;
nd[p].mn2 = s[1];
nd[p].cnt2 = (nd[p << 1].mn1 == nd[p].mn2) * nd[p << 1].cnt1 +
(nd[p << 1 | 1].mn1 == nd[p].mn2) * nd[p << 1 | 1].cnt1 +
(nd[p << 1].mn2 == nd[p].mn2) * nd[p << 1].cnt2 +
(nd[p << 1 | 1].mn2 == nd[p].mn2) * nd[p << 1 | 1].cnt2;
}
void sprdwn(int p) {
if (nd[p].lz) {
nd[p << 1].mn1 += nd[p].lz, nd[p << 1].mn2 += nd[p].lz,
nd[p << 1].lz += nd[p].lz;
nd[p << 1 | 1].mn1 += nd[p].lz, nd[p << 1 | 1].mn2 += nd[p].lz,
nd[p << 1 | 1].lz += nd[p].lz;
nd[p].lz = 0;
}
}
void bld(int l = 1, int r = n, int p = 1) {
nd[p].l = l;
nd[p].r = r;
nd[p].mn1 = 0, nd[p].mn2 = inf, nd[p].cnt1 = r - l + 1, nd[p].cnt2 = 0;
nd[p].lz = 0;
if (l == r) return;
int mid = l + r >> 1;
bld(l, mid, p << 1), bld(mid + 1, r, p << 1 | 1);
}
void init() { bld(); }
void add(int l, int r, int v, int p = 1) {
if (l <= nd[p].l && r >= nd[p].r)
return nd[p].mn1 += v, nd[p].mn2 += v, nd[p].lz += v, void();
sprdwn(p);
int mid = nd[p].l + nd[p].r >> 1;
if (l <= mid) add(l, r, v, p << 1);
if (r > mid) add(l, r, v, p << 1 | 1);
sprup(p);
}
int cnt(int l, int r, int p = 1) {
if (l <= nd[p].l && r >= nd[p].r) {
int res = 0;
if (nd[p].mn1 <= 2) res += nd[p].cnt1;
if (nd[p].mn2 <= 2) res += nd[p].cnt2;
return res;
}
sprdwn(p);
int mid = nd[p].l + nd[p].r >> 1, res = 0;
if (l <= mid) res += cnt(l, r, p << 1);
if (r > mid) res += cnt(l, r, p << 1 | 1);
return res;
}
} segt;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) scanf("%d", a + i), pos[a[i]] = i;
segt.init();
long long ans = 0;
for (int i = 1; i <= n; i++) {
int l = a[pos[i] - 1], r = a[pos[i] + 1];
if (l > i) l = 0;
if (r > i) r = 0;
if (l > r) swap(l, r);
segt.add(r + 1, i, 1);
if (1 <= l) segt.add(1, l, -1);
if (1 <= i - 1) ans += segt.cnt(1, i - 1);
}
cout << ans;
return 0;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
vector<int> ar(n);
for (auto &i : ar) cin >> i;
vector<vector<int> > pos(n);
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++)
if (ar[i] > ar[j]) pos[j].push_back(i);
vector<pair<int, int> > ans;
for (int i = n - 1; i >= 0; i--) {
sort(pos[i].begin(), pos[i].end(), [&](const int &a, const int &b) {
return (ar[a] == ar[b]) ? a < b : ar[a] < ar[b];
});
for (auto j : pos[i]) ans.push_back(make_pair(j + 1, i + 1));
}
cout << ans.size() << '\n';
for (auto [i, j] : ans) cout << i << ' ' << j << '\n';
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
static const double PI = 2 * acos(0);
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N, K;
cin >> N >> K;
int lo = 1, hi = N;
while (lo < hi) {
int mid1 = (lo + hi) / 2;
int mid2 = mid1 + 1;
cout << 1 << " " << mid1 << " " << mid2 << endl;
string input;
cin >> input;
if (input == "TAK")
hi = mid1;
else
lo = mid2;
}
int firstv = lo, secv = -1;
lo = 1, hi = firstv - 1;
if (hi >= lo) {
while (lo < hi) {
int mid1 = (lo + hi) / 2;
int mid2 = mid1 + 1;
cout << 1 << " " << mid1 << " " << mid2 << endl;
string input;
cin >> input;
if (input == "TAK")
hi = mid1;
else
lo = mid2;
}
cout << 1 << " " << lo << " " << firstv << endl;
string input;
cin >> input;
if (input == "TAK") secv = lo;
}
lo = firstv + 1, hi = N;
if (hi >= lo && secv == -1) {
while (lo < hi) {
int mid1 = (lo + hi) / 2;
int mid2 = mid1 + 1;
cout << 1 << " " << mid1 << " " << mid2 << endl;
string input;
cin >> input;
if (input == "TAK")
hi = mid1;
else
lo = mid2;
}
}
if (secv == -1) secv = lo;
cout << 2 << " " << firstv << " " << secv << endl;
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int dp[4][10000007];
int main() {
dp[0][0] = 1;
int n;
cin >> n;
for (int i = 1; i <= n; ++i)
for (int j = 0; j < 4; ++j)
for (int k = 0; k < 4; ++k)
if (j != k) {
int &ans = dp[j][i];
ans += dp[k][i - 1];
if (ans >= 1000000007) ans -= 1000000007;
}
cout << dp[0][n] << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long n, m, si;
vector<long long> g[100010], s;
long long dep[100010];
bool mar[100010];
void dfs(long long p) {
s.push_back(p);
dep[p] = s.size();
for (long long i : g[p]) {
if (!dep[i])
dfs(i);
else if (dep[p] - dep[i] + 1 >= si) {
cout << "2" << endl << dep[p] - dep[i] + 1 << endl;
for (long long j = dep[i]; j <= dep[p]; j++) cout << s[j - 1] << " ";
cout << endl;
exit(0);
}
}
if (!mar[p]) {
for (long long i : g[p]) {
mar[i] = true;
}
}
s.pop_back();
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (long long i = 0; i < m; i++) {
long long a, b;
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
si = 1;
while (si * si < n) si++;
memset(mar, 0, sizeof(mar));
memset(dep, 0, sizeof(dep));
dfs(1);
cout << "1" << endl;
for (long long i = 1; si; i++) {
if (!mar[i]) {
cout << i << " ";
si--;
}
}
cout << endl;
return 0;
}
| 13 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef long double ld;
#define F first
#define S second
const int MOD = 1e9 + 7;//XXX
const int C = 26;//XXX
void add(int &x, int y){
x += y;
while (x >= MOD) x -= MOD;
while (x < 0) x += MOD;
}
int fix(int x){
while (x >= MOD) x -= MOD;
while (x < 0) x += MOD;
return x;
}
int pw(int a, int b){
int ret = 1;
while (b){
if (b & 1)
ret = 1ll*ret*a%MOD;
b >>= 1;
a = 1ll*a*a%MOD;
}
return ret;
}
const int MAXN = 1e3 + 10;
int memo[MAXN][MAXN][2];
int n, k;
int dp(int i, int j, int dir) {
if(i == 0 || i == n+1) return 1;
if(j == 0) return 0;
//cerr << i << " " << j << " " << dir << endl;
int& ans = memo[i][j][dir];
if(~ans) return ans;
ans = 0;
if(dir == 0) {
add(ans, dp(i+1, j, 0));
if(j > 1) {
add(ans, dp(i-1, j-1, 1));
}
} else {
add(ans, dp(i-1, j, 1));
if(j > 1) {
add(ans, dp(i+1, j-1, 0));
}
}
return ans;
}
void solve() {
cin >> n >> k;
for(int i = 0; i <= n; i++) {
for(int j = 0; j <= k; j++) {
for(int a = 0; a < 2; a++) {
memo[i][j][a] = -1;
}
}
}
cout << dp(1, k, 0) << "\n";
}
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
//cout << fixed << setprecision(6);
int te = 1;
cin >> te;
for (int w = 1; w <= te; w++){
//cout << "Case #" << w << ": ";
solve();
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
int dx[] = {-1, -1, -1, 0, 0, 1, 1, 1};
int dy[] = {-1, 0, 1, -1, 1, -1, 0, 1};
long long gcd(long long x, long long y) { return (!y) ? x : gcd(y, x % y); }
long long lcm(long long x, long long y) { return ((x / gcd(x, y) * y)); }
using namespace std;
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
bool prime(long long n) {
if (n == 2)
return 1;
else if (n < 2 || !(n & 1))
return 0;
for (long long i = 3; i * i <= n; i += 2) {
if (n % i == 0) return 0;
}
return 1;
}
int main() {
fast();
long long k, p, x, y, ans = 0;
cin >> k >> p;
for (int i = 1; i <= k; i++) {
x = i;
y = i;
while (y) {
x = x * 10 + y % 10;
y /= 10;
}
ans += (x % p);
}
ans %= p;
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int M = INT_MAX;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
int h(char c) {
if (c >= 'a' && c <= 'z') return c - 'a' + 1;
if (c >= 'A' && c <= 'Z') return c - 'A' + 1;
return 0;
}
int main() {
string s;
cin >> s;
int res = 0;
for (int i = 0; i < s.length(); i++) {
bool b1, b2;
b1 = '@' < s[i];
b2 = '[' > s[i];
int x;
if (b1 && b2)
x = 1;
else
x = 0;
bool b3, b4;
b3 = '`' < s[i];
b4 = '{' > s[i];
int y;
if (b3 && b4)
y = 1;
else
y = 0;
int xx, yy;
xx = x * h(s[i]);
yy = y * h(s[i]);
res += xx - yy;
}
cout << res;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
long block_size;
bool comp(vector<long> a, vector<long> b) {
if ((a[0] / block_size) == (b[0] / block_size)) return (a[1] < b[1]);
return (a[0] < b[0]);
}
int main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(0);
long n, m, s = 0;
cin >> n >> m;
block_size = sqrt(n);
vector<long long> a(n + 1, 0);
vector<vector<long> > b(m, vector<long>(3));
vector<long> k(m, 0), sl(1e5 + 1, 0), d(1e5 + 1, 0);
for (long i = 1; i <= n; cin >> a[i], ++i)
;
for (long i = 0; i < m; cin >> b[i][0] >> b[i][1], b[i][2] = i, ++i)
;
sort(b.begin(), b.end(), comp);
for (long j = b[0][0]; j <= b[0][1]; ++j)
if (a[j] <= 1e5) {
if ((++sl[a[j]]) == a[j])
++s, d[a[j]] = 1;
else if (sl[a[j]] > a[j] && d[a[j]])
--s, d[a[j]] = 0;
}
k[b[0][2]] = s;
for (long i = 1; i < b.size(); ++i) {
if (b[i - 1][0] < b[i][0]) {
for (long j = b[i - 1][0]; j < b[i][0]; ++j)
if (a[j] <= 1e5) {
if ((--sl[a[j]]) == a[j])
++s, d[a[j]] = 1;
else if (sl[a[j]] < a[j] && d[a[j]])
--s, d[a[j]] = 0;
}
} else {
for (long j = b[i][0]; j < b[i - 1][0]; ++j)
if (a[j] <= 1e5) {
if ((++sl[a[j]]) == a[j])
++s, d[a[j]] = 1;
else if (sl[a[j]] > a[j] && d[a[j]])
--s, d[a[j]] = 0;
}
}
if (b[i - 1][1] < b[i][1]) {
for (long j = b[i - 1][1] + 1; j <= b[i][1]; ++j)
if (a[j] <= 1e5) {
if ((++sl[a[j]]) == a[j])
++s, d[a[j]] = 1;
else if (sl[a[j]] > a[j] && d[a[j]])
--s, d[a[j]] = 0;
}
} else {
for (long j = b[i][1] + 1; j <= b[i - 1][1]; ++j)
if (a[j] <= 1e5) {
if ((--sl[a[j]]) == a[j])
++s, d[a[j]] = 1;
else if (sl[a[j]] < a[j] && d[a[j]])
--s, d[a[j]] = 0;
}
}
k[b[i][2]] = s;
}
for (long i = 0; i < k.size(); cout << k[i] << '\n', ++i)
;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
struct debugger {
template <typename T>
debugger& operator,(const T& v) {
cout << v << " ";
return *this;
}
} dbg;
int dx[] = {-1, 1, 0, 0, -1, -1, 1, 1};
int dy[] = {0, 0, 1, -1, -1, 1, -1, 1};
int a[111];
int main() {
int t = 0, z = 0, len;
int n = 0, k = 0, m = 0;
int ans = 0;
ans = INT_MAX;
scanf("%d %d", &n, &k);
for (int l = 0; l < n; l++) scanf("%d", &a[l]);
sort(a, a + n);
for (int l = 0; l < n; l++) {
if (!(k % a[l])) ans = min(ans, (k / a[l]));
}
printf("%d", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename TH>
void _dbg(const char* sdbg, TH h) {
cerr << sdbg << '=' << h << '\n';
}
template <typename TH, typename... TA>
void _dbg(const char* sdbg, TH h, TA... t) {
while (*sdbg != ',') cerr << *sdbg++;
cerr << "=" << h << ",";
_dbg(sdbg + 1, t...);
}
long long n, maxr[100010], fen[100010], ans[100010];
long long smax(long long i, long long j) {
return (maxr[i] > maxr[j] or (maxr[i] == maxr[j] and (i > j))) ? i : j;
}
void update(int i) {
int curr = i;
while (curr <= n) {
fen[curr] = smax(fen[curr], i);
curr += (curr & -curr);
}
}
long long get(int i) {
long long ret = 0;
while (i) {
ret = smax(ret, fen[i]);
i -= (i & -i);
}
return ret;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 1; i < n; i++) {
cin >> maxr[i];
}
maxr[n] = n;
update(n);
ans[n] = 0;
long long ret = 0;
for (int i = n - 1; i > 0; i--) {
long long mv = get(maxr[i]);
(i, mv);
ans[i] = mv - i + ans[mv] + (n - maxr[i]);
ret += ans[i];
update(i);
}
cout << ret;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int N;
long long arr[100005], r, l, ans;
int main() {
cin >> N;
for (int i = 0; i < N; i++) cin >> arr[i];
sort(arr, arr + N);
l = r = 0;
ans = r = accumulate(arr, arr + N, r);
for (int i = 0; i < N; i++) {
r -= arr[i];
l += arr[i];
ans = min(ans, abs(r - l));
}
cout << ans + 1 << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2 * 1e5 + 5, MOD = 1e9 + 7;
long long dp[2][3];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, l, r;
cin >> n >> l >> r;
int m[3];
int prev = 0, cur = 1;
for (int i = 0; i < 3; ++i) {
int a = ceil((l - i) / 3.0);
int b = floor((r - i) / 3.0);
m[i] = b - a + 1;
dp[prev][i] = m[i];
}
for (int i = 1; i < n; ++i) {
dp[cur][0] =
(dp[prev][0] * m[0] + dp[prev][1] * m[2] + dp[prev][2] * m[1]) % MOD;
dp[cur][1] =
(dp[prev][0] * m[1] + dp[prev][1] * m[0] + dp[prev][2] * m[2]) % MOD;
dp[cur][2] =
(dp[prev][0] * m[2] + dp[prev][1] * m[1] + dp[prev][2] * m[0]) % MOD;
swap(cur, prev);
}
cout << dp[prev][0] << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct node {
long long r1;
long long r2;
} dis[2005];
bool cmp(node a, node b) { return a.r1 < b.r1; }
long long dp[2005];
int main() {
long long n, x1, y1, x2, y2;
scanf("%lld %lld %lld %lld %lld", &n, &x1, &y1, &x2, &y2);
for (register int i = 1; i <= n; i++) {
long long x, y;
scanf("%lld %lld", &x, &y);
dis[i].r1 = (x - x1) * (x - x1) + (y - y1) * (y - y1);
dis[i].r2 = (x - x2) * (x - x2) + (y - y2) * (y - y2);
}
sort(dis + 1, dis + n + 1, cmp);
for (register int i = n; i >= 1; i--) {
dp[i] = max(dp[i + 1], dis[i].r2);
}
long long ans = dp[1];
for (register int i = 1; i <= n; i++) {
if (dis[i].r1 + dp[i + 1] < ans) ans = dis[i].r1 + dp[i + 1];
}
printf("%lld\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
vector<int> a, b;
struct trie {
trie *f[2];
int sz;
trie() {
memset(f, 0, sizeof f);
sz = 0;
}
void add(int val, int with) {
auto *t = this;
for (int i = 29; i >= 0; --i) {
bool dir = val & (1 << i);
if (!t->f[dir]) {
t->f[dir] = new trie();
}
t = t->f[dir];
t->sz += with;
}
}
int qry(int x) {
auto *t = this;
int rez = 0;
int number = 0;
for (int i = 29; i >= 0; --i) {
bool dir = x & (1 << i);
if (t->f[dir] && t->f[dir]->sz) {
if (dir) number += 1 << i;
t = t->f[dir];
} else if (t->f[dir ^ 1]) {
if (!dir) number += 1 << i;
t = t->f[dir ^ 1];
} else
break;
}
return number;
}
};
int main() {
int n;
cin >> n;
a.resize(n), b.resize(n);
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < n; ++i) cin >> b[i];
sort(b.begin(), b.end());
trie *t = new trie();
for (int i = 0; i < n; ++i) t->add(b[i], 1);
for (int i = 0; i < n; ++i) {
int curr = t->qry(a[i]);
cout << (curr ^ a[i]) << ' ';
t->add(curr, -1);
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int holes[100010];
int main() {
int n, b, a, i, suma = 0, first, cnt = 0;
scanf("%d%d%d", &n, &b, &a);
for (i = 1; i <= n; i++) {
scanf("%d", &holes[i]);
suma += holes[i];
}
first = holes[1];
sort(holes + 2, holes + n + 1);
for (i = n; i > 1; i--) {
if ((first * b) / suma >= a) {
printf("%d\n", cnt);
return 0;
}
suma -= holes[i];
cnt++;
}
printf("%d\n", n - 1);
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse4")
using namespace std;
bool comp(pair<long long int, int> &a, pair<long long int, int> &b) {
return a.first > b.first;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
int n, m;
cin >> n >> m;
long long int arr[n][m];
pair<long long int, int> row[n];
pair<long long int, int> col[m];
for (auto &i : row) i.first = 0;
for (auto &i : col) i.first = 0;
long long int su = 0;
for (int i = 0; i < n; i++) {
row[i].second = i;
for (int j = 0; j < m; j++) {
cin >> arr[i][j];
su += arr[i][j];
row[i].first += arr[i][j];
col[j].second = j;
col[j].first += arr[i][j];
}
}
if (n <= 4 || m <= 4) {
cout << su << "\n";
return 0;
}
sort(col, col + m, comp);
sort(row, row + n, comp);
long long int ans = 0;
for (int i = 0; i < 4; i++) ans += row[i].first;
long long int val = 0;
for (int i = 0; i < 4; i++) val += col[i].first;
ans = max(ans, val);
for (int i = 0; i < n; i++) {
long long int ls[3] = {0};
for (int j = 0; j < m; j++) {
long long int x = col[j].first - arr[row[i].second][col[j].second];
if (x > ls[0]) {
ls[2] = ls[1];
ls[1] = ls[0];
ls[0] = x;
} else if (x > ls[1]) {
ls[2] = ls[1];
ls[1] = x;
} else if (x > ls[2])
ls[2] = x;
ans = max(ans, row[i].first + ls[0] + ls[1] + ls[2]);
}
}
for (int i = 0; i < m; i++) {
long long int ls[3] = {0};
for (int j = 0; j < n; j++) {
long long int x = row[j].first - arr[row[j].second][col[i].second];
if (x > ls[0]) {
ls[2] = ls[1];
ls[1] = ls[0];
ls[0] = x;
} else if (x > ls[1]) {
ls[2] = ls[1];
ls[1] = x;
} else if (x > ls[2])
ls[2] = x;
ans = max(ans, col[i].first + ls[0] + ls[1] + ls[2]);
}
}
if (n < m) {
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
long long int ls[2] = {0};
for (int k = 0; k < m; k++) {
long long int x = col[k].first - arr[row[i].second][col[k].second] -
arr[row[j].second][col[k].second];
if (x > ls[0]) {
ls[1] = ls[0];
ls[0] = x;
} else if (x > ls[1])
ls[1] = x;
ans = max(ans, row[i].first + row[j].first + ls[0] + ls[1]);
}
}
}
} else {
for (int i = 0; i < m; i++) {
for (int j = i + 1; j < m; j++) {
long long int ls[2] = {0};
for (int k = 0; k < n; k++) {
long long int x = row[k].first - arr[row[k].second][col[i].second] -
arr[row[k].second][col[j].second];
if (x > ls[0]) {
ls[1] = ls[0];
ls[0] = x;
} else if (x > ls[1])
ls[1] = x;
ans = max(ans, col[i].first + col[j].first + ls[0] + ls[1]);
}
}
}
}
cout << ans << "\n";
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const long long P = 1000000007;
int n, p[1004];
long long f[1004];
int main() {
int i;
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &p[i]);
f[1] = 0;
for (i = 1; i <= n; i++) f[i + 1] = (f[i] + f[i] - f[p[i]] + P + 2) % P;
printf("%I64d\n", f[n + 1]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
int gcd(int a, int b) {
if (b) return gcd(b, a % b);
return a;
}
int func1(int a, int b) {
return ((a * b) << 2) - ((a + b) << 1) - (gcd(a, b) << 1);
}
int func2(int a, int b) { return ((a * b) << 1) - (gcd(a, b) << 1); }
int func3(int a, int b) {
return ((a * b) * 5) - ((a + b) << 1) - (gcd(a, b) << 1);
}
int cal(int a, int b) {
if ((a & 1) && !(b & 1)) return func1(a, b);
if (!(a & 1) && (b & 1)) return func1(b, a);
if ((a & 1) && (b & 1))
return func2(a, b);
else
return func3(a, b);
}
int main() {
long long a, b, res = 0;
scanf("%lld%lld", &a, &b);
for (int i = 1; i <= a; i++)
for (int j = 1; j <= b; j++) {
long long tem, sz = (a - i + 1) * (b - j + 1);
if ((i & 1) && (j & 1))
tem = 0;
else
tem = ((i - 1) << 1) + ((j - 1) << 1) + 4;
tem = (tem + cal(i, j)) % mod;
tem = tem * sz % mod;
res = (res + tem) % mod;
}
res = res * 6 % mod;
printf("%lld\n", res);
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int A[100005], B[100005];
int main() {
int i, j, k, m, n;
while (~scanf("%d", &n)) {
memset(B, 0, sizeof(B));
for (i = 1; i <= n; i++) scanf("%d", &A[i]);
for (i = 1; i <= n; i++) {
m = min(A[i - 1], A[i + 1]);
m = min(m + 1, A[i]);
m = min(m, i);
A[i] = m;
}
for (i = n; i > 0; i--) {
m = min(A[i - 1], A[i + 1]);
m = min(m + 1, A[i]);
m = min(m, n - i + 1);
A[i] = m;
}
int Max = -1;
for (i = 1; i <= n; i++)
if (Max < A[i]) Max = A[i];
printf("%d\n", Max);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e15;
signed main() {
long long i, n, type, tec_speed, obg = 0, max_speed = inf;
cin >> n >> type >> tec_speed;
stack<long long> speeds;
speeds.push(inf);
long long ans = 0;
for (i = 1; i < n; i++) {
cin >> type;
if (type == 1) {
cin >> tec_speed;
while (tec_speed > max_speed) {
speeds.pop();
ans++;
max_speed = speeds.top();
}
}
if (type == 2) {
ans += obg;
obg = 0;
}
if (type == 3) {
cin >> max_speed;
speeds.push(max_speed);
while (tec_speed > max_speed) {
speeds.pop();
ans++;
max_speed = speeds.top();
}
}
if (type == 4) {
obg = 0;
}
if (type == 5) {
max_speed = inf;
speeds.push(inf);
}
if (type == 6) {
obg++;
}
}
cout << ans;
return 0;
}
| 10 |
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
using namespace std;
const long long MAX = 1e5 + 5;
vector<pair<long long, long long> > ans;
vector<long long> even;
bool O[MAX];
bool prime(long long i) {
for (long long j = 2; j * j <= i; j++)
if (i % j == 0) return false;
return true;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
for (long long i = 3; i <= n; i++) {
if (!prime(i)) continue;
vector<long long> can;
can.clear();
bool t = false;
for (long long j = i; j <= n; j += i) {
if (!O[j] && j != 2 * i)
can.push_back(j), O[j] = true;
else if (!O[j] && j == 2 * i)
t = true;
}
if ((long long)can.size() % 2 == 1 && t)
can.push_back(2 * i), O[2 * i] = true;
for (long long i = 0; i < (long long)can.size() - 1; i += 2)
ans.push_back(make_pair(can[i], can[i + 1]));
}
for (long long i = 2; i <= n; i += 2)
if (!O[i]) even.push_back(i);
for (long long i = 0; i < (long long)even.size() - 1; i += 2)
ans.push_back(make_pair(even[i], even[i + 1]));
cout << ans.size() << "\n";
for (auto it : ans) cout << it.first << " " << it.second << "\n";
;
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
string str;
int main() {
getline(cin, str);
int len = str.length() - 1;
while (!isalpha(str[len])) len--;
if (str[len] == 'A' || str[len] == 'E' || str[len] == 'I' ||
str[len] == 'O' || str[len] == 'U' || str[len] == 'Y' ||
str[len] == 'a' || str[len] == 'e' || str[len] == 'i' ||
str[len] == 'o' || str[len] == 'u' || str[len] == 'y')
printf("YES");
else
printf("NO");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string w;
cin >> w;
bool ch = 1;
for (int i = 1; i < w.size(); i++) {
if (w[i] > 92 && ch) {
ch = !ch;
break;
}
}
if (ch) {
for (int i = 0; i < w.size(); i++) {
if (w[i] > 92)
w[i] = (char)(w[i] - 32);
else
w[i] = (char)(w[i] + 32);
}
cout << w << endl;
} else
cout << w << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long double PI =
3.141592653589793238462643383279502884197169399375105820974944;
inline void io() {}
const long long mod = 1e9 + 7;
const long long maxn = 3e5 + 5;
void solve() {
long long n, k;
cin >> n >> k;
long long a[n];
map<long long, long long> mp;
for (long long i = 0; i < n; i++) {
cin >> a[i];
mp[a[i]]++;
}
long long ans = 0;
sort(a, a + n);
map<long long, long long> h;
for (long long i = 0; i < n; i++) {
long long ok = 0;
if (mp[a[i] * k] && !h[a[i]]) {
h[a[i] * k] = 1;
h[a[i]] = 1;
ans++;
}
if (!h[a[i]]) ans++;
}
cout << ans;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
io();
long long tc = 1;
while (tc--) {
solve();
cout << '\n';
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long a, b, ans;
int main() {
cin >> a >> b;
for (int i = 2; i < 62; i++) {
long long mask = (1LL << i) - 1;
for (int j = 0; j < i - 1; j++) {
long long tmp = mask ^ (1LL << j);
if (tmp >= a && tmp <= b) ans++;
}
}
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000 * 1000 * 1000;
int n, X1, Y1, X2, Y2;
int main() {
scanf("%d%d%d%d%d", &n, &X1, &Y1, &X2, &Y2);
if (X1 == 0 && X2 == 0) {
printf("%d", abs(Y1 - Y2));
return 0;
}
if (Y1 == 0 && Y2 == 0) {
printf("%d", abs(X1 - X2));
return 0;
}
if (X1 == n && X2 == n) {
printf("%d", abs(Y1 - Y2));
return 0;
}
if (Y1 == n && Y2 == n) {
printf("%d", abs(X1 - X2));
return 0;
}
int res = X1 + X2 + Y1 + Y2;
int t = 2 * n - X1 - X2 + Y1 + Y2;
res = min(res, t);
t = 2 * n - X1 - X2 + Y1 + Y2;
res = min(t, res);
t = 4 * n - X1 - X2 - Y1 - Y2;
res = min(t, res);
t = 2 * n + X1 + X2 - Y1 - Y2;
res = min(t, res);
printf("%d", res);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, m;
cin >> n >> m;
vector<long long> a(n), b(n);
set<long long> s;
for (long long i = 0; i < n; i++) cin >> a[i];
for (long long i = 0; i < n; i++) cin >> b[i], s.insert(b[i]);
sort(b.begin(), b.end());
sort(a.begin(), a.end());
long long mi = a[0], ans = INT_MAX;
for (auto x : s) {
long long dif;
if (x >= mi)
dif = x - mi;
else
dif = m + x - mi;
vector<long long> t(a);
for (long long i = 0; i < n; i++) {
t[i] = (t[i] + dif) % m;
}
sort(t.begin(), t.end());
if (t == b) {
ans = min(ans, dif);
}
}
cout << ans;
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-O3")
#pragma GCC optimize("-Ofast")
using namespace std;
long long sf[+500500], pr[+500500], ans2, ans1, p, b[+500500], a[+500500], mid,
n, i, B[+500500];
long long t[4 * +500500];
void upd(long long v, long long l, long long r, long long ps, long long x,
bool c) {
if (l == r)
t[v] = x;
else {
long long md = (l + r) >> 1;
if (ps <= md)
upd(v * 2, l, md, ps, x, c);
else
upd(v * 2 + 1, md + 1, r, ps, x, c);
if (t[v * 2] >= t[v * 2 + 1])
t[v] = t[v * 2 + 1];
else
t[v] = t[v * 2];
}
}
long long first(long long v, long long l, long long r, long long tl,
long long tr, long long x) {
if (l > r || l > tr || tl > tr || tl > r) return -1;
if (t[v] > x) return -1;
if (l == r) return l;
long long md = (l + r) >> 1;
long long fst = first(v * 2 + 1, md + 1, r, max(md + 1, tl), tr, x);
if (fst == -1) return first(v * 2, l, md, tl, min(tr, md), x);
return fst;
}
long long second(long long v, long long l, long long r, long long tl,
long long tr, long long x) {
if (l > r || l > tr || tl > tr || tl > r) return -1;
if (t[v] > x) return -1;
if (l == r) return l;
long long md = (l + r) >> 1;
long long scd = second(v * 2, l, md, tl, min(md, tr), x);
if (scd == -1) return second(v * 2 + 1, md + 1, r, max(tl, md + 1), tr, x);
return scd;
}
void build(long long v, long long l, long long r) {
t[v] = 1e18;
if (l == r) return;
long long md = (l + r) >> 1;
build(v * 2, l, md);
build(v * 2 + 1, md + 1, r);
}
int main() {
ios_base::sync_with_stdio(NULL);
iostream::sync_with_stdio(NULL);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
for (i = 1; i <= n; i++) cin >> a[i];
sf[n + 1] = pr[0] = 1e18;
for (i = 1; i <= n; i++) pr[i] = min(pr[i - 1], a[i]), ans1 += pr[i];
for (i = n; i >= 1; i--) sf[i] = min(sf[i + 1], a[i]), ans2 += sf[i];
build(1, 1, n);
upd(1, 1, n, 1, a[1], 1);
p = a[1];
b[1] = p;
for (mid = 2; mid <= n; mid++) {
long long ft = first(1, 1, n, 1, mid - 1, a[mid]);
if (ft == -1)
p = 0, ft = 0;
else
p = b[ft];
p += (mid - ft) * a[mid];
b[mid] = p;
upd(1, 1, n, mid, a[mid], 1);
}
build(1, 1, n);
upd(1, 1, n, n, a[n], 0);
p = a[n];
B[n] = a[n];
for (mid = n - 1; mid >= 1; mid--) {
long long sd = second(1, 1, n, mid + 1, n, a[mid]);
if (sd == -1)
p = 0, sd = n + 1;
else
p = B[sd];
p += (sd - mid) * a[mid];
B[mid] = p;
upd(1, 1, n, mid, a[mid], 0);
}
long long ans = 0;
mid = 1;
for (i = 1; i <= n; i++)
if (ans < b[i] + B[i] - a[i]) {
ans = b[i] + B[i] - a[i];
mid = i;
}
sf[mid + 1] = 1e18;
for (i = mid; i >= 1; i--) sf[i] = min(sf[i + 1], a[i]);
pr[mid - 1] = 1e18;
for (i = mid; i <= n; i++) pr[i] = min(pr[i - 1], a[i]);
for (i = 1; i <= mid; i++) cout << sf[i] << " ";
for (i = mid + 1; i <= n; i++) cout << pr[i] << " ";
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10;
int n;
long long m, a[MAXN], inv[MAXN];
set<int> all;
bool check(int x, int d) {
for (int i = 0; i < n; i++) {
if (!all.count((x + (long long)i * d) % m)) return false;
}
return true;
}
int main() {
cin >> m >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
all.insert(a[i]);
}
inv[1] = 1;
for (int i = 2; i < MAXN; i++) inv[i] = m - (m / i) * inv[m % i] % m;
if (n == m) {
cout << "0 1\n";
return 0;
}
if (n == 1) {
cout << a[0] << " " << 0 << '\n';
return 0;
}
if (n == 2) {
cout << min(a[0], a[1]) << " " << max(a[0], a[1]) - min(a[0], a[1]) << '\n';
return 0;
}
long long s = 0, ss = 0;
for (int i = 0; i < n; i++) {
s = (s + a[i]) % m;
ss = (ss + a[i] * a[i]) % m;
}
long long inn = (inv[n] * inv[n - 1]) % m;
long long lit = ((long long)n * (n - 1)) % m;
long long sqt = (lit * (2 * n - 1)) % m;
sqt = (sqt * inv[6]) % m;
for (int i = 0; i < n; i++) {
long long x = a[i];
long long d = 2 * s;
d = (d * inn) % m;
long long ex = (inv[n - 1] * 2) % m;
ex = (ex * x) % m;
d = (d - ex) % m;
d = (d + m) % m;
long long su = ((n * (x * x % m)) % m + (lit * (d * x % m)) % m +
(sqt * (d * d % m) % m)) %
m;
if (su != ss) continue;
if (check(x, d)) {
cout << x << " " << d << '\n';
return 0;
}
}
cout << "-1\n";
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
vector<int> ans(0);
int main() {
int a1, a2, h1, h2, c;
scanf("%d%d%d%d%d", &h1, &a1, &c, &h2, &a2);
while (1) {
if (h2 - a1 > 0) {
if (h1 - a2 > 0) {
h2 -= a1;
h1 -= a2;
ans.push_back(1);
} else {
h1 += c - a2;
ans.push_back(0);
}
} else {
ans.push_back(1);
break;
}
}
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); i++) {
if (ans[i]) {
puts("STRIKE");
} else {
puts("HEAL");
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long a, b, w, x, c;
long long solve() {
if (c <= a)
return 0;
else {
long long det = c - a;
double upp = det * x - b;
double dow = w - x;
long long lam = (long long)ceil(upp / dow);
return lam + det;
}
}
int main() {
scanf("%I64d%I64d%I64d%I64d%I64d", &a, &b, &w, &x, &c);
printf("%I64d\n", solve());
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n1;
cin >> n1;
int *a = new int[n1];
for (int i = 0; i < n1; i++) {
cin >> a[i];
}
cout << abs(a[0] - a[1]) << " " << abs(a[0] - a[n1 - 1]) << endl;
for (int i = 1; i < n1 - 1; i++) {
int x1 = abs(a[i - 1] - a[i]);
if (abs(a[i] - a[i + 1]) < x1) x1 = abs(a[i] - a[i + 1]);
cout << x1 << " ";
int x2 = abs(a[n1 - 1] - a[i]);
if (abs(a[i] - a[0]) > x2) x2 = abs(a[i] - a[0]);
cout << x2 << endl;
}
cout << abs(a[n1 - 1] - a[n1 - 2]) << " " << abs(a[0] - a[n1 - 1]) << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int read() {
char c = getchar();
int t = 0, f = 1;
while (c > '9' || c < '0') f = (f == '-') ? -1 : 1, c = getchar();
while (c >= '0' && c <= '9') t = t * 10 + c - '0', c = getchar();
return t * f;
}
int n, ans[100005], tp;
int len(int x) {
int ret = 0;
while (x) ret++, x /= 10;
return ret;
}
int check(int x) {
int y = x, tmp = 0;
while (y) tmp += y % 10, y /= 10;
return x + tmp;
}
int main() {
n = read();
int m = max(0, n - len(n) * 9);
for (int i = m; i <= n; i++)
if (check(i) == n) ans[++tp] = i;
printf("%d\n", tp);
for (int i = 1; i <= tp; i++) printf("%d ", ans[i]);
}
| 4 |
#include <bits/stdc++.h>
long long ans, x, y, n, a, s, kk;
int num[9000000];
long long sum[10000000];
int main() {
int j, k;
long long i;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &num[i]);
}
std::sort(num + 1, num + n + 1);
x = 0;
for (i = n; i >= 1; i--) {
x += num[i];
sum[n + 1 - i] = x;
}
sum[0] = sum[1];
kk = 0;
for (i = 1; i <= n; i++) {
kk += num[i] * (n - i);
}
scanf("%d", &a);
for (k = 1; k <= a; k++) {
scanf("%d", &s);
if (s == 1)
printf("%I64d\n", kk);
else {
x = 1;
y = 0;
ans = 0;
for (i = 0; i <= n; i++) {
y += x;
if (y >= n) {
ans += (sum[n] - sum[y - x]) * i;
break;
} else {
ans += (sum[y] - sum[y - x]) * i;
}
x *= s;
}
printf("%I64d\n", ans);
}
}
getchar();
getchar();
}
| 11 |
#include <bits/stdc++.h>
int fix(double x) {
if (fabs(x) <= 1e-9)
return 0;
else if (x > 1e-9)
return 1;
else
return -1;
}
int main() {
double s;
while (scanf("%lf", &s) != EOF) {
double num[4];
double ans[4];
for (int i = 1; i <= 3; i++) scanf("%lf", &num[i]);
num[0] = 0;
for (int i = 1; i <= 3; i++) num[0] += num[i];
if (fix(num[0]) == 0)
for (int i = 1; i <= 3; i++) ans[i] = s / 3;
else
for (int i = 1; i <= 3; i++) ans[i] = s * num[i] / num[0];
for (int i = 1; i <= 3; i++)
if (i == 3)
printf("%.12f\n", ans[i]);
else
printf("%.12f ", ans[i]);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, q, a, b, v, d, x, t, mx;
int l[200005];
int r[200005];
int z[200005];
vector<vector<int> > lbt;
vector<int> e[200005];
void trv(int k, int f) {
l[k] = l[f] + 1;
z[r[k]] = l[k];
for (int i = 0, br = r[k]; i < e[k].size(); i++) {
if (e[k][i] != f) {
r[e[k][i]] = br;
br++;
trv(e[k][i], k);
}
}
}
void upbt(int k, int a, int b, int x) {
for (int i = a; i < lbt[k].size(); i += i & (-i)) {
lbt[k][i] += x;
}
for (int i = b + 1; i < lbt[k].size(); i += i & (-i)) {
lbt[k][i] -= x;
}
}
int qubt(int k, int a) {
int s = 0;
for (int i = a; i > 0; i -= i & (-i)) {
s += lbt[k][i];
}
return s;
}
void up(int k, int x, int d) {
if (k == 0) {
upbt(e[0].size(), 1, d + 1, x);
return;
}
if (1 < l[k] - d) {
upbt(r[k], l[k] - d, min(z[r[k]], l[k] + d), x);
} else {
upbt(r[k], 2, min(z[r[k]], l[k] + d), x);
upbt(e[0].size(), 1, d - l[k] + 2, x);
if (d - l[k] + 2 > 1) {
upbt(r[k], 2, min(z[r[k]], d - l[k] + 2), -x);
}
}
}
int qu(int k) {
int ret = qubt(e[0].size(), l[k]);
if (k != 0) {
ret += qubt(r[k], l[k]);
}
return ret;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> q;
for (int i = 0; i < n - 1; i++) {
cin >> a >> b;
a--;
b--;
e[a].push_back(b);
e[b].push_back(a);
}
trv(0, 0);
for (int i = 0; i < e[0].size(); i++) {
lbt.push_back(vector<int>(z[i] + 5));
mx = max(mx, z[i]);
}
lbt.push_back(vector<int>(mx + 5));
for (int i = 0; i < q; i++) {
cin >> t >> v;
v--;
if (t == 0) {
cin >> x >> d;
up(v, x, d);
} else {
cout << qu(v) << "\n";
}
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
inline T1 max(T1 a, T2 b) {
return a < b ? b : a;
}
template <typename T1, typename T2>
inline T1 min(T1 a, T2 b) {
return a < b ? a : b;
}
const char lf = '\n';
namespace ae86 {
const int bufl = 1 << 15;
char buf[bufl], *s = buf, *t = buf;
inline int fetch() {
if (s == t) {
t = (s = buf) + fread(buf, 1, bufl, stdin);
if (s == t) return EOF;
}
return *s++;
}
inline int ty() {
int a = 0;
int b = 1, c = fetch();
while (!isdigit(c)) b ^= c == '-', c = fetch();
while (isdigit(c)) a = a * 10 + c - 48, c = fetch();
return b ? a : -a;
}
} // namespace ae86
using ae86::ty;
const int _ = 200007, __ = 2000007, mo = 1000000007;
int isnp[__] = {0}, lasp[__] = {0};
void fuck(int n = __ - 1) {
for (int i = 2; i <= n; i++) {
if (isnp[i]) continue;
lasp[i] = i;
for (long long j = 1ll * i * i; j <= n; j += i) {
isnp[j] = 1;
if (!lasp[j]) lasp[j] = i;
}
}
}
map<int, pair<int, int>> mp;
void gmax(int who, int d) {
if (!who) return;
if (mp[who].first < d) mp[who].second = 0;
if (mp[who].first <= d) mp[who].first = d, mp[who].second++;
}
void add(int x) {
int las = 0, cnt = 0;
while (x > 1) {
int a = lasp[x];
x /= a;
if (las != a) gmax(las, cnt), cnt = 0;
las = a, cnt++;
}
if (cnt) gmax(las, cnt);
}
int finder(int x) {
int las = 0, cnt = 0;
while (x > 1) {
int a = lasp[x];
x /= a;
if (las != a) {
if (las && mp[las].first == cnt && mp[las].second == 1) return 0;
cnt = 0;
}
las = a, cnt++;
}
if (las && mp[las].first == cnt && mp[las].second == 1) return 0;
return 1;
}
int n, val[_], fr[__] = {0};
int main() {
ios::sync_with_stdio(0), cout.tie(nullptr);
fuck();
n = ty();
for (int i = 1; i <= n; i++) val[i] = ty();
sort(val + 1, val + n + 1, greater<int>());
for (int i = 1, j = 1; i <= n; i = j + 1) {
j = i;
while (j < n && val[i] == val[j + 1]) j++;
add(val[i]);
}
for (int i = 1, j = 1; i <= n; i = j + 1) {
j = i;
while (j < n && val[i] == val[j + 1]) j++;
int cnt = j - i + 1;
if (cnt + finder(val[i]) >= 2) {
if (cnt == 1) {
fr[val[i]] = 1;
if (mp[val[i]].first == 1) mp[val[i]].second--;
}
add(val[i] - 1);
}
}
int temp = 0;
for (int i = 1, j = 1; i <= n; i = j + 1) {
j = i;
while (j < n && val[i] == val[j + 1]) j++;
int cnt = j - i + 1;
if (cnt + (cnt == 1 ? fr[val[i]] : finder(val[i])) + finder(val[i] - 1) >=
3)
temp = 1;
}
long long ans = 1;
for (auto i : mp)
while (i.second.first--) ans = ans * i.first % mo;
if (temp) ans = (ans + 1) % mo;
cout << ans << lf;
return 0;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 50;
int n, m, ver[N * 6], nxt[N * 6], head[N], tot, la, col[N], num[3];
void add(int x, int y) {
ver[++tot] = y;
nxt[tot] = head[x];
head[x] = tot;
}
void f() {
puts("-1");
exit(0);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1, x, y; i <= m; i++)
scanf("%d%d", &x, &y), add(x, y), add(y, x);
for (int i = head[1], y; i; i = nxt[i]) col[la = y = ver[i]] = 1;
for (int i = head[la], y; i; i = nxt[i])
if (col[y = ver[i]]) col[y] = 2;
for (int i = 1; i <= n; i++) num[col[i]]++;
if (!num[0] || !num[1] || !num[2]) f();
for (int x = 1; x <= n; x++) {
int nn = 0;
for (int i = head[x], y; i; i = nxt[i], nn++)
if (col[y = ver[i]] == col[x]) f();
if (nn != n - num[col[x]]) f();
}
for (int i = 1; i <= n; i++) printf("%d ", col[i] + 1);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int print(int z[], int n) {
for (int i = 0; i < n; i++) {
if (z[i] == 0) {
z[i] = 1;
return i + 1;
}
}
}
int main() {
int n, m;
cin >> n >> m;
int z[n];
for (int i = 0; i < n; i++) {
z[i] = 0;
}
int a[m][2];
for (int i = 0; i < m; i++) {
cin >> a[i][0] >> a[i][1];
}
int b[n / 3][3];
for (int i = 0; i < n / 3; i++) {
b[i][0] = 0;
b[i][1] = 0;
b[i][2] = 0;
}
int ptr = 0;
for (int i = 0; i < m; i++) {
int c = a[i][1];
int d = a[i][0];
if (ptr == 0) {
z[c - 1] = 1;
z[d - 1] = 1;
b[ptr][0] = c;
b[ptr][1] = d;
ptr++;
} else {
int j = 0, w = 0;
for (; j < ptr; j++) {
if (b[j][0] == c || b[j][1] == c || b[j][2] == c) {
if (b[j][1] == 0) {
z[d - 1] = 1;
b[j][1] = d;
w++;
break;
} else if (b[j][2] == 0) {
z[d - 1] = 1;
b[j][2] = d;
w++;
break;
} else if (!(b[j][1] == d || b[j][0] == d || b[j][2] == d)) {
printf("-1");
return 0;
} else {
w++;
break;
}
} else if (b[j][1] == d || b[j][0] == d || b[j][2] == d) {
if (b[j][1] == 0) {
z[c - 1] = 1;
b[j][1] = c;
w++;
break;
} else if (b[j][2] == 0) {
z[c - 1] = 1;
b[j][2] = c;
w++;
break;
} else if (!(b[j][0] == c || b[j][1] == c || b[j][2] == c)) {
printf("-1");
return 0;
} else {
w++;
break;
}
}
}
if (w == 0 && ptr < n / 3) {
z[c - 1] = 1;
z[d - 1] = 1;
b[ptr][0] = c;
b[ptr][1] = d;
ptr++;
} else if (w == 0 && ptr >= n / 3) {
printf("-1");
return 0;
}
}
}
for (int i = 0; i < n / 3; i++) {
if (b[i][0] == 0) {
cout << print(z, n) << " ";
} else
cout << b[i][0] << " ";
if (b[i][1] == 0) {
cout << print(z, n) << " ";
} else
cout << b[i][1] << " ";
if (b[i][2] == 0) {
cout << print(z, n) << endl;
} else
cout << b[i][2] << endl;
}
}
| 7 |
#include <bits/stdc++.h>
int main() {
int n, d, e;
std::cin >> n >> d >> e;
int result = n - n / d * d;
int dollars = n / d, euros = 0;
while (dollars > -1) {
while (dollars * d + 5 * euros * e <= n) {
result = std::min(result, n - (dollars * d + 5 * euros * e));
euros++;
}
dollars--;
}
std::cout << result << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define ull unsigned long long
#define pi 3.141592653589793238
#define lb lower_bound
#define ub upper_bound
#define rep(i,a,n) for(ll i=a;i<n;i++)
#define For(i,a,n) for(ll i=a;i<=n;i++)
const ll inf = 100000000000000000;
const ll mod = 1000000007;
const ll N=2e5+1;
typedef pair<int, int> pii;
typedef pair<ll , ll> pll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<pii> vpii;
typedef vector<pll> vpl;
typedef vector<vi> vvi;
typedef vector<vl> vvl;
bool ispalin(string s){ ll len=s.length(); rep(i , 0 , len){ if(s[i] != s[len-i-1]) {return false;}} return true;}
ll add(ll a , ll b , ll m){ ll res = (a%m+b%m)%m; if(res<0) {res+=m;} return res;}
ll mul(ll a , ll b , ll m){ ll res = (a%m*b%m)%m; if(res<0) {res+=m;} return res;}
ll power(ll a , ll b , ll m){ ll res = 1; while (b > 0) { if (b & 1) {res = mul(res,a,m);} a = mul(a , a , m); b >>= 1;} return res%m; }
ll binpow(ll a , ll b) { ll res = 1; while (b > 0) { if (b & 1) {res = (res*a);} a = (a*a); b >>= 1; } return res; }
ll binpow(ll a , ll b , ll m) { ll res = 1; while (b > 0) { if (b & 1) {res = (res*a)%m;} a = (a*a)%m; b >>= 1; } return res%m; }
bool isprime(ll n){ if (n <= 1) {return false;} if (n <= 3) {return true;} if (n%2 == 0 || n%3 == 0) {return false;} for (ll i=5; i*i<=n; i=i+6){ if (n%i == 0 || n%(i+2) == 0) {return false;}} return true; }
/// bool isprime(ll n){ int x=rand(); ll int y; y=pow((x-1),n)-pow(x,n)+1; if(y%n==0) {return true;} else {return false;} }
/// for 1 to n prime numbers .....see down code
/// bool isprime[n+1]; for(i=0;i<=n;i++) {isprime[i]=true;} isprime[0]=false; isprime[1]=false; for(i=0;i<=n;i++) { if(isprime[i] == true) { count++; for(j=i*i;j<=n;j+=i) {isprime[j]=false;} } }
ll gcd(ll a , ll b) { if(b==0) {return a;} else {gcd(b,a%b);} }
ll lcm(ll a , ll b) { ll l = (a*b)/gcd(a,b); return l; }
ll CEIL(ll a, ll b) { return (a/b+(a%b!=0));}
ll inv (ll a , ll m){ return power(a,m-2,m);}
ll C(ll n, ll r) {
if(n<r) return 0;
if(n==r) return 1;
if(r > n-r) r = n-r; // because C(n, r) == C(n, n - r)
ll ans = 1;
for(ll i = 1; i <= r; i++) {
ans *= n - r + i;
ans /= i;
}
return ans;
}
bool isPerfectSq(ll x){ if (x >= 0) { ll sr = sqrt(x); return (sr * sr == x); } return false; }
ll fact(ll n , ll m){ ll f = 1; for(ll i=1;i<=n;i++) f = (f * i)%m; return f%m;}
/* combinatorics .. */
// for getting max power of K that divides n!
ll fact_pow (ll n, ll k) { ll res = 0; while (n) { n /= k; res += n;} return res; }
void solve()
{
ll x , t;
cin>>x;
for(ll i=0;i<11;i++)
{
t = x;
if(t >= (111*i)) t -= (111*i);
if(t % 11 == 0)
{
cout<<"YES\n";
return;
}
}
cout<<"NO\n";
}
int main() {
ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
int t;
cin>>t;
while(t--)
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, e, f, g, h, i, d;
cin >> a >> b >> c;
e = a + b + c;
f = 2 * (a + b);
g = 2 * (b + c);
h = 2 * (c + a);
if (e < f) {
i = e;
} else {
i = f;
}
if (g < h) {
d = g;
} else {
d = h;
}
if (i < d) {
cout << i << endl;
} else {
cout << d << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long test = 1;
cin >> test;
while (test--) {
long long n;
cin >> n;
vector<long long> v(n);
for (long long i = 0; i < n; i++) {
cin >> v[i];
}
long long ans = 0, res = 0;
map<long long, long long> mp;
for (long long i = 0; i < n; i++) mp[v[i]]++;
for (long long i = 0; i < 102; i++) {
ans = 0;
for (long long j = 0; j < n + 1; j++) {
if (mp[j] > 0 && i != i - j) {
if (mp[i - j] > 0) ans += min(mp[j], mp[i - j]);
}
}
res = max(ans, res);
}
cout << res / 2 << "\n";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[100005], f[100005];
int Q, n, m, T;
int main() {
scanf("%d%d%d%d", &Q, &n, &m, &T);
T = min(min(n, m), T);
for (; Q--;) {
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 0; i <= m; i++) f[i] = 0;
for (int i = 1; i <= T; i++)
for (int j = 1; j <= n; j++)
for (int k = a[j]; k <= m && f[k] == f[a[j] - 1]; k++) f[k]++;
printf("%d\n", f[m]);
}
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int i, n, x, cnt = 0;
cin >> n >> x;
for (i = n; i > 0; i--) {
if (x % i == 0 && x <= n * i) cnt++;
}
cout << cnt;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string j, p;
cin >> j;
int best = 0, i, k, g, a;
for (i = 0; i < j.length() - 1; i++) {
for (k = 1; k < j.length() - i; k++) {
p = j.substr(i, k);
a = 0;
for (g = 0; g < j.length() - p.length() + 1; g++) {
if (j.substr(g, p.length()) == p) a++;
}
if (a > 1 && p.length() > best) best = p.length();
}
}
cout << best << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, x, y;
long long ans1, ans2, ans3;
long long num[110][110];
int main() {
int i, j;
scanf("%lld%lld%lld%lld%lld", &n, &m, &k, &x, &y);
if (n == 1) {
for (i = 1; i <= m; i++) {
num[1][i] = k / m;
}
k = k % m;
for (i = 1; i <= k; i++) {
num[1][i]++;
}
ans1 = -1;
ans2 = 1e18;
for (i = 1; i <= m; i++) {
ans1 = max(ans1, num[1][i]);
ans2 = min(ans2, num[1][i]);
}
printf("%lld %lld %lld\n", ans1, ans2, num[x][y]);
return 0;
}
for (i = 1; i <= m; i++) {
num[1][i] = num[n][i] = k / (2 * n * m - 2 * m);
}
for (i = 2; i < n; i++) {
for (j = 1; j <= m; j++) {
num[i][j] = num[1][1] * 2;
}
}
k %= (2 * n * m - 2 * m);
i = 1;
j = 1;
bool ok = 0;
while (k--) {
num[i][j]++;
if (j % m == 0) {
j = 0;
if (ok == 0) {
i++;
} else {
i--;
}
}
if (i == n) {
ok = 1;
}
j++;
}
ans1 = -1;
ans2 = 1e18;
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
ans1 = max(ans1, num[i][j]);
ans2 = min(ans2, num[i][j]);
}
}
printf("%lld %lld %lld\n", ans1, ans2, num[x][y]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, m;
cin >> n >> m;
long long a[n][m], b[n][m];
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) cin >> a[i][j];
}
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) cin >> b[i][j];
}
bool f = true;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
if (a[i][j] != b[i][j]) {
if (i + 1 < n && j + 1 < m) {
a[i][j] = (a[i][j] ^ 1);
a[i][j + 1] = (a[i][j + 1] ^ 1);
a[i + 1][j] = (a[i + 1][j] ^ 1);
a[i + 1][j + 1] = (a[i + 1][j + 1] ^ 1);
} else
f = false;
}
}
}
if (f)
cout << "Yes"
<< "\n";
else
cout << "No"
<< "\n";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1;
while (t--) {
solve();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<pair<int, int> > v;
int x, y;
int n;
int total = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x >> y;
v.push_back(make_pair(x, y));
}
int cost = 0;
for (int i = 0; i < v.size(); i++) {
if (v[i].first != -1) {
total = 0;
for (int j = i; j < v.size(); j++) {
if (v[j].second >= v[i].second) {
total += v[j].first;
v[j].first = -1;
} else
break;
}
cost += (total * v[i].second);
}
}
cout << cost << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char c;
int n, k, dis = 0;
cin >> n >> k;
if (k == 2) {
dis = n - 1;
} else {
if ((n % k) == 1) {
dis = n / k * 2;
} else if (n % k == 2) {
dis = n / k * 2 + 1;
} else {
dis = (n - 1) / k * 2 + 2;
}
}
cout << dis << endl;
for (int i = 2; i <= k + 1; ++i) {
cout << 1 << " " << i << endl;
}
for (int i = k + 2; i <= n; ++i) {
cout << i - k << " " << i << endl;
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
vector<pair<int, string>> input_array(n);
for (int i = 0; i < n; i++) {
cin >> input_array[i].first >> input_array[i].second;
}
int current_ = 0;
for (int i = 0; i < n; i++) {
int temp_len = input_array[i].first;
string temp_direction = input_array[i].second;
if (current_ == 0 && temp_direction != "South") {
cout << fixed << "NO";
return 0;
}
if (current_ == 20000 && temp_direction != "North") {
cout << fixed << "NO";
return 0;
}
if (temp_direction == "South") current_ += temp_len;
if (temp_direction == "North") current_ -= temp_len;
if (current_ < 0 || current_ > 20000) {
cout << fixed << "NO";
return 0;
}
}
if (current_ != 0) {
cout << fixed << "NO";
return 0;
}
cout << fixed << "YES";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int a[200000 + 1];
vector<long long int> b;
int main() {
long long int n, m;
cin >> n >> m;
for (long long int i = 1; i <= n; i++) cin >> a[i];
for (long long int i = 1; i <= m; i++) {
long long int l, r;
cin >> l >> r;
long long int sum = 0;
for (long long int i = l; i <= r; i++) {
sum += a[i];
}
b.push_back(sum);
}
long long int max_sum = 0;
for (long long int i = 0; i < b.size(); i++) {
if (b[i] > 0) {
max_sum += b[i];
}
}
cout << max_sum << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char c;
unsigned long long ret = 1;
cin >> c;
int a = c - '0', yes = 0, n = 1;
while (cin >> c) {
int x = c - '0';
if (n == 0) {
if (x == a) {
n ^= 1;
} else {
n = 1;
a = x;
yes = 0;
}
} else {
if (x == 9 - a) {
n ^= 1;
yes += 1;
} else {
n = 1;
a = x;
ret *= (yes + 1);
yes = 0;
}
}
}
if (n == 1) {
ret *= (yes + 1);
}
cout << ret << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int _ = 1e6 + 5, yl = 998244353;
long long POW(long long x, long long y) {
long long res = 1;
while (y) {
if (y & 1) res = res * x % yl;
x = x * x % yl;
y >>= 1;
}
return res;
}
long long f[_], mul[_], inv[_], n, ans;
long long C(int x, int y) { return mul[x] * inv[y] % yl * inv[x - y] % yl; }
void inc(long long &x, long long y) {
x += y;
if (x >= yl) x -= yl;
}
void dec(long long &x, long long y) {
x -= y;
if (x < 0) x += yl;
}
long long F(int x) {
if (!x) return POW(POW(3, n) - 3, n);
return C(n, x) *
((POW(3, x) - 3) * POW(3, n * (n - x)) % yl +
3 * POW(POW(3, n - x) - 1, n)) %
yl;
}
int main() {
cin >> n;
inv[0] = inv[1] = mul[0] = 1;
for (int i = 2; i <= n; ++i) inv[i] = (yl - yl / i) * inv[yl % i] % yl;
for (int i = 1; i <= n; ++i)
inv[i] = inv[i] * inv[i - 1] % yl, mul[i] = mul[i - 1] * i % yl;
ans = POW(3, n * n);
for (int i = 0; i <= n; ++i)
if (i & 1)
inc(ans, F(i));
else
dec(ans, F(i));
cout << ans << endl;
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n = 0, m = 0, k = 0;
cin >> n;
if (n == 1 || n == 2) {
cout << -1;
return 0;
}
if (n % 2 == 0) {
cout << (n * n / 4) - 1 << " " << (n * n / 4) + 1;
return 0;
} else {
cout << (n * n - 1) / 2 << " " << (n * n + 1) / 2;
return 0;
}
cout << -1;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double a, b, all;
scanf("%lf%lf%lf", &a, &b, &all);
double Ttime = 0, Ts = 0;
double alltime;
Ttime = (ceil)(a / b);
Ttime *= b;
Ts = a + (Ttime - a) / 2;
alltime = (long long int)(all / Ts) * Ttime;
all -= (long long int)(all / Ts) * Ts;
if (all <= a)
alltime += all;
else {
alltime += a;
all -= a;
alltime += all * 2;
}
printf("%.1lf\n", alltime);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long modulo = 1073741824;
int main() {
long long n;
cin >> n;
if (n == 1)
cout << 1;
else if (n == 2)
cout << 2;
else if (n & 1)
cout << n * (n - 1) * (n - 2);
else if (n % 3 == 0)
cout << (n - 3) * (n - 1) * (n - 2);
else
cout << n * (n - 1) * (n - 3);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
long long a[N], c[N];
multiset<long long> m;
int main() {
long long n, p, x;
cin >> n >> p;
for (int i = 0; i < n; i++) cin >> a[i];
cin >> x;
for (int i = 0; i < n; i++) cin >> c[i];
long long P = p, ans = 0;
for (int i = 0; i < n; i++) {
m.insert(c[i]);
if ((i + 1) * x + p < a[i]) return cout << -1, 0;
while (P < a[i]) {
ans += *m.begin();
m.erase(m.begin());
P += x;
}
}
cout << ans;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
int n, a, b, k;
int x[maxn];
int main() {
cin >> n >> a >> b >> k;
for (int i = 1; i <= n; ++i) {
cin >> x[i];
x[i] = x[i] % (a + b);
if (x[i] == 0) x[i] = a + b;
}
sort(x + 1, x + n + 1);
int ans = 0;
for (int i = 1; i <= n; ++i) {
int cnt = ceil((double)x[i] / a);
if (k >= cnt - 1) {
k -= cnt - 1;
++ans;
} else
break;
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int X[301][300];
int main(void) {
int i, j, k, n;
cin >> n;
for (i = 1; i <= n; i++)
for (j = 0; j < n; j++) cin >> X[i][j];
for (j = 0; j < n; j++) cin >> X[0][j];
for (i = 1; i <= n; i++) {
for (j = 0; true; j++)
if (X[i][j] != i) {
for (k = 0; X[0][k] > X[i][j] || X[0][k] == i; k++)
;
if (X[0][k] == X[i][j]) break;
}
cout << X[i][j] << " ";
}
return 0;
}
| 10 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.