solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int modulo = 1e9 + 7;
template <class __Ty>
bool mini(__Ty& a, __Ty b) {
return a > b ? ((a = b) | 1) : (0);
}
template <class __Ty>
bool maxi(__Ty& a, __Ty b) {
return a < b ? ((a = b) | 1) : (0);
}
template <class __Ty>
__Ty add(__Ty a, __Ty b) {
return (a + b) % (__Ty(modulo));
}
template <class __Ty>
__Ty sub(__Ty a, __Ty b) {
__Ty m(modulo);
return ((a - b) % m + m) % m;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int a[3], b[3];
for (int i = 0; i < 3; ++i) {
cin >> a[i] >> b[i];
if (a[i] > b[i]) swap(a[i], b[i]);
}
bool ans = false;
ans |= ((a[0] >= a[1] + a[2]) && (b[0] >= max(b[1], b[2])));
ans |= ((a[0] >= b[1] + a[2]) && (b[0] >= max(a[1], b[2])));
ans |= ((a[0] >= max(a[1], a[2])) && (b[0] >= b[1] + b[2]));
ans |= ((a[0] >= max(b[1], a[2])) && (b[0] >= a[1] + b[2]));
ans |= ((b[0] >= a[1] + a[2]) && (a[0] >= max(b[1], b[2])));
ans |= ((b[0] >= b[1] + a[2]) && (a[0] >= max(a[1], b[2])));
ans |= ((b[0] >= max(a[1], a[2])) && (a[0] >= b[1] + b[2]));
ans |= ((b[0] >= max(b[1], a[2])) && (a[0] >= a[1] + b[2]));
if (ans)
cout << "YES";
else
cout << "NO";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, p;
const int N = 200007;
int a[N], cnt[N];
char t[N];
pair<int, int> ans[N];
deque<int> q[2];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
cin >> (t + 1);
p = (t[n] == 'R');
for (int i = n; i >= 1; i--) {
q[p].push_back(a[i]);
cnt[p]++;
p ^= 1;
}
for (int i = n; i >= 1; i--) {
if (cnt[0] != cnt[1]) {
p = (cnt[0] < cnt[1]);
if (t[i] != t[i - 1]) {
ans[i] = make_pair(q[p].front(), p);
q[p].pop_front();
cnt[p]--;
} else {
ans[i] = make_pair(q[p].back(), p);
q[p].pop_back();
cnt[p]--;
}
} else {
p = (q[0].front() < q[1].front());
if (t[i] != t[i - 1]) {
ans[i] = make_pair(q[p].front(), p);
q[p].pop_front();
cnt[p]--;
} else {
ans[i] = make_pair(q[p ^ 1].back(), p ^ 1);
q[p ^ 1].pop_back();
cnt[p ^ 1]--;
}
}
}
for (int i = 1; i <= n; i++) {
cout << ans[i].first;
if (ans[i].second)
cout << " R" << endl;
else
cout << " L" << endl;
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e5 + 5;
template <typename T>
void read(T &x) {
x = 0;
int f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -f;
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
x *= f;
}
template <typename T>
void write(T x) {
if (x < 0) x = -x, putchar('-');
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
template <typename T>
void writeln(T x) {
write(x);
puts("");
}
long long a[MAXN], f[MAXN];
int n, m, p, ans[MAXN];
bool odd[MAXN];
void operate(int pos) {
if (pos >= n || pos <= 0) return;
int tmp = min(a[pos], a[pos + 1]);
if (tmp == 0) return;
ans[++m] = pos;
a[pos] -= tmp;
a[pos + 1] -= tmp;
}
int main() {
read(n);
for (int i = 1; i <= n; i++) read(a[i]);
for (int i = 1; i <= n; i++) {
long long fo = f[max(i - 2, 0)] + a[i];
long long fe = f[max(i - 3, 0)] + max(a[i], a[i - 1]);
f[i] = min(fo, fe);
odd[i] = f[i] == fo;
}
long long vans = min(f[n - 1], f[n]);
if (vans == f[n - 1])
p = n - 1;
else
p = n;
while (p != 0) {
if (odd[p]) {
operate(p - 1);
operate(p);
p -= 2;
} else {
operate(p - 1);
operate(p - 2);
operate(p);
p -= 3;
}
p = max(p, 0);
}
writeln(m);
for (int i = 1; i <= m; i++) writeln(ans[i]);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
long long int s, n;
void solve() {
cin >> n;
if (n == 1)
cout << -1;
else
cout << n << " " << (n + 1) << " " << n * (n + 1);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long int t = 1;
while (t--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, temp;
cin >> n;
vector<int> v;
vector<int> v2;
for (int i = 0; i < n; i++) {
cin >> temp;
v.push_back(temp);
}
for (int i = 1; i < n + 1; i++) {
for (int j = 0; j < n; j++) {
if (i == v[j]) {
v2.push_back(j + 1);
}
}
}
for (int i = 0; i < n - 1; i++) {
cout << v2[i] << " ";
}
cout << v2[n - 1];
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#define ll long long
#define pb push_back
#define ull unsigned long long
#define db double
#define lowbit(x) x&-x
#define mem(x) memset(x,0,sizeof x)
#define IOS ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)
#define vi vector<int>
#define pii pair<int,int>
const ll mod = 1000000007;
int pow_mod(int a,int b){ int ret=1;
for(;b;b>>=1,a=1LL*a*a%mod)if(b&1)ret=1LL*ret*a%mod;
return ret; }//快速幂
int gcd(int a, int b){ return a%b==0? b: gcd(b, a%b); }//递归求最大公约数
inline ll read() {ll x = 0; int t=1;char ch = getchar();
while(ch<'0'||ch>'9'){ if(ch=='-') t=-1; ch = getchar();}
while(ch>='0'&&ch<='9'){ x=x*10+ch-'0'; ch =getchar(); }
return x*t; } //快读
const int N = 100100;
int a[N];
int b[N];
void solve(){
int n;
cin >> n;
vector<pii>p;
int k = n;
while(k > 2){
int t = sqrt(k);
if(t * t != k) t ++;
for(int i = k - 1;i > t;i --){
p.push_back({i,k});
}
p.push_back({k,t});
p.push_back({k,t});
k = t;
}
cout << p.size() << endl;
for(auto it : p){
cout << it.first << ' ' << it.second << endl;
}
}
int main()
{
// freopen("B.in","r",stdin);
// freopen("B.out","w",stdout);
int t;
cin >> t;
while(t --)
solve();
return 0;
} | 4 |
#include <bits/stdc++.h>
using namespace std;
long long int n;
int fun(long long int x) {
int sum = 0;
while (x != 0) {
sum += x % 10;
x /= 10;
}
return sum;
}
int main() {
long double x = -1;
cin >> n;
for (int i = 1; i <= 81; i++) {
x = (-i + sqrt(i * i + (4 * n))) / 2;
if (fun(x) == i && (long long int)x == x) {
cout << (long long int)x << endl;
return 0;
}
}
cout << -1 << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
bool b = true;
char l1[3], l2[3], l3[3];
for (int i = 0; i < 3; i++) cin >> l1[i];
for (int i = 0; i < 3; i++) cin >> l2[i];
for (int i = 0; i < 3; i++) cin >> l3[i];
if (l2[0] == l2[2]) {
for (int i = 0; i < 3; i++) {
if (l1[i] != l3[2 - i]) b = false;
}
if (b)
cout << "YES" << endl;
else
cout << "NO" << endl;
} else
cout << "NO" << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007LL;
const int maxn = 1001;
const int maxk = 1000001;
long long C[2 * maxn + 1][2 * maxn + 1];
long long fact[maxk], inv_fact[maxk];
long long dp[maxn * 2 + 1];
long long fpow(long long x, long long n) {
long long ans = 1;
for (; n > 0; n >>= 1) {
if (n & 1) ans = ans * x % MOD;
x = x * x % MOD;
}
return ans;
}
long long inv(long long x) { return fpow(x, MOD - 2); }
void precalc() {
memset((C), (0), sizeof(C));
memset((fact), (0), sizeof(fact));
memset((inv_fact), (0), sizeof(inv_fact));
for (int _n(2 * maxn + 1), i(0); i < _n; i++) {
C[i][0] = C[i][i] = 1;
for (int _n(i), j(1); j < _n; j++)
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % MOD;
}
fact[0] = 1;
for (int _n(maxk), i(1); i < _n; i++) fact[i] = fact[i - 1] * i % MOD;
for (int _n(maxk), i(0); i < _n; i++) inv_fact[i] = inv(fact[i]);
}
long long cnk(int n, int k) {
return fact[n] * inv_fact[k] % MOD * inv_fact[n - k] % MOD;
}
int main() {
precalc();
int n, m, k;
cin >> n >> m >> k;
if (m == 1) {
cout << fpow(k, n) << endl;
return 0;
}
memset((dp), (0), sizeof(dp));
for (int _n(maxn * 2 + 1), i(1); i < _n; i++) {
dp[i] = fpow(i, n);
for (int j = i - 1; j >= 1; --j) {
dp[i] -= C[i][j] * dp[j] % MOD;
dp[i] += MOD;
dp[i] %= MOD;
}
}
long long ans = 0;
for (int _n(min(k, 2 * n) + 1), total(1); total < _n; total++) {
for (int common = (total & 1); common <= total; common += 2) {
const long long tmp = cnk(k, total);
int single = (total - common) / 2;
if (single + common > n) continue;
long long tans = fpow(common, (long long)n * (m - 2));
for (int _n(2), j(0); j < _n; j++) (tans *= dp[single + common]) %= MOD;
tans = tans * C[total][common] % MOD;
tans = tans * C[total - common][single] % MOD;
tans = tans * tmp % MOD;
ans += tans;
if (ans >= MOD) ans -= MOD;
}
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
int min(int a, int b) { return a > b ? b : a; }
int main() {
char s[10][10];
while (scanf("%s", s[0]) == 1) {
for (int i = 1; i < 8; i++) scanf("%s", s[i]);
int i, j;
int A, B, had[9] = {0};
A = B = 1e9;
for (i = 0; i < 8; i++)
for (j = 0; j < 8; j++) {
if (s[i][j] == 'W' && !had[j]) A = min(A, i);
if (s[i][j] == 'B') had[j] = 1;
}
memset(had, 0, sizeof(had));
for (i = 8 - 1; i >= 0; i--)
for (j = 0; j < 8; j++) {
if (s[i][j] == 'B' && !had[j]) B = min(B, 8 - i - 1);
if (s[i][j] == 'W') had[j] = 1;
}
if (A <= B)
printf("A\n");
else
printf("B\n");
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[3005], b[3005], c[3005], vis[3005];
bool cmp(int i, int j) { return a[i] > a[j]; }
int main() {
vector<int> p, q;
int T, i, j, k, ca = 0, n, m, K;
int s, t;
scanf("%d%d%d", &n, &s, &t);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]), c[i] = i;
}
for (int i = 0; i < n; i++) {
scanf("%d", &b[i]);
}
sort(c, c + n, cmp);
for (int i = 0; i < s; i++) {
vis[c[i]] = 1;
}
while (t--) {
k = 0;
while (k < n && vis[c[k]]) k++;
int mx = -1, v, l = c[k];
for (int i = n - 1; i >= 0; i--) {
j = -0x7f7f7f7f;
if (vis[i] == 0)
j = b[i];
else if (vis[i] == 1)
j = -a[i] + a[l] + b[i];
if (j > mx) mx = j, v = i;
}
if (vis[v]) vis[l] = 1;
vis[v] = 2;
}
int ans = 0;
for (int i = 0; i < n; i++) {
if (vis[i] == 1) {
p.push_back(i + 1);
ans += a[i];
} else if (vis[i] == 2) {
q.push_back(i + 1);
ans += b[i];
}
}
printf("%d\n", ans);
for (auto it : p) {
printf("%d ", it);
}
puts("");
for (auto it : q) {
printf("%d ", it);
}
puts("");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > V;
int main() {
int n, a, b;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a >> b;
V.push_back(make_pair(a, b));
}
int mx = 0;
sort(V.begin(), V.end());
int u = V[0].first;
priority_queue<pair<int, int> > mnBeg, mnEnd;
for (int i = 0; i <= n; i++) {
if (i < n && V[i].first <= u) {
mnEnd.push(make_pair(-V[i].second, V[i].first));
} else {
while (!mnEnd.empty() && mnEnd.top().first * -1 < u) mnEnd.pop();
if (mnEnd.size() == n) {
pair<int, int> x;
x = mnEnd.top();
mnEnd.pop();
while (!mnEnd.empty() && mnEnd.top().first * -1 < u) mnEnd.pop();
pair<int, int> xx;
xx = mnEnd.top();
mx = max(mx, -1 * xx.first - u);
mnEnd.push(x);
} else if (mnEnd.size() == n - 1) {
pair<int, int> x;
x = mnEnd.top();
mx = max(mx, -1 * x.first - u);
}
if (i < n) {
u = V[i].first;
i--;
}
}
}
cout << mx;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long int Maxn3 = 1e3 + 10;
const long long int Maxn4 = 1e4 + 10;
const long long int Maxn5 = 1e5 + 10;
const long long int Maxn6 = 1e6 + 10;
const long long int Maxn7 = 1e7 + 10;
const long long int Maxn8 = 1e8 + 10;
const long long int Maxn9 = 1e9 + 10;
const long long int Maxn18 = 1e18 + 10;
const long long int Mod1 = 1e7 + 7;
const long long int Mod2 = 1e9 + 7;
const long long int LLMax = LLONG_MAX;
const long long int LLMin = LLONG_MIN;
const long long int INTMax = INT_MAX;
const long long int INTMin = INT_MIN;
long long int mn = LLMax, mx = LLMin;
long long int a[1010][5], ans[5], ansSz;
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
long long int n;
cin >> n;
for (long long int i = 0; i < n; i++)
for (long long int j = 0; j < 5; j++) cin >> a[i][j];
if (n > 100) return cout << 0, 0;
for (long long int i = 0; i < n; i++) {
bool ok = 1;
for (long long int j = 0; j < n; j++)
for (long long int h = j + 1; h < n; h++) {
if (j == i || h == i) continue;
long long int v = 0;
for (long long int k = 0; k < 5; k++)
v += (a[j][k] - a[i][k]) * (a[h][k] - a[i][k]);
ok &= v <= 0;
}
if (ok) ans[ansSz++] = i + 1;
}
cout << ansSz << '\n';
for (long long int i = 0; i < ansSz; i++) cout << ans[i] << ' ';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int tab[100009];
int wej[100009];
int main() {
int n, i, m = 0;
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%d", &wej[i]);
for (i = 0; i < n; i++) tab[wej[i]] = tab[wej[i] - 1] + 1;
for (i = 1; i <= n; i++) m = max(m, tab[i]);
printf("%d", n - m);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n;
cin >> n;
long long arr[n], ans[n];
for (long long i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
long long j = 0;
for (long long i = 1; i < n; i += 2) {
ans[i] = arr[j];
j++;
}
for (long long i = 0; i < n; i += 2) {
ans[i] = arr[j];
j++;
}
long long count = 0;
for (long long i = 1; i < n - 1; i += 2) {
if (ans[i] < ans[i + 1] && ans[i] < ans[i - 1]) {
count++;
}
}
cout << count << '\n';
for (auto x : ans) {
cout << x << " ";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> AdjMat[201];
bool vis[201];
void dfs(int u) {
vis[u] = true;
for (int i = 0; i < AdjMat[u].size(); i++) {
if (!vis[AdjMat[u][i]]) dfs(AdjMat[u][i]);
}
}
int main() {
int n, m;
cin >> n >> m;
bool flag = false;
for (int i = 0; i < n; i++) {
int k;
cin >> k;
for (int j = 0; j < k; j++) {
int lan;
cin >> lan;
if (lan) flag = true;
AdjMat[i].push_back(n + lan);
AdjMat[n + lan].push_back(i);
}
}
if (!flag) {
printf("%d\n", n);
return 0;
}
memset(vis, false, sizeof vis);
int ans = 0;
for (int i = 0; i < n; i++) {
if (!vis[i]) {
dfs(i);
ans++;
}
}
printf("%d\n", ans - 1);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
if (n < m)
cout << m + -1 << " " << n << endl;
else if (n > m)
cout << n - 1 << " " << m << endl;
else if (n == m)
cout << n - 1 << " " << n << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
long long n;
string x = "??????????";
cin >> n;
char arr[n];
int a[n], y;
vector<int> v;
string ans = x;
for (int i = 0; i < n; ++i) {
v.resize(10);
v[0] = v[1] = v[2] = v[3] = v[4] = v[5] = v[6] = v[7] = v[8] = v[9] = 0;
cin >> arr[i] >> a[i];
int j = 0;
y = a[i];
while (y > 0) {
v[9 - j] = y % 2;
y /= 2;
j++;
}
if (arr[i] == '|') {
for (int j = 0; j < 10; ++j) {
if (v[j] == 1) ans[j] = '1';
}
} else if (arr[i] == '&') {
for (int j = 0; j < 10; ++j) {
if (v[j] == 0) ans[j] = '0';
}
} else if (arr[i] == '^') {
for (int j = 0; j < 10; ++j) {
if (ans[j] == '?') {
if (v[j] == 1) {
ans[j] = '.';
} else
ans[j] = '?';
} else if (ans[j] == '.') {
if (v[j] == 1)
ans[j] = '?';
else
ans[j] = '.';
} else if (ans[j] == '0') {
if (v[j] == 1)
ans[j] = '1';
else
ans[j] = '0';
} else if (ans[j] == '1') {
if (v[j] == 1)
ans[j] = '0';
else
ans[j] = '1';
}
}
}
}
string ans1 = "1111111111";
string ans2 = "0000000000";
string ans3 = "0000000000";
int ans11 = 0, ans22 = 0, ans33 = 0;
for (int i = 0; i < 10; ++i) {
if (ans[i] == '0') {
ans1[i] = '0';
} else if (ans[i] == '1') {
ans2[i] = '1';
} else if (ans[i] == '?') {
ans3[i] = '0';
} else
ans3[i] = '1';
ans11 += ((ans1[i] - '0') * pow(2, 9 - i));
ans22 += ((ans2[i] - '0') * pow(2, 9 - i));
ans33 += ((ans3[i] - '0') * pow(2, 9 - i));
}
cout << "3\n";
cout << "& " << ans11 << "\n";
cout << "| " << ans22 << "\n";
cout << "^ " << ans33 << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int cars[100100];
int dp[100100];
int main() {
int n;
scanf("%d", &n);
memset(dp, 0, sizeof(int) * (n + 1));
for (int i = 1; i <= n; i++) scanf("%d", cars + i);
for (int i = 1; i <= n; i++) dp[cars[i]] = dp[cars[i] - 1] + 1;
for (int i = 1; i <= n; i++) dp[0] = ((dp[0]) > (dp[i]) ? (dp[0]) : (dp[i]));
printf("%d\n", n - dp[0]);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
char c = getchar();
long long x = 0;
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return x;
}
int main() {
long long n = read(), k = read();
n /= k;
if (n % 2 == 1)
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 7;
const int mod = 1e9 + 7;
const long long INF = 1e18;
int dp[405][405][405];
char a[405], b[405];
int sta, stb;
int check(int x, int y, int z) {
if (z >= sta) {
if (y >= stb) return x;
return -10;
}
if (dp[x][y][z] != -1) return dp[x][y][z];
dp[x][y][z] = check(x, y, z + 1);
if (x < stb && a[z] == b[x])
dp[x][y][z] = max(dp[x][y][z], check(x + 1, y, z + 1));
if (y < stb && a[z] == b[y])
dp[x][y][z] = max(dp[x][y][z], check(x, y + 1, z + 1));
return dp[x][y][z];
}
bool rua() {
scanf("%s", a);
sta = strlen(a);
scanf("%s", b);
stb = strlen(b);
for (int i = 0; i <= stb; i++)
for (int j = 0; j <= stb; j++)
for (int k = 0; k <= sta; k++) dp[i][j][k] = -1;
for (int i = 0; i < stb; i++)
if (check(0, i, 0) >= i) return 1;
return 0;
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
if (rua())
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, t, m, S, sum = 0, max = 0;
cin >> n;
int *p = new int[n];
for (i = 0; i < n; i++) cin >> p[i];
for (t = 0; t < n; t++) {
sum = sum + p[t];
if (p[t] > max) max = p[t];
}
cout << max * n - sum;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m, k;
cin >> n >> m >> k;
vector<long long int> v[m + 1];
long long int A[n + 1];
for (long long int i = 1; i <= n; i++) {
cin >> A[i];
v[A[i]].push_back(i);
}
long long int l, r, mid, val, max_ = 0;
for (long long int i = 1; i <= m; i++) {
if (v[i].size() == 0) continue;
for (long long int j = 0; j < v[i].size(); j++) {
l = j;
r = v[i].size() - 1;
val = 0;
while (l <= r) {
mid = (l + r) / 2;
if (v[i][mid] - v[i][j] - (mid - j) <= k) {
val = mid - j + 1;
l = mid + 1;
} else
r = mid - 1;
}
max_ = max(val, max_);
}
}
cout << max_ << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 2e6 + 10, inf = 1e18, mod = 1e9 + 7;
long long pw(long long te, long long tee) {
if (tee == 0) return 1;
long long res = pw(te, tee / 2);
return (tee % 2 ? te * res * res : res * res);
}
long long n, cnt, ini = 0;
set<long long> ans;
void Read_input() { cin >> n; }
void Solve() {
ans.insert(0);
for (cnt = 1; cnt <= n - 1; cnt++)
ini += cnt, ini %= n, cout << ini + 1 << " ";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
Read_input(), Solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long int M = (int)1e9 + 7;
int main() {
int n;
cin >> n;
vector<int> s(n);
vector<char> arr(n, 'A');
vector<int> f(105, 0);
vector<int> freq;
for (int i = 0; i < n; ++i) {
cin >> s[i];
++f[s[i]];
}
int count1 = 0, count2 = -1;
for (int i = 0; i < n; ++i) {
if (f[s[i]] == 1) {
++count1;
freq.push_back(i);
} else if (f[s[i]] >= 3) {
count2 = i;
}
}
if ((count1) % 2 != 0 && count2 == -1) {
cout << "NO"
<< "\n";
} else if (count1 % 2 == 0) {
cout << "YES"
<< "\n";
int x = count1 / 2;
int i;
for (i = 0; i < x; ++i) {
arr[freq[i]] = 'A';
}
for (i = x; i < count1; ++i) {
arr[freq[i]] = 'B';
}
for (int i = 0; i < n; ++i) {
cout << arr[i];
}
cout << "\n";
} else if (count1 % 2 != 0 && count2 != -1) {
cout << "YES"
<< "\n";
int x = (count1 + 1) / 2;
int i;
for (i = 0; i < x; ++i) {
arr[freq[i]] = 'A';
}
for (i = x; i < count1; ++i) {
arr[freq[i]] = 'B';
}
arr[count2] = 'B';
for (int i = 0; i < n; ++i) {
cout << arr[i];
}
cout << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
double eps = 1e-10;
int main() {
double y1, y2, yw, xb, yb, r;
scanf("%lf%lf%lf%lf%lf%lf", &y1, &y2, &yw, &xb, &yb, &r);
double c = xb, b = yw - r - yb;
y1 = yw - r - y1, y2 = yw - r - y2;
double lim1 = -1, lim2 = -1;
double l = 0, ri = M_PI / 2;
while (ri - l > eps) {
double mid = (l + ri) / 2;
if (c * cos(mid) - (b + y2) * sin(mid) > r) {
lim1 = mid;
l = mid;
} else
ri = mid;
}
l = 0, ri = M_PI / 2;
while (ri - l > eps) {
double mid = (l + ri) / 2;
if ((b + y1) * sin(mid) - c * cos(mid) > r) {
lim2 = mid;
ri = mid;
} else
l = mid;
}
double lim3 = -1, lim4 = -1;
l = 0, ri = c;
while (ri - l > eps) {
double mid = (l + ri) / 2;
double a = b * mid / (c - mid);
double y = a * r / mid;
double rr = sqrt(r * r + y * y);
if (a - rr > y2) {
lim3 = mid;
ri = mid;
} else
l = mid;
}
l = 0, ri = c;
while (ri - l > eps) {
double mid = (l + ri) / 2;
double a = b * mid / (c - mid);
double y = a * r / mid;
double rr = sqrt(r * r + y * y);
if (a + r < y1) {
lim4 = mid;
l = mid;
} else
ri = mid;
}
if (lim3 > lim4 || lim3 < 0 || lim4 < 0)
printf("-1\n");
else
printf("%.10f\n", (lim3 + lim4) / 2);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int n, m;
int u[N * 2], v[N * 2];
int t, s, ds, dt;
int fa[N];
int vis[N];
vector<int> e[N];
set<int> g[N];
set<int> st;
vector<pair<int, int> > ans;
map<int, int> id[N];
void init() {
for (int i = 1; i <= n; ++i) fa[i] = i;
}
int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
void mrg(int x, int y) {
x = find(x), y = find(y);
if (x != y) {
fa[x] = y;
}
}
bool check(int x) { return x != s && x != t; }
void dfs(int x) {
vis[x] = 1;
for (auto y : e[x]) {
if (check(y) && !vis[y]) {
ans.push_back(make_pair(x, y));
dfs(y);
}
}
}
bool solve() {
set<int> st2 = st, sts;
vector<int> a;
for (int i : g[s]) {
if (g[t].find(i) != g[t].end()) {
a.push_back(i);
}
}
for (int i : g[s]) {
if (i != t) {
st2.erase(i);
sts.insert(i);
}
}
sts.insert(t);
int d = sts.size() - ds;
if ((int)a.size() < d) return 0;
for (int i = 0; i < d && i < a.size(); ++i) {
st2.insert(a[i]);
sts.erase(a[i]);
}
st2.insert(s);
for (int i : st2) {
if (g[t].find(i) == g[t].end()) return 0;
}
if ((int)st2.size() > dt) {
return 0;
}
for (int i : sts) {
int xx = id[s][i];
ans.push_back(make_pair(u[xx], v[xx]));
}
for (int i : st2) {
if (i != s) {
int xx = id[t][i];
ans.push_back(make_pair(u[xx], v[xx]));
}
}
return 1;
}
bool solve2() {
set<int> st2 = st, sts;
vector<int> a;
for (int i : g[s]) {
if (g[t].find(i) != g[t].end()) {
a.push_back(i);
}
}
g[s].erase(t);
g[t].erase(s);
for (int i : g[s]) {
if (i != t) {
st2.erase(i);
sts.insert(i);
}
}
int d = sts.size() - ds;
if ((int)a.size() < d) return 0;
for (int i = 0; i < d && i < a.size(); ++i) {
st2.insert(a[i]);
sts.erase(a[i]);
}
bool fd = 0;
for (int i : sts) {
if (g[t].find(i) != g[t].end()) {
fd = 1;
st2.insert(i);
break;
}
}
if (!fd) return 0;
for (int i : st2) {
if (g[t].find(i) == g[t].end()) return 0;
}
if ((int)st2.size() > dt) {
return 0;
}
for (int i : sts) {
int xx = id[s][i];
ans.push_back(make_pair(u[xx], v[xx]));
}
for (int i : st2) {
if (i != s) {
int xx = id[t][i];
ans.push_back(make_pair(u[xx], v[xx]));
}
}
return 1;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; ++i) {
scanf("%d%d", u + i, v + i);
e[u[i]].push_back(v[i]);
e[v[i]].push_back(u[i]);
}
scanf("%d%d%d%d", &s, &t, &ds, &dt);
init();
for (int i = 1; i <= n; ++i) {
if (!vis[i] && check(i)) {
dfs(i);
}
}
for (int i = 0; i < m; ++i) {
if (check(u[i]) && check(v[i])) {
mrg(u[i], v[i]);
}
}
for (int i = 1; i <= n; ++i) {
st.insert(find(i));
}
st.erase(s);
st.erase(t);
int c = st.size();
for (int i = 0; i < m; ++i) {
if (find(u[i]) != find(v[i])) {
g[find(u[i])].insert(find(v[i]));
g[find(v[i])].insert(find(u[i]));
id[find(u[i])][find(v[i])] = i;
id[find(v[i])][find(u[i])] = i;
}
}
if (g[s].find(t) != g[s].end()) {
if (solve()) {
puts("Yes");
for (auto p : ans) {
printf("%d %d\n", p.first, p.second);
}
return 0;
}
}
if (solve2()) {
puts("Yes");
for (auto p : ans) {
printf("%d %d\n", p.first, p.second);
}
return 0;
}
puts("No");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
const ll OO = 1e8;
int di[8] = {0, 0, 1, -1, -1, 1, -1, 1};
int dj[8] = {1, -1, 0, 0, 1, 1, -1, -1};
string ys = "YES", no = "NO";
const long double dgr = acos(-1) / 180, dg = 180 / acos(-1);
const int mod = 1e18, N = 2e5, M = 50000;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n, m;
cin >> n >> m;
int a, b, c;
double ans = 0;
vector<int> v(n);
for (auto& i : v) cin >> i;
while (m--) {
cin >> a >> b >> c;
ans = max(ans, (double)(v[a - 1] + v[b - 1]) / c);
}
cout << fixed << setprecision(15) << ans << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
void solve() {
long long n;
cin >> n;
vector<long long> a(n);
vector<long long> b(n);
for (long long i = 0; i < n; i++) {
cin >> a[i];
};
for (long long i = 0; i < n; i++) {
cin >> b[i];
};
long long min_a = LLONG_MAX;
long long min_b = LLONG_MAX;
for (long long i = 0; i < n; i++) {
min_a = min(min_a, a[i]);
min_b = min(min_b, b[i]);
}
long long ans = 0;
for (long long i = 0; i < n; i++) {
long long cnt = 0;
long long diff_a = a[i] - min_a;
long long diff_b = b[i] - min_b;
long long min_diff = min(diff_a, diff_b);
cnt += min_diff;
a[i] -= min_diff;
b[i] -= min_diff;
cnt += (a[i] - min_a);
cnt += (b[i] - min_b);
ans += cnt;
}
cout << ans << '\n';
}
int main() {
fast();
int t;
cin >> t;
while (t--) {
solve();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int maxn = 1e6 + 4;
const int maxm = 1e2 + 4;
const double pi = acos(-1.0);
int n, K;
int a[maxn];
bool vis[maxn];
vector<int> sz;
int cnt[maxm], lst[maxm];
bitset<maxn> dp;
int main() {
int ik, i, j, k, kase;
scanf("%d%d", &n, &K);
for (i = 1; i <= n; ++i) scanf("%d", a + i);
for (i = 1; i <= n; ++i)
if (!vis[i]) {
int cnt = 0;
int beg = i;
do {
cnt++;
beg = a[beg];
vis[beg] = true;
} while (beg != i);
sz.push_back(cnt);
}
int maxv = 0;
if (K <= sz.size())
maxv = 2 * K;
else if (K >= n - sz.size())
maxv = n;
else {
int tot = 0, res = 0;
for (i = 0; i < sz.size(); ++i) tot += sz[i] - sz[i] % 2, res += sz[i] & 1;
if (tot >= K * 2)
maxv = K * 2;
else if (res >= (K - tot / 2))
maxv = tot + K - tot / 2;
else
maxv = n;
}
dp.reset();
dp[0] = 1;
for (i = 0; i < sz.size(); ++i)
if (sz[i] >= 100)
dp |= dp << sz[i];
else
cnt[sz[i]]++;
for (i = 2; i < 100; ++i)
if (cnt[i]) {
memset(lst, 0x3f, sizeof lst);
for (j = 0; j <= K; ++j) {
int index = j % i;
if (dp[j])
lst[index] = j;
else if (lst[index] != inf && (j - lst[index]) / i <= cnt[i])
dp[j] = true;
}
}
int minv = dp[K] ? K : K + 1;
printf("%d %d\n", minv, maxv);
return 0;
}
| 9 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:36777216")
using namespace std;
template <class T>
inline T &RD(T &);
template <class T>
inline void OT(const T &);
inline long long RD() {
long long x;
return RD(x);
}
inline double &RF(double &);
inline double RF() {
double x;
return RF(x);
}
inline char *RS(char *s);
inline char &RC(char &c);
inline char RC();
inline char &RC(char &c) {
scanf(" %c", &c);
return c;
}
inline char RC() {
char c;
return RC(c);
}
template <class T>
inline T &RDD(T &);
inline long long RDD() {
long long x;
return RDD(x);
}
template <class T0, class T1>
inline T0 &RD(T0 &x0, T1 &x1) {
RD(x0), RD(x1);
return x0;
}
template <class T0, class T1, class T2>
inline T0 &RD(T0 &x0, T1 &x1, T2 &x2) {
RD(x0), RD(x1), RD(x2);
return x0;
}
template <class T0, class T1, class T2, class T3>
inline T0 &RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3) {
RD(x0), RD(x1), RD(x2), RD(x3);
return x0;
}
template <class T0, class T1, class T2, class T3, class T4>
inline T0 &RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4) {
RD(x0), RD(x1), RD(x2), RD(x3), RD(x4);
return x0;
}
template <class T0, class T1, class T2, class T3, class T4, class T5>
inline T0 &RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5) {
RD(x0), RD(x1), RD(x2), RD(x3), RD(x4), RD(x5);
return x0;
}
template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
inline T0 &RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5, T6 &x6) {
RD(x0), RD(x1), RD(x2), RD(x3), RD(x4), RD(x5), RD(x6);
return x0;
}
template <class T0, class T1>
inline void OT(const T0 &x0, const T1 &x1) {
OT(x0), OT(x1);
}
template <class T0, class T1, class T2>
inline void OT(const T0 &x0, const T1 &x1, const T2 &x2) {
OT(x0), OT(x1), OT(x2);
}
template <class T0, class T1, class T2, class T3>
inline void OT(const T0 &x0, const T1 &x1, const T2 &x2, const T3 &x3) {
OT(x0), OT(x1), OT(x2), OT(x3);
}
template <class T0, class T1, class T2, class T3, class T4>
inline void OT(const T0 &x0, const T1 &x1, const T2 &x2, const T3 &x3,
const T4 &x4) {
OT(x0), OT(x1), OT(x2), OT(x3), OT(x4);
}
template <class T0, class T1, class T2, class T3, class T4, class T5>
inline void OT(const T0 &x0, const T1 &x1, const T2 &x2, const T3 &x3,
const T4 &x4, const T5 &x5) {
OT(x0), OT(x1), OT(x2), OT(x3), OT(x4), OT(x5);
}
template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
inline void OT(const T0 &x0, const T1 &x1, const T2 &x2, const T3 &x3,
const T4 &x4, const T5 &x5, const T6 &x6) {
OT(x0), OT(x1), OT(x2), OT(x3), OT(x4), OT(x5), OT(x6);
}
inline char &RC(char &a, char &b) {
RC(a), RC(b);
return a;
}
inline char &RC(char &a, char &b, char &c) {
RC(a), RC(b), RC(c);
return a;
}
inline char &RC(char &a, char &b, char &c, char &d) {
RC(a), RC(b), RC(c), RC(d);
return a;
}
inline char &RC(char &a, char &b, char &c, char &d, char &e) {
RC(a), RC(b), RC(c), RC(d), RC(e);
return a;
}
inline char &RC(char &a, char &b, char &c, char &d, char &e, char &f) {
RC(a), RC(b), RC(c), RC(d), RC(e), RC(f);
return a;
}
inline char &RC(char &a, char &b, char &c, char &d, char &e, char &f, char &g) {
RC(a), RC(b), RC(c), RC(d), RC(e), RC(f), RC(g);
return a;
}
inline double &RF(double &a, double &b) {
RF(a), RF(b);
return a;
}
inline double &RF(double &a, double &b, double &c) {
RF(a), RF(b), RF(c);
return a;
}
inline double &RF(double &a, double &b, double &c, double &d) {
RF(a), RF(b), RF(c), RF(d);
return a;
}
inline double &RF(double &a, double &b, double &c, double &d, double &e) {
RF(a), RF(b), RF(c), RF(d), RF(e);
return a;
}
inline double &RF(double &a, double &b, double &c, double &d, double &e,
double &f) {
RF(a), RF(b), RF(c), RF(d), RF(e), RF(f);
return a;
}
inline double &RF(double &a, double &b, double &c, double &d, double &e,
double &f, double &g) {
RF(a), RF(b), RF(c), RF(d), RF(e), RF(f), RF(g);
return a;
}
inline void RS(char *s1, char *s2) { RS(s1), RS(s2); }
inline void RS(char *s1, char *s2, char *s3) { RS(s1), RS(s2), RS(s3); }
template <class T0, class T1>
inline T0 &RDD(T0 &a, T1 &b) {
RDD(a), RDD(b);
return a;
}
template <class T0, class T1, class T2>
inline T1 &RDD(T0 &a, T1 &b, T2 &c) {
RDD(a), RDD(b), RDD(c);
return a;
}
template <class T>
inline void RST(T &A) {
memset(A, 0, sizeof(A));
}
template <class T>
inline void FLC(T &A, int x) {
memset(A, x, sizeof(A));
}
template <class T>
inline void CLR(T &A) {
A.clear();
}
template <class T0, class T1>
inline void RST(T0 &A0, T1 &A1) {
RST(A0), RST(A1);
}
template <class T0, class T1, class T2>
inline void RST(T0 &A0, T1 &A1, T2 &A2) {
RST(A0), RST(A1), RST(A2);
}
template <class T0, class T1, class T2, class T3>
inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3) {
RST(A0), RST(A1), RST(A2), RST(A3);
}
template <class T0, class T1, class T2, class T3, class T4>
inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4) {
RST(A0), RST(A1), RST(A2), RST(A3), RST(A4);
}
template <class T0, class T1, class T2, class T3, class T4, class T5>
inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5) {
RST(A0), RST(A1), RST(A2), RST(A3), RST(A4), RST(A5);
}
template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6) {
RST(A0), RST(A1), RST(A2), RST(A3), RST(A4), RST(A5), RST(A6);
}
template <class T0, class T1>
inline void FLC(T0 &A0, T1 &A1, int x) {
FLC(A0, x), FLC(A1, x);
}
template <class T0, class T1, class T2>
inline void FLC(T0 &A0, T1 &A1, T2 &A2, int x) {
FLC(A0, x), FLC(A1, x), FLC(A2, x);
}
template <class T0, class T1, class T2, class T3>
inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, int x) {
FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x);
}
template <class T0, class T1, class T2, class T3, class T4>
inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, int x) {
FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x), FLC(A4, x);
}
template <class T0, class T1, class T2, class T3, class T4, class T5>
inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, int x) {
FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x), FLC(A4, x), FLC(A5, x);
}
template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6, int x) {
FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x), FLC(A4, x), FLC(A5, x),
FLC(A6, x);
}
template <class T>
inline void CLR(priority_queue<T> &Q) {
while (!Q.empty()) Q.pop();
}
template <class T>
inline void CLR(stack<T> &S) {
while (!S.empty()) S.pop();
}
template <class T>
inline void CLR(queue<T> &Q) {
while (!Q.empty()) Q.pop();
}
template <class T0, class T1>
inline void CLR(T0 &A0, T1 &A1) {
CLR(A0), CLR(A1);
}
template <class T0, class T1, class T2>
inline void CLR(T0 &A0, T1 &A1, T2 &A2) {
CLR(A0), CLR(A1), CLR(A2);
}
template <class T0, class T1, class T2, class T3>
inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3) {
CLR(A0), CLR(A1), CLR(A2), CLR(A3);
}
template <class T0, class T1, class T2, class T3, class T4>
inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4) {
CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4);
}
template <class T0, class T1, class T2, class T3, class T4, class T5>
inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5) {
CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4), CLR(A5);
}
template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6) {
CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4), CLR(A5), CLR(A6);
}
template <class T>
inline void CLR(T &A, int n) {
for (int i = 0; i < n; ++i) CLR(A[i]);
}
template <class T>
inline bool EPT(T &a) {
return a.empty();
}
template <class T>
inline T &SRT(T &A) {
sort(A.begin(), A.end());
return A;
}
template <class T, class C>
inline T &SRT(T &A, C cmp) {
sort(A.begin(), A.end(), cmp);
return A;
}
template <class T>
inline T &RVS(T &A) {
reverse(A.begin(), A.end());
return A;
}
template <class T>
inline T &UNQQ(T &A) {
A.resize(unique(A.begin(), A.end()) - A.begin());
return A;
}
template <class T>
inline T &UNQ(T &A) {
SRT(A);
return UNQQ(A);
}
template <class T, class C>
inline T &UNQ(T &A, C cmp) {
SRT(A, cmp);
return UNQQ(A);
}
const int MOD = int(1e9) + 7;
const int INF = 0x3f3f3f3f;
const long long INFF = 0x3f3f3f3f3f3f3f3fLL;
const double EPS = 1e-9;
const double OO = 1e20;
const double PI = acos(-1.0);
const int dx[] = {-1, 1, 0, 0};
const int dy[] = {0, 0, 1, -1};
template <class T>
inline bool checkMin(T &a, const T b) {
return b < a ? a = b, 1 : 0;
}
template <class T>
inline bool checkMax(T &a, const T b) {
return a < b ? a = b, 1 : 0;
}
template <class T, class C>
inline bool checkUpd(T &a, const T b, C c) {
return c(b, a) ? a = b, 1 : 0;
}
template <class T>
inline T min(T a, T b, T c) {
return min(min(a, b), c);
}
template <class T>
inline T max(T a, T b, T c) {
return max(max(a, b), c);
}
template <class T>
inline T min(T a, T b, T c, T d) {
return min(min(a, b), min(c, d));
}
template <class T>
inline T max(T a, T b, T c, T d) {
return max(max(a, b), max(c, d));
}
template <class T>
inline T min(T a, T b, T c, T d, T e) {
return min(min(min(a, b), min(c, d)), e);
}
template <class T>
inline T max(T a, T b, T c, T d, T e) {
return max(max(max(a, b), max(c, d)), e);
}
template <class T>
inline T sqr(T a) {
return a * a;
}
template <class T>
inline T cub(T a) {
return a * a * a;
}
template <class T>
inline T ceil(T x, T y) {
return (x - 1) / y + 1;
}
template <class T>
T abs(T x) {
return x > 0 ? x : -x;
}
inline int sgn(double x) { return x < -EPS ? -1 : x > EPS; }
inline int sgn(double x, double y) { return sgn(x - y); }
inline double cos(double a, double b, double c) {
return (sqr(a) + sqr(b) - sqr(c)) / (2 * a * b);
}
inline double cot(double x) { return 1. / tan(x); };
inline double sec(double x) { return 1. / cos(x); };
inline double csc(double x) { return 1. / sin(x); };
namespace BO {
inline bool _1(int x, int i) { return bool(x & 1 << i); }
inline bool _1(long long x, int i) { return bool(x & 1LL << i); }
inline long long _1(int i) { return 1LL << i; }
inline long long _U(int i) { return _1(i) - 1; };
inline int reverse_bits(int x) {
x = ((x >> 1) & 0x55555555) | ((x << 1) & 0xaaaaaaaa);
x = ((x >> 2) & 0x33333333) | ((x << 2) & 0xcccccccc);
x = ((x >> 4) & 0x0f0f0f0f) | ((x << 4) & 0xf0f0f0f0);
x = ((x >> 8) & 0x00ff00ff) | ((x << 8) & 0xff00ff00);
x = ((x >> 16) & 0x0000ffff) | ((x << 16) & 0xffff0000);
return x;
}
inline long long reverse_bits(long long x) {
x = ((x >> 1) & 0x5555555555555555LL) | ((x << 1) & 0xaaaaaaaaaaaaaaaaLL);
x = ((x >> 2) & 0x3333333333333333LL) | ((x << 2) & 0xccccccccccccccccLL);
x = ((x >> 4) & 0x0f0f0f0f0f0f0f0fLL) | ((x << 4) & 0xf0f0f0f0f0f0f0f0LL);
x = ((x >> 8) & 0x00ff00ff00ff00ffLL) | ((x << 8) & 0xff00ff00ff00ff00LL);
x = ((x >> 16) & 0x0000ffff0000ffffLL) | ((x << 16) & 0xffff0000ffff0000LL);
x = ((x >> 32) & 0x00000000ffffffffLL) | ((x << 32) & 0xffffffff00000000LL);
return x;
}
template <class T>
inline bool odd(T x) {
return x & 1;
}
template <class T>
inline bool even(T x) {
return !odd(x);
}
template <class T>
inline T low_bit(T x) {
return x & -x;
}
template <class T>
inline T high_bit(T x) {
T p = low_bit(x);
while (p != x) x -= p, p = low_bit(x);
return p;
}
template <class T>
inline T cover_bit(T x) {
T p = 1;
while (p < x) p <<= 1;
return p;
}
template <class T>
inline int cover_idx(T x) {
int p = 0;
while (_1(p) < x) ++p;
return p;
}
inline int clz(int x) { return __builtin_clz(x); }
inline int clz(long long x) { return __builtin_clzll(x); }
inline int ctz(int x) { return __builtin_ctz(x); }
inline int ctz(long long x) { return __builtin_ctzll(x); }
inline int lg2(int x) { return !x ? -1 : 31 - clz(x); }
inline int lg2(long long x) { return !x ? -1 : 63 - clz(x); }
inline int low_idx(int x) { return !x ? -1 : ctz(x); }
inline int low_idx(long long x) { return !x ? -1 : ctz(x); }
inline int high_idx(int x) { return lg2(x); }
inline int high_idx(long long x) { return lg2(x); }
inline int parity(int x) { return __builtin_parity(x); }
inline int parity(long long x) { return __builtin_parityll(x); }
inline int count_bits(int x) { return __builtin_popcount(x); }
inline int count_bits(long long x) { return __builtin_popcountll(x); }
} // namespace BO
using namespace BO;
namespace NT {
inline long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
inline long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
inline void INC(int &a, int b) {
a += b;
if (a >= MOD) a -= MOD;
}
inline int sum(int a, int b) {
a += b;
if (a >= MOD) a -= MOD;
return a;
}
inline void DEC(int &a, int b) {
a -= b;
if (a < 0) a += MOD;
}
inline int dff(int a, int b) {
a -= b;
if (a < 0) a += MOD;
return a;
}
inline void MUL(int &a, int b) { a = (long long)a * b % MOD; }
inline int pdt(int x, int y) {
int ret;
__asm__ __volatile__("\tmull %%ebx\n\tdivl %%ecx\n"
: "=d"(ret)
: "a"(x), "b"(y), "c"(MOD));
return ret;
}
inline int gcd(int m, int n, int &x, int &y) {
x = 1, y = 0;
int xx = 0, yy = 1, q;
while (1) {
q = m / n, m %= n;
if (!m) {
x = xx, y = yy;
return n;
}
DEC(x, pdt(q, xx)), DEC(y, pdt(q, yy));
q = n / m, n %= m;
if (!n) return m;
DEC(xx, pdt(q, x)), DEC(yy, pdt(q, y));
}
}
inline int sum(int a, int b, int c) { return sum(a, sum(b, c)); }
inline int sum(int a, int b, int c, int d) { return sum(sum(a, b), sum(c, d)); }
inline int pdt(int a, int b, int c) { return pdt(a, pdt(b, c)); }
inline int pdt(int a, int b, int c, int d) { return pdt(pdt(a, b), pdt(c, d)); }
inline int pow(int a, long long b) {
int c(1);
while (b) {
if (b & 1) MUL(c, a);
MUL(a, a), b >>= 1;
}
return c;
}
template <class T>
inline T pow(T a, long long b) {
T c(1);
while (b) {
if (b & 1) c *= a;
a *= a, b >>= 1;
}
return c;
}
template <class T>
inline T pow(T a, int b) {
return pow(a, (long long)b);
}
inline int _I(int b) {
int a = MOD, x1 = 0, x2 = 1, q;
while (1) {
q = a / b, a %= b;
if (!a) return x2;
DEC(x1, pdt(q, x2));
q = b / a, b %= a;
if (!b) return x1;
DEC(x2, pdt(q, x1));
}
}
inline void DIV(int &a, int b) { MUL(a, _I(b)); }
inline int qtt(int a, int b) { return pdt(a, _I(b)); }
struct Int {
int val;
operator int() const { return val; }
Int(int _val = 0) : val(_val) {
val %= MOD;
if (val < 0) val += MOD;
}
Int(long long _val) : val(_val) {
_val %= MOD;
if (_val < 0) _val += MOD;
val = _val;
}
Int &operator+=(const int &rhs) {
INC(val, rhs);
return *this;
}
Int operator+(const int &rhs) const { return sum(val, rhs); }
Int &operator-=(const int &rhs) {
DEC(val, rhs);
return *this;
}
Int operator-(const int &rhs) const { return dff(val, rhs); }
Int &operator*=(const int &rhs) {
MUL(val, rhs);
return *this;
}
Int operator*(const int &rhs) const { return pdt(val, rhs); }
Int &operator/=(const int &rhs) {
DIV(val, rhs);
return *this;
}
Int operator/(const int &rhs) const { return qtt(val, rhs); }
Int operator-() const { return MOD - *this; }
};
} // namespace NT
using namespace NT;
template <class T>
inline T &RD(T &x) {
char c;
while (!isdigit((c = getchar())))
;
x = c - '0';
while (isdigit((c = getchar()))) x = x * 10 + c - '0';
return x;
}
template <class T>
inline T &RDD(T &x) {
char c;
while ((c = getchar()), c != '-' && !isdigit(c))
;
if (c == '-') {
x = '0' - (c = getchar());
while (isdigit((c = getchar()))) x = x * 10 + '0' - c;
} else {
x = c - '0';
while (isdigit((c = getchar()))) x = x * 10 + c - '0';
}
return x;
}
inline double &RF(double &x) {
char c;
while ((c = getchar()), c != '-' && c != '.' && !isdigit(c))
;
if (c == '-')
if ((c = getchar()) == '.') {
x = 0;
double l = 1;
while (isdigit((c = getchar()))) l /= 10, x = x * 10 + '0' - c;
x *= l;
} else {
x = '0' - c;
while (isdigit((c = getchar()))) x = x * 10 + '0' - c;
if (c == '.') {
double l = 1;
while (isdigit((c = getchar()))) l /= 10, x = x * 10 + '0' - c;
x *= l;
}
}
else if (c == '.') {
x = 0;
double l = 1;
while (isdigit((c = getchar()))) l /= 10, x = x * 10 + c - '0';
x *= l;
} else {
x = c - '0';
while (isdigit((c = getchar()))) x = x * 10 + c - '0';
if (c == '.') {
double l = 1;
while (isdigit((c = getchar()))) l /= 10, x = x * 10 + c - '0';
x *= l;
}
}
return x;
}
inline char *RS(char *s) {
scanf("%s", s);
return s;
}
long long last_ans;
int Case;
template <class T>
inline void OT(const T &x) {
cout << x << endl;
}
const int N = int(1e3) + 9;
vector<int> adj[N];
int n, m;
int a[N], b[N];
int fa[N];
long long p[N], p0;
int Q[N], cz, op;
void add_path(int u) {
while (~fa[u]) {
Q[op++] = u;
p0 += b[u];
int v = fa[u];
fa[u] = -1;
u = v;
}
}
bool find_circle() {
for (int i = 0; i < n; ++i) fa[i] = -1, p[i] = 0;
for (int i = 0; i < op; ++i) p[Q[i]] = p0;
cz = 0;
int op = ::op;
while (cz < op) {
int u = Q[cz++];
for (auto v : adj[u])
if (v != fa[u] && p[u] > a[v]) {
if (~fa[v] || p[v] == p0 && p[u] != p0) {
add_path(u);
add_path(v);
return 1;
}
if (p[v] == p0) continue;
p[v] = p[u] + b[v];
fa[v] = u;
Q[op++] = v;
}
}
return 0;
}
bool ok(int _p0) {
op = 0;
Q[op++] = 0;
p0 = _p0;
while (find_circle())
;
return op == n;
}
int main() {
for (int ____T = RD(); ____T--;) {
RD(n, m);
for (int i = 1; i < n; ++i) RD(a[i]);
for (int i = 1; i < n; ++i) RD(b[i]);
for (int i = 0; i < n; ++i) adj[i].clear();
for (int ____n = m; ____n-- > 0;) {
int x, y;
RD(x, y);
--x;
--y;
adj[x].push_back(y);
adj[y].push_back(x);
}
int l = 2, r = int(1e9) + 1;
while (l < r) {
int m = (l + r) / 2;
if (ok(m))
r = m;
else
l = m + 1;
}
cout << l << endl;
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 210;
const int M = 1 << 7;
const int INF = 0x3f3f3f3f;
const int iinf = 1 << 30;
const long long linf = 2e18;
const int MOD = 1000000007;
const double eps = 1e-7;
void print(int x) {
cout << x << endl;
exit(0);
}
void PRINT(string x) {
cout << x << endl;
exit(0);
}
void douout(double x) { printf("%lf\n", x + 0.0000000001); }
int dp[N][M], pre[N][M], vis[N][M];
int hsh[N], maz[N][N];
char g[N][N];
int n, m, k, nn, mm;
int dx[] = {0, 0, -1, 1};
int dy[] = {-1, 1, 0, 0};
struct node {
int x, dis;
};
queue<node> q;
void modify(int x, int dis, int w, int fa) {
if (dp[x][dis] > w) {
dp[x][dis] = w;
pre[x][dis] = fa;
if (!vis[x][dis]) {
q.push((node){x, dis});
vis[x][dis] = 1;
}
}
}
void dfs(int X, int dis) {
int x = X / m, y = X % m;
g[x][y] = 'X';
if (pre[X][dis] == -1) return;
int to = pre[X][dis] / 1000, diss = pre[X][dis] % 1000;
dfs(to, diss);
if (diss - dis) dfs(to, dis - diss);
}
bool check(int x, int y) {
if (x >= 0 && x < n && y >= 0 && y < m) return true;
return false;
}
void getans() {
while (!q.empty()) {
node nw = q.front();
q.pop();
int now = nw.x, x = nw.x / m, y = nw.x % m, dis = nw.dis;
vis[now][dis] = false;
for (int i = (0); i <= (3); i++) {
int tx = x + dx[i], ty = y + dy[i];
if (!check(tx, ty)) continue;
int to = tx * m + ty;
modify(to, dis, dp[now][dis] + maz[tx][ty], now * 1000 + dis);
}
int t = mm - dis - 1;
for (int i = t; i; i = (i - 1) & t) {
modify(now, i | dis, dp[now][i] + dp[now][dis] - maz[x][y],
now * 1000 + dis);
}
}
int ans = iinf, now;
for (int i = (0); i <= (nn - 1); i++)
if (ans > dp[i][mm - 1]) {
ans = dp[i][mm - 1];
now = i;
}
dfs(now, mm - 1);
printf("%d\n", ans);
for (int i = (0); i <= (n - 1); i++) {
for (int j = (0); j <= (m - 1); j++) cout << g[i][j];
cout << endl;
}
}
signed main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = (0); i <= (n - 1); i++) {
for (int j = (0); j <= (m - 1); j++) {
scanf("%d", &maz[i][j]);
g[i][j] = '.';
}
}
nn = n * m;
mm = (1 << k);
memset(hsh, 0, sizeof(hsh));
memset(vis, 0, sizeof(vis));
for (int i = (0); i <= (nn - 1); i++)
for (int j = (0); j <= (mm - 1); j++) dp[i][j] = iinf;
for (int i = (0); i <= (k - 1); i++) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
int id = a * m + b;
hsh[id] = 1 << i;
modify(id, hsh[id], maz[a][b], -1);
}
getans();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
bool activ[100005];
bool chk[100005];
int primecnt[100005];
set<int> s[100005];
vector<int> primes[100005];
vector<int> v;
void pre() {
int t = (int)(sqrt(100000));
for (int i = 2; i <= t; i++) {
if (!chk[i]) {
for (int j = 2 * i; j <= 100000; j += i) {
chk[j] = true;
}
}
}
for (int i = 2; i <= 100000; i++)
if (!chk[i]) v.push_back(i);
for (int i = 0; i < (int)(v.size()); i++) {
for (int j = v[i]; j <= 100000; j += v[i]) {
primes[j].push_back(v[i]);
}
}
return;
}
int main() {
pre();
int n, m, x;
string p;
cin >> n >> m;
while (m--) {
cin >> p >> x;
if (p == "+") {
if (activ[x])
cout << "Already on" << endl;
else {
for (int i = 0; i < primes[x].size(); i++) {
if (primecnt[primes[x][i]] > 0) {
cout << "Conflict with " << *(s[primes[x][i]].begin()) << endl;
goto p;
}
}
cout << "Success" << endl;
activ[x] = true;
for (int i = 0; i < primes[x].size(); i++) {
primecnt[primes[x][i]]++;
s[primes[x][i]].insert(x);
}
p : {}
}
} else {
if (!activ[x])
cout << "Already off" << endl;
else {
cout << "Success" << endl;
activ[x] = false;
for (int i = 0; i < primes[x].size(); i++) {
primecnt[primes[x][i]]--;
s[primes[x][i]].erase(s[primes[x][i]].find(x));
}
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
int main() {
int n, d, x = 0, y = 0, v = 0, r = 0;
scanf("%d%d", &n, &d);
for (int i = 2 * n - 2; i >= 0; i -= 2) {
r = 4 * v | (d >> i) & 3;
x = (x << 1) | (0x936c >> r) & 1;
y = (y << 1) | (0x39c6 >> r) & 1;
v = (0x3e6b94c1 >> 2 * r) & 3;
}
printf("%d %d", x, y);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long sq(long long x) {
int lo = 0, hi = 100000;
while (lo != hi) {
int mi = (lo + hi) / 2;
if (1LL * mi * mi >= x)
hi = mi;
else
lo = mi + 1;
}
return lo;
}
int main(void) {
ios::sync_with_stdio(false);
long long a, b, c, d;
cin >> a >> b >> c >> d;
long long xa = sq(1 + 8 * a), xd = sq(1 + 8 * d);
if (xa * xa != 1 + 8 * a) {
cout << "Impossible\n";
return 0;
}
if (xd * xd != 1 + 8 * d) {
cout << "Impossible\n";
return 0;
}
xa = 1 + xa;
xd = 1 + xd;
if (xa % 2 || xd % 2) {
cout << "Impossible\n";
return 0;
}
xa /= 2;
xd /= 2;
if (xa == 1 && b + c == 0) {
for (int j = 0; j < xd; j++) cout << "1";
cout << endl;
return 0;
}
if (xd == 1 && b + c == 0) {
for (int j = 0; j < xa; j++) cout << "0";
cout << endl;
return 0;
}
if (xa * xd != b + c) {
cout << "Impossible\n";
return 0;
}
long long cnt = 0;
vector<int> ax;
for (int i = 0; i < xd; i++) {
if (cnt + xa <= b) {
ax.push_back(xa);
cnt += xa;
} else {
ax.push_back(b - cnt);
cnt = b;
}
}
sort(ax.begin(), ax.end());
string ans;
int pr = 0;
for (int i = 0; i < ax.size(); i++) {
for (int j = 0; j < ax[i] - pr; j++) cout << "0";
cout << "1";
pr = ax[i];
}
if (ax.size())
for (int j = 0; j < xa - ax.back(); j++) cout << "0";
cout << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k, i;
cin >> k;
vector<int> v(12);
for (i = 0; i < 12; i++) cin >> v[i];
sort(v.begin(), v.end(), greater<int>());
int count = 0, sum = 0;
i = 0;
while (sum < k && i < 12) {
sum += v[i];
count++;
i++;
}
if (sum < k)
cout << -1 << endl;
else
cout << count << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 5, INF = 1e9 + 5;
int n, m, k, dist[N][N], x, y, ans = INF, tmpans;
bool vis[N][N];
struct Edge {
int a, b, w;
};
Edge edges[N];
vector<pair<int, int>> graph[N];
pair<int, int> routes[N];
void dijkstra(int vv) {
fill(dist[vv], dist[vv] + N, INF);
dist[vv][vv] = 0;
priority_queue<pair<int, int>> pq;
pq.push({0, vv});
while (!pq.empty()) {
int v = pq.top().second;
pq.pop();
if (!vis[vv][v]) {
vis[vv][v] = true;
for (auto p : graph[v]) {
if (dist[vv][v] + p.second < dist[vv][p.first]) {
dist[vv][p.first] = dist[vv][v] + p.second;
pq.push({-dist[vv][p.first], p.first});
}
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m >> k;
for (int i = 0; i < m; i++) {
cin >> edges[i].a >> edges[i].b >> edges[i].w;
graph[edges[i].a].push_back({edges[i].b, edges[i].w});
graph[edges[i].b].push_back({edges[i].a, edges[i].w});
}
for (int i = 0; i < k; i++) cin >> routes[i].first >> routes[i].second;
for (int i = 1; i <= n; i++) dijkstra(i);
for (int e = 0; e < m; e++) {
tmpans = 0;
for (int i = 0; i < k; i++) {
x = routes[i].first, y = routes[i].second;
tmpans += min({dist[x][edges[e].a] + dist[y][edges[e].b],
dist[x][edges[e].b] + dist[y][edges[e].a], dist[x][y]});
}
ans = min(ans, tmpans);
}
cout << ans;
}
| 6 |
#include <bits/stdc++.h>
int main() {
int n, h, m;
int i, l[50], r[50];
int x[50], profit;
int house[50];
int j;
profit = 0;
scanf("%d%d%d", &n, &h, &m);
for (i = 1; i <= n; i++) {
house[i] = h;
}
for (i = 1; i <= m; i++) {
scanf("%d%d%d", &l[i], &r[i], &x[i]);
}
for (i = 1; i <= m; i++) {
for (j = l[i]; j <= r[i]; j++) {
if (x[i] <= house[j]) {
house[j] = x[i];
}
}
}
for (i = 1; i <= n; i++) {
profit = profit + house[i] * house[i];
}
printf("%d", profit);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T gcd(T a, T b) {
if (a == 0) return b;
return gcd(b % a, a);
}
template <typename T>
T pow(T a, T b, long long m) {
T ans = 1;
while (b > 0) {
if (b % 2 == 1) ans = ((ans % m) * (a % m)) % m;
b /= 2;
a = ((a % m) * (a % m)) % m;
}
return ans % m;
}
const long double eps = 1e-10L;
set<long long> longi, lati;
multiset<long long> width, height;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long w, h, n;
cin >> w >> h >> n;
longi.insert(0);
longi.insert(w);
lati.insert(0);
lati.insert(h);
width.insert(w);
height.insert(h);
char ori;
long long dim;
for (long long i = 1; i <= n; i++) {
cin >> ori >> dim;
if (ori == 'H') {
set<long long>::iterator it2 = lati.upper_bound(dim);
set<long long>::iterator it = it2;
it2--;
long long t = (*it) - (*it2);
multiset<long long>::iterator it3 = height.lower_bound(t);
height.erase(it3);
lati.insert(dim);
long long t1 = t - (dim - (*it2));
long long t2 = t - ((*it) - dim);
height.insert(t1);
height.insert(t2);
} else {
set<long long>::iterator it2 = longi.upper_bound(dim);
set<long long>::iterator it = it2;
it2--;
long long t = (*it) - (*it2);
multiset<long long>::iterator it3 = width.lower_bound(t);
width.erase(it3);
longi.insert(dim);
long long t1 = t - (dim - (*it2));
long long t2 = t - ((*it) - dim);
width.insert(t1);
width.insert(t2);
}
long long ans = (*width.rbegin()) * (*height.rbegin());
cout << ans << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
string s[100005];
string en;
int sz;
int poin;
bool sol = true;
void find(string x) {
for (int i = 0; i < x.size(); ++i) {
while (poin < sz && en[poin] != x[i]) ++poin;
if (poin >= sz) sol = false;
++poin;
}
}
int main() {
cin >> n;
for (int i = 0; i < n; ++i) cin >> s[i];
cin >> en;
sz = en.size();
for (int i = 0; i < n; ++i) {
find((string) "<3");
find(s[i]);
}
find((string) "<3");
if (sol)
printf("yes\n");
else
printf("no\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const unsigned long long MOD = 1000000007;
const int inf = 0x3f3f3f3f;
const int N = 105;
int vec[105];
int main() {
int n, a, temp = 0, ans = 0;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", &a);
if (a < 0) {
temp++;
if (temp == 3) {
vec[ans] = i;
ans++;
temp = 1;
}
}
}
vec[ans++] = n;
printf("%d\n", ans);
for (int i = 0; i < ans; ++i) {
if (i) printf(" ");
if (!i)
printf("%d", vec[i]);
else
printf("%d", vec[i] - vec[i - 1]);
}
puts("");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, s;
int f[10][10], ans[10][10];
int main() {
srand(time(NULL));
ios_base::sync_with_stdio(0);
cin >> n >> m >> k >> s;
for (int i = 1; i <= k; ++i)
for (int j = 0; j <= 3; ++j) f[i][j] = -100000;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) {
int x;
cin >> x;
f[x][0] = max(f[x][0], i + j);
f[x][1] = max(f[x][1], i - j);
f[x][2] = max(f[x][2], -i + j);
f[x][3] = max(f[x][3], -i - j);
}
for (int i = 1; i <= 9; ++i)
for (int j = 1; j <= 9; ++j) {
ans[i][j] = max(ans[i][j], f[i][0] + f[j][3]);
ans[i][j] = max(ans[i][j], f[i][1] + f[j][2]);
ans[i][j] = max(ans[i][j], f[i][2] + f[j][1]);
ans[i][j] = max(ans[i][j], f[i][3] + f[j][0]);
}
int p, answer = 0;
cin >> p;
for (int i = 2; i <= s; ++i) {
int cur;
cin >> cur;
answer = max(answer, ans[p][cur]);
p = cur;
}
cout << answer;
return 0;
}
| 7 |
#include <bits/stdc++.h>
template <typename T>
bool _max(T& a, T b) {
return (a < b) ? a = b, true : false;
}
template <typename T>
bool _min(T& a, T b) {
return (b < a) ? a = b, true : false;
}
template <typename T>
T power(T base, T index, T mod) {
return ((index <= 1) ? (index ? base : 1)
: (power(base * base % mod, index >> 1, mod) *
power(base, index & 1, mod))) %
mod;
}
template <typename T>
T lowbit(T n) {
return n & -n;
}
template <typename T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <typename T>
T lcm(T a, T b) {
return (a != 0 || b != 0) ? a / gcd(a, b) * b : (T)0;
}
template <typename T>
T exgcd(T a, T b, T& x, T& y) {
if (!b) return y = 0, x = 1, a;
T ans = exgcd(b, a % b, y, x);
y -= a / b * x;
return ans;
}
int a[3];
int main() {
unsigned t;
int m;
scanf("%u", &t);
while (t--) {
scanf("%d%d%d%d", a, a + 1, a + 2, &m);
std::sort(a, a + 3);
if (*a + a[1] + m + 1 < a[2])
puts("No");
else if (*a + a[1] + a[2] < m + 3)
puts("No");
else
puts("Yes");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct Tree {
int l, r;
long long key;
} tree[100010 * 4];
struct A {
int num;
long long key;
} a[100010 * 4];
int n;
bool cmp(A x, A y) {
if (x.key == y.key)
return x.num > y.num;
else
return x.key < y.key;
}
void build(int l, int r, int num) {
tree[num].l = l;
tree[num].r = r;
tree[num].key = 0;
if (l < r) {
int mid = (l + r) / 2;
build(l, mid, num * 2);
build(mid + 1, r, num * 2 + 1);
}
}
long long findmax(int l, int r, int num) {
if (l > r) return 0;
if (tree[num].l == l && tree[num].r == r) return tree[num].key;
int mid = (tree[num].l + tree[num].r) / 2;
if (r <= mid) return findmax(l, r, num * 2);
if (l > mid) return findmax(l, r, num * 2);
return max(findmax(l, mid, num * 2), findmax(mid + 1, r, num * 2 + 1));
}
void change(int x, long long y, int num) {
if (tree[num].l == tree[num].r && tree[num].l == x) {
tree[num].key = y;
return;
}
int mid = (tree[num].l + tree[num].r) / 2;
if (x <= mid)
change(x, y, num * 2);
else
change(x, y, num * 2 + 1);
tree[num].key = max(tree[num * 2].key, tree[num * 2 + 1].key);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
long long h, r;
scanf("%lld%lld", &r, &h);
a[i].key = r * r * h;
a[i].num = i;
}
sort(a + 1, a + 1 + n, cmp);
build(1, n, 1);
for (int i = 1; i <= n; i++) {
int now = a[i].num;
long long t = findmax(1, now - 1, 1) + a[i].key;
change(now, t, 1);
}
double ans = 3.141592653589793 * findmax(1, n, 1);
printf("%lf\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
int main() {
long long n, x, l, r, m, total = 0;
scanf("%I64d%I64d", &n, &x);
for (long long i = 1; i <= n; ++i) {
l = 1;
r = n;
while (l < r) {
m = (l + r) / 2;
if ((m * i) < x)
l = m + 1;
else
r = m;
}
total = (x == l * i) ? total + 1 : total;
}
printf("%I64d", total);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int add(int x, int y) {
x += y;
if (x > 1000000007) return x - 1000000007;
return x;
}
int main() {
int n;
cin >> n;
vector<int> dpr(n + 1, 0);
vector<int> dpb(n + 1, 0);
for (int i = 1; i <= n; i++) {
if (i % 2 == 1) {
dpr[i] = 1;
dpr[i] = add(dpr[i], dpr[i - 1]);
dpr[i] = add(dpr[i], dpb[i - 1]);
dpb[i] = add(dpb[i], dpb[i - 1]);
} else {
dpb[i] = 1;
dpb[i] = add(dpb[i], dpb[i - 1]);
dpb[i] = add(dpb[i], dpr[i - 1]);
dpr[i] = add(dpr[i], dpr[i - 1]);
}
}
cout << add(dpr[n], dpb[n]);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100010;
int n, m;
vector<int> vec[MAXN];
bool mark[MAXN];
int dis[MAXN];
void bfs(int x) {
queue<int> que;
que.push(x);
dis[x] = 0;
mark[x] = 1;
while (!que.empty()) {
int z = que.front();
for (int i = 0; i < vec[z].size(); i++) {
if (!mark[vec[z][i]]) {
mark[vec[z][i]] = 1;
dis[vec[z][i]] = dis[z] + 1;
que.push(vec[z][i]);
}
}
que.pop();
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
vec[a].push_back(b);
vec[b].push_back(a);
}
bfs(0);
int index = -1, max = -1;
for (int i = 0; i < n; i++) {
if (dis[i] > max) {
max = dis[i];
index = i;
}
}
for (int i = 0; i < MAXN; i++) {
mark[i] = 0;
dis[i] = 0;
}
bfs(index);
max = -1;
for (int i = 0; i < n; i++) {
if (dis[i] > max) {
max = dis[i];
}
}
cout << max << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
int main() {
int x, y, z, i, j, k, a, b, c, n, m, t, mat[210210];
scanf("%d", &t);
long long w, sum;
while (t--) {
scanf("%d %lld", &n, &w);
j = -1;
sum = 0;
c = 0;
for (x = 0; x < n; x++) {
scanf("%d", &mat[x]);
if (mat[x] >= (w + 1) / 2 && mat[x] <= w) j = x;
if (mat[x] <= w) sum += mat[x];
}
if (j != -1)
printf("1\n%d\n", j + 1);
else if (sum < (w + 1) / 2)
puts("-1");
else {
x = -1;
if (sum > w) {
for (x = 0; x < n; x++) {
if (mat[x] > w) continue;
sum -= mat[x];
if (sum >= (w + 1) / 2 && sum <= w) break;
}
}
for (y = x + 1; y < n; y++)
if (mat[y] <= w) c++;
printf("%d\n", c);
for (y = x + 1; y < n; y++)
if (mat[y] <= w) printf("%d ", y + 1);
puts("");
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool sortbysec(const array<long long int, 2> &a,
const array<long long int, 2> &b) {
return (a[0] > b[0]);
}
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
bool inline isPrime(long long int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
bool isPowerOfTwo(long long int n) {
if (n == 0) return false;
return (ceil(log2(n)) == floor(log2(n)));
}
bool prtv(vector<long long int> e) {
for (auto &i : e) cout << i << " ";
cout << "\n";
}
void prt(int i) {
if (i == 1)
cout << "YES\n";
else
cout << "NO\n";
}
int getSum(int n) {
int sum = 0;
while (n != 0) {
sum = sum + n % 10;
n = n / 10;
}
return sum;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int test = 1;
while (test--) {
set<string> hai;
queue<string> bachi;
long long int count = 0, k, ans = 0, n;
cin >> n >> k;
string s;
cin >> s;
bachi.push(s);
while (!bachi.empty() && count < k) {
string temp = bachi.front();
bachi.pop();
long long int sz = temp.size();
if (hai.find(temp) != hai.end()) continue;
hai.insert(temp);
count++;
ans += (n - sz);
if (sz == 1) continue;
string foo;
for (long long int i = (0); i < (sz); i += 1) {
foo = temp;
foo = foo.erase(i, 1);
bachi.push(foo);
}
}
if (count == k - 1) ans += n;
if (count < k - 1) ans = -1;
cout << ans << "\n";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, v[100005], t[100005], k;
vector<int> p[100005];
int main() {
int i, j, l;
scanf("%d", &n);
n++;
for (i = 2; i <= n; i++) v[i] = i;
for (i = 2; i <= n; i++) {
sort(p[i].begin(), p[i].end());
for (j = 0; j < p[i].size(); j++)
if (p[i][j] != j + 1) {
t[i] = j + 1;
break;
}
if (t[i] == 0) {
if (p[i].size() >= 1)
t[i] = p[i][p[i].size() - 1] + 1;
else
t[i] = 1;
}
k = max(k, t[i]);
if (v[i] != 1)
for (j = 2 * i; j <= n; j += i) {
while (v[j] % i == 0) v[j] /= i;
p[j].push_back(t[i]);
}
}
printf("%d\n", k);
for (i = 2; i <= n; i++) printf("%d ", t[i]);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int M = 100001;
int n, m, x, y, b, r, p, l, ri;
long long ans;
vector<int> B, R, P;
int bef(int x, int c) {
if (!c) return (lower_bound(B.begin(), B.end(), x) - B.begin() - 1);
return (lower_bound(R.begin(), R.end(), x) - R.begin() - 1);
}
int aft(int x, int c) {
if (!c) return (lower_bound(B.begin(), B.end(), x) - B.begin());
return (lower_bound(R.begin(), R.end(), x) - R.begin());
}
long long get(int x) {
long long mn = ri - B[x];
for (int i = x; i < b && B[i] < ri; i++) {
long long left = B[i] - l, right = 0;
if (i + 1 != b && B[i + 1] < ri) right = ri - B[i + 1];
mn = min(mn, left + right);
}
return mn;
}
long long get1(int x) {
long long mn = ri - R[x];
for (int i = x; i < r && R[i] < ri; i++) {
long long left = R[i] - l, right = 0;
if (i + 1 != r && R[i + 1] < ri) right = ri - R[i + 1];
mn = min(mn, left + right);
}
return mn;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cin >> n;
for (int i = 0; i < n; i++) {
char c;
cin >> x >> c;
if (c == 'B')
B.push_back(x);
else if (c == 'R')
R.push_back(x);
else
P.push_back(x);
}
b = B.size();
r = R.size();
p = P.size();
if (!P.size()) {
if (b) ans = B[b - 1] - B[0];
if (r) ans += R[r - 1] - R[0];
cout << ans;
return 0;
}
x = bef(P[0], 0);
y = bef(P[0], 1);
if (x >= 0) ans += P[0] - B[0];
if (y >= 0) ans += P[0] - R[0];
x = aft(P[p - 1], 0);
y = aft(P[p - 1], 1);
if (x != B.size()) ans += B[b - 1] - P[p - 1];
if (y != R.size()) ans += R[r - 1] - P[p - 1];
for (int i = 0; i < p - 1; i++) {
l = P[i];
ri = P[i + 1];
long long dist = ri - l;
int x = aft(l, 0), y = aft(l, 1);
if ((x == b || B[x] > ri) && (y == r || R[y] > ri)) {
ans += dist;
continue;
}
long long mn = 2 * dist;
long long k = dist;
if (x < b && B[x] < ri) k += get(x);
if (y < r && R[y] < ri) k += get1(y);
ans += min(mn, k);
}
cout << ans;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
const int N = 2e5;
vector<int> g[N];
int a[N], b[N], R[N], L[N];
struct Stack {
int top;
int items[200004];
};
void push(struct Stack *ps, int x) {
if (ps->top == 200004 - 1) {
printf("Error: Stack overflow\n");
getchar();
exit(0);
} else {
ps->top += 1;
int top = ps->top;
ps->items[top] = x;
}
}
bool isEmpty(struct Stack *ps) { return (ps->top == -1) ? true : false; }
int pop(struct Stack *ps) {
int temp;
if (ps->top == -1) {
printf("Error: Stack underflow \n");
getchar();
exit(0);
} else {
int top = ps->top;
temp = ps->items[top];
ps->top -= 1;
return temp;
}
}
void go(int arr[], int n) {
int i = 0;
struct Stack s;
s.top = -1;
int element, next;
push(&s, 0);
for (i = 1; i < n; i++) {
next = i;
if (isEmpty(&s) == false) {
element = pop(&s);
while (arr[element] < arr[next]) {
R[element] = next - element;
if (isEmpty(&s) == true) break;
element = pop(&s);
}
if (arr[element] >= arr[next]) push(&s, element);
}
push(&s, next);
}
while (isEmpty(&s) == false) {
element = pop(&s);
next = 0;
R[element] = n - element;
}
}
void go1(int arr[], int n) {
int i = 0;
struct Stack s;
s.top = -1;
int element, next;
push(&s, 0);
for (i = 1; i < n; i++) {
next = i;
if (isEmpty(&s) == false) {
element = pop(&s);
while (arr[element] <= arr[next]) {
L[element] = next - element;
if (isEmpty(&s) == true) break;
element = pop(&s);
}
if (arr[element] > arr[next]) push(&s, element);
}
push(&s, next);
}
while (isEmpty(&s) == false) {
element = pop(&s);
next = 0;
L[element] = n - element;
}
}
int main() {
int i, n, l, r, q;
cin >> n >> q;
for (i = 0; i < n; i++) cin >> a[i];
while (q--) {
cin >> l >> r;
l--, r--;
for (i = l; i < r; i++) b[i - l] = abs(a[i] - a[i + 1]);
int len = r - l;
go(b, r - l);
for (i = 0; i < (r - l) / 2; i++) swap(b[i], b[r - l - i - 1]);
go1(b, r - l);
for (i = 0; i < (r - l) / 2; i++) swap(L[i], L[r - l - i - 1]);
long long ans = 0;
for (i = 0; i < r - l; i++)
ans += (L[i] * 1LL * R[i]) * abs(a[i + l] - a[i + l + 1]);
cout << ans << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s1, s[12] = {"January", "February", "March", "April",
"May", "June", "July", "August",
"September", "October", "November", "December"};
int n, l;
cin >> s1 >> n;
for (int i = 0; i < 12; i++) {
if (s1 == s[i]) {
while (n--) {
if (i == 11) {
i = 0;
} else {
i++;
}
}
l = i;
break;
}
}
cout << s[l];
}
| 0 |
/*input
3
3 2
3 2 1
5 3
1 2 3 4 8
1 5
5
*/
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0)->sync_with_stdio(0);
int T; cin >> T; while (T--) {
int n, k; cin >> n >> k;
vector<int> a(n);
for (auto &i : a) cin >> i;
if (accumulate(a.begin(), a.end(), 0) == k) {
cout << "NO\n";
} else {
cout << "YES\n";
for (int i = 0, sum = 0; i < n; ++i) {
if (sum + a[i] == k) {
swap(a[i], a[i + 1]);
}
sum += a[i];
cout << a[i] << " ";
}
cout << "\n";
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize(3)
using namespace std;
template <typename T1, typename T2>
void ckmin(T1 &a, T2 b) {
if (a > b) a = b;
}
template <typename T1, typename T2>
void ckmax(T1 &a, T2 b) {
if (a < b) a = b;
}
template <typename T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
int read() {
int x = 0, f = 0;
char ch = getchar();
while (!isdigit(ch)) f |= ch == '-', ch = getchar();
while (isdigit(ch)) x = 10 * x + ch - '0', ch = getchar();
return f ? -x : x;
}
const int N = 1000005;
const int inf = 1e9;
char str[N];
int sum[N], n;
int a[N], len;
int dp[N];
int query(int l, int r) {
if (l < 0)
return inf;
else if (l > r)
return 0;
else
return sum[r] - sum[l - 1];
}
bool check(int mid) {
for (int i = 0; i <= len; i++) dp[i] = -inf;
dp[0] = 0;
for (int i = 1; i <= len; i++) {
if (query(dp[i - 1] + 1, a[i] - 1) <= 0) ckmax(dp[i], a[i] + mid);
if (query(dp[i - 1] + 1, a[i] - mid - 1) <= 0) ckmax(dp[i], a[i]);
if (i >= 2 && query(dp[i - 2] + 1, min(a[i - 1] - 1, a[i] - mid - 1)) <= 0)
ckmax(dp[i], a[i - 1] + mid);
}
return query(dp[len] + 1, n) <= 0;
}
int main() {
scanf("%d%s", &n, str + 1);
int B = 0, D = 0;
for (int i = 1; i <= n; i++) {
if (str[i] == '*') B++;
if (str[i] == 'P') {
D++;
a[++len] = i;
}
sum[i] = sum[i - 1] + (str[i] == '*');
}
if (D == 1) {
int Lmost = 0, L = 0;
int Rmost = 0, R = 0;
int pos;
for (int i = 1; i <= n; i++)
if (str[i] == 'P') {
pos = i;
break;
}
for (int i = pos - 1; i >= 1; i--)
if (str[i] == '*') {
Lmost = max(Lmost, pos - i);
L++;
}
for (int i = pos + 1; i <= n; i++)
if (str[i] == '*') {
Rmost = max(Rmost, i - pos);
R++;
}
if (L != R) {
if (L > R)
printf("%d %d\n", L, Lmost);
else
printf("%d %d\n", R, Rmost);
} else
printf("%d %d\n", L, min(Lmost, Rmost));
return 0;
}
printf("%d ", B);
int l = 0, r = 1e6;
while (l < r) {
int mid = l + r >> 1;
if (check(mid))
r = mid;
else
l = mid + 1;
}
printf("%d\n", l);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
string x;
cin >> x;
string a, b;
int i, t = 0;
for (i = 0; i < x.length(); i++) {
if (i == 0) {
a += '1';
b += '1';
} else {
if (x[i] == '0') {
a += '0';
b += '0';
} else if (x[i] == '1') {
if (t == 0) {
a += '1';
b += '0';
t = 1;
} else {
a += '0';
b += '1';
}
} else {
if (t == 0) {
a += '1';
b += '1';
} else {
a += '0';
b += '2';
}
}
}
}
cout << a << endl << b << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
struct TrieNode {
int cnt, l, r, z_0, z_1;
TrieNode() {
cnt = 0;
l = r = -1;
z_0 = z_1 = 0;
}
};
struct Trie {
vector<TrieNode> Trie;
void Update(int x) {
int cur = 0;
for (int i = 30; i >= 0; i--) {
int c = (((1 << i) & x) > 0);
if (Trie[cur].l == -1) {
Trie.push_back(TrieNode());
Trie[cur].l = Trie.size() - 1;
}
if (Trie[cur].r == -1) {
Trie.push_back(TrieNode());
Trie[cur].r = Trie.size() - 1;
}
if (!c)
cur = Trie[cur].l;
else
cur = Trie[cur].r;
Trie[cur].cnt++;
}
}
int Query(int x, int k) {
int ans = 0, cur = 0;
for (int i = 30; i >= 0; i--) {
int c_x = (((1 << i) & x) > 0);
int c_k = (((1 << i) & k) > 0);
if (Trie[cur].l == -1) {
Trie.push_back(TrieNode());
Trie[cur].l = Trie.size() - 1;
}
if (Trie[cur].r == -1) {
Trie.push_back(TrieNode());
Trie[cur].r = Trie.size() - 1;
}
if (!c_x) {
if (!c_k) {
ans += Trie[Trie[cur].r].cnt;
cur = Trie[cur].l;
} else
cur = Trie[cur].r;
} else {
if (!c_k) {
ans += Trie[Trie[cur].l].cnt;
cur = Trie[cur].r;
} else
cur = Trie[cur].l;
}
}
ans += Trie[cur].cnt;
return ans;
}
void Update2(int x, int col) {
int cur = 0;
for (int i = 30; i >= 0; i--) {
int c = (((1 << i) & x) > 0);
if (Trie[cur].l == -1) {
Trie.push_back(TrieNode());
Trie[cur].l = Trie.size() - 1;
}
if (Trie[cur].r == -1) {
Trie.push_back(TrieNode());
Trie[cur].r = Trie.size() - 1;
}
if (!c)
cur = Trie[cur].l;
else
cur = Trie[cur].r;
if (col == 1)
Trie[cur].z_1++;
else
Trie[cur].z_0++;
}
}
long long Query2(int x, int k, int col) {
long long ans = 0;
int cur = 0;
for (int i = 30; i >= 0; i--) {
int c_x = (((1 << i) & x) > 0);
int c_k = (((1 << i) & k) > 0);
if (Trie[cur].l == -1) {
Trie.push_back(TrieNode());
Trie[cur].l = Trie.size() - 1;
}
if (Trie[cur].r == -1) {
Trie.push_back(TrieNode());
Trie[cur].r = Trie.size() - 1;
}
if (!c_x) {
if (!c_k) {
if (col == 1)
ans += Trie[Trie[cur].r].z_1;
else
ans += Trie[Trie[cur].r].z_0;
cur = Trie[cur].l;
} else
cur = Trie[cur].r;
} else {
if (!c_k) {
if (col == 1)
ans += Trie[Trie[cur].l].z_1;
else
ans += Trie[Trie[cur].l].z_0;
cur = Trie[cur].r;
} else
cur = Trie[cur].l;
}
}
if (col == 1)
ans += Trie[cur].z_1;
else
ans += Trie[cur].z_0;
return ans;
}
void Init() {
Trie.clear();
Trie.push_back(TrieNode());
}
};
int n, m;
int a[50005];
Trie TrieTree;
int check(int x) {
TrieTree.Init();
int cnt = 0;
for (int i = 1; i <= n; i++) {
cnt += TrieTree.Query(a[i], x);
TrieTree.Update(a[i]);
}
return cnt;
}
long long BS(long long L, long long R) {
long long Ans = -1;
while (L <= R) {
long long Mid = (L + R) / 2;
if (check(Mid) >= m) {
Ans = Mid;
L = Mid + 1;
} else {
R = Mid - 1;
}
}
return Ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
if (m == 0) {
cout << 0;
return 0;
}
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
int ans = BS(0, (long long)2e9);
int lft = check(ans) - m;
long long res = 0;
for (int j = 0; j <= 30; j++) {
TrieTree.Init();
for (int i = 1; i <= n; i++) {
int c = (((1 << j) & a[i]) > 0);
res =
(res + (TrieTree.Query2(a[i], ans, 1 - c) * (1LL << j)) % mod) % mod;
TrieTree.Update2(a[i], c);
}
}
cout << ((res - lft * ans) % mod + mod) % mod;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5;
set<string> S;
set<string>::iterator it;
bool vis[maxn][10];
char s[maxn];
int n, i;
void dfs(int o, int m) {
if (vis[o][m] || o - m < 5) return;
vis[o][m] = 1;
string l(s + o - m + 1, s + o + 1), r(s + o - m * 2 + 1, s + o + 1 - m);
S.insert(l);
if (l != r) dfs(o - m, m);
int x = 5 - m;
dfs(o - m, x);
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
dfs(n, 2);
dfs(n, 3);
printf("%d\n", S.size());
it = S.begin();
while (it != S.end()) {
cout << *it << endl;
it++;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b;
cin >> a >> b;
reverse(a.begin(), a.end());
a == b ? cout << "YES" : cout << "NO";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2010;
int N;
int E[MAXN][MAXN], B[MAXN], S[MAXN], I[MAXN], S0, Cntpack;
void Visit(int x) {
S0++;
B[x] = S[x] = S0;
I[x] = 1;
int i;
for (i = 1; i <= N; i++)
if (E[x][i])
if ((B[i]) && (I[i]))
S[x] = min(S[x], B[i]);
else if (!B[i]) {
Visit(i);
S[x] = min(S[x], S[i]);
}
if (B[x] == S[x]) Cntpack++;
}
int main() {
scanf("%d", &N);
int i, j;
for (i = 1; i <= N; i++)
for (j = 1; j <= N; j++) scanf("%d", &E[i][j]);
for (i = 1; i <= N; i++) B[i] = S[i] = I[i] = 0;
S0 = Cntpack = 0;
Visit(1);
if ((S0 == N) && (Cntpack == 1))
printf("YES\n");
else
printf("NO\n");
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int N;
int a[100000], b[100000];
int p[100000], diff[100000];
set<pair<int, int> > pos;
set<pair<int, int>, greater<pair<int, int> > > neg;
int main() {
cin >> N;
for (int i = 0; i < N; i++) {
cin >> a[i];
p[a[i]] = i;
}
for (int i = 0; i < N; i++) {
cin >> b[i];
diff[i] = i - p[b[i]];
if (diff[i] >= 0)
pos.insert(pair<int, int>(diff[i], b[i]));
else
neg.insert(pair<int, int>(diff[i], b[i]));
}
int a;
set<pair<int, int> >::iterator it;
set<pair<int, int>, greater<pair<int, int> > >::iterator nit;
for (int i = 0; i < N; i++) {
it = pos.begin();
nit = neg.begin();
if (it != pos.end()) a = abs(it->first - i);
if (nit != neg.end()) a = min(a, abs(nit->first - i));
cout << a << endl;
pair<int, int> toRem = pair<int, int>(diff[i], b[i]);
if (pos.find(toRem) != pos.end())
pos.erase(toRem);
else
neg.erase(toRem);
pos.insert(pair<int, int>(N - p[b[i]] + i, b[i]));
diff[i] = N - p[b[i]] + i;
it = pos.begin();
while (it->first == i) {
neg.insert(pair<int, int>(it->first, it->second));
pos.erase(it);
it = pos.begin();
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cout << (char)((i % 4) + 'a');
}
| 1 |
#include <bits/stdc++.h>
struct sgt {
struct node {
int l, r;
double addtag, multag, s;
};
node a[5000005];
double f[100005];
int n;
private:
void pushup(int k) { a[k].s = a[k * 2].s + a[k * 2 + 1].s; }
void tagclear(int k) {
a[k].addtag = 0;
a[k].multag = 1;
}
void putadd(int k, double v) {
a[k].addtag = a[k].addtag + v;
a[k].s = a[k].s + v * (a[k].r - a[k].l + 1);
}
void putmul(int k, double v) {
a[k].multag = a[k].multag * v;
a[k].addtag = a[k].addtag * v;
a[k].s = a[k].s * v;
}
void pushdown(int k) {
putmul(k * 2, a[k].multag), putadd(k * 2, a[k].addtag);
putmul(k * 2 + 1, a[k].multag), putadd(k * 2 + 1, a[k].addtag);
tagclear(k);
}
void build(int k, int l, int r) {
tagclear(k);
a[k].l = l, a[k].r = r;
if (l == r) return a[k].s = f[l], void();
int mid = (l + r) / 2;
build(k * 2, l, mid);
build(k * 2 + 1, mid + 1, r);
pushup(k);
}
void updadd(int k, int x, int y, double v) {
if (x <= a[k].l && a[k].r <= y) return putadd(k, v), void();
int mid = (a[k].l + a[k].r) / 2;
pushdown(k);
if (x <= mid) updadd(k * 2, x, y, v);
if (mid < y) updadd(k * 2 + 1, x, y, v);
pushup(k);
}
void updmul(int k, int x, int y, double v) {
if (x <= a[k].l && a[k].r <= y) return putmul(k, v), void();
int mid = (a[k].l + a[k].r) / 2;
pushdown(k);
if (x <= mid) updmul(k * 2, x, y, v);
if (mid < y) updmul(k * 2 + 1, x, y, v);
pushup(k);
}
double query(int k, int x, int y) {
if (x <= a[k].l && a[k].r <= y) return a[k].s;
int mid = (a[k].l + a[k].r) / 2;
double ans = 0;
pushdown(k);
if (x <= mid) ans = ans + query(k * 2, x, y);
if (mid < y) ans = ans + query(k * 2 + 1, x, y);
return ans;
}
public:
void make(int nn) {
n = nn;
build(1, 1, n);
}
void add(int l, int r, double k) { updadd(1, l, r, k); }
void mul(int l, int r, double k) { updmul(1, l, r, k); }
double ask(int l, int r) { return query(1, l, r); }
};
sgt t;
int n, q;
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) scanf("%lf", &t.f[i]);
t.make(n);
while (q--) {
int opt;
scanf("%d", &opt);
if (opt == 1) {
int l1, r1, l2, r2, len1, len2;
scanf("%d%d%d%d", &l1, &r1, &l2, &r2);
len1 = r1 - l1 + 1, len2 = r2 - l2 + 1;
double x1 = t.ask(l1, r1), x2 = t.ask(l2, r2);
t.mul(l1, r1, (len1 - 1) / (double)len1), t.add(l1, r1, x2 / len2 / len1);
t.mul(l2, r2, (len2 - 1) / (double)len2), t.add(l2, r2, x1 / len1 / len2);
} else if (opt == 2) {
int l, r;
scanf("%d%d", &l, &r);
printf("%lf\n", t.ask(l, r));
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
const int maxn = 4005;
int d[maxn][maxn];
int s[maxn], c[maxn], m, n;
bool vis[maxn], vic[maxn];
bool solve() {
for (int i = 1; i <= n; i++) {
if (s[i] < 0) return false;
}
return true;
}
int main() {
scanf("%d%d", &n, &m);
memset(s, 0, sizeof(s));
memset(vis, 0, sizeof(vis));
memset(vic, 0, sizeof(vic));
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
scanf("%d", &d[i][j]);
s[i] += d[i][j];
}
}
bool frist = true;
while (!solve() || frist) {
frist = false;
for (int i = 1; i <= n; i++) {
if (s[i] < 0) {
vis[i] = !vis[i];
for (int j = 1; j <= m; j++) {
d[i][j] = -d[i][j];
}
}
}
memset(c, 0, sizeof(c));
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
c[j] += d[i][j];
}
}
for (int j = 1; j <= m; j++) {
if (c[j] < 0) {
vic[j] = !vic[j];
for (int i = 1; i <= n; i++) {
d[i][j] = -d[i][j];
}
}
}
memset(s, 0, sizeof(s));
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
s[i] += d[i][j];
}
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (vis[i]) ans++;
}
printf("%d", ans);
for (int i = 1; i <= n; i++) {
if (vis[i]) printf(" %d", i);
}
printf("\n");
ans = 0;
for (int i = 1; i <= m; i++) {
if (vic[i]) ans++;
}
printf("%d", ans);
for (int i = 1; i <= m; i++) {
if (vic[i]) printf(" %d", i);
}
printf("\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool m[3005] = {false};
vector<int> aval;
int main() {
int n, ans = 0;
cin >> n;
for (int i = 2; i <= n; i++) {
if (!m[i]) {
aval.push_back(i);
for (int j = 2 * i; j <= n; j += i) m[j] = true;
}
}
for (int i = 6; i <= n; i++) {
int t = 0;
for (int j = 0; j < aval.size(); j++) {
if (i % aval[j] == 0) t++;
}
if (t == 2) ans++;
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long NMAX = 1e5 + 5, MAX = 1e10;
int main() {
long long l, r;
cin >> l >> r;
int answer = 0;
map<long long, bool> used;
for (long long x = 1; x <= r; x *= 2)
for (long long y = 1; y <= r; y *= 3)
if (!used[x * y] && x * y >= l && x * y <= r) {
++answer;
used[x * y] = true;
}
cout << answer;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
long long int sum = 0, i, arr[n];
for (i = 0; i < n; i++) cin >> arr[i];
sum = n + arr[0];
for (i = 0; i < n - 1; i++) sum += 1 + abs(arr[i + 1] - arr[i]);
cout << sum;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int g[100001];
int main() {
int n;
scanf("%d", &n);
int win_move = -1;
for (int i = 2; i <= n; i++) {
int k = 2;
int m = i;
set<int> grundy;
while (1) {
int minus = ((k - 1) * (k)) / 2;
if (m < minus) break;
if ((m - minus) % k == 0) {
int ak = (m - minus) / k;
int ans = 0;
for (int j = 0; j < k; j++) {
ans ^= g[ak + j];
}
grundy.insert(ans);
if (ans == 0 and m == n and win_move == -1) win_move = k;
}
k++;
}
set<int>::iterator it = grundy.begin();
int ans = 0;
while (it != grundy.end() and *it == ans) {
it++;
ans++;
}
g[m] = ans;
}
printf("%d\n", win_move);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int INF = INT_MAX;
int socks[100001] = {0};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n;
int curr = 0;
int maks = 0;
cin >> n;
for (int i = 0; i < 2 * n; i++) {
int sk;
cin >> sk;
if (socks[sk] == 0) {
curr++;
maks = max(curr, maks);
socks[sk]++;
} else {
curr--;
socks[sk]++;
}
}
cout << maks << "\n";
;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long sum1[1000005], sum2[1000005];
int a[1000005][2];
int n, ans1, ans2, ans3, ans4;
bool ok;
int read() {
int ret = 0, ff = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') ff = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
ret = ret * 10 + ch - '0';
ch = getchar();
}
return ret * ff;
}
int main() {
n = read();
for (int i = 1; i <= n; i++) {
a[i - 1][0] = a[i - 1][1] = -1;
sum1[i] = read();
sum1[i] += sum1[i - 1];
}
for (int i = 1; i <= n; i++) {
sum2[i] = read();
sum2[i] += sum2[i - 1];
}
a[0][0] = 0;
a[0][1] = 0;
int last = 0;
for (int i = 1; i <= n; i++) {
while (sum1[i] - sum2[last] >= n && last <= n) last++;
if (last > n) continue;
if (a[sum1[i] - sum2[last]][0] == -1) {
a[sum1[i] - sum2[last]][0] = i;
a[sum1[i] - sum2[last]][1] = last;
} else {
ok = 1;
ans1 = a[sum1[i] - sum2[last]][0];
ans2 = i;
ans3 = a[sum1[i] - sum2[last]][1];
ans4 = last;
break;
}
while (sum1[i] - sum2[last + 1] >= 0 && last <= n - 1) {
last++;
if (a[sum1[i] - sum2[last]][0] == -1) {
a[sum1[i] - sum2[last]][0] = i;
a[sum1[i] - sum2[last]][1] = last;
} else {
ok = 1;
ans1 = a[sum1[i] - sum2[last]][0];
ans2 = i;
ans3 = a[sum1[i] - sum2[last]][1];
ans4 = last;
break;
}
if (ok) break;
}
if (ok) break;
}
if (ans4 == 0) {
puts("-1");
return 0;
}
printf("%d\n", ans2 - ans1);
for (int i = ans1 + 1; i <= ans2; i++) printf("%d ", i);
puts("");
printf("%d\n", ans4 - ans3);
for (int i = ans3 + 1; i <= ans4; i++) printf("%d ", i);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
char s[100010];
int a[100010], ans[100010];
int main() {
memset(a, 0, sizeof(a));
memset(ans, 0, sizeof(ans));
scanf("%s", &s);
int n = strlen(s);
for (int i = 1; i <= n; i++) a[i] = s[i - 1] - '0';
int l = 1, r = n, flag = 1;
if (a[l] != a[r]) {
a[l]--;
a[l + 1] += 10;
if (a[l] == 0) l++;
}
while (l <= r) {
if (a[l] != a[r]) {
if (a[l] - a[r] >= 10) {
a[r] += 10;
a[r - 1]--;
}
if (a[l] - a[r] == 1) {
a[l]--;
a[l + 1] += 10;
}
}
if (a[l] != a[r]) {
flag = 0;
break;
}
if (l != r) {
ans[l] = a[l] - a[r] / 2;
ans[r] = a[r] / 2;
} else {
if (a[l] & 1) {
flag = 0;
break;
}
ans[l] = a[r] / 2;
}
if (ans[l] < 0 || ans[l] > 9 || ans[r] < 0 || ans[l] > 9) {
flag = 0;
break;
}
l++;
r--;
}
if (flag == 0 || l <= r) {
printf("0\n");
return 0;
}
int cnt = 1;
while (ans[cnt] == 0) cnt++;
for (int i = cnt; i <= n; i++) printf("%d", ans[i]);
printf("\n");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a;
for (int i = 0; i < n; ++i) {
int tmp;
cin >> tmp;
a.push_back(tmp);
}
sort(a.begin(), a.end());
if (a[n - 1] > 25)
cout << a[n - 1] - 25;
else
cout << 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e2 + 10, pr = 29;
const long long md = 1ll * 1000000000000037;
int n, ted, lft[20], rgt[20];
long long dpt[10][maxn][maxn], dp[maxn][maxn];
string s, t[20];
map<long long, int> mp[20][maxn], mark[maxn];
void make_hash() {
for (int i = 0; i < n; i++) {
for (int l = 0; l < t[i].size(); l++) {
dpt[i][l][l] = 1ll * (t[i][l] - 'a') % md;
mp[i][1][dpt[i][l][l]]++;
for (int r = l + 1; r < t[i].size(); r++) {
dpt[i][l][r] =
1ll *
((1ll * dpt[i][l][r - 1] * pr) % md + (1ll * (t[i][r] - 'a'))) % md;
mp[i][r - l + 1][dpt[i][l][r]]++;
}
}
}
}
void count_ted(long long val1, int id) {
if (n == 0) {
if (mark[id][val1] == 0) ted++;
mark[id][val1] = 1;
return;
}
bool ch = true;
for (int i = 0; i < n; i++)
if (!(lft[i] <= mp[i][id][val1] && mp[i][id][val1] <= rgt[i])) ch = false;
if (ch) {
ted++;
for (int i = 0; i < n; i++) mp[i][id][val1] = -1;
}
}
void count_hash() {
for (int i = 0; i < s.size(); i++) {
dp[i][i] = 1ll * (s[i] - 'a') % md;
count_ted(dp[i][i], 1);
for (int j = i + 1; j < s.size(); j++) {
dp[i][j] = 1ll * ((1ll * (dp[i][j - 1] * pr) % md) + (s[j] - 'a')) % md;
count_ted(dp[i][j], j - i + 1);
}
}
}
int main() {
cin >> s >> n;
for (int i = 0; i < n; i++) cin >> t[i] >> lft[i] >> rgt[i];
make_hash();
count_hash();
cout << ted << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
int n;
cin >> n;
map<int, vector<pair<int, int>>> A;
map<pair<int, int>, int> C;
vector<int> w(n), xx(n), yy(n);
for (int i = 0; i < (int)n; ++i) {
int s, x, y;
cin >> x >> y;
s = y - x;
auto p = make_pair(x, y);
xx[i] = x;
yy[i] = y;
A[s].push_back(p);
}
for (int &a : w) cin >> a;
vector<pair<int, int>> X;
map<int, int> B;
for (auto &kv : A) {
auto &v = kv.second;
sort((v).begin(), (v).end());
}
int c = 1;
for (int &a : w) {
if (B[a] >= A[a].size()) {
cout << "NO" << '\n';
return 0;
}
X.push_back(A[a][B[a]]);
C[A[a][B[a]]] = c++;
B[a]++;
}
for (int i = 0; i < (int)n; ++i) {
int x = xx[i], y = yy[i];
int e = C[make_pair(x + 1, y)], f = C[make_pair(x, y + 1)],
g = C[make_pair(x, y)];
if ((e && e < g) || (f && f < g)) {
puts("NO");
return 0;
}
}
cout << "YES" << '\n';
for (pair<int, int> &b : X) cout << b.first << ' ' << b.second << '\n';
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,fma")
#pragma GCC optimize("unroll-loops")
using namespace std;
long long MOD = 1e9 + 7;
double eps = 1e-12;
bool check(long long mid, vector<long long> nar, vector<long long> &org) {
for (long long i = ((long long)(nar).size()) - 1; i >= 2; i--) {
if (nar[i] < mid) return false;
long long k = min(nar[i] - mid, org[i]);
k /= 3;
nar[i] -= 3 * k;
nar[i - 1] += k;
nar[i - 2] += 2 * k;
}
for (auto &it : nar) {
if (it < mid) return false;
}
return true;
}
void solve() {
int n;
cin >> n;
vector<long long> ar(n);
for (auto &it : ar) cin >> it;
long long ans = 0;
long long lo = 0, hi = 1e9;
while (lo <= hi) {
long long mid = (lo + hi) / 2;
if (check(mid, ar, ar)) {
ans = mid;
lo = mid + 1;
} else {
hi = mid - 1;
}
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
cin >> t;
for (int it = 1; it <= t; it++) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
using ll = long long;
const int N = 1e5 + 50;
const int MOD = 1e9 + 7;
int n, m;
vector<pii> graph[10 * N];
int cnt;
queue<set<int> > q;
int dist[10 * N];
void add(int a, int b, int val) {
int out, in = b;
while (val > 0) {
if (val < 10)
out = a;
else
out = cnt++;
graph[out].push_back({val % 10, in});
in = out;
val /= 10;
}
}
int main() {
memset(dist, -1, sizeof dist);
scanf("%d%d", &n, &m);
cnt = n;
for (int(i) = (0); (i) < (m); ++(i)) {
int a, b;
scanf("%d%d", &a, &b);
--a, --b;
add(a, b, i + 1);
add(b, a, i + 1);
}
dist[0] = 0;
q.push({0});
while (!q.empty()) {
set<int> si = q.front();
q.pop();
for (int i = 0; i < 10; ++i) {
set<int> nset;
for (auto node : si) {
for (auto neigh : graph[node]) {
if (neigh.first == i && dist[neigh.second] == -1) {
dist[neigh.second] = ((ll)dist[node] * 10 + i) % MOD;
nset.insert(neigh.second);
}
}
}
if (!nset.empty()) q.push(nset);
}
}
for (int(i) = (1); (i) < (n); ++(i)) printf("%d\n", dist[i]);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<int> diffs(k);
vector<int> vec_nums(n);
int curr_diff = k;
for (int i = 0; i < k; i++) {
diffs[i] = curr_diff--;
}
for (int i = 0; i < n; i++) {
vec_nums[i] = i + 1;
}
set<int> nums(vec_nums.begin(), vec_nums.end());
cout << 1 << " ";
nums.erase(1);
int curr = 1;
int flag = 0;
for (int i = 0; i < k; i++) {
if (flag == 0 && nums.find(curr + k - i) != nums.end()) {
cout << curr + k - i << " ";
nums.erase(curr + k - i);
curr = curr + k - i;
flag = 1;
continue;
}
if (flag == 1 && nums.find(curr + i - k) != nums.end()) {
cout << curr + i - k << " ";
nums.erase(curr + i - k);
curr = curr + i - k;
flag = 0;
}
}
set<int>::iterator it;
for (it = nums.begin(); it != nums.end(); it++) {
cout << *it << " ";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<string> srr;
vector<vector<int>> adj(26);
vector<int> order, dfs_num(26, -1);
bool cycle = false;
int get_index(int i) {
int j = 0;
while (srr[i][j] == srr[i + 1][j] && srr[i][j] && srr[i + 1][j]) {
++j;
}
if (!srr[i][j] || !srr[i + 1][j]) {
return -1;
}
return j;
}
void dfs(int i) {
dfs_num[i] = 0;
for (int j : adj[i]) {
if (dfs_num[j] == -1) {
dfs(j);
} else if (dfs_num[j] == 0) {
cycle = true;
}
}
dfs_num[i] = 1;
order.push_back(i);
}
int main() {
int n;
string name;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> name;
srr.push_back(name);
}
for (int i = 0; i < n - 1; ++i) {
int j = get_index(i);
if (j != -1) {
adj[srr[i][j] - 'a'].push_back(srr[i + 1][j] - 'a');
} else {
if (srr[i].length() >= srr[i + 1].length()) {
cycle = true;
}
}
}
for (int i = 0; i < 26; ++i) {
if (dfs_num[i] == -1) {
dfs(i);
}
}
if (cycle) {
cout << "Impossible";
} else {
reverse(order.begin(), order.end());
for (int i : order) {
cout << (char)(i + 'a');
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
char s[maxn], s1[maxn], ans[maxn];
int main() {
int n, k;
scanf("%d %d", &n, &k);
scanf("%s", s + 1);
for (int i = 1; i <= k; i++) {
s1[i] = s[i];
}
for (int j = 1, i = 1; i <= n; i++, j = j % k + 1) {
ans[i] = s1[j];
}
int flag = 0;
for (int i = 1; i <= n; i++) {
if (ans[i] > s[i]) {
flag = 0;
break;
}
if (ans[i] < s[i]) {
flag = 1;
break;
}
}
if (flag == 0)
printf("%d\n%s\n", n, ans + 1);
else {
for (int i = 1; i <= k; i++) {
s1[i] = s1[i] - '0';
}
s1[k]++;
for (int i = k; i >= 1; i--) {
if (s1[i] > 9) {
s1[i] -= 10;
s1[i - 1]++;
}
s1[i] += '0';
}
for (int i = 1, j = 1; i <= n; i++, j = j % k + 1) {
ans[i] = s1[j];
}
printf("%d\n%s\n", n, ans + 1);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
const int maxm = maxn * 2;
const int inf = 0x3f3f3f3f;
int head[maxn], tol, cnt, sta[maxn], a[maxn];
long long dis[maxn], sum[maxn];
struct node {
int to, next, w;
} g[maxm];
void add(int u, int v, int w) {
g[tol].to = v;
g[tol].w = w;
g[tol].next = head[u];
head[u] = tol++;
}
void dfs(int u, long long d, int cnt, int fa) {
sta[cnt] = u;
dis[cnt] = d;
int l = lower_bound(dis + 1, dis + cnt + 1, d - a[u]) - dis;
sum[sta[l - 1]]--;
sum[u]++;
for (int i = head[u]; i != -1; i = g[i].next) {
int v = g[i].to;
if (v == fa) continue;
dfs(v, d + g[i].w, cnt + 1, u);
}
}
void dfs1(int u, int fa) {
for (int i = head[u]; i != -1; i = g[i].next) {
int v = g[i].to;
if (v == fa) continue;
dfs1(v, u);
sum[u] += sum[v];
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
memset(head, -1, sizeof(head));
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 2; i <= n; i++) {
int x, y;
cin >> x >> y;
add(x, i, y);
add(i, x, y);
}
dis[0] = -1e18;
dfs(1, 0, 1, 0);
dfs1(1, 0);
for (int i = 1; i <= n; i++) cout << sum[i] - 1 << ' ';
cout << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100;
int num[30];
int vis[N];
char st[N];
int main() {
scanf("%s", st);
int len = strlen(st);
int mx = 0;
memset(vis, false, sizeof(vis));
for (int i = len - 1; i >= 0; i--) {
if (st[i] >= mx) {
vis[i] = true;
mx = max(mx, (int)st[i]);
}
}
for (int i = 0; i < len; i++) {
if (vis[i]) printf("%c", st[i]);
}
puts("");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 2e5 + 100, Maxm = 2e5 + 100, Maxb = 18;
int n, m, q, anss = 1, es = 1, he[Maxn], ne[Maxm * 2], to[Maxm * 2], tim,
dfn[Maxn], low[Maxn], bel[Maxn], bs, top, es2 = 1, he2[Maxn],
ne2[Maxm * 2], to2[Maxm * 2], fa[Maxn][Maxb], dep[Maxn],
len[Maxn][2];
string ans[2] = {"No", "Yes"};
bool whe[Maxn * 2];
void ins(int x, int y) { ne[++es] = he[x], he[x] = es, to[es] = y; }
void get(int b, int x) {
int i, y;
bel[x] = b;
for (i = he[x]; i; i = ne[i]) {
if (!whe[i] && !bel[y = to[i]]) get(b, y);
}
}
void dfs(int x, int f) {
int i, y;
low[x] = dfn[x] = ++tim;
for (i = he[x]; i; i = ne[i]) {
if (i != f) {
if (!dfn[y = to[i]])
dfs(y, i ^ 1), low[x] = min(low[x], low[y]);
else
low[x] = min(low[x], dfn[y]);
}
}
if (low[x] >= dfn[x]) whe[f] = whe[f ^ 1] = 1;
}
void ins2(int x, int y) { ne2[++es2] = he2[x], he2[x] = es2, to2[es2] = y; }
void dfs2(int x) {
int i, y;
for (i = 0; fa[x][i]; i++) {
fa[x][i + 1] = fa[fa[x][i]][i];
}
for (i = he2[x]; i; i = ne2[i]) {
if ((y = to2[i]) != fa[x][0]) {
fa[y][0] = x;
dep[y] = dep[x] + 1;
dfs2(y);
}
}
}
int LCA(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
int i;
for (i = Maxb - 1; i >= 0; i--) {
if (dep[x] - dep[y] >= 1 << i) {
x = fa[x][i];
}
}
if (x == y) return x;
for (i = Maxb - 1; i >= 0; i--) {
if (fa[x][i] != fa[y][i]) {
x = fa[x][i];
y = fa[y][i];
}
}
return fa[x][0];
}
bool check(int x) {
int i, y;
bool z = 1;
for (i = he2[x]; i; i = ne2[i]) {
if ((y = to2[i]) != fa[x][0]) {
z &= check(y);
len[x][0] = max(len[x][0], len[y][0] - 1);
len[x][1] = max(len[x][1], len[y][1] - 1);
}
}
return z & (!len[x][0] || !len[x][1]);
}
int main(int argc, const char* argv[]) {
ios::sync_with_stdio(0);
int i, j, x, y;
cin >> n >> m >> q;
for (i = 0; i < m; i++) {
cin >> x >> y;
ins(x, y);
ins(y, x);
}
for (i = 1; i <= n; i++) {
if (!dfn[i]) {
dfs(i, 0);
}
}
for (i = 1; i <= n; i++) {
if (!bel[i]) {
get(++bs, i);
}
}
for (i = 1; i <= n; i++) {
for (j = he[i]; j; j = ne[j]) {
if (bel[i] != bel[to[j]]) {
ins2(bel[i], bel[to[j]]);
}
}
}
for (i = 1; i <= n; i++) {
if (!fa[i][0]) {
dfs2(i);
}
}
while (q--) {
int lca;
cin >> x >> y;
x = bel[x];
y = bel[y];
lca = LCA(x, y);
if (!lca) anss = 0;
len[x][0] = max(len[x][0], dep[x] - dep[lca]);
len[y][1] = max(len[y][1], dep[y] - dep[lca]);
}
if (anss) anss = check(1);
cout << ans[anss] << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<pair<string, string> > vc;
int tc;
cin >> tc;
for (int i = 0; i < tc; i++) {
string a, b;
cin >> a >> b;
vc.push_back(make_pair(a, b));
}
for (int i = 0; i < tc; i++) {
if (vc[i].second == "rat") {
cout << vc[i].first << "\n";
}
}
for (int i = 0; i < tc; i++) {
if (vc[i].second == "woman" || vc[i].second == "child") {
cout << vc[i].first << "\n";
}
}
for (int i = 0; i < tc; i++) {
if (vc[i].second == "man") {
cout << vc[i].first << "\n";
}
}
for (int i = 0; i < tc; i++) {
if (vc[i].second == "captain") {
cout << vc[i].first << "\n";
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int cal(int a, int b, int c) { return abs(a - b) + abs(a - c) + abs(b - c); }
int main() {
int t;
cin >> t;
while (t--) {
int a, b, c, ans;
cin >> a >> b >> c;
ans = cal(a, b, c);
for (int i = -1; i <= 1; i++) {
for (int j = -1; j <= 1; j++) {
for (int k = -1; k <= 1; k++) {
ans = min(ans, cal(a + i, b + j, c + k));
}
}
}
cout << ans << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char s[100];
int main() {
int n;
scanf("%d", &n);
int foo = 0, bar = 0, baz = 0, quz = 1;
for (int i = 0; i < n; i++) {
int pur;
scanf("%d", &pur);
foo += pur;
bar += 1;
if (foo * quz >= bar * baz) {
baz = foo;
quz = bar;
}
}
printf("%.6f\n", baz * 1.0 / quz);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char c = getchar();
int x = 0;
bool f = 0;
for (; !isdigit(c); c = getchar()) f ^= !(c ^ 45);
for (; isdigit(c); c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48);
if (f) x = -x;
return x;
}
int f[105][105], s[105][105][105], n, m;
int dfs(int l, int r) {
if (f[l][r] >= 0) return f[l][r];
if (l > r) return f[l][r] = 0;
for (register int k = (l); k <= (r); ++k)
f[l][r] =
max(f[l][r], dfs(l, k - 1) + dfs(k + 1, r) + s[l][r][k] * s[l][r][k]);
return f[l][r];
}
signed main() {
n = read(), m = read();
for (register int i = (1); i <= (n); ++i) {
int k = read(), l, r;
while (k--) {
l = read(), r = read();
for (register int i = (1); i <= (l); ++i)
for (register int j = (r); j <= (m); ++j)
s[i][j][l]++, s[i][j][r + 1]--;
}
}
for (register int i = (1); i <= (m); ++i)
for (register int j = (i + 1); j <= (m); ++j)
for (register int k = (i); k <= (j); ++k) s[i][j][k] += s[i][j][k - 1];
memset(f, -63, sizeof f);
cout << dfs(1, m);
return 0;
}
| 10 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
const double PI = acos(-1);
template <class A, class B>
std::ostream& operator<<(std::ostream& st, const std::pair<A, B> p) {
st << "(" << p.first << ", " << p.second << ")";
return st;
}
using namespace std;
const long long oo = 1LL << 60;
const int MAX = 1 << 20;
int A[MAX], B[MAX], P[MAX], n, m;
int lst[MAX];
int nxt[MAX];
int R[MAX];
std::vector<int> IDX[MAX];
long long dp[MAX];
long long neg_sum[MAX];
long long sum[MAX];
long long T[2][MAX];
int M;
void add(int p, long long v, long long* BIT) {
for (++p; p <= M; p += ((p) & (-(p)))) BIT[p] += v;
}
long long get(int p, long long* BIT) {
long long ret = 0;
for (++p; p; p ^= ((p) & (-(p)))) ret += BIT[p];
return ret;
}
long long solve() {
M = 2 * n;
for (int i = 0; i < n; i++) {
add(A[i], P[i], T[0]);
add(A[i], min(P[i], 0), T[1]);
sum[i] = get(M, T[0]) - get(A[i], T[0]);
neg_sum[i] = get(A[i], T[1]);
long long& ret = dp[i];
ret = oo;
int x = A[i], r = R[x];
if (r == 0) {
ret = 0;
continue;
}
if (nxt[i] != -1) {
int j = nxt[i];
if (dp[j] < oo) {
long long tmp = dp[j] + neg_sum[i] - neg_sum[j] + sum[i] - sum[j];
ret = min(ret, tmp);
}
}
int y = B[r - 1];
auto ptr = upper_bound(IDX[y].begin(), IDX[y].end(), i);
if (ptr != IDX[y].begin()) {
ptr--;
int j = *ptr;
if (dp[j] < oo) {
long long s = get(M, T[0]) - get(y, T[0]) - sum[j] - P[i];
long long neg = get(y, T[1]) - neg_sum[j];
long long tmp = dp[j] + neg + s;
ret = min(ret, tmp);
}
} else
ret = oo;
}
return dp[n - 1];
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", A + i);
for (int i = 1; i <= n; i++) scanf("%d", P + i);
scanf("%d", &m);
for (int i = 1; i <= m; i++) scanf("%d", B + i);
A[0] = B[0] = 0;
A[n + 1] = B[m + 1] = n + 1;
n += 2;
m += 2;
for (int i = 0; i < (m - 1); i++)
if (B[i] >= B[i + 1]) {
puts("NO");
return 0;
}
for (int i = 0; i < (m); i++) R[B[i]] = i;
memset(lst, -1, sizeof lst);
for (int i = 0; i < (n); i++) {
IDX[A[i]].push_back(i);
nxt[i] = lst[A[i]];
lst[A[i]] = i;
}
long long ans = solve();
if (ans >= oo) {
puts("NO");
return 0;
}
puts("YES");
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double x;
double L, H;
cin >> H >> L;
cout << setprecision(15);
cout << (L * L - H * H) / (2 * H) << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned long long n, m, a;
cin >> n >> m >> a;
unsigned long long result;
if (m <= a && n <= a) {
result = 1;
} else {
if (m > a && n > a) {
result = (unsigned long long)(ceill((long double)m / a) *
ceill((long double)n / a));
} else {
if (m > a) {
result = (unsigned long long)ceill((long double)m / a);
} else {
result = (unsigned long long)ceill((long double)n / a);
}
}
}
cout << result << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long N = (long long)5e3 + 113;
const long long Dec = (long long)1e4;
int n, m, last_col, a, c;
pair<int, int> Rebr, Ver;
int col[N], dp[N][N];
vector<int> gr[N], no_gr[N];
vector<pair<int, int> > rebr;
void dfs(int v, int typ) {
col[v] = typ;
for (int i = 0; i < (int)gr[v].size(); i++) {
int to = gr[v][i];
if (!col[to]) dfs(to, typ);
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
gr[u].push_back(v);
gr[v].push_back(u);
dp[u][v] = dp[v][u] = 1;
rebr.push_back(make_pair(v, u));
}
for (int i = 1; i <= n; i++) {
if (!col[i]) {
last_col++;
dfs(i, last_col);
}
}
if (last_col > 2) {
cout << "NO";
return 0;
}
if (last_col == 2) {
for (int i = 0; i < m; i++) {
if (col[rebr[i].first] == 1) {
Rebr.first++;
} else {
Rebr.second++;
}
}
for (int i = 1; i <= n; i++) {
if (col[i] == 1) {
Ver.first++;
} else {
Ver.second++;
}
}
if ((Ver.first * (Ver.first - 1) / 2 != Rebr.first) ||
(Ver.second * (Ver.second - 1) / 2 != Rebr.second)) {
cout << "No";
return 0;
}
string ans = "";
for (int i = 1; i <= n; i++) {
if (col[i] == 1) {
ans += "a";
} else {
ans += "c";
}
}
cout << "Yes" << endl;
cout << ans;
return 0;
}
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
if (!dp[i][j]) {
no_gr[i].push_back(j);
no_gr[j].push_back(i);
a = i;
c = j;
}
}
}
for (int i = 1; i <= n; i++) {
col[i] = 2;
}
for (int i = 0; i < no_gr[c].size(); i++) {
col[no_gr[c][i]] = 1;
}
for (int i = 0; i < (int)no_gr[a].size(); i++) {
col[no_gr[a][i]] = 3;
}
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
if (abs(col[i] - col[j]) <= 1) {
if (!dp[i][j]) {
cout << "No";
return 0;
}
} else {
if (dp[i][j]) {
cout << "No";
return 0;
}
}
}
}
string ans = "";
for (int i = 1; i <= n; i++) {
if (col[i] == 1) ans += 'a';
if (col[i] == 2) ans += 'b';
if (col[i] == 3) ans += 'c';
}
cout << "Yes" << endl;
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3000;
int N, K;
char S[MAXN + 10], T[MAXN + 10];
int main() {
int i, j;
scanf("%d%d", &N, &K);
scanf("%s", S + 1);
for (i = 1; i <= N; i++) {
if (S[i] == 'L')
S[i] = 'B';
else
S[i] = 'A';
}
int inv = 0, cnt = 0;
for (i = 1; i <= N; i++) {
if (S[i] == 'A')
cnt++;
else
inv += cnt;
}
if (inv < K) return !printf("-1\n");
vector<int> Q;
for (i = 1; i <= N; i++) T[i] = S[i];
for (i = 1; i < N; i++)
if (T[i] == 'A' && T[i + 1] == 'B') Q.push_back(i);
int p = 0;
while (!Q.empty()) {
p++;
for (auto it : Q) swap(T[it], T[it + 1]);
if (p > K) return !printf("-1\n");
vector<int> QQ;
for (auto it : Q) {
if (1 <= it - 1 && it <= N && T[it - 1] == 'A') QQ.push_back(it - 1);
if (1 <= it + 1 && it + 2 <= N && T[it + 2] == 'B') QQ.push_back(it + 1);
}
Q = QQ;
Q.erase(unique(Q.begin(), Q.end()), Q.end());
}
Q.clear();
for (i = 1; i <= N; i++) T[i] = S[i];
for (i = 1; i < N; i++)
if (T[i] == 'A' && T[i + 1] == 'B') Q.push_back(i);
p = inv - K;
while (!Q.empty() && p > 0) {
int sz = min(p + 1, (int)Q.size());
while (Q.size() > sz) Q.pop_back();
printf("%d ", Q.size());
for (auto it : Q) printf("%d ", it);
printf("\n");
for (auto it : Q) swap(T[it], T[it + 1]);
p -= sz - 1;
if (p == 0) break;
vector<int> QQ;
for (auto it : Q) {
if (1 <= it - 1 && it <= N && T[it - 1] == 'A') QQ.push_back(it - 1);
if (1 <= it + 1 && it + 2 <= N && T[it + 2] == 'B') QQ.push_back(it + 1);
}
Q = QQ;
Q.erase(unique(Q.begin(), Q.end()), Q.end());
}
for (i = 1; i <= N; i++) {
if (T[i] == 'A') continue;
for (j = i - 1; j >= 1 && T[j] == 'A'; j--)
printf("1 %d\n", j), swap(T[j], T[j + 1]);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class T, size_t... Is>
struct arr_helper;
template <class T, size_t... Is>
using arr = typename arr_helper<T, Is...>::type;
template <class T>
struct arr_helper<T> {
using type = T;
};
template <class T, size_t I, size_t... Is>
struct arr_helper<T, I, Is...> {
using type = array<arr<T, Is...>, I>;
};
using ll = long long;
using u64 = uint64_t;
using u32 = uint32_t;
using vi = vector<int>;
using vl = vector<ll>;
using vvi = vector<vi>;
using pi = pair<int, int>;
using pl = pair<ll, ll>;
using vpi = vector<pi>;
[[maybe_unused]] const int INF = (int)1e9;
[[maybe_unused]] const ll INFL = (ll)1e18;
ll M = 998244353;
int mod_pow(ll b, ll e) {
ll res = 1;
for (; e; b = b * b % M, e /= 2)
if (e % 2) res = res * b % M;
return (int)res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, m, k;
cin >> n >> m >> k;
vi f(k + 1), fi(k + 1), fn(k + 1);
f[0] = 1;
for (int i = (1); i < (k + 1); ++i) f[i] = (ll)f[i - 1] * i % M;
for (int i = 0; i < (k + 1); ++i) fi[i] = mod_pow(f[i], M - 2);
fn[0] = 1;
for (int i = (1); i < (k + 1); ++i) fn[i] = fn[i - 1] * (ll)(n - i + 1) % M;
auto choose = [&](int n, int k) {
if (k > n) return 0ll;
return (ll)f[n] * fi[n - k] % M * (ll)fi[k] % M;
};
auto choose_n = [&](int k) { return fn[k] * (ll)fi[k] % M; };
ll sum = 0;
auto p = mod_pow(m, M - 2);
auto q = (ll)(m - 1) * p % M;
vi nmkitok(k + 1);
for (int i = 0; i < (k + 1); ++i) nmkitok[i] = mod_pow(n - i, k);
for (int j = 0; j < (k + 1); ++j) {
ll si = 0;
for (int ki = 0; ki < (j + 1); ++ki) {
si += (ll)(ki % 2 ? M - 1 : 1) * choose(j, ki) % M * nmkitok[ki] % M;
si %= M;
}
sum += mod_pow(M - q, j) * (ll)choose_n(j) % M * si % M;
sum %= M;
}
cout << sum << '\n';
return 0;
}
| 9 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000,100000000")
using namespace std;
const long long inf = 1e18 + 7;
const long long mod = 1e9 + 7;
const long double eps = 1e-10;
const long double PI = 2 * acos(0.0);
const long double E = 2.71828;
const long long seed = 13331;
const long long size = 500005;
long long step[] = {2, 3, 5, 7, 13, 17,
19, 31, 61, 89, 107, 127,
521, 607, 1279, 2203, 2281, 3217,
4253, 4423, 9689, 9941, 11213, 19937,
21701, 23209, 44497, 86243, 110503, 132049,
216091, 756839, 859433, 1257787, 1398269, 2976221,
3021377, 6972593, 13466917, 20996011, 24036583};
int main(void) {
long long n, a, rez = 1;
cin >> a;
if (a == 1) cout << a << endl, exit(0);
n = step[a - 1] - 1;
a = 2;
while (n) {
if (n & 1) rez = (rez * a) % mod;
a = (a * a) % mod;
n >>= 1;
}
cout << rez - 1 << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 1e6 + 10;
int a[Maxn];
pair<int, int> ma[Maxn][5];
int pre[Maxn][5];
int main() {
int cas, n;
cin >> cas;
while (cas--) {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
int cnt = 0;
ma[0][cnt++] = pair<int, int>(-Maxn, -Maxn);
for (int i = 1; i <= n; i++) {
if (cnt == 0) break;
int b[4] = {Maxn, Maxn, Maxn, Maxn};
int pre_index[4] = {-1, -1, -1, -1};
for (int j = 0; j < cnt; j++) {
if (-a[i] > ma[i - 1][j].first && b[0] > ma[i - 1][j].second)
b[0] = ma[i - 1][j].second, pre_index[0] = j;
else if (-a[i] > ma[i - 1][j].second && b[1] > ma[i - 1][j].first)
b[1] = ma[i - 1][j].first, pre_index[1] = j;
if (a[i] > ma[i - 1][j].first && b[2] > ma[i - 1][j].second)
b[2] = ma[i - 1][j].second, pre_index[2] = j;
else if (a[i] > ma[i - 1][j].second && b[3] > ma[i - 1][j].first)
b[3] = ma[i - 1][j].first, pre_index[3] = j;
}
cnt = 0;
if (b[0] != Maxn)
pre[i][cnt] = pre_index[0], ma[i][cnt++] = pair<int, int>(-a[i], b[0]);
if (b[1] != Maxn)
pre[i][cnt] = pre_index[1], ma[i][cnt++] = pair<int, int>(b[1], -a[i]);
if (b[2] != Maxn)
pre[i][cnt] = pre_index[2], ma[i][cnt++] = pair<int, int>(a[i], b[2]);
if (b[3] != Maxn)
pre[i][cnt] = pre_index[3], ma[i][cnt++] = pair<int, int>(b[3], a[i]);
}
if (!cnt) {
cout << "NO\n";
continue;
}
cout << "YES\n";
for (int i = n, index = 0; i > 0; i--) {
pair<int, int> res = ma[i][index];
index = pre[i][index];
if (res.first == -a[i] || res.second == -a[i]) a[i] *= -1;
}
for (int i = 1; i <= n; i++) cout << a[i] << " ";
cout << endl;
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
void change(long long &a, long long &b, long long &c) {
if (a > b) swap(a, b);
if (a > c) swap(a, c);
if (b > c) swap(b, c);
}
bool isprime[10000010];
long long prime[1000010];
int total;
vector<pair<long long, int> > fac;
long long s[110][110];
long long add[110];
int T;
long long ans;
set<pair<pair<int, long long>, pair<long long, long long> > > ooxx;
void dfs(int dep, long long a, long long b, long long c) {
if (ooxx.find(make_pair(make_pair(dep, a), make_pair(b, c))) != ooxx.end())
return;
ooxx.insert(make_pair(make_pair(dep, a), make_pair(b, c)));
if (dep == T) {
if ((a + b + c) % 2 == 1) return;
if (a == b && b == c) {
ans += 1;
return;
}
if (a == b || b == c) {
ans += 3;
return;
}
ans += 6;
return;
}
int len = fac[dep].second;
s[dep][0] = 1;
for (int i = 1; i <= len; i++) s[dep][i] = s[dep][i - 1] * fac[dep].first;
for (int i = 0; i <= len; i++)
for (int j = 0; i + j <= len; j++) {
int k = len - i - j;
long long la = a * s[dep][i];
long long lb = b * s[dep][j];
long long lc = c * s[dep][k];
change(la, lb, lc);
if (la + lb * add[dep + 1] <= lc) continue;
dfs(dep + 1, la, lb, lc);
}
}
int main() {
total = 0;
memset(isprime, true, sizeof(isprime));
for (int i = 2; i <= 10000000; i++)
if (isprime[i]) {
prime[total++] = i;
for (long long j = (long long)i * i; j <= 10000000; j += i)
isprime[j] = false;
}
long long n;
scanf("%I64d", &n);
if (n % 3 != 0) {
printf("0\n");
return 0;
}
n /= 3;
fac.clear();
for (int i = 0; i < total && prime[i] * prime[i] <= n; i++) {
if (n % prime[i] == 0) {
int T = 0;
while (n % prime[i] == 0) {
n /= prime[i];
T++;
}
fac.push_back(make_pair(prime[i], T));
}
}
if (n != 1) fac.push_back(make_pair(n, 1));
ans = 0;
if (fac[0].first != 2) {
printf("0\n");
return 0;
}
T = fac.size();
add[T] = 1;
for (int i = T - 1; i >= 0; i--) {
add[i] = add[i + 1];
for (int j = 0; j < fac[i].second; j++) add[i] *= fac[i].first;
}
ooxx.clear();
dfs(0, 1, 1, 1);
printf("%I64d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int mod = 1e9 + 7;
void solve() {
long long n, m, k;
cin >> n >> m >> k;
long long kl = k;
long long arr[m];
for (long long i = 0; i < m; i++) cin >> arr[i];
long long c = 0, d = 0;
long long i = 0;
long long lb = 0;
while (i < m) {
long long b = 0;
while (arr[i] - d <= k) {
i++;
b++;
}
d += b;
if (b > 0)
c++;
else
k = arr[i] - d - 1 - (arr[i] - d - 1) % kl + kl;
}
cout << c << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
t = 1;
while (t--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
long long power(long long x, long long b) {
long long res = 1;
if (b == 0) return 1;
while (b > 0) {
if (b % 2 != 0) res = (res * x);
b = b / 2;
x = (x * x);
}
return res;
}
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long x, y;
cin >> x >> y;
long long a, b;
cin >> a >> b;
long long p = abs(x - y);
long long ans1 = p * a + min(x, y) * b;
long long ans2 = min(x, y) * a + max(x, y) * a;
cout << min(ans1, ans2) << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, pos;
string st;
cin >> n >> k >> st;
cout << "PRINT " << st[k - 1] << endl;
pos = k;
if (n - k < k - 1) {
while (k < n) {
cout << "RIGHT" << endl;
cout << "PRINT " << st[++k - 1] << endl;
}
while (k > pos) {
cout << "LEFT" << endl;
k--;
}
while (k > 1) {
cout << "LEFT" << endl;
cout << "PRINT " << st[--k - 1] << endl;
}
} else {
while (k > 1) {
cout << "LEFT" << endl;
cout << "PRINT " << st[--k - 1] << endl;
}
while (k < pos) {
cout << "RIGHT" << endl;
k++;
}
while (k < n) {
cout << "RIGHT" << endl;
cout << "PRINT " << st[++k - 1] << endl;
}
}
cin >> n;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = numeric_limits<int>::max();
const long long linf = numeric_limits<long long>::max();
int main() {
int n;
scanf("%d", &n);
vector<int> a;
a.resize(n);
for (int i = 0; i < (n); ++i) {
scanf("%d", &a[i]);
}
sort(a.begin(), a.end());
long long till = a[0];
int ans = 1;
for (int i = 0; i < (n); ++i) {
if (i == 0) continue;
if (a[i] >= till) ans++, till += a[i];
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2")
#pragma GCC optimize("trapv")
using namespace std;
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cout << *it << " : " << a << endl;
err(++it, args...);
}
vector<double> a, b;
long long int n;
double l;
bool check(double time) {
double vel = 1.0, pos_left = 0.0, remain = time, pos_right = 0.0;
for (int i = 1; i <= n; i++) {
double dis = b[i] - b[i - 1];
if (dis / vel > remain) {
pos_left += remain * vel;
remain = 0;
break;
} else {
pos_left += dis;
remain -= dis / vel;
vel += 1.0;
}
}
if (remain > 0) {
pos_left += remain * vel;
}
vel = 1.0, remain = time;
for (int i = 1; i <= n; i++) {
double dis = a[i] - a[i - 1];
if (dis / vel > remain) {
pos_right += remain * vel;
remain = 0;
break;
} else {
pos_right += dis;
remain -= dis / vel;
vel += 1.0;
}
}
if (remain > 0) {
pos_right += remain * vel;
}
if (l - pos_left <= pos_right)
return true;
else
return false;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin.exceptions(cin.failbit);
;
int cas;
cin >> cas;
while (cas--) {
cin >> n >> l;
a.resize(n + 1);
b.clear();
a[0] = 0;
for (long long int i = 1; i < (n + 1); ++i) {
cin >> a[i];
b.push_back(l - a[i]);
}
b.push_back(0);
reverse((b).begin(), (b).end());
double lo = 0, hi = l;
for (int iter = 1; iter <= 40; iter++) {
double mid = (lo + hi) / 2;
if (check(mid))
hi = mid;
else
lo = mid;
}
cout << setprecision(16) << fixed;
if (check(lo))
cout << lo << endl;
else
cout << hi << endl;
}
return 0;
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.