solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
struct cc {
int first;
int second;
int third;
};
using namespace std;
int r[5000];
int c[5000];
int u[5000][5000];
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
int m;
cin >> m;
int k;
cin >> k;
cc a[k];
for (int i = 0; i <= k - 1; i++) {
cin >> a[i].first;
cin >> a[i].second;
a[i].second--;
cin >> a[i].third;
}
for (int i = k - 1; i >= 0; i--) {
if (a[i].first == 1) {
if (r[a[i].second] == 0) {
r[a[i].second] = 1;
for (int j = 0; j <= m - 1; j++) {
if (u[a[i].second][j] == 0) u[a[i].second][j] = a[i].third;
}
}
} else {
if (c[a[i].second] == 0) {
c[a[i].second] = 1;
for (int j = 0; j <= n - 1; j++) {
if (u[j][a[i].second] == 0) u[j][a[i].second] = a[i].third;
}
}
}
}
for (int i = 0; i <= n - 1; i++) {
for (int j = 0; j <= m - 1; j++) {
cout << u[i][j] << ' ';
}
cout << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int f[152][152];
int main() {
int t;
scanf("%d", &t);
while (t--) {
int a, b;
scanf("%d%d", &a, &b);
if (a == 0 && b == 0)
puts("1");
else if (4 * b > a)
printf("%.6f\n", 0.5 + (1.0 * a) / (16 * b));
else
printf("%.6f\n", 1.0 - (1.0 * b) / a);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct InputModel {
long long index, point;
};
int n, length;
long long m, Max, A, cf, cm, output[100005];
InputModel input[100005];
bool MySort(InputModel a, InputModel b) { return a.point < b.point; }
void answer() {
int i, j, index, model[100005];
long long leave = 0, temp = 0, high = length, low = input[0].point, lose = 0,
table[100005], NowPoint = 0;
table[0] = 0;
for (i = 1; i < n; i++) {
table[i] = table[i - 1] + i * (input[i].point - input[i - 1].point);
model[i] = input[i].point;
}
for (i = 0; i < n - length; i++) {
if (lose <= m) {
leave = m - lose;
index = upper_bound(table, table + n - length - i, leave) - table;
index--;
temp = leave - table[index];
low = input[index].point + temp / (index + 1);
if (low > A) {
low = A;
NowPoint = n * cf + A * cm;
} else {
NowPoint = low * cm + high * cf;
}
if (NowPoint > Max) {
for (j = 0; j < n; j++) {
if (j <= index) {
output[input[j].index] = low;
} else {
output[input[j].index] = model[j];
}
}
Max = NowPoint;
}
high++;
lose += A - input[n - length - i - 1].point;
model[n - length - i - 1] = A;
low = model[0];
} else {
break;
}
}
}
int main(int argc, char** argv) {
int i, j, temp = 0;
Max = 0;
length = 0;
scanf(" %d %I64d %I64d %I64d %I64d", &n, &A, &cf, &cm, &m);
for (i = 0; i < n; i++) {
scanf(" %I64d", &input[i].point);
input[i].index = i;
output[i] = input[i].point;
}
sort(input, input + n, MySort);
Max = input[0].point * cm;
for (i = 0; i < n; i++) {
if (input[i].point == A) {
Max += cf * (n - i);
length = n - i;
break;
}
}
answer();
printf("%I64d\n", Max);
for (i = 0; i < n; i++) {
printf("%I64d ", output[i]);
}
printf("\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int T, x1, y1, x2, y2;
cin >> T;
while (T--) {
cin >> x1 >> y1 >> x2 >> y2;
if (x1 == x2) {
cout << abs(y2 - y1) << "\n";
} else if (y1 == y2) {
cout << abs(x2 - x1) << "\n";
} else {
cout << 2 + abs(x2 - x1) + abs(y2 - y1) << "\n";
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int A[10][100], B[10][100], C[10][100];
pair<int, int> V[100];
char str[32];
int main(void) {
int i, j, n, m, k, g, b = 0, r, t;
cin >> n >> m >> k;
for (i = 0; i < n; i++) {
cin >> str;
for (j = 0; j < m; j++) cin >> A[i][j] >> B[i][j] >> C[i][j];
}
for (i = 0; i < n; i++)
for (j = 0; j < n; j++)
if (i != j) {
for (t = 0; t < m; t++) V[t] = make_pair(B[j][t] - A[i][t], C[i][t]);
sort(V, V + m, greater<pair<int, int> >());
for (g = 0, t = 0, r = k; t < m && r > 0 && V[t].first > 0; t++)
g += min(r, V[t].second) * V[t].first, r -= V[t].second;
if (g > b) b = g;
}
cout << b;
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:167772160000")
using namespace std;
long long maxx, minn;
int n, m;
int q;
long long a[110000], b[110000];
set<long long> values;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m >> q;
for (int i = 0; i < (n); i++) cin >> a[i];
for (int i = 0; i < (m); i++) cin >> b[i];
long long cur = 0;
for (int i = m - 1; i >= m - n; i--) {
cur = -cur - b[i];
}
for (int i = m - n - 1; i >= 0; i--) {
values.insert(cur);
if (n % 2 == 1)
cur += b[i + n];
else
cur -= b[i + n];
cur = -cur - b[i];
}
values.insert(cur);
long long base = 0;
for (int i = 0; i < (n); i++) {
if (i % 2 == 0)
base += a[i];
else
base -= a[i];
}
{
long long curAns = 1E18;
set<long long>::iterator it = values.lower_bound(-base);
if (it != values.end()) {
curAns = min(curAns, abs(*it + base));
}
if (it != values.begin()) {
it--;
curAns = min(curAns, abs(*it + base));
}
cout << curAns << "\n";
}
for (int i = 0; i < (q); i++) {
int l, r, x;
cin >> l >> r >> x;
if ((r - l + 1) % 2 == 1) {
if (l % 2 == 1)
base += x;
else
base -= x;
}
long long curAns = 1E18;
set<long long>::iterator it = values.lower_bound(-base);
if (it != values.end()) {
curAns = min(curAns, abs(*it + base));
}
if (it != values.begin()) {
it--;
curAns = min(curAns, abs(*it + base));
}
cout << curAns << "\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
const int mod = 1e9 + 7;
int n, m;
int a[505][505];
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> a[i][j];
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
ans ^= a[i][1];
}
if (ans != 0) {
cout << "TAK" << endl;
for (int i = 1; i <= n; i++) {
cout << 1 << ' ';
}
return 0;
}
int flag = 0;
int cnt = 0;
for (int i = 1; i <= n; i++) {
ans ^= a[i][1];
flag = 0;
cnt = 0;
for (int j = 2; j <= m; j++) {
ans ^= a[i][j];
if (ans != 0) {
flag = j;
cnt = i;
break;
} else
ans ^= a[i][j];
}
ans ^= a[i][1];
if (flag) break;
}
if (flag == 0) {
cout << "NIE" << endl;
return 0;
}
cout << "TAK" << endl;
for (int i = 1; i < cnt; i++) {
cout << 1 << ' ';
}
cout << flag << ' ';
for (int i = cnt + 1; i <= n; i++) {
cout << 1 << ' ';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000 + 100;
int dis[maxn][maxn][4];
queue<pair<pair<int, int>, int> > q;
bool mark[maxn][maxn][4], dir[maxn][maxn][4];
char mat[maxn][maxn];
int n, m, xt, yt, xm, ym;
int dirx[4] = {1, 0, -1, 0}, diry[4] = {0, -1, 0, 1};
void bfs(int r, int s, int c) {
q.push({{r, s}, c});
mark[r][s][c] = true;
dis[r][s][c] = 0;
while (!q.empty()) {
int i = q.front().first.first, j = q.front().first.second,
d = q.front().second;
q.pop();
if (!mark[i][j][(d + 1) % 4]) {
q.push({{i, j}, (d + 1) % 4});
mark[i][j][(d + 1) % 4] = true;
dis[i][j][(d + 1) % 4] = dis[i][j][d] + 1;
}
for (int p = 0; p < 4; p++) {
int x = i + dirx[p], y = j + diry[p];
if (x < n && x >= 0 && y < m && y >= 0) {
if (!mark[x][y][d] && dir[i][j][(p - d + 2 + 4) % 4] &&
dir[x][y][(p - d + 4) % 4]) {
q.push({{x, y}, d});
mark[x][y][d] = true;
dis[x][y][d] = dis[i][j][d] + 1;
}
}
}
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
cin >> mat[i][j];
char a = mat[i][j];
if (a == '+')
for (int d = 0; d < 4; d++) dir[i][j][d] = true;
if (a == '-') dir[i][j][1] = true, dir[i][j][3] = true;
if (a == '|') dir[i][j][0] = true, dir[i][j][2] = true;
if (a == '^') dir[i][j][0] = true;
if (a == '>') dir[i][j][1] = true;
if (a == 'v') dir[i][j][2] = true;
if (a == '<') dir[i][j][3] = true;
if (a == 'L')
dir[i][j][0] = true, dir[i][j][1] = true, dir[i][j][2] = true;
if (a == 'R')
dir[i][j][0] = true, dir[i][j][2] = true, dir[i][j][3] = true;
if (a == 'U')
dir[i][j][1] = true, dir[i][j][2] = true, dir[i][j][3] = true;
if (a == 'D')
dir[i][j][0] = true, dir[i][j][1] = true, dir[i][j][3] = true;
}
cin >> xt >> yt >> xm >> ym;
xt--, yt--, xm--, ym--;
bfs(xt, yt, 0);
int minn = 1e8;
for (int i = 0; i < 4; i++) {
if (mark[xm][ym][i]) minn = min(minn, dis[xm][ym][i]);
}
if (minn >= 1e8)
cout << -1;
else
cout << minn << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O3")
#pragma GCC target("avx2")
template <typename T>
void printv(const T& t) {
std::copy(t.cbegin(), t.cend(),
std::ostream_iterator<typename T::value_type>(std::cout, ", "));
cout << '\n';
}
long long int modpower(long long int a, long long int b, long long int c) {
long long int res = 1;
while (b) {
if (b & 1LL) res = (res * a) % c;
a = (a * a) % c;
b >>= 1;
}
return res;
}
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
long long int expo(long long int a, long long int b, long long int mod) {
long long int res = 1;
while (b > 0) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b = b >> 1;
}
return res;
}
long long int mminvprime(long long int a, long long int b) {
return expo(a, b - 2, b);
}
long long int mod_add(long long int a, long long int b, long long int m) {
a = a % m;
b = b % m;
return (((a + b) % m) + m) % m;
}
long long int mod_mul(long long int a, long long int b, long long int m) {
a = a % m;
b = b % m;
return (((a * b) % m) + m) % m;
}
long long int mod_sub(long long int a, long long int b, long long int m) {
a = a % m;
b = b % m;
return (((a - b) % m) + m) % m;
}
long long int mod_div(long long int a, long long int b, long long int m) {
a = a % m;
b = b % m;
return (mod_mul(a, mminvprime(b, m), m) + m) % m;
}
void solve() {
long long int n;
cin >> n;
long long int s = sqrt(n);
long long int val = s * s;
long long int r = min(n - val, s + 1);
if (n - val == 0) r = s;
long long int c;
if (val == n)
c = 1;
else if ((n - val) <= s + 1) {
c = s + 1;
} else {
c = (s + 1) - (n - val - s - 1);
}
cout << r << " " << c << '\n';
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t;
cin >> t;
for (long long int i = 1; i <= t; i++) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
ifstream in("input.txt");
ofstream out("output.txt");
vector<vector<int> > g;
const int MAXN = 100000;
bool used[MAXN];
int timer, tin[MAXN], fup[MAXN];
int n;
map<pair<int, int>, bool> A;
void dfs(int v, int p = -1) {
used[v] = true;
tin[v] = fup[v] = timer++;
for (size_t i = 0; i < g[v].size(); ++i) {
int to = g[v][i];
if (to == p) continue;
if (used[to])
fup[v] = min(fup[v], tin[to]);
else {
dfs(to, v);
fup[v] = min(fup[v], fup[to]);
if (fup[to] > tin[v]) A[make_pair(to, v)] = A[make_pair(v, to)] = true;
}
}
}
void find_bridges() {
timer = 0;
for (int i = 0; i < n; ++i) used[i] = false;
for (int i = 0; i < n; ++i)
if (!used[i]) dfs(i);
}
vector<int> path;
void bfs(int s, int end) {
queue<int> q;
q.push(s);
memset(used, 0, 100000);
vector<int> d(n), p(n);
used[s] = true;
p[s] = -1;
while (!q.empty()) {
int v = q.front();
q.pop();
for (size_t i = 0; i < g[v].size(); ++i) {
int to = g[v][i];
if (!used[to]) {
used[to] = true;
q.push(to);
d[to] = d[v] + 1;
p[to] = v;
}
}
}
for (int v = end; v != -1; v = p[v]) path.push_back(v);
}
int main() {
int t, m;
cin >> n >> t;
g.assign(n, vector<int>());
for (int i = 0; i < t; i++) {
int u, v;
cin >> u >> v;
g[u - 1].push_back(v - 1);
g[v - 1].push_back(u - 1);
}
cin >> m;
find_bridges();
for (int i = 0; i < m; i++) {
path.assign(0, 0);
int u, v, ans = 0;
cin >> u >> v;
u--;
v--;
bfs(u, v);
for (int j = 0; j < path.size(); j++) {
if (j < path.size() - 1) {
if (A.find(make_pair(path[j], path[j + 1])) != A.end()) ans++;
}
}
cout << ans << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long INFTY = 1LL << 60;
const int MAXN = 10005;
int N, C;
int P[MAXN];
int S[MAXN];
long long prevdp[MAXN];
long long curdp[MAXN];
int main() {
ios::sync_with_stdio(0);
cin >> N >> C;
for (int i = 1; i <= N; i++) cin >> P[i];
for (int i = 1; i <= N; i++) cin >> S[i];
for (int i = 1; i <= N; i++) prevdp[i] = INFTY;
for (int i = 1; i <= N; i++) {
for (int j = 0; j <= i; j++) {
curdp[j] = INFTY;
if (j < i) curdp[j] = prevdp[j] + (long long)j * C + P[i];
if (j > 0) curdp[j] = min(curdp[j], prevdp[j - 1] + S[i]);
}
memcpy(prevdp, curdp, sizeof(curdp));
}
long long best = INFTY;
for (int i = 0; i <= N; i++) best = min(best, curdp[i]);
cout << best << "\n";
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 0;
const int mo = 0;
int k, cnt;
int main() {
cin >> k;
for (int i = 0; i < 26; i++) {
cnt = 0;
while ((cnt + 1) * cnt / 2 <= k) cnt++;
k -= cnt * (cnt - 1) / 2;
for (int j = 0; j < cnt; j++) printf("%c", 'a' + i);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, f, k;
int from[210], to[210];
bool empty[210];
vector<pair<int, int> > v;
signed main() {
int len;
cin >> n >> f;
for (int i = 0; i < f; i++) {
cin >> len;
for (int j = 0; j < len; j++) {
cin >> from[k];
from[k]--;
k++;
}
}
for (int i = 0; i < k; i++) to[i] = i;
for (int i = 0; i < n; i++) empty[i] = true;
for (int i = 0; i < k; i++) empty[from[i]] = false;
while (1) {
bool finish = true;
for (int i = 0; i < k; i++)
if (from[i] != to[i]) finish = false;
if (finish) break;
bool find = false;
for (int i = 0; i < k; i++) {
if (empty[to[i]]) {
find = true;
v.push_back(make_pair(from[i], to[i]));
empty[from[i]] = true;
empty[to[i]] = false;
from[i] = to[i];
break;
}
}
if (find) continue;
int x = -1, y = -1, id = -1;
for (int i = 0; i < k; i++) {
if (from[i] != to[i]) {
x = from[i];
id = to[i];
}
}
for (int i = 0; i < n; i++) {
if (empty[i]) y = i;
}
v.push_back(make_pair(x, y));
empty[x] = true;
empty[y] = false;
from[id] = y;
}
cout << v.size() << endl;
for (int i = 0; i < v.size(); i++)
cout << v[i].first + 1 << " " << v[i].second + 1 << endl;
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=2e5+7;
const int modn = 1e9+7;
int a[maxn],b[maxn];
map<int,int> mp,mp2;
int binaryl(int value,int l,int r){
int res = l-1;
while(r >= l){
int mid = (r+l) >> 1;
if(b[mid] < value){
res = mid;
l = mid+1;
}
else r = mid-1;
}
return res;
}
int binaryr(int value,int l,int r){
int res = r + 1;
while(r >= l){
int mid = (r+l) >> 1;
if(b[mid] > value){
res = mid;
r = mid-1;
}
else l = mid+1;
}
return res;
}
int main(){
int T;
scanf("%d",&T);
while(T--){
mp.clear();
mp2.clear();
int n,m;
scanf("%d%d",&n,&m);
int midn = n+1,midm = m+1;
for(int i = 1;i <= n;i++){
scanf("%d",&a[i]);
mp[a[i]] = 1;
if(midn == n+1 && a[i] > 0)midn = i;
}
for(int j = 1;j <= m;j++){
scanf("%d",&b[j]);
mp2[b[j]] = 1;
if(midm == m+1 && b[j] > 0)midm = j;
}
int lstart = 0;
for(int i = 1;i < midm;i++){
if(mp[b[i]])lstart++;
}
int ans1 = lstart,ans2 = 0;
int now = midn-1;
int len = 0;
for(int i = midm-1;i >= 1;i--){
// printf("%d\n",i);
int res = lstart;
int bb = b[i]-len;
while(now && bb <= a[now]){
if(mp2[a[now]])res--;
len++;
bb--;
now--;
}
if(!len)continue;
int where = b[i] - len+1;
where = binaryl(where,1,i);
// printf("%d: where==%d res==%d len==%d\n",i,where,res,len);
lstart = res;
res += i - where;
ans1 = max(ans1,res);
}
int rstart = 0;
for(int i = midm;i <= m;i++){
if(mp[b[i]])rstart++;
}
ans2 = rstart;
now = midn;
len = 0;
for(int i = midm;i <= m;i++){
int res = rstart;
int bb = b[i] + len;
while(now <= n && bb >= a[now]){
if(mp2[a[now]])res--;
len++;
bb++;
now++;
}
if(len == 0)continue;
int where = b[i] + len-1;
where = binaryr(where,i,m);
// printf("%d: where==%d res==%d len==%d\n",i,where,res,len);
rstart = res;
res += where - i;
ans2 = max(ans2,res);
}
// printf("%d %d\n",ans1,ans2);
printf("%d\n",ans1+ans2);
}
}
/*
1000
5 5
-5 -3 -1 8 100
-9 -7 -3 1000 1001
1 5
-5
-10 -9 -8 -7 -4
5 5
-5 -4 -3 -2 -1
-100 -99 -96 -95 -94
*/
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 100;
int dp[N], h[N];
int main() {
int t;
cin >> t;
while (t--) {
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
cin >> h[i];
}
bool ans = true;
dp[1] = m;
for (int i = 2; i <= n; i++) {
int x = abs(h[i] - h[i - 1]);
int y = (h[i] < k) ? 0 : h[i] - k;
if (h[i - 1] > y)
dp[i] = dp[i - 1] + (h[i - 1] - y);
else
dp[i] = dp[i - 1] - (y - h[i - 1]);
if (dp[i] < 0) {
ans = false;
break;
}
}
if (ans)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, f, t, maxjoy, joy;
cin >> n >> k >> f >> t;
if (t > k) {
maxjoy = f - (t - k);
} else {
maxjoy = f;
}
while (--n) {
cin >> f >> t;
if (t > k) {
joy = f - (t - k);
} else {
joy = f;
}
if (joy > maxjoy) {
maxjoy = joy;
}
}
cout << maxjoy << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1061109567;
const long long LINF = 4557430888798830399ll;
const int MOD = 1000000007;
template <typename T>
void read(T &x) {
x = 0;
char c = getchar();
if (c == EOF) exit(0);
while (!isdigit(c)) c = getchar();
while (isdigit(c)) {
x = x * 10 + (c - '0');
c = getchar();
}
assert(c != EOF);
}
int reads(char *s) {
int l = 0;
*s = getchar();
if (*s == EOF) exit(0);
while (*s != ' ' && *s != '\t' && *s != '\r' && *s != '\n' && *s != EOF) {
++s;
++l;
*s = getchar();
}
assert(*s != EOF);
*s = '\0';
return l;
}
long long qpow(long long x, long long n) {
long long res = 1;
while (n) {
if (n & 1) res = res * x % MOD;
x = x * x % MOD;
n >>= 1;
}
return res;
}
int n, l, k;
char s[1000005];
char t[1005][1005];
void test_case() {
sort(s + 1, s + 1 + n * l);
int cur = 0, b = 1;
for (int j = 1; j <= l; ++j) {
for (int i = b; i <= k; ++i) {
t[i][j] = s[++cur];
if (i > 1 && t[i][j] > t[i - 1][j]) b = i;
}
if (k == 1 || t[k][j] != t[k - 1][j]) {
for (int tj = j + 1; tj <= l; ++tj) t[k][tj] = s[++cur];
break;
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= l; ++j) {
if (t[i][j] == '\0') t[i][j] = s[++cur];
putchar(t[i][j]);
}
putchar('\n');
}
}
int main() {
while (1) {
read(n), read(l), read(k);
reads(s + 1);
memset(t, '\0', sizeof(t));
test_case();
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double h, m, s, t1, t2;
cin >> h >> m >> s >> t1 >> t2;
if (h == 12) h = 0;
s = s * 6;
m = m * 6 + s / 60;
h = h * 30 + m / 12;
int flag = 0;
t1 *= 30, t2 *= 30;
if (t1 > t2) swap(t1, t2);
if (s <= t2 && s >= t1) flag++;
if (h <= t2 && h >= t1) flag++;
if (m <= t2 && m >= t1) flag++;
if (flag == 3 || flag == 0)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
int n, m, init, target, k;
vector<vector<int> > g, gg;
vector<int> path, vis, dis, parent;
void bfs(int s) {
vis[s] = 1;
queue<pair<int, int> > q;
q.push({s, 0});
while (q.size()) {
int u = q.front().first;
int d = q.front().second;
q.pop();
dis[u] = d;
for (int v : g[u]) {
if (!vis[v]) {
vis[v] = 1;
q.push({v, d + 1});
}
}
}
}
void solve() {
int max_rec = 0;
int min_rec = 0;
int v = init;
int pos = 0;
int c = 0;
while (v != target) {
pos++;
int u = path[pos];
if (dis[u] + 1 != dis[v]) {
max_rec++;
min_rec++;
v = u;
continue;
}
int paths = 0;
for (int w : gg[v]) {
if (dis[v] == dis[w] + 1) paths++;
}
if (paths != 1) {
max_rec++;
}
v = path[pos];
}
cout << min_rec << " " << max_rec << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int u, v;
cin >> n >> m;
g.assign(n + 1, vector<int>());
gg.assign(n + 1, vector<int>());
for (int i = 0; i < m; ++i) {
cin >> u >> v;
g[v].push_back(u);
gg[u].push_back(v);
}
cin >> k;
path.resize(k);
for (int j = 0; j < k; ++j) {
cin >> path[j];
}
init = path[0];
target = path[k - 1];
dis.assign(n + 1, 0);
vis.assign(n + 1, 0);
bfs(target);
for (int l = 1; l <= n; ++l) {
}
solve();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1 << 16;
int n, d[N + 10], s[N + 10], fa[N + 10], m = 0;
queue<int> q;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d%d", &d[i], &s[i]);
if (d[i] == 1) q.push(i);
fa[i] = -1;
}
while (!q.empty()) {
int x = q.front();
q.pop();
if (d[x] == 0) continue;
fa[x] = s[x];
d[x]--;
d[fa[x]]--;
s[fa[x]] = s[fa[x]] ^ x;
if (d[fa[x]] == 1) q.push(fa[x]);
m++;
}
printf("%d\n", m);
for (int i = 0; i < n; i++)
if (fa[i] != -1 && i != fa[i]) printf("%d %d\n", fa[i], i);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_A = 1e6;
const int MIN_A = 0;
int xorSums[MAX_A + 1];
void BuildXorSums() {
xorSums[0] = 0;
for (int i = 1; i <= MAX_A; ++i) {
xorSums[i] = (i ^ xorSums[i - 1]);
}
}
const int C = 1000;
struct TQuery {
int L;
int R;
int I;
};
inline int GetBit(int mask, int num) { return (mask >> num) & 1; }
const int BIT_COUNT = 20;
void Show(int x) {
for (int i = 0; i < BIT_COUNT; ++i) {
cout << GetBit(x, i);
}
}
struct TNode {
int Next[2];
int Marker;
};
const int MAX_N = 5e4;
const int MAX_NODE_COUNT = 2 * (MAX_N * 20 + 100);
TNode nodes[MAX_NODE_COUNT];
priority_queue<int, vector<int>, greater<int>> freeNodes;
void InitMemory() {
while (!freeNodes.empty()) {
freeNodes.pop();
}
for (int i = 0; i < MAX_NODE_COUNT; ++i) {
freeNodes.push(i);
}
}
void Clear(int index) { nodes[index].Next[0] = nodes[index].Next[1] = -1; }
int GetNewNode() {
int nodeIndex = freeNodes.top();
freeNodes.pop();
Clear(nodeIndex);
return nodeIndex;
}
int GetNewMinNode() {
int newNode = GetNewNode();
nodes[newNode].Marker = MAX_A + 1;
return newNode;
}
int GetNewMaxNode() {
int newNode = GetNewNode();
nodes[newNode].Marker = -1;
return newNode;
}
void FreeNode(int node) { freeNodes.push(node); }
void FreeRoot(int root) {
for (int b = 0; b < 2; ++b) {
if (nodes[root].Next[b] != -1) {
FreeRoot(nodes[root].Next[b]);
}
}
FreeNode(root);
}
void AddMin(int v, int marker, int val) {
nodes[v].Marker = min(nodes[v].Marker, marker);
for (int i = BIT_COUNT - 1; i >= 0; --i) {
int b = GetBit(val, i);
if (nodes[v].Next[b] == -1) {
nodes[v].Next[b] = GetNewMinNode();
}
v = nodes[v].Next[b];
nodes[v].Marker = min(nodes[v].Marker, marker);
}
}
void AddMax(int v, int marker, int val) {
nodes[v].Marker = max(nodes[v].Marker, marker);
for (int i = BIT_COUNT - 1; i >= 0; --i) {
int b = GetBit(val, i);
if (nodes[v].Next[b] == -1) {
nodes[v].Next[b] = GetNewMaxNode();
}
v = nodes[v].Next[b];
nodes[v].Marker = max(nodes[v].Marker, marker);
}
}
int GetMaxXorWithSmallerMarker(int v, int marker, int val) {
int result = 0;
for (int i = BIT_COUNT - 1; i >= 0; --i) {
int b = GetBit(val, i);
if (nodes[v].Next[1 - b] != -1 &&
nodes[nodes[v].Next[1 - b]].Marker <= marker) {
v = nodes[v].Next[1 - b];
result += (1 - b) * (1 << i);
} else if (nodes[v].Next[b] != -1 &&
nodes[nodes[v].Next[b]].Marker <= marker) {
v = nodes[v].Next[b];
result += b * (1 << i);
} else {
return 0;
}
}
return result ^ val;
}
int GetMaxXorWithGreaterMarker(int v, int marker, int val) {
int result = 0;
for (int i = BIT_COUNT - 1; i >= 0; --i) {
int b = GetBit(val, i);
if (nodes[v].Next[1 - b] != -1 &&
nodes[nodes[v].Next[1 - b]].Marker >= marker) {
v = nodes[v].Next[1 - b];
result += (1 - b) * (1 << i);
} else if (nodes[v].Next[b] != -1 &&
nodes[nodes[v].Next[b]].Marker >= marker) {
v = nodes[v].Next[b];
result += b * (1 << i);
} else {
return 0;
}
}
return result ^ val;
}
int GetResultStraight(int l, int r, const vector<int>& a) {
int maxRoot = GetNewMaxNode();
int minRoot = GetNewMinNode();
int result = 0;
for (int i = l; i <= r; ++i) {
AddMax(maxRoot, a[i], xorSums[a[i]]);
AddMin(minRoot, a[i], xorSums[a[i] - 1]);
result =
max(result, GetMaxXorWithSmallerMarker(minRoot, a[i], xorSums[a[i]]));
result = max(result,
GetMaxXorWithGreaterMarker(maxRoot, a[i], xorSums[a[i] - 1]));
}
FreeRoot(maxRoot);
FreeRoot(minRoot);
return result;
}
int main() {
BuildXorSums();
int n, m;
scanf("%d%d", &n, &m);
vector<int> a(n);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
}
vector<TQuery> q(m);
for (int i = 0; i < m; ++i) {
scanf("%d%d", &q[i].L, &q[i].R);
--q[i].L;
--q[i].R;
q[i].I = i;
}
vector<vector<TQuery>> groups;
for (int i = 0; i * C < n; ++i) {
groups.push_back(vector<TQuery>());
int il = i * C;
int ir = min((i + 1) * C, n);
for (int j = 0; j < m; ++j) {
if (q[j].L >= il && q[j].L < ir) {
groups.back().push_back(q[j]);
}
}
sort(groups.back().begin(), groups.back().end(),
[](const TQuery& lhs, const TQuery& rhs) { return lhs.R < rhs.R; });
}
InitMemory();
vector<int> results(m);
for (int i = 0; i < (int)groups.size(); ++i) {
int ir = min((i + 1) * C, n);
{
for (int qi = 0; qi < (int)groups[i].size(); ++qi) {
const TQuery& q = groups[i][qi];
if (q.R < ir) {
results[q.I] = GetResultStraight(q.L, q.R, a);
}
}
}
if (ir < n) {
int maxRoot = GetNewMaxNode();
int minRoot = GetNewMinNode();
int rightResult = 0;
const auto& addToMo = [&a, maxRoot, minRoot, &rightResult](int index) {
AddMax(maxRoot, a[index], xorSums[a[index]]);
AddMin(minRoot, a[index], xorSums[a[index] - 1]);
rightResult = max(
rightResult,
GetMaxXorWithSmallerMarker(minRoot, a[index], xorSums[a[index]]));
rightResult =
max(rightResult, GetMaxXorWithGreaterMarker(maxRoot, a[index],
xorSums[a[index] - 1]));
};
int r = ir;
addToMo(r);
for (int qi = 0; qi < (int)groups[i].size(); ++qi) {
const TQuery& q = groups[i][qi];
if (q.R < ir) {
continue;
}
while (r < q.R) {
++r;
addToMo(r);
}
int curResult = rightResult;
for (int j = q.L; j < ir; ++j) {
curResult = max(curResult, GetMaxXorWithSmallerMarker(minRoot, a[j],
xorSums[a[j]]));
curResult = max(curResult, GetMaxXorWithGreaterMarker(
maxRoot, a[j], xorSums[a[j] - 1]));
}
curResult = max(curResult, GetResultStraight(q.L, ir - 1, a));
results[q.I] = curResult;
}
FreeRoot(maxRoot);
FreeRoot(minRoot);
}
}
for (int i = 0; i < m; ++i) {
printf("%d\n", results[i]);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int T = 1;
for (int qq = 1; qq <= T; qq++) {
int n, d, ans = 0;
cin >> n >> d;
string s;
cin >> s;
for (int i = 0; i < n;) {
int j;
if (i + d >= n - 1) {
ans++;
break;
}
for (j = i + d; j > i; j--) {
if (s[j] == '1') {
ans++;
break;
}
}
if (i == j) {
cout << "-1" << endl;
return 0;
}
i = j;
}
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename S>
ostream &operator<<(ostream &os, const pair<T, S> &v) {
os << "(";
os << v.first << "," << v.second << ")";
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << "[";
int sz = v.size();
for (int i = 0; i < sz; ++i) {
os << v[i];
if (i != sz - 1) os << ",";
}
os << "]\n";
return os;
}
vector<pair<int, int> > pts;
vector<int> toDo;
int N;
vector<int> suffMax, prefMax;
vector<int> suffMin, prefMin;
bool check(int K) {
int ptL = -1, ptR = -1;
for (int i = 0; i < toDo.size(); i++) {
int curY = toDo[i];
while (ptL < N - 1 && pts[ptL + 1].second < curY) {
ptL++;
}
while (ptR < N - 1 && pts[ptR + 1].second - curY <= K) {
ptR++;
}
int xmin = min(prefMin[ptL + 1], suffMin[ptR + 1]);
int xmax = max(prefMax[ptL + 1], suffMax[ptR + 1]);
if (xmax - xmin <= K && xmax >= xmin) {
return 1;
}
}
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> N;
set<int> X;
for (int i = 0; i < N; i++) {
int xx, yy;
cin >> xx >> yy;
pts.push_back({xx + yy, xx - yy});
X.insert(xx - yy);
}
sort(pts.begin(), pts.end(),
[&](pair<int, int> a, pair<int, int> b) { return a.second < b.second; });
suffMin.resize(N + 1, 2e9);
suffMax.resize(N + 1, -2e9);
prefMin.resize(N + 1, 2e9);
prefMax.resize(N + 1, -2e9);
for (int i = 0; i < N; i++) {
prefMax[i + 1] = max(prefMax[i], pts[i].first);
prefMin[i + 1] = min(prefMin[i], pts[i].first);
}
for (int i = N - 1; i >= 0; i--) {
suffMax[i] = max(suffMax[i + 1], pts[i].first);
suffMin[i] = min(suffMin[i + 1], pts[i].first);
}
for (auto u : X) {
toDo.push_back(u);
}
int lo = 0, hi = (int)2e9 + 3;
while (hi > lo) {
long long mid = ((long long)hi + lo) / 2;
if (check(mid)) {
hi = mid;
} else {
lo = mid + 1;
}
}
cout << fixed << setprecision(3) << (long double)lo / 2 << endl;
cerr << "Time : " << (double)clock() / (double)CLOCKS_PER_SEC << "s\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxm = 1e5 + 5;
int maze[2][maxm];
int n, q;
set<pair<int, int> > s;
int code(int r, int c) { return r * n + c; }
void link(int r, int c) {
for (int i = -1; i < 2; i++)
if (maze[r ^ 1][c + i])
s.insert(make_pair((code(r, c)), (code(r ^ 1, c + i)))),
s.insert(make_pair((code(r ^ 1, c + i)), (code(r, c))));
}
void dlink(int r, int c) {
for (int i = -1; i < 2; i++)
s.erase(make_pair((code(r, c)), (code(r ^ 1, c + i)))),
s.erase(make_pair((code(r ^ 1, c + i)), (code(r, c))));
}
bool check(int r, int c) {
maze[r][c] ^= 1;
if (maze[r][c])
link(r, c);
else
dlink(r, c);
if (!s.empty())
return false;
else
return true;
}
int main() {
scanf("%d%d", &n, &q);
memset(maze, 0, sizeof maze);
while (q--) {
int r, c;
scanf("%d%d", &r, &c);
r--;
if (check(r, c))
puts("Yes");
else
puts("No");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
template <class C, class E>
inline bool contains(const C& container, const E& element) {
return container.find(element) != container.end();
}
template <class T>
inline void checkmin(T& a, T b) {
if (b < a) a = b;
}
template <class T>
inline void checkmax(T& a, T b) {
if (b > a) a = b;
}
using namespace std;
int n;
string s;
bool Check(int i) {
if (i == 0) return true;
vector<bool> d(10, false);
while (i != 0) {
int dig = i % 10;
if (d[dig]) return false;
d[dig] = true;
i = i / 10;
}
return true;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout << std::setprecision(15);
cout << std::fixed;
int l, r;
cin >> l >> r;
for (int i = (l), _b = (r); i <= _b; i++) {
if (Check(i)) {
cout << i;
return 0;
}
}
cout << -1;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void DBGpair(T a, string s = "") {
cerr << s << (s == "" ? "" : ": ") << a.first << ", " << a.second << "\n";
}
template <class T>
void DBGvec(vector<T> a) {
for (T i : a) cerr << i << " ";
cerr << "\n";
}
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
char dir[] = {'R', 'L', 'D', 'U'};
const int MOD = 1e9 + 7;
const long long INF = 1e9;
void setIO(string filename) {
if (fopen((filename + ".in").c_str(), "r")) {
freopen((filename + ".in").c_str(), "r", stdin);
freopen((filename + ".out").c_str(), "w", stdout);
}
}
void solve() {
int n, m, x, y;
cin >> n >> m >> x >> y;
vector<vector<int>> grid(n, vector<int>(m));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
char x;
cin >> x;
if (x == '#')
grid[i][j] = 1;
else
grid[i][j] = 0;
}
}
vector<int> pre0(m + 1), pre1(m + 1);
for (int i = 0; i < m; i++) {
int cnt = 0;
for (int j = 0; j < n; j++) cnt += grid[j][i];
pre1[i + 1] = pre1[i] + cnt;
pre0[i + 1] = pre0[i] + n - cnt;
}
DBGvec(pre0);
DBGvec(pre1);
vector<vector<int>> dp(m + 1, vector<int>(2, 1e9));
dp[0][0] = 0;
dp[0][1] = 0;
for (int i = 1; i <= m; i++) {
for (int j = x; j <= y; j++) {
if (i - j >= 0) {
int p0 = dp[i - j][1], p1 = dp[i - j][0];
p0 += pre0[i] - pre0[i - j];
p1 += pre1[i] - pre1[i - j];
dp[i][0] = min(dp[i][0], p0);
dp[i][1] = min(dp[i][1], p1);
}
}
}
cout << min(dp[m][0], dp[m][1]) << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int t = 1;
for (int i = 1; i <= t; i++) solve();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string s;
vector<char> v;
cin >> n >> s;
for (int i = 0; i < n; i++) {
if (s[i] != s[i + 1]) {
v.push_back(s[i]);
}
}
cout << s.size() - v.size();
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char s[100];
scanf("%s", s);
int n = strlen(s);
int r = 0, i, x, q = 0;
for (i = n - 1, x = 1, r = 0; i >= 0; i--, x *= 2) {
r += (s[i] == '4') ? 0 : x;
}
int p = 0;
while (--n) {
p = p + (1 << n);
}
printf("%d", p + r + 1);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, fl1 = 0, fl2 = 0, fl3 = 0;
string s;
cin >> s;
for (i = 0; i < s.length(); i++)
if (s[i] >= 'A' && s[i] <= 'Z') fl1 = 1;
for (i = 0; i < s.length(); i++)
if (s[i] >= 'a' && s[i] <= 'z') fl2 = 1;
for (i = 0; i < s.length(); i++)
if (s[i] >= '0' && s[i] <= '9') fl3 = 1;
if (s.length() >= 5 && fl1 == 1 && fl2 == 1 && fl3 == 1)
cout << "Correct" << endl;
else
cout << "Too weak" << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100100;
int TN = 1;
int n, x, us[N], mn = N, ans;
set<int> st;
void solve() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x;
st.insert(x);
auto it = st.find(x);
it++;
if (it == st.end()) {
us[x]++;
continue;
}
it++;
if (it == st.end()) {
it--;
us[*it]--;
}
}
for (int i = n; i >= 1; i--) {
if (us[i] <= mn) {
mn = us[i];
ans = i;
}
}
cout << ans;
return;
}
int main() {
ios_base::sync_with_stdio(0);
while (TN--) solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int N = 100005;
using namespace std;
int n, k;
long long ans;
int a[N], fen[N];
int main() {
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) a[i] = i;
for (int l = 1, r = n; l <= min(n / 2, k); l++, r--) swap(a[l], a[r]);
for (int i = n; i > 0; i--) {
for (int j = a[i]; j > 0; j -= j & -j) ans += fen[j];
for (int j = a[i]; j <= n; j += j & -j) fen[j]++;
}
printf("%lld", ans);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
string old, ne;
unordered_map<string, string> f, b;
vector<string> ch;
int main() {
cin >> n;
for (int i = (0); i < (n); ++i) {
cin >> old >> ne;
if (b.find(old) == b.end()) {
ch.push_back(old);
f[old] = ne;
b[ne] = old;
} else {
f[b[old]] = ne;
b[ne] = b[old];
}
}
cout << ch.size() << endl;
for (string o : ch) {
cout << o << " " << f[o] << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n, i, t, tim;
double first, second, s, d = 1e6;
vector<pair<double, double> > v[2];
long long check(double mid) {
long long i, l, r;
vector<pair<long long, long long> > vv;
for (i = 0; i < v[0].size(); ++i) {
if (v[0][i].first / v[0][i].second <= mid) {
vv.push_back({-1e18, -2});
vv.push_back({1e18, 2});
continue;
}
l = (long long)((mid * (s * s - v[0][i].second * v[0][i].second) +
v[0][i].second * v[0][i].first) /
s);
if (l >= v[0][i].first) {
vv.push_back({v[0][i].first, -2});
vv.push_back({l, 2});
}
}
for (i = 0; i < v[1].size(); ++i) {
if ((d - v[1][i].first) / v[1][i].second <= mid) {
vv.push_back({-1e18, -1});
vv.push_back({1e18, 1});
continue;
}
r = (d - (long long)((mid * (s * s - v[1][i].second * v[1][i].second) +
v[1][i].second * (d - v[1][i].first)) /
s));
if (r <= v[1][i].first) {
vv.push_back({v[1][i].first, 1});
vv.push_back({r, -1});
}
}
sort(vv.begin(), vv.end());
long long f = 0, g = 0;
for (i = 0; i < vv.size(); ++i) {
if (vv[i].second % 2 == 0)
f -= vv[i].second;
else
g -= vv[i].second;
if (f > 0 && g > 0) return 1;
}
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout << fixed;
cout << setprecision(10);
cin >> n >> s;
for (i = 0; i < n; ++i) {
cin >> first >> second >> t;
v[t - 1].push_back({first, second});
}
sort(v[0].begin(), v[0].end());
sort(v[1].begin(), v[1].end());
double lo = 0, hi = 1e6 + 1, mid;
for (i = 0; i < 80; ++i) {
mid = (lo + hi) / 2;
if (check(mid))
hi = mid;
else
lo = mid;
}
if (check(lo))
cout << lo;
else if (check(mid))
cout << mid;
else
cout << hi;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int ac, bc, cc;
int main() {
string str, s;
cin >> str;
s = str;
int flag = 1;
sort(s.begin(), s.end());
if (s != str) {
printf("NO\n");
return 0;
}
for (int i = 0; i < str.size(); i++) {
if (str[i] == 'a')
ac++;
else if (str[i] == 'b')
bc++;
else if (str[i] == 'c')
cc++;
}
if (ac >= 1 && bc >= 1 && (cc == ac || cc == bc)) {
printf("YES\n");
} else
printf("NO\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, maxValue = 0;
cin >> a >> b >> c;
maxValue =
max((a + b + c),
max((a * (b + c)),
max((a * b + c), max(a + b * c, max(a * b * c, (a + b) * c)))));
cout << maxValue << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f, N = 1e6 + 5, MOD = 1e9 + 7;
int T, cas = 0;
bool vis[N];
long long p, k;
long long quick_mod(long long a, long long b, long long m) {
long long ret = 1;
a %= m;
while (b > 0) {
if (b & 1) ret = ret * a % m;
a = a * a % m;
b >>= 1;
}
return ret;
}
int main() {
cin >> p >> k;
if (k == 0) {
cout << quick_mod(p, p - 1, MOD) << endl;
return 0;
}
if (k == 1) {
cout << quick_mod(p, p, MOD) << endl;
return 0;
}
memset(vis, false, sizeof(vis));
long long ans = 1;
int cnt = 0;
for (int i = 0; i < p; i++) {
int idx = i, flag = 0;
while (!vis[idx]) {
vis[idx] = 1;
flag++;
idx = 1LL * idx * k % p;
}
cnt += flag > 1;
}
cout << quick_mod(p, cnt, MOD) << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int mod1 = int(1e9) + 7;
int y[1000100];
long long pow26[1000100];
int lpref[1000100];
int kmp[1000100];
void longest_pref(string &w) {
int pos = 1;
int cnd = 0;
lpref[0] = 0;
while (pos < w.length()) {
cout << pos << " " << w[pos] << ", cnd: " << cnd << " " << w[cnd] << " ";
if (w[pos] == w[cnd]) {
cnd++;
lpref[pos] = cnd;
cout << "1: " << lpref[pos] << " ";
pos++;
} else if (cnd > 0)
cnd = lpref[cnd];
else {
lpref[pos] = 0;
cout << "2: " << lpref[pos] << " ";
pos++;
}
cout << endl;
}
}
void kmp_table(string &w) {
int pos = 2;
int cnd = 0;
kmp[0] = -1;
kmp[1] = 0;
while (pos < w.length() + 1) {
if (w[pos - 1] == w[cnd]) {
cnd++;
kmp[pos] = cnd;
pos++;
} else if (cnd > 0)
cnd = kmp[cnd];
else {
kmp[pos] = 0;
pos++;
}
}
}
int main() {
int n, m;
cin >> n >> m;
string p;
cin >> p;
for (int i = 0; i < (int)(m); ++i) cin >> y[i];
pow26[0] = 1LL;
for (int i = 1; i <= (int)(n); ++i) {
pow26[i] = 26 * pow26[i - 1];
pow26[i] %= mod1;
}
if (m == 0) {
cout << pow26[n] << endl;
return 0;
}
kmp_table(p);
vector<int> prefs;
int pl = p.length();
int k = pl;
while (k > 0) {
prefs.push_back(kmp[k]);
k = kmp[k];
}
sort((prefs).begin(), (prefs).end());
long long ans = 1;
ans *= pow26[y[0] - 1];
for (int i = 1; i <= (int)(m - 1); ++i) {
int diff = pl - y[i] + y[i - 1];
if (diff <= 0) {
diff = -diff;
ans *= pow26[diff];
ans %= mod1;
} else {
auto it = lower_bound((prefs).begin(), (prefs).end(), diff);
if (*it != diff) {
cout << 0 << endl;
if (n == 58534) {
cout << diff << " " << y[i] << " " << y[i - 1] << " " << pl << endl;
cout << p[0] << " " << p[pl - 1] << endl;
for (int i = 0; i < (int)(prefs.size()); ++i)
cout << prefs[i] << endl;
}
return 0;
}
}
}
int diff = n - y[m - 1] + 1;
if (diff < pl) {
cout << "dfg" << endl;
cout << 0 << endl;
} else {
ans *= pow26[diff - pl];
ans %= mod1;
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
const int Q = 3e5 + 7;
int d[N], ra[N];
vector<pair<int, int>> g[N];
unordered_set<int> tokens[N];
long long dist[N];
long long ans[Q];
vector<int> to_ans;
int find(int idx) {
if (d[idx] == 0) return idx;
return d[idx] = find(d[idx]);
}
bool join(int x, int y) {
x = find(x);
y = find(y);
if (x == y) return false;
if (ra[x] > ra[y]) swap(x, y);
d[x] = y;
for (auto &v : tokens[x]) {
if (tokens[y].count(v)) {
to_ans.push_back(v);
tokens[y].erase(v);
} else
tokens[y].insert(v);
}
if (ra[x] == ra[y]) ++ra[y];
return true;
}
struct Edge {
int a, b;
long long w;
Edge() : a(0), b(0), w(0) {}
Edge(int _a, int _b, long long _w) : a(_a), b(_b), w(_w) {}
};
Edge el[Q], nel[Q];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
clock_t ttt = clock();
int n, m, k, q;
cin >> n >> m >> k >> q;
for (int i = 1; i <= m; ++i) {
cin >> el[i].a >> el[i].b >> el[i].w;
nel[i].a = el[i].a;
nel[i].b = el[i].b;
g[el[i].a].emplace_back(el[i].b, el[i].w);
g[el[i].b].emplace_back(el[i].a, el[i].w);
}
for (int i = 1; i <= q; ++i) {
int a, b;
cin >> a >> b;
tokens[a].insert(i);
tokens[b].insert(i);
}
for (int i = k + 1; i <= n; ++i) dist[i] = 1LL << 60;
priority_queue<pair<long long, int>, vector<pair<long long, int>>,
greater<pair<long long, int>>>
dji;
for (int i = 1; i <= k; ++i) dji.emplace(0LL, i);
while (!dji.empty()) {
auto v = dji.top();
dji.pop();
if (v.first > dist[v.second]) continue;
for (auto &cc : g[v.second]) {
if (dist[cc.first] > dist[v.second] + cc.second) {
dist[cc.first] = dist[v.second] + cc.second;
dji.emplace(dist[cc.first], (int)cc.first);
}
}
}
for (int i = 1; i <= m; ++i) {
nel[i].w = dist[el[i].a] + dist[el[i].b] + el[i].w;
}
sort(nel + 1, nel + 1 + m,
[](const Edge &lhs, const Edge &rhs) { return lhs.w < rhs.w; });
for (int i = 1; i <= m; ++i) {
auto &v = nel[i];
if (!join(v.a, v.b)) continue;
for (auto &letans : to_ans) {
ans[letans] = v.w;
}
to_ans.clear();
}
for (int i = 1; i <= q; ++i) {
cout << ans[i] << '\n';
}
cerr << "Time taken " << (double)(clock() - ttt) / CLOCKS_PER_SEC
<< " seconds\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n;
int m[64][64];
void solve() {
cin >> n;
int p = 1, q = 2;
memset(m, 0, sizeof(m));
for (int i = 0; i <= n / 2; i++)
for (int j = n / 2 - i; j < n - (n / 2 - i); j++) m[i][j] = p, p += 2;
for (int i = n / 2 + 1; i < n; i++)
for (int j = i - n / 2; j < n - (i - n / 2); j++) m[i][j] = p, p += 2;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (m[i][j] == 0) m[i][j] = q, q += 2;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) cout << m[i][j] << " ";
cout << endl;
}
}
bool check() {
for (int i = 0; i < n; i++) {
int sum = 0;
for (int j = 0; j < n; j++) sum += m[i][j];
if (sum & 1 != 1) return false;
sum = 0;
for (int j = 0; j < n; j++) sum += m[j][i];
if (sum & 1 != 1) return false;
}
int sum = 0;
for (int i = 0; i < n; i++) sum += m[i][i];
if (sum & 1 != 1) return false;
sum = 0;
for (int i = 0; i < n; i++) sum += m[i][n - 1 - i];
if (sum & 1 != 1) return false;
return true;
}
int main() {
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000000;
long long need[100001], sum[100002];
int axis[100002], minv[1 << 20], l[100001];
void makeTree(int i, int l, int r, int n) {
minv[i] = inf;
if (l + 1 == r) return;
int mid = (l + r) / 2;
makeTree(i * 2, l, mid, n);
makeTree(i * 2 + 1, mid, r, n);
}
int getMin(int i, int l, int r, int l1, int r1) {
if (l1 == r1) return inf;
if (l1 <= l && r <= r1) return minv[i];
int mid = (l + r) / 2, res = inf;
if (l1 < mid) res = min(res, getMin(i * 2, l, mid, l1, r1));
if (r1 > mid) res = min(res, getMin(i * 2 + 1, mid, r, l1, r1));
return res;
}
void change(int i, int l, int r, int loc, int x) {
minv[i] = min(minv[i], x);
if (l + 1 == r) return;
int mid = (l + r) / 2;
if (loc < mid) change(i * 2, l, mid, loc, x);
if (loc >= mid) change(i * 2 + 1, mid, r, loc, x);
}
int query(int tot, int t, int g, int m) {
int a, b, res = inf;
a = lower_bound(axis, axis + tot, g - t) - axis;
b = lower_bound(axis, axis + tot, m - t) - axis;
res = min(res, getMin(1, 0, tot, a, b));
a = lower_bound(axis, axis + tot, g + m - t) - axis;
b = lower_bound(axis, axis + tot, 2 * m - t) - axis;
res = min(res, getMin(1, 0, tot, a, b));
return res;
}
int main() {
int n, g, r;
scanf("%d%d%d", &n, &g, &r);
int m = g + r;
for (int i = 0; i <= n; i++) scanf("%d", &l[i]);
sum[0] = 0;
for (int i = 0; i <= n; i++) sum[i + 1] = sum[i] + l[i];
for (int i = 0; i <= n + 1; i++) axis[i] = (int)(sum[i] % m);
sort(axis, axis + n + 2);
int tot = unique(axis, axis + n + 2) - axis;
makeTree(1, 0, tot, n);
need[n] = l[n];
for (int i = n - 1; i >= 0; i--) {
int tmp = lower_bound(axis, axis + tot, (int)(sum[i + 1] % m)) - axis;
change(1, 0, tot, tmp, i + 1);
tmp = query(tot, (m - (int)(sum[i] % m)) % m, g, m);
if (tmp < inf) {
long long s = sum[tmp] - sum[i];
need[i] = need[tmp] + (s / m + 1) * m;
} else {
need[i] = sum[n + 1] - sum[i];
}
}
int q;
scanf("%d", &q);
for (int i = 0; i < q; i++) {
int t;
scanf("%d", &t);
int tmp = query(tot, (int)(t % m), g, m);
long long ans;
if (tmp < inf) {
long long s = t + sum[tmp];
ans = need[tmp] + (s / m + 1) * m;
} else {
ans = t + sum[n + 1];
}
printf("%I64d\n", ans);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, m, stk[2001], DFS, top, f[2001], N, Dfn[2001], lv, ans, ml, x, y;
vector<int> Y[2001], E[2001];
int Tarjan(int F, int X) {
if (Dfn[X]) return Dfn[X];
int low = Dfn[X] = ++DFS;
stk[++top] = X;
for (int i = 0; i < Y[X].size(); ++i)
if (Y[X][i] != F) low = min(low, Tarjan(X, Y[X][i]));
if (low == Dfn[X])
for (++N;;) {
f[stk[top]] = N;
if (stk[top--] == X) break;
}
return low;
}
int Dfs(int F, int X) {
Dfn[X] = 1;
int m1 = 0, m2 = 0, tmp;
if (E[X].size() < 2) lv++;
for (int i = 0; i < E[X].size(); ++i)
if (E[X][i] != F)
if ((tmp = Dfs(X, E[X][i])) > m1)
m2 = m1, m1 = tmp;
else if (tmp > m2)
m2 = tmp;
ml = max(ml, m1 + m2 + 1);
return m1 + 1;
}
int main() {
cin >> n >> m;
for (; m--;) {
cin >> x >> y;
Y[x].push_back(y);
Y[y].push_back(x);
}
for (int i = 1; i <= n; ++i) Tarjan(0, i);
for (int i = 1; i <= n; ++i)
for (int j = 0; j < Y[i].size(); ++j)
if (f[Y[i][j]] == f[i])
continue;
else
E[f[i]].push_back(f[Y[i][j]]);
memset(Dfn, 0, sizeof Dfn);
for (int i = 1; i <= N; ++i)
if (!Dfn[i]) {
ml = lv = 0;
Dfs(0, i);
ans -= ml + lv - 3;
if (ml == 1 && lv == 1) ans--;
}
cout << ans - 1 + n;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int next() {
int x;
cin >> x;
return x;
}
long long lnext() {
long long x;
cin >> x;
return x;
}
int main() {
cout.precision(20);
ios_base::sync_with_stdio(false);
int tests = next();
while (tests-- > 0) {
int n = next();
int k = next();
string s;
cin >> s;
vector<pair<int, int> > answer;
string t;
for (int i = 0; i < k - 1; i++) {
t.push_back('(');
t.push_back(')');
}
for (int i = 0; i < n / 2 - (k - 1); i++) t.push_back('(');
for (int i = 0; i < n / 2 - (k - 1); i++) t.push_back(')');
for (int i = 0; i < n; i++) {
if (s[i] != t[i]) {
int j = i;
while (s[j] != t[i]) j++;
reverse(s.begin() + i, s.begin() + j + 1);
answer.emplace_back(i + 1, j + 1);
}
}
cout << answer.size() << "\n";
for (auto an : answer) cout << an.first << " " << an.second << "\n";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (!b) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
int main() {
long long n;
cin >> n;
long long mx = 1;
for (int i = 0; i < 10; ++i)
for (int j = i + 1; j < 10; ++j)
for (int k = j + 1; k < 10; ++k)
if (n - i > 0 && n - j > 0 && n - k > 0)
mx = max(mx, lcm(n - i, lcm(n - j, n - k)));
cout << max(mx, n) << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXM = 35;
const int MAXN = 202020;
const int MOD = 998244353;
uint64_t ans[MAXM + 1];
vector<uint64_t> RREF;
uint64_t msb(uint64_t x) {
int lg = 63 - __builtin_clzll((unsigned long long)x);
return ((uint64_t)1) << lg;
}
void put(uint64_t x) {
for (auto y : RREF) {
uint64_t m = msb(y);
if (x & m) x ^= y;
}
if (x) {
uint64_t m = msb(x);
for (auto& y : RREF)
if (y & m) y ^= x;
RREF.push_back(x);
}
}
int N, M;
int main() {
cin >> N >> M;
vector<uint64_t> VV;
for (int i = 0; i < N; ++i) {
uint64_t T;
cin >> T;
VV.push_back(T);
}
sort(VV.begin(), VV.end());
for (auto x : VV) put(x);
for (int i = 0; i < (int)RREF.size(); ++i) {
for (int j = 0; j < i; ++j) {
assert(!(RREF[j] & msb(RREF[i])));
assert(!(RREF[i] & msb(RREF[j])));
}
}
for (auto& x : RREF) x ^= msb(x);
assert((int)RREF.size() <= M);
using pui = pair<uint64_t, int>;
vector<pair<pui, long long> > V;
V.emplace_back(make_pair(uint64_t(0), 0), 1LL);
for (auto x : RREF) {
vector<pair<pui, int> > U;
for (auto [pp, ii] : V) {
auto [vv, cc] = pp;
U.emplace_back(pp, ii);
U.emplace_back(make_pair(vv ^ x, cc + 1), ii);
}
sort(U.begin(), U.end());
V.clear();
auto [cur, cnt] = U[0];
for (int i = 1; i < (int)U.size(); ++i) {
auto [pp, ii] = U[i];
if (cur == pp) {
cnt += ii;
if (cnt >= MOD) cnt -= MOD;
} else {
V.emplace_back(cur, cnt);
cur = pp;
cnt = ii;
}
}
V.emplace_back(cur, cnt);
}
for (auto [pp, ii] : V) {
auto [vv, cc] = pp;
int tot = __builtin_popcountll((unsigned long long)vv) + cc;
ans[tot] += ii;
if (ans[tot] >= MOD) ans[tot] -= MOD;
}
long long p = 1;
for (int i = 0; i < N - (int)RREF.size(); ++i) p = (p + p) % MOD;
for (int i = 0; i <= M; ++i) {
ans[i] = ans[i] * p % MOD;
cout << ans[i] << " ";
}
cout << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int II() {
int q;
scanf("%d", &q);
return q;
}
long long LII() {
long long q;
scanf("%lld", &q);
return q;
}
int N, K;
string s;
void solve() {
cin >> N >> K;
cin >> s;
vector<pair<int, int> > v;
int i = 0, j = 0;
for (int ii = 1; ii < K; ii++) {
for (int k = i; k < N; k++) {
if (s[k] == '(') {
j = k;
break;
}
}
v.push_back({i, j});
reverse(s.begin() + i, s.begin() + j + 1);
i++;
j = i;
for (int k = i; k < N; k++) {
if (s[k] == ')') {
j = k;
break;
}
}
v.push_back({i, j});
reverse(s.begin() + i, s.begin() + j + 1);
i++, j = i;
}
int q = N / 2 - K + 1;
while (q > 0 && q--) {
for (int k = i; k < N; k++) {
if (s[k] == '(') {
j = k;
break;
}
}
v.push_back({i, j});
reverse(s.begin() + i, s.begin() + j + 1);
i++, j = i;
}
cout << v.size() << endl;
for (auto it : v) {
cout << it.first + 1 << " " << it.second + 1 << endl;
}
}
int32_t main() {
int tt;
cin >> tt;
int cas = 1;
while (tt--) {
solve();
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n1, n2, k1, k2;
cin >> n1 >> n2 >> k1 >> k2;
long long dp[n1 + 1][n2 + 1][2];
for (long long i = 0; i <= n1; i++)
for (long long j = 0; j <= n2; j++) dp[i][j][0] = dp[i][j][1] = 0;
dp[0][0][0] = dp[0][0][1] = 1;
for (long long i = 0; i <= n1; i++)
for (long long j = 0; j <= n2; j++) {
for (long long k = 1; k <= k1; k++)
if (i - k >= 0)
dp[i][j][0] = (dp[i - k][j][1] + dp[i][j][0]) % 100000000;
for (long long k = 1; k <= k2; k++)
if (j - k >= 0)
dp[i][j][1] = (dp[i][j - k][0] + dp[i][j][1]) % 100000000;
if (!i and !j) dp[i][i][0] = dp[i][j][1] = 1;
}
cout << (dp[n1][n2][1] + dp[n1][n2][0]) % 100000000;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.precision(20);
long long t = 1;
while (t--) {
solve();
cout << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, p, q, count = 0;
cin >> n;
cin >> p;
int x[p];
for (int i = 0; i < p; i++) cin >> x[i];
cin >> q;
if (p == 0 && q == 0) {
cout << "Oh, my keyboard!";
exit(0);
}
int y[q];
int z[p + q];
for (int i = 0; i < q; i++) cin >> y[i];
for (int i = 0; i < p; i++) z[i] = x[i];
for (int j = 0; j < q; j++) z[p + j] = y[j];
sort(z, z + p + q);
for (int i = 0; i < (p + q - 1); i++) {
if (z[i] != z[i + 1]) count++;
}
if ((count + 1) == n)
cout << "I become the guy.";
else
cout << "Oh, my keyboard!";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
if (a < b) {
return gcd(b, a);
}
if (a % b == 0) {
return b;
}
return gcd(b, a % b);
}
long long int lcm(long long int a, long long int b) {
long long int g = gcd(a, b);
return (a / g) * b;
}
long long int SumTopN(vector<long long int> p, long long int n) {
if (n == 0) return 0;
return p[p.size() - n];
}
long long int FindContribution(vector<long long int> p, long long int l,
long long int a, long long int b,
long long int x, long long int y,
long long int mid) {
long long int Common = mid / l;
long long int xs = mid / a - Common;
long long int ys = mid / b - Common;
long long int sum = SumTopN(p, Common);
long long int sum_x = SumTopN(p, xs + Common) - SumTopN(p, Common);
long long int sum_y = SumTopN(p, ys + Common) - SumTopN(p, Common);
long long int next_sum_x =
SumTopN(p, xs + ys + Common) - SumTopN(p, ys + Common);
long long int next_sum_y =
SumTopN(p, xs + ys + Common) - SumTopN(p, xs + Common);
if (sum_x * x + next_sum_y * y > sum_y * y + next_sum_x * x) {
sum_y = next_sum_y;
} else {
sum_x = next_sum_x;
}
long long int totalContribution = sum * (x + y) + sum_x * x + sum_y * y;
totalContribution = totalContribution / 100;
return totalContribution;
}
int main() {
long long int q;
cin >> q;
while (q--) {
long long int n;
cin >> n;
vector<long long int> p;
for (long long int i = 0; i < n; i++) {
long long int w;
cin >> w;
p.push_back(w);
}
sort(p.begin(), p.end());
for (long long int i = n - 2; i >= 0; i--) {
p[i] += p[i + 1];
}
long long int x, a;
cin >> x >> a;
long long int y, b;
cin >> y >> b;
long long int k;
cin >> k;
long long int l = lcm(a, b);
long long int high = n;
long long int low = 1;
long long int ans = -1;
while (low < high) {
long long int mid = (high + low) / 2;
long long int totalContribution = FindContribution(p, l, a, b, x, y, mid);
if (totalContribution >= k) {
high = mid;
} else {
low = mid + 1;
}
}
long long int totalContribution = FindContribution(p, l, a, b, x, y, low);
if (totalContribution >= k) {
ans = low;
}
cout << ans << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void bfs(vector<vector<uint64_t>>& g,
map<tuple<uint64_t, uint64_t>, uint64_t>& i2r) {
vector<bool> visit(g.size());
deque<tuple<uint64_t, uint64_t, uint64_t>> ev;
map<int64_t, vector<uint64_t>> roads_by_day;
visit[1] = true;
int day = 0;
for (auto e : g[1]) {
day += 1;
ev.push_back({1, e, day});
roads_by_day[day].push_back(i2r[{1, e}]);
}
while (!ev.empty()) {
auto crt = ev.front();
uint64_t nv = get<1>(crt);
ev.pop_front();
if (!visit[nv]) {
visit[nv] = true;
int day = 0;
int noDay = get<2>(crt);
for (auto e : g[nv]) {
if (!visit[e]) {
day += 1;
if (day == noDay) {
day += 1;
}
ev.push_back({nv, e, day});
roads_by_day[day].push_back(i2r[{min(nv, e), max(nv, e)}]);
}
}
}
}
cout << roads_by_day.size() << endl;
for (auto kv : roads_by_day) {
cout << kv.second.size() << " ";
for (auto ed : kv.second) {
cout << ed << " ";
}
cout << endl;
}
}
int main() {
ios::sync_with_stdio(false);
uint64_t n;
cin >> n;
vector<vector<uint64_t>> v(n + 1);
map<tuple<uint64_t, uint64_t>, uint64_t> i2r;
for (uint64_t i = 0; i < n - 1; i++) {
uint64_t x;
cin >> x;
uint64_t y;
cin >> y;
v[x].push_back(y);
v[y].push_back(x);
i2r[{min(x, y), max(x, y)}] = i + 1;
}
bfs(v, i2r);
return 0;
}
| 5 |
#include <bits/stdc++.h>
int main() {
int n, a[1001];
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
if (a[i] % 2 == 0) a[i]--;
printf("%d ", a[i]);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void prologue() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
}
const int MAX = 100007;
bool visited[MAX];
vector<vector<int>> g, rg;
vector<int> finish;
vector<int> scc;
void ddfs(int node) {
if (visited[node]) return;
visited[node] = true;
for (int i = 0; i < g[node].size(); ++i) {
ddfs(g[node][i]);
}
finish.push_back(node);
}
void rddfs(int node, int scc_num) {
if (visited[node]) return;
visited[node] = true;
scc[node] = scc_num;
for (int i = 0; i < rg[node].size(); ++i) {
rddfs(rg[node][i], scc_num);
}
}
bool dfs(int node) {
if (visited[node]) return false;
visited[node] = true;
bool cycle_found = false;
for (int i = 0; i < g[node].size(); ++i) {
cycle_found |= (scc[node] == scc[g[node][i]]);
cycle_found |= dfs(g[node][i]);
}
for (int i = 0; i < rg[node].size(); ++i) {
cycle_found |= (scc[node] == scc[rg[node][i]]);
cycle_found |= dfs(rg[node][i]);
}
return cycle_found;
}
int main() {
prologue();
int n, m;
cin >> n >> m;
g.assign(n, decltype(g)::value_type());
rg.assign(n, decltype(rg)::value_type());
scc.assign(n, 0);
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
g[u - 1].push_back(v - 1);
rg[v - 1].push_back(u - 1);
}
memset(visited, 0, sizeof(visited));
for (int i = 0; i < n; ++i) {
if (!visited[i]) ddfs(i);
}
memset(visited, 0, sizeof(visited));
int scc_num = 0;
for (int i = finish.size() - 1; i >= 0; --i) {
if (!visited[finish[i]]) rddfs(finish[i], ++scc_num);
}
memset(visited, 0, sizeof(visited));
int no_cycles = 0;
for (int i = 0; i < n; ++i) {
if (!visited[i]) {
no_cycles += !dfs(i);
}
}
cout << n - no_cycles;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9, Pi = acos(-1);
struct pnt {
int x, y;
};
istream& operator>>(istream& is, pnt& p) {
is >> p.x >> p.y;
return is;
}
ostream& operator<<(ostream& os, pnt& p) {
os << p.x << " " << p.y;
return os;
}
int n, d;
vector<pnt> v;
int check(pnt a, pnt b) {
double g = asin(((double)a.x * b.y - a.y * b.x) /
sqrt(a.x * a.x + a.y * a.y) / sqrt(b.x * b.x + b.y * b.y)) *
180 / Pi;
if (g < 0) return -1;
if (g == 0) return 0;
if (g > 0) return 1;
}
int main() {
srand(NULL);
cin >> n >> d;
v.push_back({0, d});
v.push_back({d, 0});
v.push_back({n, n - d});
v.push_back({n - d, n});
v.push_back(v[0]);
int m;
cin >> m;
vector<int> pr;
for (int i = 3; i < 1000; i++) {
int q = 0;
for (int j = 2; j * j < i; j++) {
if (i % j == 0) {
q++;
break;
}
}
if (q == 0) {
pr.push_back(i);
}
}
for (int j = 0; j < m; j++) {
int z = 0, l = 0, r = 0;
pnt p, p2;
cin >> p.x >> p.y;
for (int i = 1; i < v.size(); i++) {
pnt a = {v[i].x - v[i - 1].x, v[i].y - v[i - 1].y};
pnt b = {p.x - v[i - 1].x, p.y - v[i - 1].y};
int fl = check(a, b);
if (fl == 1) {
l++;
}
if (fl == -1) {
r++;
}
}
if (l > 0 && r > 0) {
cout << "NO\n";
} else {
cout << "YES\n";
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long size = 1e5;
int n, q, sz = 1, tree[4 * size];
pair<int, int> dat[100005];
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
void init(int s) {
while (sz < s) {
sz *= 2;
}
for (int i = 0; i < 2 * sz - 1; ++i) {
tree[i] = 0;
}
}
void upd(int pos, int a) {
tree[pos += sz - 1] = a;
while (pos > 0) {
pos = (pos - 1) / 2;
tree[pos] = gcd(tree[pos * 2 + 1], tree[pos * 2 + 2]);
}
}
int ask(int l, int r, int cl, int cr, int cur) {
if (cr <= l || cl >= r) return 0;
if (cl >= l && cr <= r)
return tree[cur];
else
return gcd(ask(l, r, cl, (cl + cr) / 2, cur * 2 + 1),
ask(l, r, (cl + cr) / 2, cr, cur * 2 + 2));
}
int main() {
ios_base::sync_with_stdio(0);
;
cin >> n;
init(n);
for (int i = 0; i < n; ++i) {
int s;
cin >> s;
dat[i] = {s, i};
upd(i, s);
}
sort(dat, dat + n);
cin >> q;
for (int i = 0; i < q; ++i) {
int l, r, gcd, from, to;
pair<int, int> tmp;
cin >> l >> r;
gcd = ask(l - 1, r, 0, sz, 0);
tmp = {gcd, l - 1};
from = lower_bound(dat, dat + n, tmp) - dat;
tmp = {gcd, r};
to = lower_bound(dat, dat + n, tmp) - dat;
cout << r - l + 1 - to + from << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
string get(string &a, string &b, int type) {
string s1, s0;
s1 += a[0];
s1 += a[1];
s1 += b[0];
s0 += a[0];
s0 += a[1];
s0 += a[2];
if (type == 1) return s1;
return s0;
}
vector<vector<pair<int, int> > > g;
vector<int> used, mt, mt1;
vector<string> names[2];
map<string, int> all;
vector<int> part;
vector<int> part1;
vector<string> bck;
bool dfs(int v) {
if (used[v]) return 0;
used[v] = 1;
for (auto to : g[v]) {
if (to.second == 1) {
if (mt[to.first] != -1 && bck[part[to.first]] == names[0][mt[to.first]])
continue;
} else {
if (mt1[to.first] != -1) continue;
}
if (mt[to.first] == -1 || dfs(mt[to.first]) || mt1[to.first] == -1 ||
dfs(mt1[to.first])) {
if (to.second == 0) {
mt[part1[to.first]] = v;
} else {
mt[to.first] = v;
}
if (to.second == 1) {
mt1[part[to.first]] = v;
} else {
mt1[to.first] = v;
}
return 1;
}
}
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
vector<pair<string, string> > v(n);
names[0].resize(n);
names[1].resize(n);
for (int i = 0; i < n; i++) {
string a, b;
cin >> a >> b;
v[i] = {a, b};
names[0][i] = get(a, b, 0);
names[1][i] = get(a, b, 1);
all[names[0][i]] = 0;
all[names[1][i]] = 0;
}
int m = 0;
for (auto &it : all) {
bck.push_back(it.first);
it.second = m++;
}
part.resize(m);
part1.resize(m);
g.resize(n);
for (int i = 0; i < n; i++) {
part[all[names[1][i]]] = all[names[0][i]];
part1[all[names[0][i]]] = all[names[1][i]];
g[i].push_back({all[names[1][i]], 1});
g[i].push_back({all[names[0][i]], 0});
}
mt.assign(m, -1);
mt1.assign(m, -1);
for (int v = 0; v < n; v++) {
used.assign(n, 0);
dfs(v);
}
vector<string> ans(n, "#");
for (int i = 0; i < m; i++) {
if (mt[i] == -1) continue;
ans[mt[i]] = bck[i];
}
for (int i = 0; i < n; i++) {
if (ans[i] == "#") {
cout << "NO\n";
return 0;
}
}
cout << "YES\n";
for (int i = 0; i < n; i++) {
cout << ans[i] << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int long long MAXN = 1e9;
int main() {
ios::sync_with_stdio(false);
string s;
cin >> s;
int pivot;
for (int i = 0; i < s.length(); i++)
if (s[i] == '^') {
pivot = i;
break;
}
int long long left = 0, right = 0;
for (int i = 0; i < pivot; i++)
if (s[i] != '=') left += (int long long)(s[i] - '0') * (pivot - i);
for (int i = pivot + 1; i < s.length(); i++)
if (s[i] != '=') right += (int long long)(s[i] - '0') * (i - pivot);
if (left > right) cout << "left\n";
if (left < right) cout << "right\n";
if (left == right) cout << "balance\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math,O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const int mod = 1000003273;
const int N = 500005;
const int M = 500057;
int n, a[600005], p[600005], pw[600005];
long long ans;
vector<pair<int, int>> v;
map<pair<int, int>, int> m;
void add(int x) {
v.push_back(make_pair(x, ((long long)pw[(int)v.size()] * x +
((int)v.size() ? v.back().second : 0)) %
mod));
}
void del() {
if ((int)v.size()) v.pop_back();
}
void rec(int l = 1, int r = n) {
if (l == r) return;
int tm = (l + r) / 2;
m.clear();
v.clear();
for (int i = tm; i >= l; i--) {
if ((int)v.size() && v.back().first == a[i])
del();
else
add(a[i]);
if ((int)v.size())
m[make_pair(v.back().second, (int)v.size())]++;
else
m[make_pair(0, 0)]++;
}
v.clear();
for (int i = tm + 1; i <= r; i++) {
if ((int)v.size() && v.back().first == a[i])
del();
else
add(a[i]);
if ((int)v.size())
ans += m[make_pair(v.back().second, (int)v.size())];
else
ans += m[make_pair(0, 0)];
}
rec(l, tm);
rec(tm + 1, r);
}
void solve() {
ans = 0;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
rec();
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cout.precision(30);
cerr.precision(7);
;
pw[0] = M;
for (int i = 1; i <= N; i++) pw[i] = ((long long)pw[i - 1] * M) % mod;
int T;
cin >> T;
while (T--) solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int arr[] = {'R', 'O', 'Y', 'G', 'B', 'I', 'V'};
int number;
cin >> number;
string concate;
int meadian = 3;
int index = 0;
for (int r = 0; r < number; r++) {
if (index < 7) {
concate += arr[index];
} else {
concate += concate[meadian];
meadian++;
}
index++;
}
cout << concate;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int n;
int st[N], top;
int main() {
scanf("%d", &n);
st[top = 0] = 0;
for (int i = 0, x; i < n; ++i) {
scanf("%d", &x);
int l = 0, r = top, mid;
while (r > l) {
mid = l + r + 1 >> 1;
if (st[mid] < x)
l = mid;
else
r = mid - 1;
}
if (r == top) top++;
st[r + 1] = x;
}
printf("%d\n", top);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
#define PI 3.14159265358979323
#define ll long long int
#define vi vector <int>
#define vl vector <ll>
#define all(v) (v).begin(),(v).end()
#define pb push_back
#define ff first
#define ss second
#define MOD 1000000007
ll power(ll a, ll b) { //a^b
ll res = 1;
a = a % MOD;
while (b > 0) {
if (b & 1) {res = (res * a) % MOD; b--;}
a = (a * a) % MOD;
b >>= 1;
}
return res;
}
ll gcd(ll a, ll b) {return (b == 0) ? a : gcd(b, a % b);}
int main() {
#ifndef ONLINE_JUDGE
// for getting input from input.txt
freopen("input.txt", "r", stdin);
// for writing output to output.txt
freopen("output.txt", "w", stdout);
#endif
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll t;
cin >> t;
while (t--) {
ll n;
cin >> n;
vector <string> v(n);
for (ll i = 0; i < n; i++)
cin >> v[i];
vl c(3, 0);
for (ll i = 0; i < n; i++) {
for (ll j = 0; j < n; j++) {
if (v[i][j] == 'X')
c[(i + j) % 3]++;
}
}
pair<ll, ll> mi;
mi.ff = 0;
mi.ss = c[0];
if (c[1] < mi.ss) {
mi.ss = c[1];
mi.ff = 1;
}
if (c[2] < mi.ss) {
mi.ss = c[2];
mi.ff = 2;
}
for (ll i = 0; i < n; i++) {
for (ll j = 0; j < n; j++) {
if (v[i][j] == 'X' && (i + j) % 3 == mi.ff)
cout << "O";
else
cout << v[i][j];
}
cout << "\n";
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
ll n, k;
cin >> n >> k;
string s;
cin >> s;
ll mx = -1, mn = 1e9;
map<char, ll> mp;
for (char i : s) {
mp[i]++;
}
for (auto i : mp) {
mx = max(mx, i.second);
mn = min(mn, i.second);
}
if (mp.size() < k or k > n) return cout << 0, 0;
return cout << ((ll)mp.size() * mn), 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void splitstr(const string &s, vector<string> &v) {
istringstream in(s);
copy(istream_iterator<string>(in), istream_iterator<string>(),
back_inserter(v));
}
void err(vector<string>::iterator it) {}
template <typename T, typename... Args>
void err(vector<string>::iterator it, T a, Args... args) {
cerr << *it << " = " << a << '\n';
err(++it, args...);
}
int main() {
ios_base::sync_with_stdio(0);
int n = 0, a = 0, no[100004], x[100005], t = 0, k = 0, m = 0, i = 0, j = 0,
ans = 0, b = 0, c = 0, d = 0, y = 0, f = 0, l = 0, r = 0;
string str, s;
vector<pair<int, int> > v;
cin >> n;
for (__typeof(n) i = (0) - ((0) > (n)); i != (n) - ((0) > (n));
i += 1 - 2 * ((0) > (n))) {
cin >> no[i] >> x[i];
v.push_back(make_pair(no[i], x[i]));
ans += no[i];
}
cout << ans / 2 << '\n';
for (__typeof(n) i = (0) - ((0) > (n)); i != (n) - ((0) > (n));
i += 1 - 2 * ((0) > (n))) {
if (v[i].first == 1) {
queue<int> q;
q.push(i);
while (!q.empty()) {
int tem = q.front();
q.pop();
v[tem].first -= 1;
int u = v[tem].second;
cout << tem << " " << u << '\n';
v[u].first -= 1;
v[u].second ^= tem;
if (v[u].first == 1) q.push(u);
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
double const eps = 1e-9;
int const inf = 0x3fffffff;
long long const infl = 0x3fffffffffffffffLL;
int const K = 100003;
template <class T>
inline T sqr(const T &a) {
return a * a;
}
int const N = 1 << 17;
int n, a[N], ne[N];
map<int, int> f;
long long hs[N], pw[N];
int pv[N], q[N + N];
void add(int i) {
i += N;
q[i] = i - N;
for (i >>= 1; i; i >>= 1)
if (pv[q[i + i]] <= pv[q[i + i + 1]])
q[i] = q[i + i];
else
q[i] = q[i + i + 1];
}
int get(int x, int y) {
int rs = 0;
x += N, y += N;
for (; x <= y; x = (x + 1) / 2, y = (y - 1) / 2) {
if (pv[q[x]] < pv[rs] || pv[q[x]] == pv[rs] && q[x] < rs) rs = q[x];
if (pv[q[y]] < pv[rs] || pv[q[y]] == pv[rs] && q[y] < rs) rs = q[y];
}
return rs;
}
void mpv() {
pv[0] = inf;
for (int i = 1; i <= n; i++) {
pv[i] = inf;
for (int j = ne[i]; j; j = ne[j])
if (j + (j - i) - 1 <= n && (hs[j - 1] - hs[i - 1]) * pw[j - i] ==
(hs[j + (j - i) - 1] - hs[j - 1])) {
pv[i] = j - i;
add(i);
break;
}
}
}
int main() {
scanf("%d", &n);
hs[0] = 0, pw[0] = 1;
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
hs[i] = hs[i - 1] + a[i] * pw[i - 1];
pw[i] = pw[i - 1] * K;
if (f.find(a[i]) != f.end()) ne[f[a[i]]] = i;
f[a[i]] = i;
}
mpv();
int cr = 1;
for (;;) {
int v = get(cr, n);
if (!v) break;
cr = v + pv[v];
}
cout << n - cr + 1 << endl;
for (int i = cr; i <= n; i++) printf("%d ", a[i]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5;
vector<int> vc[N + 10];
pair<long long, int> c[N + 10];
bool mrk[N + 10];
void dfs(int v) {
mrk[v] = true;
for (int i = 0; i < vc[v].size(); i++) {
int u = vc[v][i];
if (!mrk[u]) dfs(u);
}
return;
}
int main() {
long long n, m, cnt = 0;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> c[i].first, c[i].second = i;
while (m--) {
int x, y;
cin >> x >> y, x--, y--;
vc[x].push_back(y);
vc[y].push_back(x);
}
sort(c, c + n);
for (int i = 0; i < n; i++)
if (!mrk[c[i].second]) dfs(c[i].second), cnt += c[i].first;
return cout << cnt, 0;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
long long f1[100010];
long long f2[100010];
list<int> l[100010];
int a[100010];
void dfs(int x) {
if (a[x]) {
f1[x] = 1;
f2[x] = 0;
} else {
f1[x] = 0;
f2[x] = 1;
}
for (auto v : l[x]) {
dfs(v);
f1[x] = (f1[x] * (f2[v] + f1[v]) + f2[x] * f1[v]) % mod;
f2[x] = f2[x] * (f2[v] + f1[v]) % mod;
}
}
int main() {
int n;
int x, i;
scanf("%d", &n);
for (i = 2; i <= n; i++) {
scanf("%d", &x);
x++;
l[x].push_back(i);
}
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
dfs(1);
printf("%I64d\n", f1[1]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
inline long long rand(long long x, long long y) {
return rng() % (y + 1 - x) + x;
}
string inline to_string(char c) {
string second(1, c);
return second;
}
template <typename T>
inline T gcd(T a, T b) {
return a == 0 ? llabs(b) : gcd(b % a, a);
}
using ll = int;
using ld = long double;
using pi = pair<ll, ll>;
using spi = pair<ll, pi>;
using dpi = pair<pi, pi>;
ll n, m, A[(2003)], S[(2003)], C[(2003) * 2], mx[(2003)], sum[(2003) * 2];
pi lvl[(2003)][1 << 12 | 3][2], dp[1 << 12 | 3][2];
inline void put(pi& x, pi y, ll start, ll b) {
if (b) {
if (x.first < y.first) x = y;
} else {
if (x.first + sum[min(n + m, start + x.second)] <
y.first + sum[min(n + m, start + y.second)])
x = y;
}
}
string b2(ll x) {
string second = "";
while (x) second += to_string(x & 1), x >>= 1;
return second;
}
inline ll firstt(ll x) {
for (ll i = 0; i <= ll(20); ++i) {
if (1 << i & x) continue;
return i;
}
assert(0);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
for (ll i = 1; i <= ll(n); ++i) cin >> A[i];
for (ll i = 1; i <= ll(n); ++i) cin >> S[i];
for (ll i = 1; i <= ll(n + m); ++i) cin >> C[i];
for (ll i = 1; i <= ll(n + m); ++i) sum[i] = sum[i - 1] + C[i];
for (auto& i : lvl)
for (auto& j : i)
for (auto& k : j) k = pi(-int(1e9 + 1e6), 0);
ll takeout = (((1 << 28) - 1) ^ ((1 << 12) - 1));
for (ll i = 1; i <= ll(n); ++i) {
for (auto& i : dp)
for (auto& j : i) j = pi(-int(1e9 + 1e6), 0);
dp[0][0] = dp[0][1] = pi(0, 0);
for (ll j = A[i]; j <= ll(min(m, A[i] + 11)); ++j) {
ll diff = j - A[i];
for (ll b = 0; b <= ll(1); ++b)
for (ll kk = 0; kk <= ll((1 << 12) - 1); ++kk)
if (lvl[j][kk][b].first != -int(1e9 + 1e6)) {
ll k = kk << diff, other = __builtin_popcount(k & takeout),
toadd = 0, sup = 0;
k &= ((1 << 12) - 1);
if (((k & (1 << 11)) == 0 && diff) || other != diff)
other = 0;
else
sup = other + lvl[j][kk][b].second;
ll first_zero = firstt(k);
if (first_zero == 12) {
if (b == 1) continue;
toadd = lvl[j][kk][b].second + other, sup = 0;
}
put(dp[(k + 1) & ((1 << 12) - 1)][b],
pi(lvl[j][kk][b].first +
sum[min(n + m, A[i] + first_zero + toadd)] -
sum[A[i] - 1] - S[i],
sup),
A[i] + 12, b);
}
}
for (ll j = 0; j <= ll((1 << 12) - 1); ++j) {
put(dp[j][0], dp[j][1], A[i] + 12, 0);
put(dp[j][1], dp[j][0], A[i] + 12, 1);
}
for (ll b = 0; b <= ll(1); ++b)
dp[1][b] = max(dp[1][b], pi(C[A[i]] - S[i], 0));
for (ll b = 0; b <= ll(1); ++b)
for (ll j = 1; j <= ll(i); ++j)
if (A[j] - A[i] > 11) {
dp[1][b] = max(dp[1][b], pi(mx[j] + C[A[i]] - S[i], 0));
}
for (ll b = 0; b <= ll(1); ++b)
for (ll j = 0; j <= ll((1 << 12) - 1); ++j) {
put(lvl[A[i]][j][b], dp[j][b], A[i] + 12, b);
mx[i] = max(mx[i], dp[j][b].first);
}
}
cout << *max_element(mx + 1, mx + n + 1) << '\n';
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 110000;
int a[maxn], tot[maxn], ans[maxn];
int main() {
int n;
scanf("%d", &n);
memset(tot, 0, sizeof(tot));
bool flag = true;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
if (a[i] > n) {
flag = false;
} else {
ans[i] = ++tot[a[i]];
}
}
if (!flag) {
puts("-1");
return 0;
}
for (int i = 1, tmp = 0; i <= n; i++) {
tmp += tot[i];
if (tmp == n) {
break;
}
if ((i > 1) && (tot[i] > tot[i - 1])) {
puts("-1");
return 0;
}
}
printf("%d\n", tot[1]);
for (int i = 0; i < n; i++) {
printf("%d", ans[i]);
i < n - 1 ? putchar(' ') : puts("");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
int row[1005], col[1005];
char field[1005][1005], buf[1005];
int main(void) {
int i, j, m, n;
long long total;
scanf("%d %d", &n, &m);
for (i = 0; i < n; ++i) {
scanf("%s", buf);
for (j = 0; j < m; ++j) {
field[i][j] = buf[j];
if (field[i][j] == '*') {
row[i]++;
col[j]++;
}
}
}
total = 0;
for (i = 0; i < n; ++i)
for (j = 0; j < m; ++j)
if (field[i][j] == '*') total += (row[i] - 1) * (col[j] - 1);
printf("%I64d\n", total);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
long long power(long long x, int k) {
if (k == 0) return 1;
if (k == 1) return x % MOD;
long long mid = power(x * x % MOD, k >> 1);
if (k & 1)
return mid * x % MOD;
else
return mid;
}
long long inverse(long long x) { return power(x, MOD - 2); }
const int MN = 200111;
long long f[2][MN], g[2][MN];
long long left__[2][MN], right__[2][MN];
vector<int> ke[MN];
int n;
void dfs1(int u) {
f[0][u] = 1LL;
f[1][u] = 1LL;
for (int v : ke[u]) {
dfs1(v);
f[0][u] = (f[0][u] * f[0][v]) % MOD;
f[1][u] = (f[1][u] * (f[1][v] + 2 * f[0][v])) % MOD;
}
long long p[2];
p[0] = p[1] = 1LL;
for (int v : ke[u]) {
left__[0][v] = p[0];
left__[1][v] = p[1];
p[0] = p[0] * f[0][v] % MOD;
p[1] = p[1] * (f[1][v] + f[0][v] + f[0][v]) % MOD;
}
p[0] = p[1] = 1LL;
for (int id = (ke[u].size() - 1), _b = (0); id >= _b; id--) {
int v = ke[u][id];
right__[0][v] = p[0];
right__[1][v] = p[1];
p[0] = p[0] * f[0][v] % MOD;
p[1] = p[1] * (f[1][v] + f[0][v] + f[0][v]) % MOD;
}
f[1][u] = (f[1][u] - f[0][u] + MOD) % MOD;
}
void dfs2(int u, int fu) {
if (u == 1) {
g[0][u] = 1LL;
g[1][u] = 0LL;
} else {
long long f_0_ignore = left__[0][u] * right__[0][u] % MOD;
g[0][u] = g[0][fu] * f_0_ignore % MOD;
long long p = left__[1][u] * right__[1][u] % MOD;
g[1][u] = (g[1][fu] + g[0][fu]) * p % MOD;
}
for (int v : ke[u]) {
dfs2(v, u);
}
}
int main() {
ios ::sync_with_stdio(false);
while (scanf("%d", &n) == 1) {
for (int i = (1), _b = (n); i <= _b; i++) ke[i].clear();
for (int i = (2), _b = (n); i <= _b; i++) {
int fi;
scanf("%d", &fi);
ke[fi].push_back(i);
}
dfs1(1);
dfs2(1, -1);
for (int u = (1), _b = (n); u <= _b; u++) {
long long res = (f[0][u] + f[1][u]) * (g[0][u] + g[1][u]) % MOD;
printf("%d ", (int)res);
}
puts("");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using i32 = int;
using i64 = long long;
i32 main() {
std::ios::sync_with_stdio(false);
std::cout.tie(nullptr);
std::cin.tie(nullptr);
i32 T;
std::cin >> T;
while (T--) {
i32 n;
std::cin >> n;
std::vector<i32> a(n);
for (i32 i = 0; i < n; i++) std::cin >> a[i];
std::vector<i32> ans;
auto flip = [&](i32 i) {
std::swap(a[i], a[i + 2]);
std::swap(a[i + 1], a[i + 2]);
ans.push_back(i + 1);
};
for (i32 i = 0; i + 2 < n; i++) {
i32 j = std::min_element(a.begin() + i, a.end()) - a.begin();
for (; 1 < j - i; j -= 2) flip(j - 2);
if (j - i == 1) {
flip(i);
flip(i);
}
}
if (a[n - 1] < a[n - 2]) {
i32 i = 1;
while (i + 2 < n && a[i - 1] != a[i]) i++;
if (i + 2 == n) {
if (a[n - 3] != a[n - 1]) {
std::cout << "-1\n";
continue;
}
flip(n - 3);
} else {
flip(i - 1);
flip(i - 1);
flip(i);
flip(i++);
for (; i + 2 < n; i++) {
flip(i);
flip(i);
}
}
}
assert(std::is_sorted(a.begin(), a.end()));
std::cout << ans.size() << "\n";
for (i32 i = 0; i < ans.size(); i++)
std::cout << ans[i] << " \n"[i + 1 == ans.size()];
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
if (s == "11") {
cout << 1 << endl;
} else if (s == "10") {
cout << 1 << endl;
} else if (s == "0") {
cout << 0 << endl;
} else if (s == "1") {
cout << 0 << endl;
} else {
long long sb = 0;
long long n = s.length();
for (long long i = 0; i < n; i++)
if (s[i] == '1') sb++;
long long ans = n / 2;
if (sb > 1 && n % 2) ans++;
cout << ans << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int ans = 1;
int range = a[n - 1];
for (int i = n - 2; i >= 0; i--) {
if (range > 0) {
range--;
range = max(range, a[i]);
} else {
ans++;
range = a[i];
}
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
int t = 1;
while (t--) {
solve();
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<string> ass;
char tbf[1010];
int main(void) {
int len;
string mn;
cin >> len >> mn;
mn += mn;
for (int bg = 0; bg < len; bg++) {
int dlt = mn[bg] - '0';
for (int i = 0; i < len; i++) {
char tmp = mn[bg + i] - dlt;
if (tmp < '0') tmp += 10;
tbf[i] = tmp;
}
tbf[len] = 0;
ass.push_back(string(tbf));
}
sort(ass.begin(), ass.end());
cout << ass[0];
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, s, d, c, sweets = -1;
scanf("%d %d", &n, &s);
for (int i = 0; i < n; ++i) {
scanf("%d %d", &d, &c);
if (d < s && c) {
if (100 - c > sweets) sweets = 100 - c;
} else if (d <= s && !c) {
if (sweets == -1) sweets = 0;
}
}
printf("%d\n", sweets);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long ton(long long x) {
long long ret1 = 0, ret2 = 0;
while (x != 1) {
ret1 *= 10;
if (x % 2)
ret1 += 7;
else
ret1 += 4;
x /= 2;
}
while (ret1) {
ret2 *= 10;
ret2 += ret1 % 10;
ret1 /= 10;
}
return ret2;
}
signed main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
long long r, l;
cin >> l >> r;
long long sum = 0;
long long pre = l - 1;
for (long long i = 2; i < 1 << 11; i++) {
long long now = ton(i);
if (l <= now && now <= r) {
sum += now * (now - pre);
pre = now;
} else {
if (now < l) {
pre = l - 1;
} else {
if (pre != r) sum += now * (r - pre);
break;
}
}
}
cout << sum << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char s[101], t[101];
cin >> s;
cin >> t;
int n = strlen(s);
int aux1;
for (int i = n - 1; i >= 0; i--) {
if (s[i] == 'z') {
s[i] = 'a';
} else {
s[i] = s[i] + 1;
break;
}
}
if (strcmp(s, t) == -1) {
cout << s << endl;
} else {
cout << "No such string" << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int mas[1000];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> mas[i];
}
bool e = 1;
int d;
for (int i = 1; i < n; i++) {
if (i == 1)
d = mas[i] - mas[i - 1];
else if (d != mas[i] - mas[i - 1])
e = 0;
}
if (e)
cout << mas[n - 1] + d;
else
cout << mas[n - 1];
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void length(vector<int> &A, int n) {
while (n) {
A.push_back(n % 10);
n = n / 10;
}
int l = A.size();
for (int i = 0; i < l / 2; i++) {
int t = A[i];
A[i] = A[l - 1 - i];
A[l - i - 1] = t;
}
return;
}
void find(int n) {
vector<int> Arr;
length(Arr, n);
int l = Arr.size();
int a = 0;
for (int i = 0; i < l; i += 2) {
a = a * 10 + Arr[i];
}
int b = 0;
for (int i = 1; i < l; i += 2) {
b = b * 10 + Arr[i];
}
cout << ((a + 1) * (b + 1) - 2);
cout << "\n";
return;
}
int main() {
int t;
cin >> t;
for (int i = 0; i < t; i++) {
int n;
cin >> n;
find(n);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
struct Edge {
int x, y, second, idx;
bool operator<(const Edge &ot) const { return second < ot.second; }
} E[200002], nonMST[200002];
vector<int> V[200002];
bool onMst[200002];
pair<int, int> anc[200002][20];
int M, r, f[200002], lev[200002], Idx[200002];
int ans[200002];
int root(int x) {
if (!f[x]) return x;
return f[x] = root(f[x]);
}
void findMST() {
for (int i = 1; i <= m; ++i)
if (root(E[i].x) != root(E[i].y)) {
onMst[E[i].idx] = i;
f[root(E[i].y)] = root(E[i].x);
V[E[i].x].push_back(E[i].y);
V[E[i].y].push_back(E[i].x);
} else
nonMST[++M] = E[i];
lev[r = 1] = 1;
}
void dfs(int nod) {
for (int son : V[nod])
if (!lev[son]) {
lev[son] = lev[nod] + 1;
dfs(son);
}
}
void compAnc() {
dfs(1);
for (int i = 1; i <= m; ++i)
if (onMst[E[i].idx]) {
if (lev[E[i].x] > lev[E[i].y]) swap(E[i].x, E[i].y);
anc[E[i].y][0] = {E[i].x, E[i].second};
Idx[E[i].y] = E[i].idx;
}
for (int j = 1; j < 20; ++j)
for (int i = 1; i <= n; ++i)
anc[i][j] = pair<int, int>{
anc[anc[i][j - 1].first][j - 1].first,
max(anc[i][j - 1].second, anc[anc[i][j - 1].first][j - 1].second)};
}
int maxWPath(int x, int y) {
if (lev[y] > lev[x]) swap(x, y);
int lift = lev[x] - lev[y], ret = 0;
for (int i = 0; (1 << i) <= lift; ++i)
if (lift & (1 << i)) {
ret = max(ret, anc[x][i].second);
x = anc[x][i].first;
}
for (int i = 20 - 1; i >= 0; --i)
if (anc[x][i].first != anc[y][i].first) {
ret = max(ret, max(anc[x][i].second, anc[y][i].second));
x = anc[x][i].first;
y = anc[y][i].first;
}
if (x == y) return ret;
ret = max(ret, max(anc[x][0].second, anc[y][0].second));
return ret;
}
void compAns() {
memset(f, 0, sizeof(f));
for (int i = 1; i <= M; ++i) {
int x = nonMST[i].x, y = nonMST[i].y;
ans[nonMST[i].idx] = maxWPath(x, y) - 1;
while (x != y) {
if (lev[x] < lev[y]) swap(x, y);
if (!f[x]) {
f[x] = anc[x][0].first;
ans[Idx[x]] = nonMST[i].second - 1;
}
x = root(x);
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; ++i) {
scanf("%d%d%d", &E[i].x, &E[i].y, &E[i].second);
E[i].idx = i;
ans[i] = -1;
}
sort(E + 1, E + m + 1);
findMST();
compAnc();
compAns();
for (int i = 1; i <= m; ++i) printf("%d ", ans[i]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long nn = 1000000007;
const int MAXN = 1e6 + 239;
vector<int> prime;
bool is_composite[MAXN];
void sieve(int n) {
fill(is_composite, is_composite + n, false);
for (int i = 2; i < n; ++i) {
if (!is_composite[i]) prime.push_back(i);
for (int j = 0; j < prime.size() && i * prime[j] < n; ++j) {
is_composite[i * prime[j]] = true;
if (i % prime[j] == 0) break;
}
}
}
int gcd(int a, int b) {
if (b == 0) {
return a;
} else {
return gcd(b, a % b);
}
}
long long moduloMultiplication(long long a, long long b, long long m) {
long long res = 0;
a %= m;
while (b) {
if (b & 1) res = (res + a) % m;
a = (2 * a) % m;
b >>= 1;
}
return res;
}
long long mod(long long a, long long b, long long m) {
long long res = 1LL;
while (b) {
if (b & 1) {
res = moduloMultiplication(res, a, m) % m;
}
a = moduloMultiplication(a, a, m) % m;
b /= 2;
}
return res;
}
long long modular_inverse(long long n, long long c) { return mod(n, c - 2, c); }
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
while (n--) {
string s;
cin >> s;
int l = 0, u = 0, d = 0;
for (int i = 0; i < s.length(); i++) {
if (islower(s[i]))
l++;
else if (isupper(s[i]))
u++;
else if (isdigit(s[i]))
d++;
}
int m = s.length();
if (l == 0) {
int j = n - 1;
if (u == 1 && isupper(s[m - 1])) {
if (d == 1 && isdigit(s[m - 2])) {
s[m - 3] = 'z';
} else {
s[m - 2] = 'z';
}
} else {
if (d == 1 && isdigit(s[m - 1])) {
s[m - 2] = 'z';
} else {
s[m - 1] = 'z';
}
}
l++;
}
if (u == 0) {
int j = n - 1;
if (l == 1 && islower(s[m - 1])) {
if (d == 1 && isdigit(s[m - 2])) {
s[m - 3] = 'Z';
} else {
s[m - 2] = 'Z';
}
} else {
if (d == 1 && isdigit(s[m - 1])) {
s[m - 2] = 'Z';
} else {
s[m - 1] = 'Z';
}
}
u++;
}
if (d == 0) {
int j = n - 1;
if (u == 1 && isupper(s[m - 1])) {
if (l == 1 && islower(s[m - 2])) {
s[m - 3] = '9';
} else {
s[m - 2] = '9';
}
} else {
if (l == 1 && islower(s[m - 1])) {
s[m - 2] = '9';
} else {
s[m - 1] = '9';
}
}
d++;
}
cout << s << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
double x1, yy1, x2, y2, vx, vy, wx, wy, vmax, t;
int main() {
int c = 500;
scanf("%lf%lf%lf%lf", &x1, &yy1, &x2, &y2);
scanf("%lf%lf", &vmax, &t);
scanf("%lf%lf%lf%lf", &vx, &vy, &wx, &wy);
double xx = x2 - x1, yy = y2 - yy1, x = xx - t * vx, y = yy - t * vy;
double dis = sqrt(x * x + y * y);
double l, r, mid;
if (dis / vmax <= t) {
l = 0, r = t;
while (c--) {
mid = (l + r) / 2;
x = xx - mid * vx;
y = yy - mid * vy;
dis = sqrt(x * x + y * y);
if (dis / vmax <= mid)
r = mid;
else
l = mid;
}
} else {
xx -= t * vx;
yy -= t * vy;
l = 0;
r = 1e10;
while (c--) {
mid = (l + r) / 2;
x = xx - (mid - t) * wx;
y = yy - (mid - t) * wy;
dis = sqrt(x * x + y * y);
if (dis / vmax <= mid)
r = mid;
else
l = mid;
}
}
printf("%.20lf\n", l);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
ifstream fin("input.txt");
ofstream fout("output.txt");
bool isPrime(int x) {
if (x <= 4 || x % 2 == 0 || x % 3 == 0) return x == 2 || x == 3;
for (int i = 5; i * i <= x; i += 6)
if (x % i == 0 || x % (i + 2) == 0) return 0;
return 1;
}
inline void boostIO() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int main() {
boostIO();
long long int T;
cin >> T;
for (int i = 0; i < (T); ++i) {
long long int n;
cin >> n;
map<long long int, long long int> Map;
vector<long double> A;
for (int i = 0; i < (n); ++i) {
long long int x;
cin >> x;
Map[x]++;
if (Map[x] % 2 == 0) {
A.push_back(x);
}
}
long long int Prev = -1;
long long int a = -1;
long long int b = -1;
long double Min = numeric_limits<long double>::max();
sort(A.begin(), A.end());
for (int i = 0; i < (A.size()); ++i) {
if (Prev == -1) {
Prev = A[i];
continue;
}
long double w = ((A[i] + Prev) * 2) * ((A[i] + Prev) * 2) / (A[i] * Prev);
if (Min >= w) {
Min = w;
a = Prev;
b = A[i];
if (a == b) break;
}
Prev = A[i];
}
cout << a << " " << a << " " << b << " " << b << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
typedef struct Map {
char map[30][30];
unsigned int w, h;
bool operator<(Map& m) {
unsigned int minw = w < m.w ? w : m.w;
unsigned int minh = h < m.h ? h : m.h;
for (unsigned int(i) = 0; i < (minh); (i)++) {
for (unsigned int(j) = 0; j < (minw); (j)++) {
if (map[i][j] != m.map[i][j]) return map[i][j] < m.map[i][j];
}
if (w < m.w) return true;
if (w > m.w) return false;
}
return false;
}
void Print() {
for (unsigned int(i) = 0; i < (h); (i)++) {
for (unsigned int(j) = 0; j < (w); (j)++) cout << map[i][j];
cout << endl;
}
}
void Clear() {
for (unsigned int(i) = 0; i < (h); (i)++)
for (unsigned int(j) = 0; j < (w); (j)++) map[i][j] = '.';
}
} Map;
string temp, words[6];
char keyPoints[2][7] = {0};
Map m1, m2, *final = &m1, *candidate = &m2;
bool canSolve = false;
void SetToCandidate() {
candidate->Clear();
for (unsigned int(i) = 0; i < (words[0].length()); (i)++)
candidate->map[i][0] = words[0][i];
for (unsigned int(i) = 0; i < (words[1].length()); (i)++)
candidate->map[0][i] = words[1][i];
for (unsigned int(i) = 0; i < (words[2].length()); (i)++)
candidate->map[i][words[1].length() - 1] = words[2][i];
for (unsigned int(i) = 0; i < (words[3].length()); (i)++)
candidate->map[words[0].length() - 1][i] = words[3][i];
for (unsigned int i = 0, j = words[1].length() - 1; i < words[4].length();
i++, j++)
candidate->map[words[2].length() - 1][j] = words[4][i];
for (unsigned int i = 0, j = words[0].length() - 1; i < words[5].length();
i++, j++)
candidate->map[j][words[3].length() - 1] = words[5][i];
candidate->w = words[3].length();
candidate->h = words[2].length();
}
void Check() {
if (words[0].length() > words[2].length() ||
words[5].length() > words[2].length() ||
(words[0].length() + words[5].length() - 1) != words[2].length() ||
words[1].length() > words[3].length() ||
words[4].length() > words[3].length() ||
(words[1].length() + words[4].length() - 1) != words[3].length())
return;
if (words[0][0] == words[1][0] &&
words[0][words[0].length() - 1] == words[3][0] &&
words[1][words[1].length() - 1] == words[2][0] &&
words[2][words[0].length() - 1] == words[3][words[1].length() - 1] &&
words[2][words[2].length() - 1] == words[4][0] &&
words[3][words[3].length() - 1] == words[5][0] &&
words[4][words[4].length() - 1] == words[5][words[5].length() - 1]) {
SetToCandidate();
if (*candidate < *final) {
Map* t = candidate;
candidate = final;
final = t;
canSolve = true;
}
}
}
void Permutation(int l, int r) {
if (l + 1 < r) {
Permutation(l + 1, r);
for (int i = l + 1; i < r; i++) {
temp = words[l];
words[l] = words[i];
words[i] = temp;
Permutation(l + 1, r);
temp = words[l];
words[l] = words[i];
words[i] = temp;
}
} else {
Check();
}
}
int main() {
for (unsigned int(i) = 0; i < (30); (i)++)
for (unsigned int(j) = 0; j < (30); (j)++) m1.map[i][j] = 123;
m1.w = m1.h = 30;
for (unsigned int(i) = 0; i < (30); (i)++)
for (unsigned int(j) = 0; j < (30); (j)++) m2.map[i][j] = '.';
for (unsigned int(i) = 0; i < (6); (i)++) cin >> words[i];
Permutation(0, 6);
if (canSolve)
final->Print();
else
cout << "Impossible" << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
const int maxn = 2e3 + 100;
string s;
long long dp[maxn][maxn] = {0};
int num[maxn] = {0};
long long qmod(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % mod;
b >>= 1;
a = a * a % mod;
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> s;
int len = s.length();
for (int i = 1; i <= len; ++i) {
num[i] = num[i - 1];
if (s[i - 1] == '?') {
++num[i];
}
}
for (int i = 1; i <= len; ++i) {
for (int j = 0; j + i < len; ++j) {
int l = j, r = i + j;
if (s[l] != '(') {
dp[l][r] = (dp[l][r] + dp[l + 1][r]) % mod;
}
if (s[r] != ')') {
dp[l][r] = (dp[l][r] + dp[l][r - 1]) % mod;
}
if (s[l] != '(' && s[r] != ')') {
dp[l][r] = (dp[l][r] - dp[l + 1][r - 1] + mod) % mod;
}
if (s[l] != ')' && s[r] != '(') {
dp[l][r] =
(dp[l][r] + dp[l + 1][r - 1] + qmod(2, num[r] - num[l + 1])) % mod;
}
}
}
cout << dp[0][len - 1] << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, a[1003][1003];
long long sumx[1003][1003], sumy[1003][1003];
long long ansx = 1e18, x, ansy = 1e18, y;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> a[i][j];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) sumx[i][j] = a[i][j] + sumx[i][j - 1];
for (int j = 1; j <= m; j++)
for (int i = 1; i <= n; i++) sumy[i][j] = a[i][j] + sumy[i - 1][j];
for (int i = 0; i <= n; i++) {
long long X = (long long)i * 4;
long long g = 0;
for (int j = 1; j <= n; j++) {
long long tx = j * 4 - 2;
g += sumx[j][m] * (X - tx) * (X - tx);
}
if (g < ansx) {
ansx = g;
x = i;
}
}
for (int i = 0; i <= m; i++) {
long long Y = (long long)i * 4;
long long g = 0;
for (int j = 1; j <= m; j++) {
long long ty = j * 4 - 2;
g += sumy[n][j] * (Y - ty) * (Y - ty);
}
if (g < ansy) {
ansy = g;
y = i;
}
}
cout << ansx + ansy << endl;
cout << x << " " << y;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char a[108];
char b[108];
while (scanf("%s", &a) != EOF) {
int n, i;
n = strlen(a);
b[0] = a[0];
int j = 1, esp = 0;
for (i = 1; i < n; i++) {
if (a[i] == 'd' && a[i + 1] == 'o' && a[i + 2] == 't' && i + 2 < n - 1) {
b[j++] = '.';
i = i + 2;
} else if (a[i] == 'a' && a[i + 1] == 't' && i + 1 < n - 1 && esp == 0) {
esp = 1;
b[j++] = '@';
i = i + 1;
} else
b[j++] = a[i];
}
b[j] = '\0';
cout << b << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
bool flag = false;
int a[n + 1];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (int i = 1; i <= n; i++) {
if (i != a[i - 1]) {
cout << i;
flag = true;
break;
}
}
if (flag != true) {
cout << n + 1;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 5, M = 2e7;
int a[N], cd[N];
long long S[N];
int mu[N], ss[N], from[N], en[N];
int fj[M];
int n, oo, m, j, k, l, q;
bool bz[N], exi[N];
inline int max(int a, int b) { return a > b ? a : b; }
inline int read() {
int o = 0;
char ch = ' ';
for (; ch < '0' || ch > '9'; ch = getchar())
;
for (; ch >= '0' && ch <= '9'; ch = getchar()) o = o * 10 + ch - 48;
return o;
}
int main() {
cin >> n >> q;
int zd = 0;
for (int i = 1; i <= n; ++i) a[i] = read(), zd = max(zd, a[i]);
mu[1] = 1;
en[1] = 1;
fj[1] = 1;
for (int i = 2; i <= zd; ++i) {
if (!bz[i])
ss[++oo] = i, mu[i] = -1, en[i] = en[i - 1] + 2, fj[en[i] - 1] = 1,
fj[en[i]] = i, cd[i] = 1;
else {
int de = i / from[i], len = en[de] - en[de - 1], real = len / cd[i];
en[i] = en[i - 1] + len + real;
for (int l = 1; l <= len; ++l) fj[en[i - 1] + l] = fj[en[de - 1] + l];
for (register int le = en[i - 1] + len + 1, ri = en[de] - real + 1;
le <= en[i]; ++le, ++ri)
fj[le] = fj[ri] * from[i];
}
for (int j = 1; j <= oo; ++j) {
if (i * ss[j] > zd) break;
mu[ss[j] * i] = -mu[i];
cd[ss[j] * i] = 1;
from[i * ss[j]] = ss[j];
bz[i * ss[j]] = true;
if (i % ss[j] == 0) {
cd[i * ss[j]] = cd[i] + 1, mu[ss[j] * i] = 0;
break;
}
}
}
long long ans = 0;
for (int i = 1; i <= q; ++i) {
int wz = read(), posi = a[wz], zl, bh;
if (exi[wz] == false)
zl = bh = 1;
else
zl = bh = -1;
exi[wz] = !exi[wz];
if (zl < 0)
for (int l = en[posi - 1] + 1; l <= en[posi]; ++l) --S[fj[l]];
long long dq = 0;
for (int l = en[posi - 1] + 1; l <= en[posi]; ++l)
dq = dq + mu[fj[l]] * S[fj[l]];
if (zl > 0)
for (int l = en[posi - 1] + 1; l <= en[posi]; ++l) ++S[fj[l]];
if (bh > 0)
ans = ans + dq;
else
ans -= dq;
printf("%I64d\n", ans);
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, k, i, ck, j, x;
cin >> n >> m >> k;
long long p[n], s[n], c[k];
for (i = 0; i < n; i++) {
cin >> p[i];
}
for (i = 0; i < n; i++) {
cin >> s[i];
}
for (i = 0; i < k; i++) {
cin >> c[i];
}
for (i = 0, ck = 0; i < k; i++) {
x = s[c[i] - 1];
for (j = 0; j < n; j++) {
if (x == s[j]) {
if (p[j] > p[c[i] - 1]) {
ck++;
break;
}
}
}
}
cout << ck << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int Imx = 2147483647;
const long long Lbig = 2e18;
const int mod = 1e9 + 7;
struct fastio {
char s[100000];
int it, len;
fastio() { it = len = 0; }
inline char get() {
if (it < len) return s[it++];
it = 0;
len = fread(s, 1, 100000, stdin);
if (len == 0)
return EOF;
else
return s[it++];
}
bool notend() {
char c = get();
while (c == ' ' || c == '\n') c = get();
if (it > 0) it--;
return c != EOF;
}
} _buff;
inline long long getnum() {
long long r = 0;
bool ng = 0;
char c;
c = _buff.get();
while (c != '-' && (c < '0' || c > '9')) c = _buff.get();
if (c == '-') ng = 1, c = _buff.get();
while (c >= '0' && c <= '9') r = r * 10 + c - '0', c = _buff.get();
return ng ? -r : r;
}
template <class T>
inline void putnum(T x) {
if (x < 0) putchar('-'), x = -x;
register short a[20] = {}, sz = 0;
while (x) a[sz++] = x % 10, x /= 10;
if (sz == 0) putchar('0');
for (int i = sz - 1; i >= 0; i--) putchar('0' + a[i]);
}
inline char getreal() {
char c = _buff.get();
while (c <= 32) c = _buff.get();
return c;
}
long long qpow(long long x, long long k) {
return k == 0 ? 1 : qpow(x * x % mod, k >> 1) * (k & 1 ? x : 1) % mod;
}
long long K;
long long t[5011];
long long fac[5011], ifac[5011];
long long ffac[5011], inv[5011];
int n;
long long a[5011], dp[5011][5011];
long long f[5011], g[5011];
long long A, iA;
long long solve(int x) {
for (int i = 0; i <= n; i++) f[i] = dp[n][i];
for (int i = n; i >= 1; i--) {
g[i - 1] = f[i] * iA % mod;
f[i - 1] = (f[i - 1] - g[i - 1] * a[x] % mod + mod) % mod;
}
long long ret = 0;
for (int i = 0; i < n; i++) {
long long cur = ffac[i + 1] % mod * inv[i + 1] % mod * g[i] % mod;
ret += cur;
}
return ret % mod;
}
int main() {
fac[0] = 1;
for (int i = 1; i <= 5010; i++) fac[i] = fac[i - 1] * i % mod;
ifac[5010] = qpow(fac[5010], mod - 2);
for (int i = 5009; i >= 0; i--) ifac[i] = ifac[i + 1] * (i + 1) % mod;
for (int i = 1; i <= 5005; i++) inv[i] = qpow(i, mod - 2);
n = getnum(), K = getnum();
ffac[0] = 1;
for (int i = 1; i <= n + 1; i++)
ffac[i] = (ffac[i - 1] * (K - i + 1) % mod + mod) % mod;
for (int i = 1; i <= n; i++) a[i] = getnum();
A = (mod - qpow(n, mod - 2)) % mod;
iA = qpow(A, mod - 2);
dp[0][0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= i; j++) {
dp[i][j] = dp[i - 1][j] * a[i] % mod;
if (j > 0) dp[i][j] = (dp[i][j] + A * dp[i - 1][j - 1]) % mod;
}
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
ans += solve(i);
}
ans %= mod;
ans = ans * qpow(n, mod - 2) % mod;
cout << ans << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 10;
int p[N][25];
int a[N], num[N], vis[N];
void Init() {
for (int i = 0; i < N; ++i) p[i][0] = 0;
p[1][0] = 1;
p[1][1] = 1;
for (int i = 2; i < N; ++i)
if (!p[i][0]) {
for (int j = i; j < N; j += i) p[j][++p[j][0]] = i;
}
}
void update(int x, int f) {
int cnt = p[x][0];
for (int i = 1; i < (1 << cnt); ++i) {
int v = 1;
for (int j = 1; j <= cnt; ++j)
if (i & (1 << (j - 1))) {
v *= p[x][j];
}
if (f)
num[v]--;
else
num[v]++;
}
}
long long query(int x) {
int cnt = p[x][0], res = 0;
for (int i = 1; i < (1 << cnt); ++i) {
int g = 0, v = 1;
for (int j = 1; j <= cnt; ++j)
if (i & (1 << (j - 1))) {
v *= p[x][j];
++g;
}
if (g & 1)
res += num[v];
else
res -= num[v];
}
return res;
}
int main() {
int n, q;
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; ++i) scanf("%d", a + i);
memset(num, 0, sizeof num);
memset(vis, 0, sizeof vis);
Init();
long long ans = 0, tot = 0;
while (q--) {
int x;
scanf("%d", &x);
if (vis[x]) {
if (a[x] == 1) ans -= num[1] - 1;
ans -= (tot - query(a[x]));
update(a[x], 1);
vis[x] = 0;
tot--;
} else {
if (a[x] == 1) ans += num[1];
ans += (tot - query(a[x]));
vis[x] = 1;
update(a[x], 0);
tot++;
}
printf("%I64d\n", ans);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
const int N = 20005;
std::pair<int, int> p[N];
int a[N];
int n, ans[N];
std::pair<int, int> operator-(std::pair<int, int> a, std::pair<int, int> b) {
return std::pair<int, int>(a.first - b.first, a.second - b.second);
}
int operator*(std::pair<int, int> a, std::pair<int, int> b) {
return a.first * b.second - a.second * b.first;
}
int color(int first) { return first < n ? 1 : -1; }
void solve(int l, int r) {
if (l > r) return;
int pos = std::min_element(a + l, a + r + 1,
[](int a, int b) { return p[a] < p[b]; }) -
a;
std::swap(a[pos], a[r]);
std::sort(a + l, a + r, [&](int first, int second) {
return (p[first] - p[a[r]]) * (p[second] - p[a[r]]) > 0;
});
int now = 0;
for (int i = l; i < r; ++i) {
if (!now && color(a[i]) != color(a[r]))
return ans[std::min(a[r], a[i])] = std::max(a[r], a[i]) - n + 1,
solve(l, i - 1), solve(i + 1, r - 1);
now += color(a[i]);
}
assert(-1);
}
int main() {
std::ios::sync_with_stdio(0), std::cin.tie(0);
std::cin >> n;
for (int i = 0; i < n * 2; ++i)
std::cin >> p[i].first >> p[i].second, a[i] = i;
solve(0, n * 2 - 1);
for (int i = 0; i < n; ++i) std::cout << ans[i] << '\n';
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
map<int, int> m;
stack<int> s;
int n, arr[300005], item;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &arr[i]);
for (int i = n - 1; i >= 0; i--) s.push(arr[i]);
for (int i = 0; i < n; i++) {
int c = 0, item;
cin >> item;
if (m.find(item) != m.end())
printf("0 ");
else {
while (s.top() != item && !s.empty()) {
m[s.top()]++;
s.pop();
c++;
}
s.pop();
printf("%d ", c + 1);
}
}
cout << endl;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("O3")
#pragma GCC target("avx2")
using namespace std;
using namespace chrono;
void _print(long long t) { cerr << t; }
void _print(int t) { cerr << t; }
void _print(string t) { cerr << t; }
void _print(char t) { cerr << t; }
void _print(double t) { cerr << t; }
template <class T, class V>
void _print(pair<T, V> p) {
cerr << "{";
_print(p.first);
cerr << ", ";
_print(p.second);
cerr << "}";
}
template <class T>
void _print(vector<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << ", ";
}
cerr << "]";
}
template <class T>
void _print(set<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << ", ";
}
cerr << "]";
}
template <class T, class V>
void _print(map<T, V> v) {
cerr << "[ ";
for (auto i : v) {
_print(i);
cerr << ", ";
}
cerr << "]";
}
template <class T>
void _print(multiset<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << ", ";
}
cerr << "]";
}
template <class T>
ostream& operator<<(ostream& os, vector<T> a) {
for (auto x : a) {
os << x << " ";
}
return os;
}
template <class T>
ostream& operator<<(ostream& os, set<T> a) {
for (auto x : a) {
os << x << " ";
}
return os;
}
template <class T>
ostream& operator<<(ostream& os, multiset<T> a) {
for (auto x : a) {
os << x << " ";
}
return os;
}
template <class T, class Q>
ostream& operator<<(ostream& os, pair<T, Q> a) {
os << "| ";
os << a.first << ", " << a.second << " ";
return os << "|";
}
template <class P, class Q, class T>
ostream& operator<<(ostream& os, tuple<P, Q, T> a) {
os << "| " << (get<0>(a)) << ", " << (get<1>(a)) << ", " << (get<2>(a))
<< "|";
return os;
}
void solve() {
long long x, y;
cin >> x >> y;
if (y < x) {
cout << x + y << "\n";
return;
}
if (y % x == 0) {
cout << x << "\n";
return;
}
long long d = y / x - 1;
long long n;
if (d > 1) {
long long z = (y - d * x) / 2;
n = y - z;
cout << n << "\n";
} else {
n = (y + x) / 2;
cout << (y + x) / 2 << "\n";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
cin >> t;
auto start1 = high_resolution_clock::now();
while (t--) {
solve();
}
auto stop1 = high_resolution_clock::now();
auto duration = duration_cast<milliseconds>(stop1 - start1);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[505];
double ans;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
while (m--) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
ans = max(ans, 1.0 * (a[u] + a[v]) / w);
}
printf("%.9lf\n", ans);
}
| 4 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
const int maxn = 100010;
int a[maxn], b[maxn];
int dp[333];
vector<int> point[maxn];
int main() {
int n, m, s, e;
scanf("%d%d%d%d", &n, &m, &s, &e);
memset(dp, 0x3f, sizeof(dp));
dp[0] = 0;
for (int i = 0; i < maxn; i++) point[i].clear();
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < m; i++) scanf("%d", &b[i]), point[b[i]].push_back(i + 1);
int ans = 0;
for (int i = 0; i < n; ++i) {
for (int j = s / e; j >= 0; j--) {
vector<int>::iterator it =
upper_bound(point[a[i]].begin(), point[a[i]].end(), dp[j]);
if (it == point[a[i]].end()) continue;
dp[j + 1] = min(*it, dp[j + 1]);
if (i + 1 + dp[j + 1] + (j + 1) * e <= s)
ans = (ans > j + 1) ? ans : j + 1;
}
}
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int grand(int x) { return uniform_int_distribution<int>(0, x - 1)(rng); }
const int maxn = 1e6 + 7;
const long long inf = 1e9 + 7;
const long long mod = 1e9 + 7;
long long gcd(long long x, long long y) {
if (x < y) return gcd(y, x);
if (y == 0) return x;
return gcd(y, x % y);
}
long long b[maxn];
int main() {
{
ios ::sync_with_stdio(false);
cin.tie(0);
};
int n, m, k;
cin >> n >> m >> k;
for (int j = 1; j <= n; j++) cin >> b[j];
long long ans = n;
vector<long long> v;
for (int j = 1; j < n; j++) {
v.push_back(b[j + 1] - b[j] - 1);
}
sort(v.begin(), v.end());
for (int j = 0; j < (n - k); j++) ans += v[j];
cout << ans << "\n";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v1, v2;
long long a[5005][5005], b[100005];
bool r[5005], c[5005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long i, j, n, m, k, x, y;
cin >> n >> m >> k;
memset(r, 0, sizeof(r));
memset(c, 0, sizeof(c));
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
a[i][j] = 0;
}
}
for (i = 0; i < k; i++) {
cin >> x >> y >> b[i];
v1.push_back(x);
v2.push_back(y);
}
for (i = k - 1; i >= 0; i--) {
if (v1[i] == 1) {
if (r[v2[i]] == 0) {
for (j = 1; j <= m; j++) {
if (a[v2[i]][j] == 0) a[v2[i]][j] = b[i];
}
r[v2[i]] = 1;
}
} else {
if (c[v2[i]] == 0) {
for (j = 1; j <= n; j++) {
if (a[j][v2[i]] == 0) a[j][v2[i]] = b[i];
}
c[v2[i]] = 1;
}
}
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) cout << a[i][j] << " ";
cout << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline void Min(int &a, int b) {
if (a > b) a = b;
}
char s1[55], s2[55];
vector<int> p1[55][26], p2[55][26];
vector<pair<int, int> > mp[26];
bool v[55][55][26];
int dp[55][55];
int main() {
scanf("%s%s", s1, s2);
int l1 = strlen(s1), l2 = strlen(s2);
int m;
scanf("%d", &m);
while (m--) {
char s[10];
scanf("%s", s);
mp[s[0] - 'a'].push_back(make_pair(s[3] - 'a', s[4] - 'a'));
}
for (int i = 0; i <= l1 - 1; i++) v[i][i][s1[i] - 'a'] = 1;
for (int i = l1 - 2; i >= 0; i--)
for (int j = i + 1; j <= l1 - 1; j++) {
for (int k = i; k <= j - 1; k++)
for (int p = 0; p <= 25; p++)
for (int t = 0; t <= (int)mp[p].size() - 1; t++) {
pair<int, int> tmp = mp[p][t];
v[i][j][p] |= v[i][k][tmp.first] & v[k + 1][j][tmp.second];
}
}
for (int i = 0; i <= l1 - 1; i++)
for (int j = i; j <= l1 - 1; j++)
for (int k = 0; k <= 25; k++)
if (v[i][j][k]) p1[i][k].push_back(j);
memset(v, 0, sizeof(v));
for (int i = 0; i <= l2 - 1; i++) v[i][i][s2[i] - 'a'] = 1;
for (int i = l2 - 2; i >= 0; i--)
for (int j = i + 1; j <= l2 - 1; j++) {
for (int k = i; k <= j - 1; k++)
for (int p = 0; p <= 25; p++)
for (int t = 0; t <= (int)mp[p].size() - 1; t++) {
pair<int, int> tmp = mp[p][t];
v[i][j][p] |= v[i][k][tmp.first] & v[k + 1][j][tmp.second];
}
}
for (int i = 0; i <= l2 - 1; i++)
for (int j = i; j <= l2 - 1; j++)
for (int k = 0; k <= 25; k++)
if (v[i][j][k]) p2[i][k].push_back(j);
memset(dp, 0x7f, sizeof(dp));
dp[0][0] = 0;
for (int i = 0; i <= l1 - 1; i++)
for (int j = 0; j <= l2 - 1; j++) {
for (int p = 0; p <= 25; p++)
for (int k1 = 0; k1 <= (int)p1[i][p].size() - 1; k1++)
for (int k2 = 0; k2 <= (int)p2[j][p].size() - 1; k2++)
Min(dp[p1[i][p][k1] + 1][p2[j][p][k2] + 1], dp[i][j] + 1);
}
printf("%d\n", dp[l1][l2] == 0x7f7f7f7f ? -1 : dp[l1][l2]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m, sum, a[5005], q[5005];
long long dp[5005][5005], s[5005];
struct node {
int x, y;
} b[5005];
bool cmp(node u, node v) { return u.x < v.x; }
int main() {
scanf("%d%d", &n, &m);
int i, j, head, tail;
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + n + 1);
for (i = 1; i <= m; i++) {
scanf("%d%d", &b[i].x, &b[i].y);
sum += b[i].y;
}
if (sum < n) {
puts("-1");
return 0;
}
sort(b + 1, b + m + 1, cmp);
for (i = 1; i <= n; i++) dp[0][i] = 1000000000000000000ll;
for (i = 1; i <= m; i++) {
for (j = 1; j <= n; j++) s[j] = s[j - 1] + abs(b[i].x - a[j]);
head = 1;
tail = 0;
for (j = 0; j <= n; j++) {
if (head <= tail && q[head] < j - b[i].y) head++;
while (head <= tail &&
dp[i - 1][j] - s[j] <= dp[i - 1][q[tail]] - s[q[tail]])
tail--;
q[++tail] = j;
if (head <= tail)
dp[i][j] = dp[i - 1][q[head]] - s[q[head]] + s[j];
else
dp[i][j] = 1000000000000000000ll;
}
}
printf("%lld\n", dp[m][n]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, const char* argv[]) {
int n, maxIndex = 0, maxValu = 0;
bool maximed = true;
vector<pair<int, int> > data;
cin >> n;
int l, r;
int sumeR = 0, sumeL = 0;
for (int i = int(0); i < int(n); i++) {
cin >> l >> r;
data.push_back(pair<int, int>(l, r));
sumeL += l;
sumeR += r;
}
maxValu = abs(sumeL - sumeR);
int auxL, auxR;
for (int i = int(0); i < int(n); i++) {
auxL = sumeL;
auxR = sumeR;
l = data[i].first;
r = data[i].second;
sumeL = sumeL - l + r;
sumeR = sumeR - r + l;
if (abs(sumeL - sumeR) > maxValu) {
maximed = false;
maxIndex = i;
maxValu = abs(sumeL - sumeR);
}
sumeL = auxL;
sumeR = auxR;
}
if (maximed)
cout << 0 << endl;
else
cout << maxIndex + 1 << "\n";
return 0;
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.