text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int i, j, k, n, ans = 0;
cin >> n;
pair<long long int, long long int> a[n];
long long int b[n];
for (i = 0; i < n; i++) {
cin >> a[i].first;
a[i].second = i;
}
sort(a, a + n);
j = 1;
for (i = 0; i < n; i++) {
b[a[i].second] = max(a[i].first, j);
j = b[a[i].second] + 1;
}
for (i = 0; i < n; i++) cout << b[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, x;
vector<pair<int, int> > v;
int cont[400000];
int main(void) {
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> x;
v.push_back(make_pair(x, i));
}
memset(cont, 0, sizeof cont);
sort(v.begin(), v.end());
int cnt = v[0].first;
for (int i = 0; i < v.size(); ++i) {
cont[v[i].second] = max(cnt, v[i].first);
cnt = cont[v[i].second] + 1;
}
for (int i = 0; i < n; ++i) cout << cont[i] << " ";
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, i, j, mx;
pair<int, int> a[500000];
int ans[500000];
int main() {
cin >> n;
for (i = 0; i < n; ++i) {
cin >> a[i].first;
a[i].second = i;
}
sort(a, a + n);
mx = a[0].first - 1;
for (i = 0; i < n; ++i) {
ans[a[i].second] = max(mx, a[i].first);
mx = ans[a[i].second] + 1;
}
for (i = 0; i < n; ++i) cout << ans[i] << " ";
cin >> n;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct rek {
int a, nr;
rek(int _nr = 0, int _a = 0) : a(_a), nr(_nr) {}
bool operator<(const rek& x) const {
return a < x.a || (a == x.a && nr < x.nr);
}
} t[300000];
int res[300000];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int a;
scanf("%d", &a);
t[i] = rek(i, a);
}
sort(t, t + n);
int next = t[0].a;
int prev = t[0].a;
res[t[0].nr] = next++;
for (int i = 1; i < n; i++) {
if (t[i].a == prev) {
res[t[i].nr] = next++;
} else {
next = max(next, t[i].a);
res[t[i].nr] = next++;
prev = t[i].a;
}
}
for (int i = 0; i < n; i++) printf("%d ", res[i]);
printf("\n");
}
|
#include <bits/stdc++.h>
using namespace std;
unsigned long long min(unsigned long long x, unsigned long long y) {
if (x < y) return x;
return y;
}
unsigned long long max(unsigned long long x, unsigned long long y) {
if (x < y) return y;
return x;
}
long long min(long long x, long long y) {
if (x < y) return x;
return y;
}
long long max(long long x, long long y) {
if (x < y) return y;
return x;
}
double min(double x, double y) {
if (x < y) return x;
return y;
}
double max(double x, double y) {
if (x < y) return y;
return x;
}
unsigned long long gcd(unsigned long long x, unsigned long long y) {
if (!x) return y;
if (!y) return x;
if (x > y) swap(x, y);
return gcd(x, y % x);
}
unsigned long long inv(unsigned long long a, unsigned long long c) {
if (a == 1) {
return 1;
}
return ((c - (c / a)) * inv(c % a, c)) % c;
}
int n, a[300005] = {0}, idx[300005] = {0};
int comp(int x, int y) { return a[x] < a[y]; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
for (int i = 0; i < n; i++) {
idx[i] = i;
cin >> a[i];
}
sort(idx, idx + n, comp);
for (int i = 1; i < n; i++) {
if (a[idx[i]] <= a[idx[i - 1]]) {
a[idx[i]] = a[idx[i - 1]] + 1;
}
}
for (int i = 0; i < n; i++) {
cout << a[i] << " ";
}
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
pair<int, int> a[300010];
int res[300010];
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> a[i].first;
a[i].second = i;
}
sort(a + 1, a + n + 1);
int last = a[1].first;
res[a[1].second] = last;
for (long long i = 2; i <= n; i++) {
a[i].first = max(a[i].first, last + 1);
last = a[i].first;
res[a[i].second] = a[i].first;
}
for (long long i = 1; i <= n; i++) cout << res[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int x;
int i;
};
node a[300010];
int b[300010];
map<int, int> mp;
bool cmp(node p, node q) { return (p.x < q.x); }
int main() {
int x, y, i, j, n, k;
cin >> n;
for (i = 0; i < n; i++) {
cin >> a[i].x;
mp[a[i].x]++;
a[i].i = i;
}
sort(a, a + n, cmp);
for (i = 0, j = 1; i < n; i++) {
if (i == 0)
b[a[i].i] = a[i].x;
else if ((a[i].x == a[i - 1].x)) {
j = max(j, a[i].x + 1);
while (1) {
if (j <= a[i].x || mp[j] > 0) {
j++;
continue;
}
break;
}
b[a[i].i] = j;
mp[j]++;
} else {
b[a[i].i] = a[i].x;
}
}
for (i = 0; i < n; i++) cout << b[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
struct node {
int num, give, hao;
} p[300005];
bool cmp(node a, node b) { return a.num < b.num; }
bool cmp2(node a, node b) { return a.hao < b.hao; }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &p[i].num);
p[i].hao = i;
}
sort(p + 1, p + n + 1, cmp);
p[1].give = p[1].num;
for (int i = 2; i <= n; i++) {
if (p[i].num == p[i - 1].num || p[i].num <= p[i - 1].give)
p[i].give = p[i - 1].give + 1;
else if (p[i].num > p[i - 1].give)
p[i].give = p[i].num;
}
sort(p + 1, p + n + 1, cmp2);
for (int i = 1; i <= n; i++) printf("%d ", p[i].give);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e5 + 5;
const int INF = 2e9;
const int MOD = 2e4;
map<int, int> used;
pair<int, int> arr[MAXN];
int RES[MAXN];
int main() {
int N = 0;
scanf("%i", &N);
for (int i = 1; i <= N; i++) {
scanf("%i", &arr[i].first);
arr[i].second = i;
used[arr[i].first]++;
}
int curM = 0;
sort(arr + 1, arr + N + 1);
for (int i = 1; i <= N; i++) {
if (arr[i].first > curM) {
curM = arr[i].first + 1;
RES[arr[i].second] = arr[i].first;
} else {
RES[arr[i].second] = curM++;
}
}
for (int i = 1; i <= N; i++) printf("%i ", RES[i]);
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:20000000")
using namespace std;
int ri() {
int x;
scanf("%d", &x);
return x;
}
long long rll() {
long long x;
scanf("%lld", &x);
return x;
}
pair<int, int> mas[3 * 100500];
int res[3 * 100500];
void solve() {
int n = ri();
for (int i = (int)(1); i <= (int)(n); i++) mas[i] = make_pair(ri(), i);
sort(mas + 1, mas + 1 + n);
res[mas[1].second] = mas[1].first;
int r = mas[1].first + 1;
for (int i = (int)(2); i <= (int)(n); i++) {
if (r > mas[i].first)
res[mas[i].second] = r, r++;
else
res[mas[i].second] = mas[i].first, r = mas[i].first + 1;
}
for (int i = (int)(1); i <= (int)(n); i++) cout << res[i] << ' ';
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300006;
int a[N];
int b[N];
bool myfunc(int i, int j) { return a[i] < a[j] ? 1 : 0; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) b[i] = i;
sort(b, b + n, myfunc);
for (int i = 1; i < n; i++) {
if (a[b[i]] <= a[b[i - 1]]) a[b[i]] = a[b[i - 1]] + 1;
}
for (int i = 0; i < n; i++) cout << a[i] << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
struct num {
int a, b;
} arr[300010];
bool ca(struct num a, struct num b) { return (a.a < b.a); }
bool cb(struct num a, struct num b) { return (a.b < b.b); }
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i].a;
arr[i].b = i;
}
sort(arr, arr + n, ca);
int temp = 0;
temp = arr[0].a;
for (int i = 1; i < n; i++) {
if (arr[i].a <= temp) {
arr[i].a = temp + 1;
temp++;
} else {
temp = arr[i].a;
}
}
sort(arr, arr + n, cb);
for (int i = 0; i < n; i++) {
cout << arr[i].a << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
ifstream fin("A.in");
ofstream fout("A.out");
int nr, cnt, n;
int rat[300001];
vector<int> H[666013];
struct pr {
int x, i;
} a[300001];
bool cmp(pr a, pr b) { return a.x < b.x; }
bool sear(int x, pr X) {
int h = x % 666013;
for (vector<int>::iterator it = H[h].begin(); it != H[h].end(); ++it) {
if (*it == x) return 0;
}
rat[X.i] = x;
H[h].push_back(x);
return 1;
}
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i].x;
a[i].i = i;
}
sort(a + 1, a + n + 1, cmp);
int current = 0;
for (int i = 1; i <= n; ++i) {
current = max(current, a[i].x);
while (!sear(current, a[i])) {
++current;
}
++current;
}
for (int i = 1; i <= n; ++i) {
cout << rat[i] << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct user {
long long want, id;
};
bool cmp(const user& a, const user& b) { return a.want < b.want; }
int main() {
set<long long> used;
long long n;
cin >> n;
vector<user> ar(n);
vector<long long> ans(n);
for (long long i = 0; i < n; i++) {
cin >> ar[i].want;
ar[i].id = i;
}
sort(ar.begin(), ar.end(), cmp);
long long last = 0;
for (int i = 0; i < n; i++) {
if (ar[i].want > last) {
ans[ar[i].id] = ar[i].want;
last = ar[i].want;
} else {
last++;
ans[ar[i].id] = last;
}
}
for (int i = 0; i < n; i++) cout << ans[i] << ' ';
return 0;
}
|
#include <bits/stdc++.h>
int n, print[300001];
struct q {
int su, no;
bool operator()(q a, q b) { return a.su < b.su; }
} user[300001];
int main() {
int i, now = 0;
scanf("%d", &n);
for (i = 0; i < n; i++) {
user[i].no = i;
scanf("%d", &user[i].su);
}
std::sort(user, user + n, q());
for (i = 0; i < n; i++) {
if (user[i].su > now) now = user[i].su;
print[user[i].no] = now;
now++;
}
for (i = 0; i < n; i++) printf("%d ", print[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
long long num;
long long answer;
long long id;
};
int sf1(node a, node b) { return (a.num < b.num); }
int sf2(node a, node b) { return (a.id < b.id); }
int main() {
long long N;
cin >> N;
node *a = (node *)malloc(sizeof(node) * N);
long long i;
for (i = 0; i < N; i++) {
cin >> a[i].num;
a[i].id = i;
}
sort(a, a + N, sf1);
long long curr = a[0].num;
for (i = 0; i < N; i++) {
if (a[i].num <= curr) {
a[i].answer = curr;
curr++;
} else {
a[i].answer = a[i].num;
curr = a[i].num;
curr++;
}
}
sort(a, a + N, sf2);
for (i = 0; i < N; i++) {
cout << a[i].answer << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M;
int p[300005], rk[300005];
bool cmp(int a, int b) { return p[a] < p[b]; }
int main() {
int i, j;
scanf("%d", &N);
for (i = 1; i <= N; i++) scanf("%d", &p[i]), rk[i] = i;
sort(rk + 1, rk + 1 + N, cmp);
for (i = 1; i <= N; i++) p[rk[i]] = max(p[rk[i]], p[rk[i - 1]] + 1);
for (i = 1; i <= N; i++) printf("%d ", p[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef struct {
int num;
int index;
} p;
p arr[300001];
int ans[300001];
inline void fastread(int* a) {
register char c = 0;
while (c < 33) c = getchar();
*a = 0;
while (c > 33) {
*a = *a * 10 + c - '0';
c = getchar();
}
}
int cmp(p a, p b) { return a.num < b.num; }
int main() {
int n, i, add;
fastread(&n);
for (i = 0; i < n; i++) {
fastread(&arr[i].num);
arr[i].index = i;
}
sort(arr, arr + n, cmp);
add = 1;
for (i = 0; i < n; i++) {
if (add >= arr[i].num)
ans[arr[i].index] = add++;
else
add = arr[i].num + 1, ans[arr[i].index] = arr[i].num;
}
for (i = 0; i < n; i++) printf("%d ", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct xx {
int x, y, r;
};
vector<xx> a;
int n, r;
bool cmp(xx x, xx y) { return x.x < y.x; }
bool cmp2(xx x, xx y) { return x.y < y.y; }
int main() {
cin >> n;
a.resize(n);
for (int i = 0; i < n; i++) {
cin >> a[i].x;
a[i].y = i;
}
sort(a.begin(), a.end(), cmp);
r = 0;
for (int i = 0; i < n; i++) {
if (a[i].x > r)
r = a[i].x;
else
r++;
a[i].r = r;
}
sort(a.begin(), a.end(), cmp2);
for (int i = 0; i < n; i++) {
cout << a[i].r << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct data {
int x, y;
} v[300005];
inline bool cmp(data d1, data d2) {
if (d1.x != d2.x) return d1.x < d2.x;
return d1.y < d2.y;
}
inline bool cmp2(data d1, data d2) { return d1.y < d2.y; }
int n;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &v[i].x);
v[i].y = i;
}
sort(v + 1, v + n + 1, cmp);
int minv = 0;
for (int i = 1; i <= n; i++) {
if (minv < v[i].x) {
minv = v[i].x + 1;
} else {
v[i].x = minv;
minv++;
}
}
sort(v + 1, v + n + 1, cmp2);
for (int i = 1; i <= n; i++) printf("%d ", v[i].x);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
pair<long long, int> a[300005];
int b[300005];
int main() {
int n, i;
cin >> n;
for (i = 0; i < n; i++) {
cin >> a[i].first;
a[i].second = i;
}
sort(a, a + n);
for (i = 1; i < n; i++) {
if (a[i].first <= a[i - 1].first) a[i].first = a[i - 1].first + 1;
}
for (i = 0; i < n; i++) {
b[a[i].second] = a[i].first;
}
for (i = 0; i < n; i++) {
cout << b[i] << " ";
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n_users = 0;
cin >> n_users;
vector<long long int> wishes(n_users, 0);
map<long long int, long long int> rating;
for (long long int i = 0; i < n_users; i++) {
cin >> wishes[i];
if (rating[wishes[i]] == 0)
rating[wishes[i]] = wishes[i];
else
rating[wishes[i]] += 1;
}
long long int maxrating = 0;
for (map<long long int, long long int>::iterator it = rating.begin();
it != rating.end(); it++) {
it->second = max(maxrating + it->second - it->first + 1, it->second);
maxrating = it->second;
}
for (long long int i = 0; i < n_users; i++) {
cout << rating[wishes[i]] << ' ';
rating[wishes[i]] -= 1;
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct input {
int nilai;
int indeks;
};
struct comp {
bool operator()(input a, input b) {
if (a.nilai != b.nilai)
return a.nilai < b.nilai;
else
return a.indeks < b.indeks;
}
};
input data[300005];
int ans[300005];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int a;
scanf("%d", &a);
data[i].nilai = a;
data[i].indeks = i;
}
sort(data + 1, data + 1 + n, comp());
for (int i = 2; i <= n; i++) {
data[i].nilai = max(data[i].nilai, data[i - 1].nilai + 1);
}
for (int i = 1; i <= n; i++) {
ans[data[i].indeks] = data[i].nilai;
}
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long expo(long long a, long long b, long long m) {
long long result = 1;
while (b) {
if (b & 1) {
result = (result * a) % m;
}
b = (b >> 1) % m;
a = (a * a) % m;
}
return result;
}
double expof(double a, int b) {
double result = 1;
while (b) {
if (b & 1) {
result = (result * a);
}
b = (b >> 1);
a = (a * a);
}
return result;
}
bool comp(pair<long long, long long> a, pair<long long, long long> b) {
if (a.second < b.second) return true;
}
int good[8][8], visited[8][8];
void dfs(pair<int, int> a) {
int n = 8;
int dir[4][2] = {{1, 1}, {1, -1}, {-1, -1}, {-1, 1}};
int i = a.first, j = a.second;
visited[i][j] = 1;
for (int k = 0; k < 4; ++k) {
int dx = i + dir[k][0] * 2;
int dy = j + dir[k][1] * 2;
if (0 <= dx and dx < n and 0 <= dy and dy < n and !visited[dx][dy]) {
if (good[dx][dy]) good[dx][dy]++;
}
}
}
int main() {
long long n;
pair<long long, long long> a[300005];
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i].first;
a[i].second = i;
}
sort(a, a + n);
long long cur = a[0].first;
for (int i = 1; i < n; ++i) {
if (a[i].first <= cur) {
a[i].first = cur + 1;
cur = a[i].first;
} else
cur = a[i].first;
}
sort(a, a + n, comp);
for (int i = 0; i < n; ++i) {
cout << a[i].first << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct user {
int id;
int rating;
};
bool myfunction(user i, user j) { return (i.rating < j.rating); }
bool myfunction2(user i, user j) { return (i.id < j.id); }
int main(int argc, char** argv) {
int n = 0;
cin >> n;
if (n > 1) {
user arr[300001];
int sum = 0;
for (int i = 0; i < n; i++) {
arr[i].id = i;
cin >> arr[i].rating;
sum += arr[i].rating;
}
std::sort(arr, arr + n, myfunction);
for (int i = 1; i < n; i++) {
if (arr[i].rating <= arr[i - 1].rating)
arr[i].rating = arr[i - 1].rating + 1;
}
std::sort(arr, arr + n, myfunction2);
cout << arr[0].rating;
for (int i = 1; i < n; i++) cout << " " << arr[i].rating;
cout << endl;
} else {
int te = 0;
cin >> te;
cout << te << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool sortbysec(const pair<int, int> &a, const pair<int, int> &b) {
return (a.second < b.second);
}
long long i, j;
long long prime_flag[1000000];
void calculate_prime_flag() {
prime_flag[0] = prime_flag[1] = 1;
for (i = 2; i < 1000000; i++) {
if (prime_flag[i] == 0) {
for (j = i * i; j < 1000000; j += i) {
prime_flag[j] = 1;
}
}
}
}
int LPS(char *str) {
int n = strlen(str);
int i, j, cl;
int l[n][n];
for (i = 0; i < n; i++) l[i][i] = 1;
for (cl = 2; cl <= n; cl++) {
for (i = 0; i < n - cl + 1; i++) {
j = i + cl - 1;
if (str[i] == str[j] && cl == 2)
l[i][j] = 2;
else if (str[i] == str[j])
l[i][j] = l[i + 1][j - 1] + 2;
else
l[i][j] = max(l[i][j - 1], l[i + 1][j]);
}
}
return l[0][n - 1];
}
int gcd(int a, int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
int findGCD(int arr[], int n) {
int result = arr[0];
for (int i = 1; i < n; i++) result = gcd(arr[i], result);
return result;
}
bool prime(int s) {
for (int i = 2; i <= sqrt(s); i++) {
if ((s % i) != 0)
return true;
else
return false;
}
}
int myXOR(int x, int y) {
int res = 0;
for (int i = 31; i >= 0; i--) {
bool b1 = x & (1 << i);
bool b2 = y & (1 << i);
bool xoredBit = (b1 & b2) ? 0 : (b1 | b2);
res <<= 1;
res |= xoredBit;
}
return res;
}
void SieveOfEratosthenes(int z, int n) {
bool prime[n + 1];
memset(prime, true, sizeof(prime));
for (int p = 2; p * p <= n; p++) {
if (prime[p] == true) {
for (int i = p * p; i <= n; i += p) prime[i] = false;
}
}
for (int p = z; p <= n; p++)
if (prime[p]) cout << p << " ";
}
int main() {
long long n;
cin >> n;
long long x;
vector<pair<long long, long long>> a;
for (int i = 0; i < n; i++) {
cin >> x;
a.push_back({x, i});
}
sort(a.begin(), a.end());
map<long long, long long> mp;
for (int i = 0; i < n; i++) {
if (mp[a[i].first] == 0)
mp[a[i].first]++;
else {
a[i].first = a[i - 1].first + 1;
mp[a[i].first]++;
}
}
sort(a.begin(), a.end(), sortbysec);
for (int i = 0; i < n; i++) cout << a[i].first << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vl = vector<ll>;
const int INF = 0x3f3f3f3f;
template <class K, class V>
ostream& operator<<(ostream& out, const pair<K, V>& v) {
out << '(' << v.first << ',' << v.second << ')';
return out;
}
template <class C, class = typename C::iterator>
struct _cprint {
using type = void;
};
template <>
struct _cprint<string> {};
template <class C, class = typename _cprint<C>::type>
ostream& operator<<(ostream& out, const C& v) {
for (auto x : v) out << x << ' ';
return out;
}
template <class C>
inline void chmax(C& x, const C& a) {
if (x < a) x = a;
}
template <class C>
inline void chmin(C& x, const C& a) {
if (x > a) x = a;
}
template <class C>
inline C mod(C a, C b) {
return (a % b + b) % b;
}
int n;
vi a;
vi b;
int main() {
cin >> n;
a = b = vi(n);
for (int i = 0; i < n; i++) cin >> a[i];
vector<pair<int, int>> tmp;
for (int i = 0; i < n; i++) tmp.emplace_back(a[i], i);
sort((tmp).begin(), (tmp).end());
int cur = 0;
for (int i = 0; i < n; i++) {
if (cur <= tmp[i].first) {
b[tmp[i].second] = tmp[i].first;
cur = tmp[i].first + 1;
} else {
b[tmp[i].second] = cur;
cur++;
}
}
cout << b << endl;
}
|
#include <bits/stdc++.h>
long a[400000][2];
int comp1(const void *a, const void *b) {
long t;
t = ((long *)a)[0] - ((long *)b)[0];
if (t > 0) {
return 1;
} else if (t == 0) {
return 0;
} else {
return -1;
}
}
int comp2(const void *a, const void *b) {
long t;
t = ((long *)a)[1] - ((long *)b)[1];
if (t > 0) {
return 1;
} else if (t == 0) {
return 0;
} else {
return -1;
}
}
int main() {
long i, k, n;
scanf("%ld", &n);
for (i = 0; i < n; i++) {
scanf("%ld", &a[i][0]);
a[i][1] = i;
}
qsort(a, n, sizeof(long) * 2, comp1);
for (i = 0, k = -1; i < n; i++) {
if (a[i][0] <= k) {
a[i][0] = k + 1;
k++;
} else {
k = a[i][0];
}
}
qsort(a, n, sizeof(long) * 2, comp2);
printf("%ld", a[0][0]);
for (i = 1; i < n; i++) {
printf(" %ld", a[i][0]);
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3228;
const int MOD = 1000 * 1000 * 1000 + 7;
void solve() {
int n;
cin >> n;
vector<pair<int, int> > rating(n);
for (int i = 0; i < n; ++i) {
int r;
cin >> r;
rating[i].first = r;
rating[i].second = i;
}
sort(rating.begin(), rating.end());
vector<int> ans(n);
ans[rating[0].second] = rating[0].first;
for (int i = 1; i < n; ++i) {
rating[i].first = max(rating[i].first, rating[i - 1].first + 1);
ans[rating[i].second] = rating[i].first;
}
for (int i = 0; i < n; ++i) {
cout << ans[i] << " ";
}
cout << "\n";
}
int main() {
double tt = clock();
cout.tie(nullptr);
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
solve();
return 0;
}
|
#include <bits/stdc++.h>
const int OO = (long long)2e9;
const double eps = 1e-9;
const long long MAX = 300001;
const long long MOD = 1000000007;
using namespace std;
long long n, Min;
pair<long long, long long> arr[MAX], tmp[MAX];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = (0); i < (n); ++i) {
cin >> arr[i].first;
arr[i].second = i;
}
sort(arr, arr + n);
Min = arr[0].first;
for (int i = (0); i < (n); ++i) {
arr[i].first = max(Min, arr[i].first);
Min = (max(Min, arr[i].first)) + 1;
}
for (int i = (0); i < (n); ++i) {
tmp[i].first = arr[i].second;
tmp[i].second = arr[i].first;
}
sort(tmp, tmp + n);
for (int i = (0); i < (n); ++i) cout << tmp[i].second << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 300006;
int n, a[MAXN];
pair<int, int> B[MAXN];
struct myclass {
bool operator()(pair<int, int> A, pair<int, int> B) {
return A.second < B.second;
}
};
int main() {
scanf("%d", &n);
for (int i = 0; i < (n); i++) {
scanf("%d", &a[i]);
B[i] = make_pair(a[i], i);
}
sort(B, B + n);
for (int i = (1); i <= (n - 1); i++)
if (B[i].first <= B[i - 1].first) B[i].first = B[i - 1].first + 1;
sort(B, B + n, myclass());
for (int i = 0; i < (n); i++) printf("%d ", B[i].first);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct pnt {
long long a, num, b;
};
bool cmp(pnt a, pnt b) { return a.a < b.a || (a.a == b.a && a.num < b.num); }
bool cmp2(pnt a, pnt b) { return a.num < b.num; }
pnt a[301000];
int main() {
int i, n;
long long uk = 0;
cin >> n;
for (i = 0; i < n; i++) {
cin >> a[i].a;
a[i].num = i;
}
sort(a, a + n, cmp);
for (i = 0; i < n; i++) {
if (a[i].a > uk)
uk = a[i].a;
else
uk++;
a[i].b = uk;
}
sort(a, a + n, cmp2);
for (i = 0; i < n; i++) cout << a[i].b << " ";
return 0;
}
|
#include <bits/stdc++.h>
template <class T>
T gcd(T x, T y) {
if (y == 0) return x;
return gcd(y, x % y);
}
template <class T>
T lcm(T x, T y) {
return ((x / gcd(x, y)) * y);
}
template <class T>
T maxt(T x, T y) {
if (x > y)
return x;
else
return y;
}
template <class T>
T mint(T x, T y) {
if (x < y)
return x;
else
return y;
}
template <class T>
T power(T x, T y) {
T res = 1, a = x;
while (y) {
if (y & 1) {
res *= a;
}
a *= a;
y >>= 1;
}
return res;
}
template <class T>
T bigmod(T x, T y, T mod) {
T res = 1, a = x;
while (y) {
if (y & 1) {
res = (res * a) % mod;
}
a = (a * a) % mod;
y >>= 1;
}
return res;
}
int dir[8][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1},
{-1, -1}, {-1, 1}, {1, -1}, {1, 1}};
using namespace std;
struct data {
int val, id;
};
data iput[400000];
bool comp(const data &a, const data &b) {
if (a.val < b.val) return true;
return false;
}
bool cmp(const data &a, const data &b) {
if (a.id < b.id) return true;
return false;
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> iput[i].val;
iput[i].id = i;
}
sort(iput, iput + n, comp);
int res = 0;
for (int i = 1; i < n; i++) {
if (iput[i - 1].val == iput[i].val) {
iput[i].val++;
res = iput[i].val;
} else if (iput[i - 1].val > iput[i].val) {
iput[i].val = ++res;
}
}
sort(iput, iput + n, cmp);
for (int i = 0; i < n; i++) {
printf("%d ", iput[i].val);
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
inline char contains(char bits[], int number) {
return ((bits[number >> 3]) & (1 << (number & 7)));
}
inline void set(char bits[], int number) {
bits[number >> 3] |= (1 << (number & 7));
}
struct compare {
bool operator()(std::pair<int, int> i, std::pair<int, int> j) {
return ((i.second) < (j.second));
}
} ballerSort;
int main(int argc, char** argv) {
int num = 0;
std::cin >> num;
std::cin.ignore(256, '\n');
std::map<int, int> ratingmap;
char* bits = (char*)calloc(125037500, sizeof(char));
std::vector<std::pair<int, int> > desired_ratings;
std::map<int, int> output_map;
char c;
char i = 0;
char word[11];
int current_rating = 0;
while (c = getc(stdin)) {
if (c == ' ' || c == '\n') {
word[i] = '\0';
desired_ratings.push_back(std::make_pair(current_rating++, atoi(word)));
i = 0;
} else {
word[i] = c;
i++;
}
if (c == '\n') {
break;
}
}
std::sort(desired_ratings.begin(), desired_ratings.end(), ballerSort);
int first = 0, actual = 0;
for (std::vector<std::pair<int, int> >::iterator iter =
desired_ratings.begin();
iter != desired_ratings.end(); ++iter) {
int rating;
int desired_rating = iter->second;
if (first <= desired_rating && desired_rating <= actual)
rating = ++actual;
else {
rating = desired_rating;
first = desired_rating;
}
while (contains(bits, rating)) {
rating++;
}
actual = rating;
output_map[iter->first] = rating;
set(bits, rating);
}
for (int i = 0; i < num; i++) {
printf("%d ", output_map[i]);
}
printf("\n");
free(bits);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<pair<int, int> > vals(n);
for (int i = 0; i < n; i++) {
cin >> vals[i].first;
vals[i].second = i;
}
sort(vals.begin(), vals.end());
vector<int> ans(n);
int t = -1;
for (int i = 0; i < n; i++)
if (t < vals[i].first) {
t = vals[i].first;
ans[vals[i].second] = t;
} else {
t++;
ans[vals[i].second] = t;
}
for (int i = 0; i < n; i++) cout << ans[i] << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
typedef struct {
int a;
int b;
} k;
int cmp(const void *a, const void *b) { return (*(k *)a).a - (*(k *)b).a; }
int cmp1(const void *a, const void *b) {
return (*(k *)a).b > (*(k *)b).b ? 1 : -1;
}
k name[300010];
int main() {
int n, i;
int set[300010];
while (scanf("%d", &n) != EOF) {
for (i = 0; i < n; i++) {
scanf("%d", &name[i].a);
;
name[i].b = i + 1;
}
qsort(name, n, sizeof(name[0]), cmp);
set[name[0].b] = name[0].a;
for (i = 1; i < n; i++) {
if (name[i].a <= name[i - 1].a) name[i].a = name[i - 1].a + 1;
set[name[i].b] = name[i].a;
}
for (i = 1; i < n; i++) {
printf("%d ", set[i]);
}
printf("%d\n", set[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void prep() {
cin.tie(0);
cin.sync_with_stdio(0);
};
const double pi = acos(-1.);
long long mod = 1000000007;
long long mymod(long long num) {
if (num < 0 && !(num % mod == 0)) {
if (mod == 1) {
return 0;
}
return mod - abs(num) % mod;
} else {
return num % mod;
}
}
const int biggg = 1000000000;
const double eps = .000000001;
int main() {
prep();
int n;
cin >> n;
pair<int, int> arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i].first;
arr[i].second = i;
}
sort(arr, arr + n);
int b[n];
int curval = 0;
for (int i = 0; i < n; i++) {
curval = max(curval, arr[i].first);
b[arr[i].second] = curval;
curval++;
}
for (int i = 0; i < n; i++) {
cout << b[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
;
long long n;
cin >> n;
vector<pair<long long, long long> > a(n);
vector<long long> b(n);
for (long long i = 0; i < n; ++i) {
cin >> a[i].first;
a[i].second = i;
}
sort(a.begin(), a.end());
long long cur = a[0].first - 1;
for (long long i = 0; i < a.size(); ++i) {
cur = max(a[i].first, cur + 1);
b[a[i].second] = cur;
}
for (long long i = 0; i < b.size(); ++i) cout << b[i] << " ";
}
|
#include <bits/stdc++.h>
struct item {
int rate;
int index;
};
void sortx(item*[], int, int);
int main() {
int n;
scanf("%d", &n);
item* d[n];
for (int i = 0; i < n; i++) {
item* a = new item();
scanf("%d", &a->rate);
a->index = i;
d[i] = a;
}
std::sort(d, d + n,
[](item* x, item* y) -> bool { return x->rate < y->rate; });
int cur = 0;
int r[n];
for (int i = 0; i < n; i++) {
if (d[i]->rate > cur) {
r[d[i]->index] = d[i]->rate;
cur = d[i]->rate;
} else {
r[d[i]->index] = ++cur;
}
}
for (int i = 0; i < n - 1; i++) {
printf("%d ", r[i]);
}
printf("%d\n", r[n - 1]);
return 0;
}
void sortx(item* d[], int start, int end) {
int i = start, j = end, mid = (i + j) / 2;
item* t = d[mid];
while (true) {
while (d[i]->rate < t->rate) i++;
while (d[j]->rate > t->rate) j--;
if (i >= j) break;
if (d[i]->rate != d[j]->rate) {
item* x;
x = d[i];
d[i] = d[j];
d[j] = x;
}
i++;
j--;
}
if (start < j) sortx(d, start, j);
if (j + 1 < end) sortx(d, j + 1, end);
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
pair<int, int> a[300005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i].first;
a[i].second = i;
}
sort(a, a + n);
for (int i = 1; i < n; i++) {
a[i].first = max(a[i - 1].first + 1, a[i].first);
}
for (int i = 0; i < n; i++) {
swap(a[i].first, a[i].second);
}
sort(a, a + n);
for (int i = 0; i < n; i++) cout << a[i].second << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, cur = 1, res[300005];
pair<int, int> arr[300005];
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> arr[i].first;
for (int i = 0; i < n; i++) arr[i].second = i;
sort(arr, arr + n);
for (int i = 0; i < n; i++) {
if (cur < arr[i].first) cur = arr[i].first;
res[arr[i].second] = cur;
cur++;
}
for (int i = 0; i < n; i++) cout << res[i] << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 0, 1, -1, 1, -1, 1, -1}, dy[] = {1, -1, 0, 0, 1, -1, -1, 1};
inline void cn(long& n) {
n = 0;
long ch = getchar();
int sign = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') sign = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
n = (n << 3) + (n << 1) + ch - '0', ch = getchar();
n = n * sign;
}
template <class T>
void cmin(T& a, T b) {
if (b < a) a = b;
}
template <class T>
void cmax(T& a, T b) {
if (b > a) a = b;
}
template <class T>
int len(const T& c) {
return (int)c.size();
}
template <class T>
int len(char c[]) {
return (int)strlen(c);
}
string itos(long n) {
string s;
while (n) {
s += (n % 10 + 48);
n /= 10;
}
reverse(s.begin(), s.end());
return s;
}
long stoi(string s) {
long n = 0;
for (int i(0), _n(len(s)); i < _n; ++i) n = n * 10 + (s[i] - 48);
return n;
}
void init() {}
long n, res[300005], p, cur, a;
pair<long, long> ar[300005];
int main() {
cin >> n;
for (int i(0), _n(n); i < _n; ++i) {
cin >> a;
ar[i] = make_pair(a, i);
}
sort(ar, ar + n);
cur = ar[0].first;
for (int i(0), _n(n); i < _n; ++i) {
if (ar[i].first < cur) {
ar[i].first = cur;
cur++;
} else if (ar[i].first > cur)
cur = ar[i].first + 1;
else
cur++;
res[ar[i].second] = ar[i].first;
}
for (int i(0), _n(n); i < _n; ++i) cout << res[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, y;
};
int compare(struct node p1, struct node p2) { return p1.y < p2.y; }
int main() {
int n, i;
cin >> n;
long long a[n + 5], an[n + 5], ans[n + 5];
node p[n + 5];
for (i = 0; i < n; i++) {
cin >> a[i];
p[i].x = i;
p[i].y = a[i];
}
sort(p, p + n, compare);
ans[0] = p[0].y;
for (i = 1; i < n; i++) {
if (p[i].y > ans[i - 1]) {
ans[i] = p[i].y;
} else
ans[i] = ans[i - 1] + 1;
}
for (i = 0; i < n; i++) {
an[p[i].x] = ans[i];
}
for (i = 0; i < n; i++) cout << an[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
struct t {
int k;
int a;
int b;
} v[300005];
bool sort_a(struct t x, struct t y) { return (x.a < y.a); }
bool sort_k(struct t x, struct t y) { return (x.k < y.k); }
int main() {
int i;
scanf("%d", &n);
for (i = 0; i < n; ++i) {
scanf("%d", &v[i].a);
v[i].k = i;
}
sort(v, v + n, sort_a);
for (i = 0; i < n; ++i) {
if (i == 0)
v[i].b = v[i].a;
else
v[i].b = max(v[i - 1].b + 1, v[i].a);
}
sort(v, v + n, sort_k);
for (i = 0; i < n; ++i) printf("%d ", v[i].b);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
struct node {
int x, idx;
} s[501010];
int cmp(node a, node b) { return a.x < b.x; }
int ans[501010];
void init() {
int i, j;
for (i = 1; i <= n; i++) {
scanf("%d", &s[i].x);
s[i].idx = i;
}
sort(s + 1, s + n + 1, cmp);
int p;
for (i = 1, p = -1; i <= n; i++) {
p = max(p + 1, s[i].x);
ans[s[i].idx] = p;
}
for (i = 1; i <= n; i++) printf("%d ", ans[i]);
puts("");
}
int main() {
int i, j;
while (scanf("%d", &n) != EOF) {
init();
}
}
|
#include <bits/stdc++.h>
using namespace std;
void cp() {
ios ::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
int main() {
cp();
{
string s, t;
cin >> s >> t;
if (s.length() == t.length() + 1) {
long long m = 0;
long long in = -1;
char f;
long long j = 0;
for (long long i = 0; i < s.length(); i += 1) {
if (s[i] != t[j]) {
f = s.at(i);
in = i;
m++;
j--;
}
j++;
}
vector<long long> ans;
if (m == 1) {
while (in > -1) {
if (s[in] == f) {
in--;
} else {
break;
}
}
in++;
while (in < s.length()) {
if (s[in] == f) {
ans.push_back(in + 1);
in++;
} else {
break;
}
}
cout << ans.size();
cout << endl;
;
for (long long i = 0; i < ans.size(); i += 1) cout << ans[i] << " ";
} else {
cout << "0\n";
}
} else {
cout << "0\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct my {
char c;
int n;
bool operator==(const my& x) const { return (c == x.c); }
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
string s, t;
cin >> s >> t;
s += 'A';
t += 'A';
vector<my> a;
char pre = s[0];
int cnt = 1;
for (int i = 1; i < s.size(); i++) {
if (s[i] == pre)
cnt++;
else {
a.push_back({pre, cnt});
pre = s[i];
cnt = 1;
}
}
vector<my> b;
pre = t[0];
cnt = 1;
for (int i = 1; i < t.size(); i++) {
if (t[i] == pre)
cnt++;
else {
b.push_back({pre, cnt});
pre = t[i];
cnt = 1;
}
}
if (a == b) {
int k = 0;
for (int i = 0; i < b.size(); i++) {
if (a[i].n > b[i].n) {
cout << a[i].n << '\n';
for (int j = k; j < k + a[i].n; j++) {
cout << j + 1 << ' ';
}
break;
} else
k += a[i].n;
}
} else {
s.pop_back();
t.pop_back();
int ans = -1, cnt = 0;
bool flag = true;
for (int i = 0, j = 0; i < s.size(); i++, j++) {
if (j == t.size()) {
ans = (ans == -1 && cnt == 0 ? j : -1);
break;
}
if (s[i] != t[j]) {
if (flag) j--;
flag = false;
ans = i;
cnt++;
}
if (cnt == 2) {
ans = -1;
break;
}
}
if (ans == -1)
cout << 0;
else
cout << 1 << '\n' << ans + 1;
}
}
|
#include <bits/stdc++.h>
using namespace std;
string a, b;
int main() {
int i, j, k;
while (cin >> a >> b) {
int index;
int cnt = 0;
bool have1, have2;
have1 = have2 = 0;
for (i = 0; i < b.length(); i++) {
if (have1) {
if (a[i + 1] != b[i]) {
have2 = true;
break;
}
} else {
if (a[i] != b[i]) {
index = i;
i--;
have1 = true;
}
}
}
if (have1) {
if (have2)
cout << "0" << endl;
else {
cnt = 1;
for (i = index - 1; i >= 0; i--)
if (a[i] == a[index]) {
cnt++;
} else
break;
cout << cnt << endl;
index -= cnt;
index++;
while (cnt--) {
cout << ++index << " ";
}
cout << endl;
}
} else {
cnt = 1;
index = b.length();
for (i = index - 1; i >= 0; i--)
if (a[i] == a[index]) {
cnt++;
} else
break;
cout << cnt << endl;
index -= cnt;
index++;
while (cnt--) {
cout << ++index << " ";
}
cout << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void umax(T &a, T b) {
if (a < b) a = b;
}
const int maxn = 5000 + 10;
const int INF = 1e9 + 7;
inline void solve(void) {
string s1, s2;
cin >> s1 >> s2;
int n = s1.length();
int f = 0, f1 = 0;
for (int i = (0); i < (n - 1); i++) {
if (s1[i] == s2[i])
f++;
else
break;
}
for (int i = (n - 1); i >= (0); i--) {
if (s1[i + 1] != s2[i]) {
f1 = i + 1;
break;
}
}
vector<int> ans;
if (f1 <= f) {
char s = s1[f1];
for (int i = (f1); i < (n); i++) {
if (s == s1[i])
ans.push_back(i + 1);
else
break;
}
} else {
cout << "0";
return;
}
cout << ans.size() << endl;
for (int i = (0); i < (ans.size()); i++) cout << ans[i] << " ";
return;
}
void init() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
}
int main(int argc, const char *argv[]) {
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXLEN = 1e6 + 5;
char str1[MAXLEN], str2[MAXLEN];
int main(void) {
fgets(str1, MAXLEN, stdin);
fgets(str2, MAXLEN, stdin);
int len = strlen(str2);
if (str1[0] != str2[0]) {
bool b = 0;
for (int i = 0; i < len; i++)
if (str1[i + 1] != str2[i]) {
b = 1;
break;
}
if (b)
putchar('0');
else
printf("1\n1");
return 0;
}
int l = 0;
int r;
for (r = 1; r <= len; r++) {
if (str1[r - 1] != str1[r]) l = r;
if (str1[r] != str2[r]) break;
}
for (int i = r; i < len; i++)
if (str1[i + 1] != str2[i]) {
putchar('0');
return 0;
}
printf("%d\n", r - l + 1);
for (int i = l; i <= r; i++) printf("%d ", i + 1);
return 0;
}
|
#include <bits/stdc++.h>
char a[(1000 * 1000 + 1)], b[(1000 * 1000 + 1)], *i = a, *j = b, *k, *l;
int main() {
gets(a);
gets(b);
while (*i == *j) i++, j++;
l = k = i++;
while (*i == *j && *i) i++, j++;
if (*i == 0) {
while (*l == *k) l--;
printf("%d\n", k - l);
while (k - l) printf("%d ", l - a + 2), l++;
} else
puts("0");
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b;
cin >> a >> b;
string d;
set<int> pos;
bool flag = false;
for (int i = 0; i < b.size(); i++) {
if (a[i] != b[i]) {
flag = true;
pos.insert(i + 1);
for (int h = i; h < a.size(); h++) {
if (a[h] == a[i])
pos.insert(h + 1);
else
break;
}
for (int k = i; k >= 0; k--) {
if (a[k] == a[i])
pos.insert(k + 1);
else
break;
}
for (int j = i + 1; j < a.size(); j++) d += a[j];
if (d != b) {
cout << 0;
return 0;
}
break;
} else
d += a[i];
}
if (flag == false) {
int siz = a.size();
pos.insert(siz);
for (int k = siz - 1; k >= 0; k--) {
if (a[k] == a[siz - 1])
pos.insert(k + 1);
else
break;
}
}
if (d != b) {
cout << a;
cout << 0;
return 0;
} else {
cout << pos.size() << endl;
set<int>::iterator it;
for (it = pos.begin(); it != pos.end(); it++) cout << *it << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-9;
const int MAXN = 1100000;
int a[MAXN];
char tmp[MAXN];
string s1, s2;
vector<int> v;
int main() {
scanf("%s", &tmp);
s1 = tmp;
scanf("%s", &tmp);
s2 = tmp;
int idx = -1;
for (int i = 0; i < (int)(s1.size()); ++i) {
if (s1[i] != s2[i]) {
idx = i;
break;
}
}
bool ok = 0;
if (idx == -1) {
idx = s1.size();
--idx;
ok = 1;
} else {
ok = 1;
for (int i = (int)(idx + 1); i < (int)(s1.size()); ++i) {
if (s1[i] != s2[i - 1]) {
ok = 0;
}
}
}
v.clear();
v.reserve(MAXN);
if (ok) {
for (int i = idx; i > -1; --i) {
if (s1[i] == s1[idx]) {
v.push_back(i + 1);
} else
break;
}
reverse(v.begin(), v.end());
}
cout << v.size() << endl;
for (int i = 0; i < (int)(v.size()); ++i) {
printf("%d ", v[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
long long int maxx(long long int& a, long long int& b) { return a > b ? a : b; }
long long int minn(long long int& a, long long int& b) { return a > b ? b : a; }
using namespace std;
void boostIO() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
long long int gcd(long long int a, long long int b) {
return b == 0 ? a : gcd(b, a % b);
}
int int_gcd(int a, int b) { return b == 0 ? a : int_gcd(b, a % b); }
long long int lcm(long long int a, long long int b) {
return a / gcd(a, b) * b;
}
long long int poww(long long int base, long long int exp, long long int mod) {
base %= mod;
long long int result = 1;
while (exp > 0) {
if (exp & 1) result = (result * base) % mod;
base = (base * base) % mod;
exp >>= 1;
}
return result;
}
long long int pref_hash[1002000], power[1001000], inverse[1001000];
int main() {
string a, b;
cin >> a >> b;
long long int base = 131, hash_b = 0;
power[0] = 1, inverse[0] = 1;
for (int i = 1; i <= 1000100; i++) {
power[i] = (power[i - 1] * base) % 1000000007;
}
for (int i = 1; i <= a.size(); i++) {
pref_hash[i] = (pref_hash[i - 1] + a[i - 1] * power[i]) % 1000000007;
}
for (int i = 0; i < b.size(); i++) {
hash_b = (hash_b + b[i] * power[i + 1]) % 1000000007;
}
vector<int> ans;
long long int value;
int n = a.size();
long long int inv = poww(131, 1000000007 - 2, 1000000007);
for (int i = 0; i < a.size(); i++) {
value =
(pref_hash[i] +
((pref_hash[n] - pref_hash[i + 1] + 1000000007) % 1000000007) * inv) %
1000000007;
if (value == hash_b) {
ans.push_back(i + 1);
}
value = (value + a[i] * power[i]) % 1000000007;
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) {
printf("%d ", ans[i]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long BASE = 31, MOD = 1e9 + 7, N = 1e6 + 5;
string s, t;
long long n, p[N], pre[N];
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
p[0] = 1;
for (long long i = 1; i < N; i++) p[i] = p[i - 1] * BASE % MOD;
long long T = 1;
while (T--) {
cin >> s >> t;
n = s.size();
for (long long i = 0; i < n; i++)
pre[i + 1] = (pre[i] * BASE + (s[i] - 'a' + 1)) % MOD;
long long tx = 0;
for (long long i = 0; i < t.size(); i++)
tx = (tx * BASE + (t[i] - 'a' + 1)) % MOD;
vector<long long> ans;
for (long long i = 0; i < n; i++) {
long long sx = (pre[i] * p[n - i - 1] % MOD + pre[n] -
pre[i + 1] * p[n - i - 1] % MOD + MOD) %
MOD;
if (sx == tx) ans.push_back(i + 1);
}
cout << ans.size() << '\n';
for (auto &&x : ans) cout << x << ' ';
cout << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, x, y;
string A, B;
cin >> A >> B;
for (x = 0; A[x] == B[x];) x++;
for (y = B.size(); y >= 0 && A[y + 1] == B[y];) y--;
printf("%d\n", x > y ? x - y : 0);
for (i = y + 1; i <= x; i++) cout << i + 1 << " ";
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string a, b;
char c;
long int e = 0, d = 0, f = 0, g = 0;
cin >> a >> b;
vector<int> v;
for (int i = 0; i < a.length(); i++) {
if (a[i] != b[e]) {
c = a[i];
e--;
d++;
if (d > 1) {
cout << 0;
return 0;
}
f = i;
}
e++;
}
for (int i = f; i >= 0; i--) {
if (a[i] == c) {
v.push_back(i + 1);
} else {
break;
}
}
sort(v.begin(), v.end());
for (int i = f + 1; i < a.length(); i++) {
if (a[i] == c) {
v.push_back(i + 1);
}
if (a[i] != c) {
break;
}
}
cout << v.size() << endl;
for (int i = 0; i < v.size(); i++) {
cout << v[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
int prefix_length(char a[], char b[]) {
int i = 1;
while (a[i] == b[i]) ++i;
return i - 1;
}
int suffix_length(char a[], char b[], int len) {
int i = len;
while (i >= 2 && a[i] == b[i - 1]) i--;
return len - i;
}
int main() {
static char a[(int)1e6 + 2], b[(int)1e6 + 2];
gets(&a[1]);
gets(&b[1]);
int len = strlen(&a[1]);
int prefix = prefix_length(a, b);
int suffix = suffix_length(a, b, len);
int total = (prefix + 1) - (len - suffix) + 1;
if (total < 0) total = 0;
printf("%d\n", total);
for (int i = 0; i < total; ++i) {
printf("%d", i + len - suffix);
if (i + 1 < total)
printf(" ");
else
printf("\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
string s1, s2;
int main() {
cin >> s1 >> s2;
int now = 0;
int i, j, ans = 0, l = 0, r = 0, head = 0, tail = 0, f = 0, pos;
while (head < s1.size()) {
if (s1[head] == s2[tail]) {
head++;
tail++;
continue;
} else {
if (f == 0) {
f = 1;
pos = head;
ans = 1;
head++;
} else {
f = 2;
break;
}
}
}
if (f == 2) {
cout << 0 << endl;
} else {
for (i = pos - 1; i >= 0; i--) {
if (s1[i] == s1[pos]) {
ans++;
} else
break;
}
cout << ans << endl;
for (i = pos - ans + 1; i <= pos; i++) cout << i + 1 << ' ';
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool isOn(T mask, T pos) {
return mask & (1 << pos);
}
template <typename T>
inline int Off(T mask, T pos) {
return mask ^ (1 << pos);
}
template <typename T>
inline int On(T mask, T pos) {
return mask | (1 << pos);
}
template <class T>
inline int countbit(T n) {
return (n == 0) ? 0 : (1 + countbit(n & (n - 1)));
}
template <class T>
string toBinary(T n) {
string ret = "";
while (n) {
if (n % 2 == 1)
ret += '1';
else
ret += '0';
n >>= 1;
}
reverse(ret.begin(), ret.end());
return ret;
}
template <class T>
string toString(T n) {
ostringstream ost;
ost << n;
ost.flush();
return ost.str();
}
int toInt(string s) {
int r = 0;
istringstream sin(s);
sin >> r;
return r;
}
long long int toLInt(string s) {
long long int r = 0;
istringstream sin(s);
sin >> r;
return r;
}
double toDouble(string s) {
double r = 0;
istringstream sin(s);
sin >> r;
return r;
}
vector<string> token(string str, string deli) {
char *cstr, *p, *deli_c;
deli_c = new char[deli.size() + 1];
cstr = new char[str.size() + 1];
strcpy(deli_c, deli.c_str());
strcpy(cstr, str.c_str());
vector<string> vec;
p = strtok(cstr, deli_c);
while (p != NULL) {
vec.push_back(string(p));
p = strtok(NULL, deli_c);
}
delete[] cstr;
return vec;
}
template <class T>
inline T GCD(T a, T b) {
if (a < 0) return GCD(-a, b);
if (b < 0) return GCD(a, -b);
return (b == 0) ? a : GCD(b, a % b);
}
template <class T>
inline T LCM(T a, T b) {
if (a < 0) return LCM(-a, b);
if (b < 0) return LCM(a, -b);
return a * (b / GCD(a, b));
}
long long int dp[1000003];
template <class T>
inline T BIGMOD(T n, T m, T mod) {
long long int ans = 1;
long long int k = n;
long long int mm = m;
if (dp[mm] != -1) {
return dp[mm];
}
while (m) {
if (m & 1) {
ans *= k;
if (ans > mod) ans %= mod;
}
k *= k;
if (k > mod) k %= mod;
m >>= 1;
}
return dp[mm] = ans;
}
template <class T>
T modInverse(T b, T m) {
return BIGMOD(b, m - 2, m);
}
long long int fastExpo(long long int b, long long int p) {
long long int res = 1, x = b;
while (p) {
if (p & 1) res *= x;
x *= x;
p = p >> 1;
}
return res;
}
long long int hash_table(char c[]) {
long long int len = strlen(c);
long long int hash_value = 0, base = 26, mod = 10000007;
for (long long int i = 0; i < len; i++) {
long long int n = c[i] - 64;
long long int power = BIGMOD(base, i, mod);
n = ((n % mod) * (power % mod)) % mod;
hash_value = ((hash_value % mod) + (n % mod)) % mod;
}
return hash_value;
}
double dist(int x, int y, int x1, int y1) {
return sqrt(((x1 - x) * (x1 - x)) + ((y1 - y) * (y1 - y)));
}
void makelengthequal(int p, char *a, char *b) {
int l1, l2;
l1 = strlen(a);
l2 = strlen(b);
int dif = (p - l1);
{
for (int j = l1 - 1; j >= 0; j--) {
a[j + dif] = a[j];
}
for (int i = 0; i < dif; i++) a[i] = '0';
}
a[p] = '\0';
dif = (p - l2);
{
for (int j = l2 - 1; j >= 0; j--) {
b[j + dif] = b[j];
}
for (int i = 0; i < dif; i++) b[i] = '0';
}
b[p] = '\0';
cout << a << endl << b << endl;
}
vector<long long int> v;
int main() {
string s, ss;
ios_base::sync_with_stdio(0);
cin.tie(0);
;
cin >> s >> ss;
memset(dp, -1, sizeof(dp));
int cnt = 0;
long long int hash_value_ss = 0;
for (int i = ss.size() - 1; i >= 0; i--) {
long long int y = BIGMOD(25, cnt, 1000000007);
long long int x = (ss[i] - 'a' + 1);
long long int r = (x * y) % 1000000007;
hash_value_ss += r;
hash_value_ss %= 1000000007;
cnt++;
}
cnt = 0;
long long int h = 0;
for (int i = s.size() - 1; i >= 0; i--) {
long long int y = BIGMOD(25, cnt, 1000000007);
long long int x = (s[i] - 'a' + 1);
long long int r = (x * y) % 1000000007;
h += r;
h %= 1000000007;
cnt++;
v.push_back(h);
}
long long int fr_h = 0;
cnt = s.size() - 1;
cnt--;
vector<int> rs;
int k = 0;
for (int i = ((int)(v.size())) - 2; i >= 0; i--) {
long long int fr_t = fr_h + v[i];
fr_t %= 1000000007;
if (fr_t == hash_value_ss) {
rs.push_back(k + 1);
}
long long int x = s[k] - 'a' + 1;
long long int y = BIGMOD(25, cnt, 1000000007);
long long int r = (x * y) % 1000000007;
fr_h += r;
fr_h %= 1000000007;
k++;
cnt--;
}
if (fr_h == hash_value_ss) {
rs.push_back(k + 1);
}
printf("%d\n", rs.size());
for (int i = 0; i < rs.size(); i++) {
if (i != 0) printf(" ");
printf("%d", rs[i]);
}
printf("\n");
}
|
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const long long mod = 1500450271;
const long long base = 131;
long long p[1000099], h[1000099], first, hr[1000099], h2;
int i, n1, n2, l;
vector<int> ans;
char s1[1000099], s2[1000099];
int main() {
p[0] = 1;
scanf("%s", s1);
scanf("%s", s2);
n1 = strlen(s1);
n2 = strlen(s2);
l = max(n1, n2) + 1;
for (i = 1; i <= l; i++) p[i] = (base * p[i - 1]) % mod;
h[0] = s1[0];
for (i = 1; i <= n1 - 1; i++) {
h[i] = (h[i - 1] * base + s1[i]) % mod;
}
hr[n1 - 1] = s1[n1 - 1];
for (i = n1 - 2; i >= 0; i--) {
hr[i] = (s1[i] * p[n1 - 1 - i] + hr[i + 1]) % mod;
}
h2 = 0;
for (i = 0; i < n2; i++) h2 = (h2 * base + s2[i]) % mod;
for (i = 0; i < n1; i++) {
long long first =
(i ? h[i - 1] : 0) * p[n1 - 1 - i] + (i == n1 - 1 ? 0 : hr[i + 1]);
first %= mod;
if (first == h2) ans.push_back(i + 1);
}
l = ((int)(ans).size());
printf("%d", l);
putchar(10);
for (i = 0; i < l; i++) {
if (i) putchar(' ');
printf("%d", ans[i]);
}
}
|
#include <bits/stdc++.h>
char s[1000020];
char c[1000020];
int l, r;
int main() {
scanf("%s %s", s, c);
for (r = 0; s[r] == c[r];) r++;
for (l = strlen(c); l >= 0 && s[l + 1] == c[l];) l--;
printf("%d\n", r > l ? r - l : 0);
for (int i = l + 1; i <= r; i++) printf("%d ", i + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
string s, c;
int main() {
ios_base::sync_with_stdio(0);
cin.tie();
cout.tie();
cin >> s >> c;
n = s.size();
int r = 0;
while (s[r] == c[r]) r++;
int l = c.size() - 1;
while (l >= 0 && s[l + 1] == c[l]) l--;
if (r > l)
cout << r - l << "\n";
else {
cout << 0;
return 0;
}
for (int i = l + 1; i <= r; i++) cout << i + 1 << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
char a[1000005], b[1000005];
char tmp;
vector<int> pos;
scanf("%s\n", &a);
scanf("%s\n", &b);
int sizea = strlen(a);
bool diff = false;
int ans = -1;
int j = 0;
for (int i = 0; i < sizea - 1; i++, j++) {
if (a[i] != b[j]) {
if (diff) {
printf("0\n");
return 0;
} else {
diff = true;
ans = i;
j--;
}
}
}
if (ans == -1) {
ans = sizea - 1;
} else {
if (a[sizea - 1] != b[sizea - 2]) {
printf("0\n");
return 0;
}
}
int i = ans;
ans = 1;
pos.push_back(i + 1);
while (i > 0) {
if (a[i] == a[i - 1]) {
ans++;
pos.push_back(i);
i--;
} else {
i = -100;
}
}
printf("%d\n", ans);
for (int k = pos.size() - 1; k >= 0; k--) {
printf("%d ", pos[k]);
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 10;
int n;
string s, t;
bool mark[MAXN], mark2[MAXN];
int ans[MAXN], sz;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> s >> t;
n = t.size();
for (int i = 0; i < n && s[i] == t[i]; i++) mark[i] = 1;
for (int i = n - 1; ~i && t[i] == s[i + 1]; i--) mark2[i] = 1;
for (int i = 0; i <= n; i++)
if ((!i || mark[i - 1]) && (i == n || mark2[i])) ans[sz++] = i + 1;
cout << sz << "\n";
for (int i = 0; i < sz; i++) cout << ans[i] << " ";
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void checkmin(T &t, T x) {
if (x < t) t = x;
}
template <class T>
void checkmax(T &t, T x) {
if (x > t) t = x;
}
template <class T>
void _checkmin(T &t, T x) {
if (t == -1) t = x;
if (x < t) t = x;
}
template <class T>
void _checkmax(T &t, T x) {
if (t == -1) t = x;
if (x > t) t = x;
}
char s[1000020];
char c[1000020];
int l, r;
int main() {
scanf("%s %s", s, c);
for (r = 0; s[r] == c[r];) r++;
for (l = strlen(c); l >= 0 && s[l + 1] == c[l];) l--;
printf("%d\n", r > l ? r - l : 0);
for (int i = l + 1; i <= r; i++) printf("%d ", i + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace std;
long long gcd(long long a, long long b) {
if (a < b)
return gcd(b, a);
else if (b == 0)
return a;
else
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
long long pow(long long b, long long e) {
if (e == 0)
return 1;
else if (e % 2 == 0) {
long long a = pow(b, e / 2);
return a * a;
} else {
long long a = pow(b, e / 2);
return b * a * a;
}
}
long long pow_m(long long x, long long y, long long m = 1000000007) {
x = x % m;
long long res = 1;
while (y) {
if (y & 1) res = res * x;
res %= m;
y = y >> 1;
x = x * x;
x %= m;
}
return res;
}
long long modInverse(long long a, long long m) { return pow_m(a, m - 2, m); }
long long max(long long a, long long b) {
if (a >= b)
return a;
else
return b;
}
long long min(long long a, long long b) {
if (a <= b)
return a;
else
return b;
}
long long bin_coff(long long n, long long k, long long m) {
vector<vector<long long>> ans(n + 1, vector<long long>(k, 0));
for (long long i = 0; i < n + 1; i++) {
for (long long j = 0; j < min(i, k) + 1; j++) {
if (j == 0 || j == i)
ans[i][j] = 1;
else
ans[i][j] = ans[i - 1][j - 1] % m + ans[i - 1][j] % m;
}
}
return ans[n][k] % m;
}
long long inverse(long long i) {
if (i == 1) return 1;
return (1000000007 -
((1000000007 / i) * inverse(1000000007 % i)) % 1000000007 +
1000000007) %
1000000007;
}
const long long N = 10000007;
vector<bool> primes(N + 1, true);
void eren() {
primes[0] = false;
primes[1] = false;
for (long long i = 2; i * i <= N; i++) {
if (primes[i]) {
for (long long j = i * i; j <= N; j += i) primes[j] = false;
}
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
eren();
int tt = 1;
for (int it = 0; it < tt; it++) {
string s1, s2;
cin >> s1 >> s2;
vector<long long> pos[26];
for (long long i = 0; i < s1.size(); i++) {
pos[s1[i] - 'a'].push_back(i + 1);
}
long long cnt = 0, idx = s1.length() - 1;
char p = s1[s1.size() - 1];
for (long long i = 0; i < s1.length(); i++) {
if (i >= s2.length()) break;
if (s1[i] != s2[i]) {
cnt++;
if (cnt > 1) break;
p = s1[i];
idx = i;
s1.erase(i, 1);
i--;
}
}
if (cnt > 1) {
cout << "0\n";
return 0;
}
vector<long long> ans;
ans.push_back(idx);
idx--;
while (idx >= 0 && s1[idx] == p) ans.push_back(idx), idx--;
cout << ans.size() << "\n";
for (long long i = ans.size() - 1; i >= 0; i--) cout << ans[i] + 1 << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << '\n';
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
long long pows(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
long long powm(long long x, long long y, long long m = 1000000007) {
x = x % m;
long long res = 1;
while (y) {
if (y & 1) res = res * x;
res %= m;
y = y >> 1;
x = x * x;
x %= m;
}
return res;
}
long long modInverse(long long a, long long m = 1000000007) {
return powm(a, m - 2, m);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, m, i, j, k, x, y, z, t, e, f, p, q, g, l, r, o, w, h,
count1 = 0, prod = 1, a, b, c, d, index, x1, x2, y1, y2, diff, ans = 0,
sum = 0, sum1 = 0, sum2 = 0, flag = 0, flag1 = 0, flag2 = 0;
string s, s1, s2;
cin >> s >> s1;
p = 31;
n = s.size();
m = s1.size();
long long powers[n + 1];
powers[0] = 1;
for (i = 1; i <= n; i++) {
powers[i] = powers[i - 1] * p;
powers[i] %= 1000000007;
}
long long pre[n + 1];
pre[0] = 0;
for (i = 0; i < n; i++) {
pre[i + 1] = (pre[i] + (s[i] - 'a' + 1) * powers[i]) % 1000000007;
}
long long hs = 0;
for (i = 0; i < m; i++) {
hs = (hs + (s1[i] - 'a' + 1) * powers[i]) % 1000000007;
}
vector<long long> v;
if (((pre[n] - pre[1] + 1000000007) % 1000000007) ==
((hs * p) % 1000000007)) {
v.push_back(1);
}
for (i = 2; i <= n; i++) {
x = (pre[n] - pre[i] + 1000000007) % 1000000007;
x += (pre[i - 1] * p) % 1000000007;
x %= 1000000007;
if (x == (hs * p) % 1000000007) {
v.push_back(i);
}
}
cout << v.size() << "\n";
for (i = 0; i < v.size(); i++) {
cout << v[i] << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, s1;
cin >> s;
cin >> s1;
vector<int> ans;
int o = -1;
for (int i = 0; i < s1.size(); i++) {
if (s[i] != s1[i]) {
o = i;
break;
}
}
if (o == -1) o = s.size() - 1;
for (int i = o + 1; i < s.size(); i++)
if (s[i] != s1[i - 1]) {
cout << 0 << endl;
return 0;
}
ans.push_back(o);
int O_o = o;
o--;
while (o >= 0 && s[o] == s[O_o]) {
ans.push_back(o);
o--;
}
cout << ans.size() << endl;
for (int i = ans.size() - 1; i >= 0; i--) cout << ans[i] + 1 << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long A = 257, B = 1003, MOD = 1e9 + 7;
long long num1[1000004], num2[1000004];
string s, t;
pair<long long, long long> f[1000004], b[1000004];
bool okay(pair<long long, long long> gogo, long long x) {
pair<long long, long long> pu;
pu.first = 0, pu.second = 0;
if (x != 0) {
pu.first = f[x - 1].first * A % MOD;
pu.second = f[x - 1].second * B % MOD;
}
if (x != t.size()) {
pu.first = (pu.first + b[x].first) % MOD;
pu.second = (pu.second + b[x].second) % MOD;
}
for (char c = 'a'; c <= 'z'; c++) {
if (make_pair((pu.first + c * num1[t.size() - x]) % MOD,
(pu.second + c * num2[t.size() - x]) % MOD) == gogo)
return true;
}
return false;
}
int main() {
num1[0] = 1;
num2[0] = 1;
for (long long i = 1; i < 1000004; i++) {
num1[i] = num1[i - 1] * A % MOD;
num2[i] = num2[i - 1] * B % MOD;
}
cin >> s >> t;
pair<long long, long long> l;
for (long long i = 0; i < s.size(); i++) {
l.first = (l.first + s[i] * num1[s.size() - i - 1]) % MOD;
l.second = (l.second + s[i] * num2[s.size() - i - 1]) % MOD;
}
f[0].first = t[0] * num1[t.size() - 1];
f[0].second = t[0] * num2[t.size() - 1];
for (long long i = 1; i < t.size(); i++) {
f[i].first = (f[i - 1].first + t[i] * num1[t.size() - i - 1]) % MOD;
f[i].second = (f[i - 1].second + t[i] * num2[t.size() - i - 1]) % MOD;
}
b[t.size() - 1].first = t[t.size() - 1];
b[t.size() - 1].second = t[t.size() - 1];
for (long long i = int(t.size()) - 2; i >= 0; i--) {
b[i].first = (b[i + 1].first + t[i] * num1[t.size() - i - 1]) % MOD;
b[i].second = (b[i + 1].second + t[i] * num2[t.size() - i - 1]) % MOD;
}
vector<long long> ans;
for (long long i = 0; i <= t.size(); i++) {
if (okay(l, i)) {
ans.push_back(i);
}
}
cout << ans.size() << endl;
for (long long i = 0; i < ans.size(); i++) cout << ans[i] + 1 << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 1000006, MaxC = 0x3F3F3F3F, NA = -1;
char s[MaxN], t[MaxN];
bool b[MaxN], c[MaxN], d[MaxN];
int k, n;
int main(void) {
int i;
while (scanf(" %s %s", s, t) != EOF) {
n = strlen(t);
assert(n + 1 == (int)strlen(s));
b[0] = true;
c[n] = true;
for (i = 0; i < n; i++) {
b[i + 1] = (s[i] == t[i]);
c[i] = (s[i + 1] == t[i]);
}
for (i = 1; i <= n; i++) b[i] &= b[i - 1];
for (i = n - 1; i >= 0; i--) c[i] &= c[i + 1];
for (i = 0; i <= n; i++) d[i] = b[i] && c[i];
k = 0;
for (i = 0; i <= n; i++) k += d[i];
printf("%d\n", k);
for (i = 0; i <= n; i++)
if (d[i]) {
k--;
printf("%d%c", i + 1, k > 0 ? ' ' : '\n');
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b;
cin >> a >> b;
int x = 0, y = 0;
int n = b.length();
while (x < n && a[x] == b[x]) x++;
while (y < n && a[n - y] == b[n - 1 - y]) y++;
int res = x + y + 2 - (n + 1);
res = max(0, min(res, n + 1));
cout << res << endl;
int start = n - y + 1;
for (int i = 0; i < res; i++) cout << (start + i) << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s1, s2;
cin >> s1 >> s2;
int n = s2.length();
int c = 0;
int g = -1;
int j = 0;
int f = 0;
int i;
for (i = 0; i < n;) {
if (s1[j] != s2[i]) {
if (c > 0) {
f = 1;
break;
}
g = j;
c++;
i--;
}
if (i == n - 1 && j == n - 1) {
g = j + 1;
}
j++;
i++;
if (j > n) {
break;
}
}
if (i < n || f == 1) {
cout << "0\n";
} else {
int p;
if (g != 0) {
for (p = g; p > 0; p--) {
if (s1[p] != s1[p - 1]) {
break;
}
}
cout << g - p + 1 << "\n";
for (int i = p; i <= g; i++) {
cout << i + 1 << " ";
}
cout << "\n";
} else {
cout << "1\n1\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
unsigned long long h[1000005];
unsigned long long pwr[1000005];
char str[1000005];
char str1[1000005];
int main() {
int i, j, n, m, t;
pwr[0] = 1;
for (i = 1; i <= 1000000; i++) pwr[i] = pwr[i - 1] * 97;
scanf("%s", str);
scanf("%s", str1);
int len = strlen(str);
int len1 = strlen(str1);
unsigned long long val = 0;
h[0] = str[0] - 'a' + 1;
for (i = 1; i < len; i++) h[i] = h[i - 1] * 97 + str[i] - 'a' + 1;
for (i = 0; i < len1; i++) {
val = val * 97 + (str1[i] - 'a' + 1);
}
set<int> ans;
if (h[len - 1] - h[0] * pwr[len - 1] == val) {
ans.insert(1);
}
unsigned long long pw = 97;
for (i = 1; i < len; i++) {
unsigned long long val1 =
h[i - 1] * pwr[len - i - 1] + h[len - 1] - h[i] * pwr[len - 1 - i];
if (val == val1) {
ans.insert(i + 1);
}
}
cout << ans.size() << endl;
set<int>::iterator it;
for (it = ans.begin(); it != ans.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> res;
int main() {
string s1, s2;
cin >> s1 >> s2;
int p = s2.length();
char c = s1[p];
for (int i = 0; i < s2.length(); i++) {
if (s1[i] != s2[i]) {
p = i;
c = s1[p];
s1.erase(p, 1);
res.push_back(i + 1);
break;
}
}
if (s1.length() != s2.length()) {
res.push_back(p + 1);
s1.erase(p, 1);
}
for (int i = 0; i < s2.length(); i++) {
if (s1[i] != s2[i]) {
cout << 0;
return 0;
}
}
for (int i = p - 1; i >= 0; i--) {
if (s1[i] == c && s2[i] == c) {
res.push_back(i + 1);
} else {
break;
}
}
sort(res.begin(), res.end());
cout << res.size() << endl;
for (auto it : res) {
cout << it << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char **argv) {
unsigned long long h1, h2;
string s1, s2;
cin >> s1 >> s2;
vector<unsigned long long> h(s1.length());
vector<unsigned long long> pows(s1.length());
pows[0] = 1;
for (int i = 1; i < pows.size(); ++i) pows[i] = pows[i - 1] * 31;
h1 = h2 = 0;
for (int i = 0; i < s2.length(); ++i) h2 += (s2[i] - 'a' + 1) * pows[i];
h[0] = s1[0] - 'a' + 1;
for (int i = 1; i < s1.length(); ++i) {
h[i] = (s1[i] - 'a' + 1) * pows[i];
h[i] += h[i - 1];
}
vector<int> pos;
for (int i = 0; i < s1.length(); ++i) {
h1 = (i > 0 ? h[i - 1] : 0) * 31;
h1 += h[s1.length() - 1] - h[i];
if (h1 == h2 * 31) pos.push_back(i);
}
cout << pos.size() << endl;
for (int i = 0; i < pos.size(); ++i) cout << pos[i] + 1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s, t;
int main() {
long long n, m, i, j, k;
cin >> s >> t;
n = s.size();
m = t.size();
for (i = 0; i < n; i++)
if (s[i] != t[i]) break;
for (j = m - 1; j >= 0; j--)
if (s[j + 1] != t[j]) break;
cout << ((i > j) ? (i - j) : (0)) << "\n";
for (k = j + 2; k <= i + 1; k++) cout << k << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s, s2, s3;
vector<int> res;
int main() {
cin >> s >> s2;
int n = s.size(), no = 0, x;
for (int i = 0; i < n; i++) {
if (i == n - 1 && no == 0) break;
if (s[i] != s2[i - no]) {
no++;
x = i;
}
}
if (no > 1) {
cout << 0;
return 0;
}
if (no == 1) {
int j = x;
while (j > 0 && s[j] == s[j - 1]) {
res.push_back(j + 1);
j--;
}
res.push_back(j + 1);
cout << res.size() << '\n';
for (int i = res.size() - 1; i >= 0; i--) {
cout << res[i] << ' ';
}
}
if (no == 0) {
int j = n - 1;
while (j > 0 && s[j] == s[j - 1]) {
res.push_back(j + 1);
j--;
}
res.push_back(j + 1);
cout << res.size() << '\n';
for (int i = res.size() - 1; i >= 0; i--) {
cout << res[i] << ' ';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1000000000 + 7;
const long long int N = 10000000 + 6;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string st1;
string st2;
cin >> st1 >> st2;
int n = st2.size();
int l = 0, r = 0;
for (int i = 0; i < n; i++) {
if (st1[i] == st2[i])
l++;
else
break;
}
for (int j = n - 1; j >= 0; j--) {
if (st2[j] == st1[j + 1])
r++;
else
break;
}
if (l + 1 < n + 1 - r)
cout << 0 << endl;
else {
int start = max(0, n - r);
int end = min(n, l);
if (start > end) swap(start, end);
cout << end - start + 1 << '\n';
for (int i = start; i <= end; i++) cout << i + 1 << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int SZ = 1 << 20;
char s1[SZ], s2[SZ];
int x, y;
int main() {
gets(s1);
gets(s2);
int n = (int)strlen(s1);
if ((int)strlen(s2) != n - 1) {
puts("0");
return 0;
}
for (int i = 0; i < n - 1; ++i) {
if (s1[i] != s2[i]) break;
x = i + 1;
}
for (int i = 0; i < n - 1; ++i) {
if (s1[n - 1 - i] != s2[n - 2 - i]) break;
y = i + 1;
}
vector<int> r;
for (int i = 0; i < n; ++i)
if (x >= i && y >= n - i - 1) r.push_back(i + 1);
printf("%d\n", (int)r.size());
for (int i = 0; i < (int)r.size(); ++i)
printf("%d%c", r[i], i == (int)r.size() - 1 ? '\n' : ' ');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
unsigned long long aa, hs, hh[1000007], pw[1000007], p1, p2, p3, bs = 101;
int main() {
long long l, u, v, w, x, y, z, a, b, c, d, e, f, t = 1, tc;
long long flg, sz, cnt, gt, ans, mx, mn;
long long m, k, i, j;
long long low, hi, md, sm, ff;
long long n;
pw[0] = 1;
for (int i = 1; i < 1000007; i++) pw[i] = pw[i - 1] * bs;
string st1, st2;
cin >> st1 >> st2;
sz = st1.size();
hs = 0;
for (int i = 0; i < sz; i++) {
hs = hs * bs + (st1[i] - 'a' + 1);
hh[i + 1] = hs;
}
hs = 0;
sz = st2.size();
for (int i = 0; i < sz; i++) {
hs = hs * bs + (st2[i] - 'a' + 1);
}
aa = hs;
sz = st1.size();
vector<long long> tk;
for (int i = 1; i < sz + 1; i++) {
p1 = hh[i - 1];
p2 = hh[sz] - hh[i] * pw[sz - i];
p3 = p1 * pw[sz - i] + p2;
if (p3 == aa) {
tk.push_back(i);
;
}
}
sz = tk.size();
printf("%lld\n", sz);
if (sz) {
printf("%lld", tk[0]);
for (int i = 1; i < sz; i++) printf(" %lld", tk[i]);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b;
int v = -1;
cin >> a >> b;
int jud = 1;
if (a.length() == b.length() + 1) {
v = b.length();
for (int i = 0; i < b.length(); i++) {
if (jud == 1 && a[i] != b[i]) {
jud = 2;
v = i;
}
if (jud == 2 && a[i + 1] != b[i]) {
v = -1;
break;
}
}
}
if (v == -1)
printf("0\n");
else {
int j;
for (j = v; j >= 0; j--) {
if (a[v] != a[j]) break;
}
j++;
printf("%d\n", v - j + 1);
for (int i = j; i <= v; i++) {
if (i == j)
printf("%d", i + 1);
else
printf(" %d", i + 1);
}
printf("\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int OO = 0x3f3f3f3f, N = 1e6 + 5, mod = 1e9 + 7;
const double pi = acos(-1), eps = 1e-9;
string s1, s2;
bool frnt[N], bak[N];
vector<int> ans;
int main() {
cin >> s1 >> s2;
for (int i = 0; i < s1.size(); ++i) {
if (s1[i] != s2[i]) break;
frnt[i] = 1;
}
for (int i = s1.size() - 1; i >= 0; --i) {
if (s1[i] != s2[i - 1]) break;
bak[i] = 1;
}
if (bak[1]) ans.push_back(1);
for (int i = 1; i + 1 < s1.size(); ++i)
if (frnt[i - 1] && bak[i + 1]) ans.push_back(i + 1);
if (frnt[s1.size() - 2]) ans.push_back(s1.size());
printf("%d\n", ans.size());
for (int go : ans) printf("%d ", go);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b;
cin >> a >> b;
int res = -1, pos = -1, j = 0;
for (int i = 0; i < b.size(); i++) {
if (a[j] != b[i]) {
pos = j;
if (res != -1 || a[j + 1] != b[i]) {
res = 0;
break;
}
res = 1;
j++;
}
j++;
}
if (res == -1) res = 1, pos = a.size() - 1;
if (res) {
vector<int> v;
v.push_back(pos);
while (pos > 0 && a[--pos] == a[v[0]]) v.push_back(pos);
cout << v.size() << endl;
for (int i = v.size() - 1; i >= 0; i--) cout << v[i] + 1 << ' ';
cout << endl;
} else
cout << 0 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[1000010], c[1000010];
int r, l;
int main() {
scanf("%s %s", &s, &c);
for (r = 0; s[r] == c[r];) r++;
for (l = strlen(c); l >= 0 && c[l] == s[l + 1];) l--;
if (r > l)
printf("%d\n", r - l);
else
printf("0");
for (int i = l + 1; i <= r; i++) printf("%d ", i + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s1, s2;
int l1, l2;
list<int> poss;
cin >> s1 >> s2;
l1 = s1.length();
l2 = s2.length();
if (l1 < l2 || l1 > l2 + 1) {
cout << 0 << endl;
return 0;
}
int i = 0, j = 0;
char c;
bool found = false;
int pos;
for (; i < l1 && j < l2; i++, j++) {
if (s1[i] != s2[j]) {
if (!found) {
c = s1[i];
pos = i;
i++;
found = true;
} else {
cout << 0 << endl;
return 0;
}
}
}
if (!found) {
c = s1[l1 - 1];
pos = l1 - 1;
}
if (found && s2[l2 - 1] != s1[l1 - 1]) {
cout << 0 << endl;
return 0;
}
poss.push_front(pos);
j = pos - 1;
while (j >= 0 && s2[j] == s1[j + 1]) {
poss.push_front(j);
j--;
}
cout << poss.size() << endl;
list<int>::iterator it = poss.begin();
for (; it != poss.end(); it++) {
cout << (*it) + 1 << " ";
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
string s, t;
cin >> s >> t;
int l = t.size() - 1, r = 0;
while (s[r] == t[r]) {
r++;
}
while (s[l + 1] == t[l]) {
l--;
}
if (r >= l) {
cout << r - l << endl;
for (int i = l + 1; i <= r; i++) cout << i + 1 << " ";
} else
cout << 0 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s, p;
int t, n;
vector<int> v, c;
set<int> let;
int main() {
cin >> s >> p;
if (s == p) return cout << 0, 0;
for (int i = 0; i < s.size(); i++)
if (s[i] != p[t])
n++, v.push_back(i + 1), let.insert(s[i]);
else
t++;
if (v.size() > 1) return cout << 0, 0;
int f = v[0] - 1;
for (int i = f; s[i] == *let.begin(); i--) c.push_back(i);
cout << c.size() << endl;
sort(begin(c), end(c));
for (auto i : c) cout << i + 1 << " ";
}
|
#include <bits/stdc++.h>
int main() {
char *str1, *str2;
str1 = (char *)malloc(1000001);
str2 = (char *)malloc(1000001);
int c1 = 0, c2 = 0;
int flag = 0, mod = 1, pos, pos2, id = 0, len, i, same = 0, j;
scanf("%s", str1);
scanf("%s", str2);
len = strlen(str1);
for (i = 0; i < len; i++) {
if (str1[c1] != str2[c2]) {
if (flag == 1) {
mod = 0;
break;
}
pos = c1 + 1;
flag = 1;
for (j = c1 - 1; j >= 0; j--) {
if (str1[j] == str1[c1]) {
same++;
pos2 = j;
} else
break;
}
c1++;
} else {
c1++;
c2++;
}
}
if (mod == 0)
printf("0\n");
else {
if (same > 0) {
printf("%d\n", same + 1);
for (i = pos2; i < pos2 + same + 1; i++) {
printf("%d", i + 1);
if (i != c1 - 1) printf(" ");
}
printf("\n");
} else {
printf("1\n");
printf("%d\n", pos);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int longestCommonPrefix(vector<string> &strs) {
int j = 0;
int n = strs.size();
if (!n) return 0;
sort(strs.begin(), strs.begin() + n);
for (j = 0; j < strs[0].size() && j < strs[n - 1].size() &&
strs[0][j] == strs[n - 1][j];
j++)
;
return strs[0].substr(0, j).size();
}
int main() {
int l, r;
bool x;
vector<int> pos;
string s, s_inverse, t, t_inverse;
cin >> s >> t;
s_inverse = s;
t_inverse = t;
reverse(s_inverse.begin(), s_inverse.end());
reverse(t_inverse.begin(), t_inverse.end());
vector<string> vec1, vec2;
vec1.push_back(s);
vec1.push_back(t);
vec2.push_back(s_inverse);
vec2.push_back(t_inverse);
l = longestCommonPrefix(vec1);
r = longestCommonPrefix(vec2);
x = (l + 1 < s.size() - r);
if (!x) {
int n = s.size();
int maxx = max(n - r, 1);
int minn = min(l + 1, n);
cout << abs(maxx - minn) + 1 << endl;
for (int i = maxx; i <= minn; i++) {
cout << i << " ";
}
cout << endl;
} else {
cout << "0\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s1[1000005], s2[1000005];
int n, wz = -1;
int main() {
cin >> (s1 + 1) >> (s2 + 1);
n = strlen(s1 + 1);
for (int i = 1, j = 1; i <= n; i++, j++) {
if (i == n && wz == -1 && s1[i] == s2[i - 1]) break;
if (s1[i] == s2[j]) continue;
if (wz != -1) {
cout << 0;
return 0;
}
wz = i;
j--;
}
if (wz == -1) {
cout << n << endl;
for (int i = 1; i <= n; i++) cout << i << ' ';
return 0;
}
int sum = 0, j;
for (int i = wz; s1[i] == s1[wz]; i++) sum++;
for (j = wz - 1; s1[j] == s1[wz]; j--) sum++;
cout << sum << endl;
for (++j; j < wz; j++) cout << j << ' ';
for (int i = wz; s1[i] == s1[wz]; i++) cout << i << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[1100000];
char s1[1100000];
bool pref[1100000];
bool suf[1100000];
int main() {
gets(s);
gets(s1);
int n = strlen(s);
if (n == 1) {
printf("1\n1\n");
return 0;
}
pref[0] = (s[0] == s1[0]);
for (int i = 1; i < n - 1; i++) pref[i] = pref[i - 1] && s[i] == s1[i];
suf[n - 1] = (s[n - 1] == s1[n - 2]);
for (int i = n - 2; i > 0; i--) suf[i] = suf[i + 1] && (s[i] == s1[i - 1]);
int cnt = 0;
for (int i = 0; i < n; i++)
if ((i == 0 || pref[i - 1]) && (i == n - 1 || suf[i + 1])) cnt++;
printf("%d\n", cnt);
for (int i = 0; i < n; i++)
if ((i == 0 || pref[i - 1]) && (i == n - 1 || suf[i + 1]))
printf("%d ", i + 1);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
long long powmod(long long a, long long b, long long mod) {
if (b == 0 || a == 1) {
if (mod == 1)
return 0;
else
return 1;
}
if (b % 2 == 0) {
long long k = powmod(a, b / 2, mod);
return (k * k) % mod;
} else {
long long k = powmod(a, b / 2, mod);
return ((k * k) % mod * a) % mod;
}
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
if (b == 0) return a;
if (a > b)
return gcd(a % b, b);
else
return gcd(b % a, a);
}
long long prime(long long p) {
for (long long i = 2; i * i <= p; i++) {
if (p % i == 0 && i < p) return i;
}
return 1;
}
long long inv(long long a, long long mod) { return powmod(a, mod - 2, mod); }
long long random_modul() {
uniform_int_distribution<long long> u1(1e9, 2e9);
long long pepega = u1(rnd);
while (prime(pepega) != 1) pepega = u1(rnd);
return pepega;
}
long long mod;
void solve() {
string s1, s2;
cin >> s1 >> s2;
long long p = 113;
long long a = s2.size();
vector<long long> pref1(a + 1);
vector<long long> pref2(a);
long long cur = 1;
for (long long i = 0; i <= a; i++) {
if (i) pref1[i] = pref1[i - 1];
pref1[i] += cur * (s1[i] - '0');
cur *= p;
cur %= mod;
pref1[i] %= mod;
}
cur = 1;
for (long long i = 0; i < a; i++) {
if (i) pref2[i] = pref2[i - 1];
pref2[i] += cur * (s2[i] - '0');
cur *= p;
cur %= mod;
pref2[i] %= mod;
}
vector<long long> ans;
for (long long i = 0; i < a + 1; i++) {
long long new_hash = 0;
if (i) new_hash += pref1[i - 1];
if (i < a) new_hash += (pref1[a] - pref1[i] + mod) * inv(p, mod);
new_hash %= mod;
if (new_hash == pref2[a - 1]) {
ans.push_back(i + 1);
}
}
cout << ans.size() << "\n";
for (long long i = 0; i < ans.size(); i++) cout << ans[i] << " ";
return;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long tututu;
tututu = 1;
mod = random_modul();
for (long long qwerty = 0; qwerty < tututu; qwerty++) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string a, b;
int main() {
cin >> a >> b;
int lenb = b.length() - 1;
int i = 0, j = lenb;
while (a[i] == b[i]) i++;
while (a[j + 1] == b[j]) j--;
if (j >= i)
cout << 0;
else {
cout << i - j << endl;
for (int k = j + 1; k <= i; k++) cout << k + 1 << " ";
}
}
|
#include <bits/stdc++.h>
const int k = 10007;
const int max = 1e6;
unsigned long long first_prefixes[max], second_prefixes[max],
first_suffixes[max], second_suffixes[max];
inline void fill_hashes_for(std::string string, int n,
unsigned long long *prefixes,
unsigned long long *suffixes) {
prefixes[0] = (unsigned long long)(unsigned char)string[0];
for (int i = 1; i < n; ++i) {
prefixes[i] = (prefixes[i - 1] * k + string[i]);
}
suffixes[n - 1] = (unsigned long long)(unsigned char)string[n - 1];
for (int i = n - 2; i >= 0; --i) {
suffixes[i] = (suffixes[i + 1] * k + string[i]);
}
}
int main() {
std::string first, second;
std::cin >> first >> second;
int first_len = (int)first.length();
int second_len = (int)second.length();
fill_hashes_for(first, first_len, first_prefixes, first_suffixes);
fill_hashes_for(second, second_len, second_prefixes, second_suffixes);
std::vector<int> result;
for (int i = 0; i < first_len; ++i) {
if ((i == 0 || first_prefixes[i - 1] == second_prefixes[i - 1]) &&
(i == first_len - 1 || first_suffixes[i + 1] == second_suffixes[i]))
result.push_back(i + 1);
}
printf("%d\n", result.size());
for (int index : result) {
printf("%d ", index);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s1, s2;
cin >> s1 >> s2;
int pre = 0, suf = 0;
for (int i = 0; i < s2.size(); i++) {
if (s1[i] == s2[i])
pre++;
else
break;
}
for (int i = s2.size() - 1; i >= 0; i--) {
if (s1[i + 1] == s2[i])
suf++;
else
break;
}
int n = s1.size();
if (pre + suf >= s2.size()) {
cout << -max(n - suf, 1) + min(pre + 1, n) + 1 << endl;
for (int i = max(n - suf, 1); i <= min(pre + 1, n); i++) {
cout << i << " ";
}
} else {
cout << "0" << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
const int M = 1e8;
const long long Max = 1e18 + 1000;
int a[N];
int main() {
string s1, s2;
while (cin >> s1 >> s2) {
string s3;
bool falg = 0;
int ans = 0;
for (int i = 0; i < s1.length(); i++) {
if (s1[i] == s2[i] && falg == 0) s3 += s1[i];
if (falg) {
s3 += s1[i];
continue;
}
if (s1[i] != s2[i]) {
falg = 1;
ans = i;
continue;
}
}
if (s2 != s3)
cout << 0 << endl;
else {
int k = 0;
for (int i = ans; i >= 0; i--) {
if (s1[i] == s1[ans])
a[k++] = i + 1;
else
break;
}
cout << k << endl;
sort(a, a + k);
for (int i = 0; i < k; i++) cout << a[i] << " ";
cout << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool ckmin(T& a, const T& b) {
return b < a ? a = b, 1 : 0;
}
template <class T>
bool ckmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const long double pii = 3.14159265359;
const int MOD = 1000000007;
const char nl = '\n';
const int MX = 200001;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
string s1, s2;
cin >> s1 >> s2;
int i1 = 0, i2 = (int)(s1).size() - 1;
for (int x = 0; x < ((int)(s1).size() - 1); x++) {
if (s1[x] == s2[x]) {
i1 = x + 1;
} else
break;
}
for (int x = ((int)(s1).size()) - 1; x >= 1; x--) {
if (s1[x] == s2[x - 1]) {
i2 = x - 1;
} else
break;
}
bool flag = true;
if (i2 < i1) {
for (int x = i2; x < (i1 + 1); x++) {
if (s1[x] != s1[i2]) flag = false;
}
} else
flag = false;
if (flag) {
i1 = i2;
}
if (i1 != i2 && i2 != 0) {
cout << 0;
return 0;
}
vector<int> res;
res.push_back(i2 + 1);
for (int x = i2 + 1; x < ((int)(s1).size()); x++) {
if (s1[x] == s1[i2]) {
res.push_back(x + 1);
} else
break;
}
cout << (int)(res).size() << nl;
for (auto& i : res) cout << i << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, l, r, tot, ans[1111111];
char a[1111111], b[1111111];
int main() {
scanf("%s", a + 1);
scanf("%s", b + 1);
n = strlen(a + 1);
m = strlen(b + 1);
for (l = 1; a[l] == b[l]; l++)
;
for (r = n; a[r] == b[r - 1]; r--)
;
for (int i = 1; i <= n; i++)
if (i <= l && i >= r) ans[++tot] = i;
printf("%d\n", tot);
if (tot) {
for (int i = 1; i < tot; i++) printf("%d ", ans[i]);
printf("%d\n", ans[tot]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int mod = 1e9 + 7;
long long int Max(long long int a, long long int b, long long int c) {
return max(a, max(c, b));
}
void solve() {
string st1, st2;
cin >> st1 >> st2;
int N = st1.size();
char bad = '*';
int index = -1;
int happen = 0;
int j = 0;
for (int i = 0; i < N; i++) {
if (j < N - 1 and st1[i] != st2[j]) {
happen++;
bad = st1[i];
index = i;
} else
j++;
}
if (happen > 1) {
cout << 0 << endl;
return;
}
if (bad == '*') {
index = N - 1;
bad = st1[N - 1];
int i = N - 1;
int count = 0;
while (i >= 0 and st1[i] == bad) {
i--;
count++;
}
cout << count << endl;
for (int I = i + 1; I < N; I++) {
cout << I + 1 << ' ';
}
return;
}
int count = 0;
int i = index;
while (i < N and st1[i] == bad) {
i++;
count++;
}
i = index - 1;
int start = index;
while (i >= 0 and st1[i] == bad) {
count++;
start--;
i--;
}
cout << count << endl;
for (int i = 0; i < count; i++) {
cout << (start++) + 1 << ' ';
}
cout << endl;
return;
}
int main() {
bool test = false;
if (test) {
int tt;
cin >> tt;
while (tt > 0) {
solve();
tt--;
}
} else {
solve();
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.