problem_id stringlengths 6 6 | language stringclasses 2 values | original_status stringclasses 3 values | original_src stringlengths 19 243k | changed_src stringlengths 19 243k | change stringclasses 3 values | i1 int64 0 8.44k | i2 int64 0 8.44k | j1 int64 0 8.44k | j2 int64 0 8.44k | error stringclasses 270 values | stderr stringlengths 0 226k |
|---|---|---|---|---|---|---|---|---|---|---|---|
p02762 | C++ | Time Limit Exceeded | #include <iostream>
#include <vector>
using namespace std;
int belong_group_num[100001] = {0};
int group_member_cnt[100001] = {0};
vector<vector<int>> frineds_group;
void make_group(const int person, const int group_num,
vector<vector<int>> friends_link) {
if (belong_group_num[person] != 0)
return;
belong_group_num[person] = group_num;
group_member_cnt[group_num]++;
for (int i = 0; i < friends_link[person].size(); i++) {
int next_member = friends_link[person][i];
make_group(next_member, group_num, friends_link);
}
}
int main(void) {
int N, M, K;
cin >> N >> M >> K;
vector<vector<int>> friends_link(N + 1);
vector<vector<int>> blocks(N + 1);
for (int i = 1; i <= N; i++) {
belong_group_num[i] = 0;
group_member_cnt[i] = 0;
}
for (int i = 0; i < M; i++) {
int A, B;
cin >> A >> B;
friends_link[A].push_back(B);
friends_link[B].push_back(A);
}
for (int i = 0; i < K; i++) {
int A, B;
cin >> A >> B;
blocks[A].push_back(B);
blocks[B].push_back(A);
}
int group_cnt = 0;
frineds_group.clear();
for (int i = 1; i <= N; i++) {
if (belong_group_num[i] != 0)
continue;
group_cnt++;
make_group(i, group_cnt, friends_link);
}
// output answer
for (int i = 1; i <= N; i++) {
int ans = group_member_cnt[belong_group_num[i]];
ans -= friends_link[i].size(); // 直接のお友達を引く
ans -= 1; // 自分自身を引く
// blockしている人を引く
for (int j = 0; j < blocks[i].size(); j++) {
int block_member = blocks[i][j];
if (belong_group_num[block_member] == belong_group_num[i]) {
ans--;
}
}
cout << ans << " ";
}
cout << endl;
return 0;
}
| #include <iostream>
#include <vector>
using namespace std;
int belong_group_num[100001] = {0};
int group_member_cnt[100001] = {0};
vector<vector<int>> frineds_group;
void make_group(const int person, const int group_num,
const vector<vector<int>> &friends_link) {
if (belong_group_num[person] != 0)
return;
belong_group_num[person] = group_num;
group_member_cnt[group_num]++;
for (int i = 0; i < friends_link[person].size(); i++) {
int next_member = friends_link[person][i];
make_group(next_member, group_num, friends_link);
}
}
int main(void) {
int N, M, K;
cin >> N >> M >> K;
vector<vector<int>> friends_link(N + 1);
vector<vector<int>> blocks(N + 1);
for (int i = 1; i <= N; i++) {
belong_group_num[i] = 0;
group_member_cnt[i] = 0;
}
for (int i = 0; i < M; i++) {
int A, B;
cin >> A >> B;
friends_link[A].push_back(B);
friends_link[B].push_back(A);
}
for (int i = 0; i < K; i++) {
int A, B;
cin >> A >> B;
blocks[A].push_back(B);
blocks[B].push_back(A);
}
int group_cnt = 0;
frineds_group.clear();
for (int i = 1; i <= N; i++) {
if (belong_group_num[i] != 0)
continue;
group_cnt++;
make_group(i, group_cnt, friends_link);
}
// output answer
for (int i = 1; i <= N; i++) {
int ans = group_member_cnt[belong_group_num[i]];
ans -= friends_link[i].size(); // 直接のお友達を引く
ans -= 1; // 自分自身を引く
// blockしている人を引く
for (int j = 0; j < blocks[i].size(); j++) {
int block_member = blocks[i][j];
if (belong_group_num[block_member] == belong_group_num[i]) {
ans--;
}
}
cout << ans << " ";
}
cout << endl;
return 0;
}
| replace | 10 | 11 | 10 | 11 | TLE | |
p02762 | C++ | Runtime Error | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define P pair<int, int>
using ll = int64_t;
using namespace std;
struct unionfind { // 構造体の定義
vector<int> d; // メンバ変数
unionfind(int n = 0)
: d(n, -1) {
} // コンストラクタ（構造体が呼ばれたときにすぐに実行される処理）
int find(int x) {
if (d[x] < 0)
return x;
return d[x] = find(d[x]);
}
bool unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y)
return false;
if (d[x] < d[y])
swap(x, y); // d[x] is smaller. Then, connect d[x] to d[y].
d[y] += d[x];
d[x] = y;
return true;
}
bool same(int x, int y) { return find(x) == find(y); }
int size(int x) { return -(d[find(x)]); }
};
int main() {
int n, m, k;
cin >> n >> m >> k;
int fr[10005];
vector<int> bl[10005];
unionfind uf(n);
rep(i, m) {
int a, b;
cin >> a >> b;
--a;
--b;
fr[a]++;
fr[b]++;
uf.unite(a, b);
}
rep(i, k) {
int a, b;
cin >> a >> b;
--a;
--b;
bl[a].push_back(b);
bl[b].push_back(a);
}
rep(i, n) {
int ans;
ans = uf.size(i) - 1 - fr[i];
for (int a : bl[i]) {
if (uf.same(i, a))
ans--;
}
cout << ans << " ";
}
cout << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define P pair<int, int>
using ll = int64_t;
using namespace std;
struct unionfind { // 構造体の定義
vector<int> d; // メンバ変数
unionfind(int n = 0)
: d(n, -1) {
} // コンストラクタ（構造体が呼ばれたときにすぐに実行される処理）
int find(int x) {
if (d[x] < 0)
return x;
return d[x] = find(d[x]);
}
bool unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y)
return false;
if (d[x] < d[y])
swap(x, y); // d[x] is smaller. Then, connect d[x] to d[y].
d[y] += d[x];
d[x] = y;
return true;
}
bool same(int x, int y) { return find(x) == find(y); }
int size(int x) { return -(d[find(x)]); }
};
int main() {
int n, m, k;
cin >> n >> m >> k;
int fr[100005];
vector<int> bl[100005];
unionfind uf(n);
rep(i, m) {
int a, b;
cin >> a >> b;
--a;
--b;
fr[a]++;
fr[b]++;
uf.unite(a, b);
}
rep(i, k) {
int a, b;
cin >> a >> b;
--a;
--b;
bl[a].push_back(b);
bl[b].push_back(a);
}
rep(i, n) {
int ans;
ans = uf.size(i) - 1 - fr[i];
for (int a : bl[i]) {
if (uf.same(i, a))
ans--;
}
cout << ans << " ";
}
cout << endl;
return 0;
} | replace | 34 | 36 | 34 | 36 | 0 | |
p02762 | C++ | Runtime Error | #include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
typedef long long ll;
const ll MOD = 1e9 + 7;
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define REP(i, num, n) for (int i = num, i##_len = (n); i < i##_len; ++i)
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
template <class T> inline void add(T &a, T b) {
a = ((a + b) % MOD + MOD) % MOD;
};
#define print(x) (cout << (x) << endl)
#define pb push_back
#define mp make_pair
#define sz(x) int(x.size())
#define fs first
#define sc second
const int INF = 1e9;
const ll LLINF = 1e16;
template <typename T> vector<T> make_v(size_t a) { return vector<T>(a); }
template <typename T, typename... Ts> auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
template <typename T, typename U, typename... V>
typename enable_if<is_same<T, U>::value != 0>::type fill_v(U &u, const V... v) {
u = U(v...);
}
template <typename T, typename U, typename... V>
typename enable_if<is_same<T, U>::value == 0>::type fill_v(U &u, const V... v) {
for (auto &e : u)
fill_v<T>(e, v...);
}
template <typename T> T gcd(T a, T b) { return b ? gcd(b, a % b) : a; }
template <typename T> T ngcd(vector<T> a) {
T res;
res = a[0];
for (int i = 1; i < a.size() && res != 1; i++) {
res = gcd(a[i], res);
}
return res;
}
template <typename T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
template <typename T> T nlcm(vector<T> numbers) {
T res;
res = numbers[0];
for (int i = 1; i < numbers.size(); i++) {
res = lcm(res, numbers[i]);
}
return res;
}
// 割り算の切り上げ処理
template <typename T> T round_up(T a, T b) { return (a + b - 1) / b; }
// 約数列挙
template <typename T> vector<T> calc_divisor(T n) {
vector<T> res;
for (T i = 1LL; i * i <= n; ++i) {
if (n % i == 0) {
res.push_back(i);
T j = n / i;
if (j != i)
res.push_back(j);
}
}
sort(res.begin(), res.end());
return res;
}
// 素数判定
template <typename T> bool isPrime(T x) {
T i;
if (x < 2)
return 0;
else if (x == 2)
return 1;
if (x % 2 == 0)
return 0;
for (i = 3; i * i <= x; i += 2)
if (x % i == 0)
return 0;
return 1;
}
// 桁和
template <typename T> T digsum(T n) {
T res = 0;
while (n > 0) {
res += n % 10;
n /= 10;
}
return res;
}
// 指定した文字cが文字列に何文字入ってるか
ll stringcount(string s, char c) { return count(s.cbegin(), s.cend(), c); }
using pint = pair<int, int>;
using pll = pair<ll, ll>;
struct UnionFind {
vector<int> par;
UnionFind(int n) : par(n, -1) {}
void init(int n) { par.assign(n, -1); }
int root(int x) {
if (par[x] < 0)
return x;
else
return par[x] = root(par[x]);
}
bool issame(int x, int y) { return root(x) == root(y); }
bool merge(int x, int y) {
x = root(x);
y = root(y);
if (x == y)
return false;
if (par[x] > par[y])
swap(x, y); // merge technique
par[x] += par[y];
par[y] = x;
return true;
}
int size(int x) { return -par[root(x)]; }
};
int deg[100005];
vector<int> to[100005];
int main(void) {
cout.tie(0);
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
int n, m, k;
cin >> n >> m >> k;
UnionFind uf(m);
rep(i, m) {
int a, b;
cin >> a >> b;
--a;
--b;
deg[a]++;
deg[b]++;
uf.merge(a, b);
}
rep(i, k) {
int c, d;
cin >> c >> d;
--c;
--d;
to[c].push_back(d);
to[d].push_back(c);
}
rep(i, n) {
int ans = uf.size(i) - 1 - deg[i];
for (int u : to[i]) {
if (uf.issame(i, u))
--ans;
}
print(ans);
}
}
| #include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
typedef long long ll;
const ll MOD = 1e9 + 7;
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define REP(i, num, n) for (int i = num, i##_len = (n); i < i##_len; ++i)
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
template <class T> inline void add(T &a, T b) {
a = ((a + b) % MOD + MOD) % MOD;
};
#define print(x) (cout << (x) << endl)
#define pb push_back
#define mp make_pair
#define sz(x) int(x.size())
#define fs first
#define sc second
const int INF = 1e9;
const ll LLINF = 1e16;
template <typename T> vector<T> make_v(size_t a) { return vector<T>(a); }
template <typename T, typename... Ts> auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
template <typename T, typename U, typename... V>
typename enable_if<is_same<T, U>::value != 0>::type fill_v(U &u, const V... v) {
u = U(v...);
}
template <typename T, typename U, typename... V>
typename enable_if<is_same<T, U>::value == 0>::type fill_v(U &u, const V... v) {
for (auto &e : u)
fill_v<T>(e, v...);
}
template <typename T> T gcd(T a, T b) { return b ? gcd(b, a % b) : a; }
template <typename T> T ngcd(vector<T> a) {
T res;
res = a[0];
for (int i = 1; i < a.size() && res != 1; i++) {
res = gcd(a[i], res);
}
return res;
}
template <typename T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
template <typename T> T nlcm(vector<T> numbers) {
T res;
res = numbers[0];
for (int i = 1; i < numbers.size(); i++) {
res = lcm(res, numbers[i]);
}
return res;
}
// 割り算の切り上げ処理
template <typename T> T round_up(T a, T b) { return (a + b - 1) / b; }
// 約数列挙
template <typename T> vector<T> calc_divisor(T n) {
vector<T> res;
for (T i = 1LL; i * i <= n; ++i) {
if (n % i == 0) {
res.push_back(i);
T j = n / i;
if (j != i)
res.push_back(j);
}
}
sort(res.begin(), res.end());
return res;
}
// 素数判定
template <typename T> bool isPrime(T x) {
T i;
if (x < 2)
return 0;
else if (x == 2)
return 1;
if (x % 2 == 0)
return 0;
for (i = 3; i * i <= x; i += 2)
if (x % i == 0)
return 0;
return 1;
}
// 桁和
template <typename T> T digsum(T n) {
T res = 0;
while (n > 0) {
res += n % 10;
n /= 10;
}
return res;
}
// 指定した文字cが文字列に何文字入ってるか
ll stringcount(string s, char c) { return count(s.cbegin(), s.cend(), c); }
using pint = pair<int, int>;
using pll = pair<ll, ll>;
struct UnionFind {
vector<int> par;
UnionFind(int n) : par(n, -1) {}
void init(int n) { par.assign(n, -1); }
int root(int x) {
if (par[x] < 0)
return x;
else
return par[x] = root(par[x]);
}
bool issame(int x, int y) { return root(x) == root(y); }
bool merge(int x, int y) {
x = root(x);
y = root(y);
if (x == y)
return false;
if (par[x] > par[y])
swap(x, y); // merge technique
par[x] += par[y];
par[y] = x;
return true;
}
int size(int x) { return -par[root(x)]; }
};
int deg[100005];
vector<int> to[100005];
int main(void) {
cout.tie(0);
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
int n, m, k;
cin >> n >> m >> k;
UnionFind uf(n);
rep(i, m) {
int a, b;
cin >> a >> b;
--a;
--b;
deg[a]++;
deg[b]++;
uf.merge(a, b);
}
rep(i, k) {
int c, d;
cin >> c >> d;
--c;
--d;
to[c].push_back(d);
to[d].push_back(c);
}
rep(i, n) {
int ans = uf.size(i) - 1 - deg[i];
for (int u : to[i]) {
if (uf.issame(i, u))
--ans;
}
print(ans);
}
}
| replace | 164 | 165 | 164 | 165 | 0 | |
p02762 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vll;
#define all(x) (x).begin(), (x).end()
ll inf = LLONG_MAX;
long double pi = M_PI;
void Yes() { cout << "Yes" << endl; }
void No() { cout << "No" << endl; }
void YES() { cout << "YES" << endl; }
void NO() { cout << "NO" << endl; }
// UnionFind
// 全て添字で扱うこと
struct union_find {
vll parent;
vll sizes;
// 初期化
void init(ll n) {
for (ll i = 0; i < n; i++)
parent.push_back(i);
for (ll i = 0; i < n; i++)
sizes.push_back(1);
return;
}
// 頂点nの根
ll root(ll n) {
if (parent[n] == n)
return n;
return parent[n] = root(parent[n]);
}
// 頂点nと間接的に繋がっている頂点の数(自身含む)
ll size(ll n) { return sizes[root(n)]; }
// 頂点a, bが間接的に繋がっているか判定
bool is_united(ll a, ll b) { return (root(a) == root(b)); }
// 頂点aを含むグラフに頂点bを含むグラフを結合
void unite(ll a, ll b) {
if (is_united(a, b))
return;
sizes[root(a)] += size(b);
parent[root(b)] = root(a);
return;
}
};
int main() {
ll n, m, k;
cin >> n >> m >> k;
union_find uf;
uf.init(n);
vll a(m), b(m), c(m), d(m);
vector<vll> nx(n);
for (ll i = 0; i < m; i++) {
cin >> a[i] >> b[i];
uf.unite(a[i] - 1, b[i] - 1);
nx[a[i] - 1].push_back(b[i] - 1);
nx[b[i] - 1].push_back(a[i] - 1);
}
vll cnt(n, 0);
for (ll i = 0; i < k; i++) {
cin >> c[i] >> d[i];
if (uf.is_united(c[i] - 1, d[i] - 1)) {
cnt[c[i] - 1]++;
cnt[d[i] - 1]++;
}
}
for (ll i = 0; i < n - 1; i++) {
cout << uf.size(i) - 1 - nx[i].size() - cnt[i] << " ";
}
cout << uf.size(n - 1) - 1 - nx[n - 1].size() - cnt[n - 1] << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vll;
#define all(x) (x).begin(), (x).end()
ll inf = LLONG_MAX;
long double pi = M_PI;
void Yes() { cout << "Yes" << endl; }
void No() { cout << "No" << endl; }
void YES() { cout << "YES" << endl; }
void NO() { cout << "NO" << endl; }
// UnionFind
// 全て添字で扱うこと
struct union_find {
vll parent;
vll sizes;
// 初期化
void init(ll n) {
for (ll i = 0; i < n; i++)
parent.push_back(i);
for (ll i = 0; i < n; i++)
sizes.push_back(1);
return;
}
// 頂点nの根
ll root(ll n) {
if (parent[n] == n)
return n;
return parent[n] = root(parent[n]);
}
// 頂点nと間接的に繋がっている頂点の数(自身含む)
ll size(ll n) { return sizes[root(n)]; }
// 頂点a, bが間接的に繋がっているか判定
bool is_united(ll a, ll b) { return (root(a) == root(b)); }
// 頂点aを含むグラフに頂点bを含むグラフを結合
void unite(ll a, ll b) {
if (is_united(a, b))
return;
sizes[root(a)] += size(b);
parent[root(b)] = root(a);
return;
}
};
int main() {
ll n, m, k;
cin >> n >> m >> k;
union_find uf;
uf.init(n);
vll a(m), b(m), c(k), d(k);
vector<vll> nx(n);
for (ll i = 0; i < m; i++) {
cin >> a[i] >> b[i];
uf.unite(a[i] - 1, b[i] - 1);
nx[a[i] - 1].push_back(b[i] - 1);
nx[b[i] - 1].push_back(a[i] - 1);
}
vll cnt(n, 0);
for (ll i = 0; i < k; i++) {
cin >> c[i] >> d[i];
if (uf.is_united(c[i] - 1, d[i] - 1)) {
cnt[c[i] - 1]++;
cnt[d[i] - 1]++;
}
}
for (ll i = 0; i < n - 1; i++) {
cout << uf.size(i) - 1 - nx[i].size() - cnt[i] << " ";
}
cout << uf.size(n - 1) - 1 - nx[n - 1].size() - cnt[n - 1] << endl;
} | replace | 57 | 58 | 57 | 58 | 0 | |
p02762 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
#define rep(i, N) for (ll(i) = 0; (i) < (N); (i)++)
const int mod = 1000000007;
struct UnionFind {
vector<int> d;
UnionFind(int n = 0) : d(n, -1) {}
int find(int x) {
if (d[x] < 0)
return x;
return d[x] = find(d[x]);
}
bool unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y)
return false;
if (d[x] > d[y])
swap(x, y);
d[x] += d[y];
d[y] = x;
return true;
}
bool same(int x, int y) { return find(x) == find(y); }
int size(int x) { return -d[find(x)]; }
};
int main() {
int n, m, k;
cin >> n >> m >> k;
vector<int> deg(m);
UnionFind uf(n);
rep(i, m) {
int a, b;
cin >> a >> b;
a--;
b--;
uf.unite(a, b);
deg[a]++;
deg[b]++;
}
vector<vector<int>> block(n);
rep(i, k) {
int c, d;
cin >> c >> d;
c--;
d--;
block[c].push_back(d);
block[d].push_back(c);
}
rep(i, n) {
int ans = uf.size(i) - 1 - deg[i];
for (int x : block[i]) {
if (uf.same(i, x))
ans--;
}
printf("%d%c", ans, i == n - 1 ? '\n' : ' ');
}
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
#define rep(i, N) for (ll(i) = 0; (i) < (N); (i)++)
const int mod = 1000000007;
struct UnionFind {
vector<int> d;
UnionFind(int n = 0) : d(n, -1) {}
int find(int x) {
if (d[x] < 0)
return x;
return d[x] = find(d[x]);
}
bool unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y)
return false;
if (d[x] > d[y])
swap(x, y);
d[x] += d[y];
d[y] = x;
return true;
}
bool same(int x, int y) { return find(x) == find(y); }
int size(int x) { return -d[find(x)]; }
};
int main() {
int n, m, k;
cin >> n >> m >> k;
vector<int> deg(n);
UnionFind uf(n);
rep(i, m) {
int a, b;
cin >> a >> b;
a--;
b--;
uf.unite(a, b);
deg[a]++;
deg[b]++;
}
vector<vector<int>> block(n);
rep(i, k) {
int c, d;
cin >> c >> d;
c--;
d--;
block[c].push_back(d);
block[d].push_back(c);
}
rep(i, n) {
int ans = uf.size(i) - 1 - deg[i];
for (int x : block[i]) {
if (uf.same(i, x))
ans--;
}
printf("%d%c", ans, i == n - 1 ? '\n' : ' ');
}
} | replace | 33 | 34 | 33 | 34 | 0 | |
p02762 | C++ | Time Limit Exceeded | #pragma GCC optimize("O3")
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("unroll-loops")
#include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <ratio>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef long double LD;
#define int ll
#define double LD
#define pb push_back
#define mp make_pair
#define REP(i, n) for (int i = 0; i < n; i++)
#define loop(i, n) for (int i = 0; i < n; i++)
#define FOR(i, a, b) for (int i = a; i < b; i++)
#define REPD(i, n) for (int i = n - 1; i >= 0; i--)
#define FORD(i, a, b) for (int i = a; i >= b; i--)
#define remax(a, b) a = max(a, b)
#define remin(a, b) a = min(a, b)
#define mem(a, b) memset(a, b, sizeof a)
#define append push_back
#define all(v) v.begin(), v.end()
#define F first
#define S second
#define print(x) cout << (x) << endl
#define PRECISION(x) cout << fixed << setprecision(x)
#define FAST_IO \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
const double PI = acos(-1);
const int MOD = 1000000007;
const int FMOD = 998244353;
const double eps = 1e-9;
mt19937 RNG(chrono::steady_clock::now().time_since_epoch().count());
int find(int i, int *parent) {
if (parent[i] == i)
return i;
find(parent[i], parent);
}
signed main() {
int n, m, k;
cin >> n >> m >> k;
int connected[n + 1], parent[n + 1], size[n + 1];
vector<int> v[n + 1];
FOR(i, 1, n + 1) {
connected[i] = 0;
parent[i] = i;
size[i] = 1;
}
loop(i, m) {
int x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
connected[x]++;
connected[y]++;
x = find(x, parent);
y = find(y, parent);
if (x != y) {
parent[y] = x;
size[x] += size[y];
}
}
loop(i, k) {
int x, y;
cin >> x >> y;
if (find(x, parent) == find(y, parent)) {
connected[x]++;
connected[y]++;
}
}
FOR(i, 1, n + 1) { cout << size[find(i, parent)] - connected[i] - 1 << " "; }
} | #pragma GCC optimize("O3")
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("unroll-loops")
#include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <ratio>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef long double LD;
#define int ll
#define double LD
#define pb push_back
#define mp make_pair
#define REP(i, n) for (int i = 0; i < n; i++)
#define loop(i, n) for (int i = 0; i < n; i++)
#define FOR(i, a, b) for (int i = a; i < b; i++)
#define REPD(i, n) for (int i = n - 1; i >= 0; i--)
#define FORD(i, a, b) for (int i = a; i >= b; i--)
#define remax(a, b) a = max(a, b)
#define remin(a, b) a = min(a, b)
#define mem(a, b) memset(a, b, sizeof a)
#define append push_back
#define all(v) v.begin(), v.end()
#define F first
#define S second
#define print(x) cout << (x) << endl
#define PRECISION(x) cout << fixed << setprecision(x)
#define FAST_IO \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
const double PI = acos(-1);
const int MOD = 1000000007;
const int FMOD = 998244353;
const double eps = 1e-9;
mt19937 RNG(chrono::steady_clock::now().time_since_epoch().count());
int find(int i, int *parent) {
if (parent[i] == i)
return i;
else
return parent[i] = find(parent[i], parent);
}
signed main() {
int n, m, k;
cin >> n >> m >> k;
int connected[n + 1], parent[n + 1], size[n + 1];
vector<int> v[n + 1];
FOR(i, 1, n + 1) {
connected[i] = 0;
parent[i] = i;
size[i] = 1;
}
loop(i, m) {
int x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
connected[x]++;
connected[y]++;
x = find(x, parent);
y = find(y, parent);
if (x != y) {
parent[y] = x;
size[x] += size[y];
}
}
loop(i, k) {
int x, y;
cin >> x >> y;
if (find(x, parent) == find(y, parent)) {
connected[x]++;
connected[y]++;
}
}
FOR(i, 1, n + 1) { cout << size[find(i, parent)] - connected[i] - 1 << " "; }
} | replace | 72 | 74 | 72 | 74 | TLE | |
p02762 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#include <iomanip>
#include <math.h>
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const int INF = 1001001001;
const int mod = 1e9 + 7;
struct Unionfind {
vector<int> d;
Unionfind(int n) : d(n, -1) {}
int root(int x) {
if (d[x] < 0) {
return x;
}
return d[x] = root(d[x]);
}
bool unite(int x, int y) {
x = root(x);
y = root(y);
if (x == y) {
return false;
}
if (d[x] > d[y]) {
swap(x, y);
}
d[x] += d[y];
d[y] = x;
return true;
}
bool same(int x, int y) { return root(x) == root(y); }
int size(int x) { return -d[root(x)]; }
};
int main() {
int N, M, K;
cin >> N >> M >> K;
Unionfind uf(N);
vector<int> fre(M);
for (int i = 0; i < M; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
fre[a]++;
fre[b]++;
uf.unite(a, b);
}
vector<vector<int>> block(N);
for (int i = 0; i < K; i++) {
int c, d;
cin >> c >> d;
c--;
d--;
block[c].push_back(d);
block[d].push_back(c);
}
for (int i = 0; i < N; i++) {
int sum = uf.size(i) - 1 - fre[i];
for (int c : block[i]) {
if (uf.same(i, c)) {
sum--;
}
}
cout << sum << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#include <iomanip>
#include <math.h>
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const int INF = 1001001001;
const int mod = 1e9 + 7;
struct Unionfind {
vector<int> d;
Unionfind(int n) : d(n, -1) {}
int root(int x) {
if (d[x] < 0) {
return x;
}
return d[x] = root(d[x]);
}
bool unite(int x, int y) {
x = root(x);
y = root(y);
if (x == y) {
return false;
}
if (d[x] > d[y]) {
swap(x, y);
}
d[x] += d[y];
d[y] = x;
return true;
}
bool same(int x, int y) { return root(x) == root(y); }
int size(int x) { return -d[root(x)]; }
};
int main() {
int N, M, K;
cin >> N >> M >> K;
Unionfind uf(N);
vector<int> fre(N);
for (int i = 0; i < M; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
fre[a]++;
fre[b]++;
uf.unite(a, b);
}
vector<vector<int>> block(N);
for (int i = 0; i < K; i++) {
int c, d;
cin >> c >> d;
c--;
d--;
block[c].push_back(d);
block[d].push_back(c);
}
for (int i = 0; i < N; i++) {
int sum = uf.size(i) - 1 - fre[i];
for (int c : block[i]) {
if (uf.same(i, c)) {
sum--;
}
}
cout << sum << endl;
}
return 0;
} | replace | 52 | 53 | 52 | 53 | 0 | |
p02762 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
struct UnionFind {
vector<int> p;
UnionFind(int n) : p(n, 1) {}
int root(int x) {
if (p.at(x) < 0)
return x;
return p.at(x) = root(p.at(x));
}
bool issame(int x, int y) { return root(x) == root(y); }
bool merge(int x, int y) {
x = root(x), y = root(y);
if (x == y)
return 0;
if (p.at(x) > p.at(y))
swap(x, y);
p.at(x) += p.at(y);
p.at(y) = x;
return 1;
}
int size(int x) { return -p.at(root(x)); }
};
int main() {
int N, M, K, A, B;
cin >> N >> M >> K;
UnionFind uf(N);
vector<set<int>> fb(N);
rep(i, M) {
cin >> A >> B;
uf.merge(--A, --B);
fb.at(A).insert(B);
fb.at(B).insert(A);
}
rep(i, K) {
cin >> A >> B;
if (uf.issame(--A, --B)) {
fb.at(A).insert(B);
fb.at(B).insert(A);
}
}
rep(i, N) cout << uf.size(i) - fb.at(i).size() - 1 << " ";
cout << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
struct UnionFind {
vector<int> p;
UnionFind(int n) : p(n, -1) {}
int root(int x) {
if (p.at(x) < 0)
return x;
return p.at(x) = root(p.at(x));
}
bool issame(int x, int y) { return root(x) == root(y); }
bool merge(int x, int y) {
x = root(x), y = root(y);
if (x == y)
return 0;
if (p.at(x) > p.at(y))
swap(x, y);
p.at(x) += p.at(y);
p.at(y) = x;
return 1;
}
int size(int x) { return -p.at(root(x)); }
};
int main() {
int N, M, K, A, B;
cin >> N >> M >> K;
UnionFind uf(N);
vector<set<int>> fb(N);
rep(i, M) {
cin >> A >> B;
uf.merge(--A, --B);
fb.at(A).insert(B);
fb.at(B).insert(A);
}
rep(i, K) {
cin >> A >> B;
if (uf.issame(--A, --B)) {
fb.at(A).insert(B);
fb.at(B).insert(A);
}
}
rep(i, N) cout << uf.size(i) - fb.at(i).size() - 1 << " ";
cout << endl;
} | replace | 6 | 7 | 6 | 7 | -11 | |
p02762 | C++ | Time Limit Exceeded | #include <algorithm>
#include <assert.h>
#include <stdio.h>
#include <string.h>
#pragma warning(disable : 4996)
#define N_MAX 100001
#define M_MAX 100001
#define K_MAX 100001
int N, M, K;
struct NodeInfo {
int index;
int dec;
int size;
int rank;
NodeInfo *p;
NodeInfo() : index(-1), dec(1), size(1), rank(0), p(NULL) {}
};
NodeInfo infos[N_MAX];
int GetGroupIndex(NodeInfo *ni) {
while (ni->p != NULL) {
ni = ni->p;
}
return ni->index;
}
void Merge(NodeInfo *a, NodeInfo *b) {
int ai = GetGroupIndex(a);
int bi = GetGroupIndex(b);
if (ai != bi) {
if (infos[ai].rank > infos[bi].rank) {
int tmp = ai;
ai = bi;
bi = tmp;
}
infos[bi].p = &infos[ai];
infos[ai].size += infos[bi].size;
if (infos[ai].rank < infos[bi].rank + 1) {
infos[ai].rank = infos[bi].rank + 1;
}
}
a->dec += 1;
b->dec += 1;
}
int main(void) {
scanf("%d %d %d", &N, &M, &K);
for (int i = 0; i <= N; ++i) {
infos[i].index = i;
}
// friend ship
for (int i = 0; i < M; ++i) {
int A, B;
scanf("%d %d", &A, &B);
Merge(&infos[A], &infos[B]);
}
// block ship
for (int i = 0; i < K; ++i) {
int C, D;
scanf("%d %d", &C, &D);
if (GetGroupIndex(&infos[C]) == GetGroupIndex(&infos[D])) {
++infos[C].dec;
++infos[D].dec;
}
}
for (int i = 1; i <= N; ++i) {
int gi = GetGroupIndex(&infos[i]);
printf("%d ", infos[gi].size - infos[i].dec);
}
return 0;
}
| #include <algorithm>
#include <assert.h>
#include <stdio.h>
#include <string.h>
#pragma warning(disable : 4996)
#define N_MAX 100001
#define M_MAX 100001
#define K_MAX 100001
int N, M, K;
struct NodeInfo {
int index;
int dec;
int size;
int rank;
NodeInfo *p;
NodeInfo() : index(-1), dec(1), size(1), rank(0), p(NULL) {}
};
NodeInfo infos[N_MAX];
int GetGroupIndex(NodeInfo *ni) {
while (ni->p != NULL) {
ni = ni->p;
}
return ni->index;
}
void Merge(NodeInfo *a, NodeInfo *b) {
int ai = GetGroupIndex(a);
int bi = GetGroupIndex(b);
if (ai != bi) {
if (infos[ai].rank < infos[bi].rank) {
int tmp = ai;
ai = bi;
bi = tmp;
}
infos[bi].p = &infos[ai];
infos[ai].size += infos[bi].size;
if (infos[ai].rank < infos[bi].rank + 1) {
infos[ai].rank = infos[bi].rank + 1;
}
}
a->dec += 1;
b->dec += 1;
}
int main(void) {
scanf("%d %d %d", &N, &M, &K);
for (int i = 0; i <= N; ++i) {
infos[i].index = i;
}
// friend ship
for (int i = 0; i < M; ++i) {
int A, B;
scanf("%d %d", &A, &B);
Merge(&infos[A], &infos[B]);
}
// block ship
for (int i = 0; i < K; ++i) {
int C, D;
scanf("%d %d", &C, &D);
if (GetGroupIndex(&infos[C]) == GetGroupIndex(&infos[D])) {
++infos[C].dec;
++infos[D].dec;
}
}
for (int i = 1; i <= N; ++i) {
int gi = GetGroupIndex(&infos[i]);
printf("%d ", infos[gi].size - infos[i].dec);
}
return 0;
}
| replace | 33 | 34 | 33 | 34 | TLE | |
p02762 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int par[100003], sz[100003];
int find(int v) {
if (par[v] == v)
return v;
return par[v] = find(par[v]);
}
void union_set(int u, int v) {
u = find(u);
v = find(v);
if (u != v) {
if (sz[u] < sz[v])
swap(u, v);
par[v] = u;
sz[u] += sz[v];
}
}
int main() {
int n, m, k;
cin >> n >> m >> k;
int a[n + 1];
int b[n + 1];
memset(a, 0, sizeof(a));
memset(b, 0, sizeof(b));
int u, v;
for (int i = 1; i <= n; i++) {
par[i] = i;
sz[i] = 1;
}
for (int i = 0; i < m; i++) {
cin >> u >> v;
a[u]++;
a[v]++;
union_set(u, v);
}
u = find(u);
for (int i = 0; i < k; i++) {
cin >> u >> v;
if (find(u) == find(v))
b[u]++, b[v]++;
}
for (int i = 1; i <= n; i++) {
int ans = sz[find(i)] - 1 - a[i] - b[i];
cout << ans << " ";
}
cout << "\n";
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int par[100003], sz[100003];
int find(int v) {
if (par[v] == v)
return v;
return par[v] = find(par[v]);
}
void union_set(int u, int v) {
u = find(u);
v = find(v);
if (u != v) {
if (sz[u] < sz[v])
swap(u, v);
par[v] = u;
sz[u] += sz[v];
}
}
int main() {
int n, m, k;
cin >> n >> m >> k;
int a[n + 1];
int b[n + 1];
memset(a, 0, sizeof(a));
memset(b, 0, sizeof(b));
int u, v;
for (int i = 1; i <= n; i++) {
par[i] = i;
sz[i] = 1;
}
for (int i = 0; i < m; i++) {
cin >> u >> v;
a[u]++;
a[v]++;
union_set(u, v);
}
// u=find(u);
for (int i = 0; i < k; i++) {
cin >> u >> v;
if (find(u) == find(v))
b[u]++, b[v]++;
}
for (int i = 1; i <= n; i++) {
int ans = sz[find(i)] - 1 - a[i] - b[i];
cout << ans << " ";
}
cout << "\n";
return 0;
}
| replace | 36 | 37 | 36 | 37 | 0 | |
p02762 | C++ | Runtime Error | #include <iostream>
#include <queue>
#include <set>
#include <vector>
struct Person {
unsigned int index;
unsigned int candidates;
std::set<int> friends, blocked;
bool operator<(const Person &other) const { return index < other.index; }
};
typedef std::vector<Person> Graph;
typedef std::vector<std::set<int>> Group;
const int N = (int)(1e5 + 10);
void bfs(const Graph &g, bool *visited, std::set<int> &group, int start) {
std::queue<int> q;
q.emplace(start);
while (!q.empty()) {
int cur = q.front();
q.pop();
if (visited[cur]) {
continue;
}
visited[cur] = true;
group.emplace(cur);
for (int person : g[cur].friends) {
if (!visited[person]) {
q.emplace(person);
}
}
}
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
std::cout.tie(nullptr);
#if DEBUG_ON
freopen("input", "r", stdin);
#endif
int n, m, k;
std::cin >> n >> m >> k;
Graph g(n + 1);
for (int i = 0; i < n; ++i) {
g[i].index = i;
}
for (int i = 0; i < m; ++i) {
int u, v;
std::cin >> u >> v;
g[u].friends.emplace(v);
g[v].friends.emplace(u);
}
for (int i = 0; i < k; ++i) {
int u, v;
std::cin >> u >> v;
g[u].blocked.emplace(v);
g[v].blocked.emplace(u);
}
Group groups(m);
int groupIndex = 0;
bool visited[N] = {false};
for (int i = 1; i < n; ++i) {
if (!visited[i]) {
bfs(g, visited, groups[groupIndex++], i);
}
}
for (int i = 0; i < groupIndex; ++i) {
for (int member : groups[i]) {
g[member].candidates = groups[i].size() - (1 + g[member].friends.size());
for (int blocked : g[member].blocked) {
if (groups[i].count(blocked) && !g[member].friends.count(blocked)) {
--g[member].candidates;
}
}
}
}
for (int i = 1; i <= n; ++i) {
std::cout << g[i].candidates << ' ';
}
std::cout << '\n';
return 0;
} | #include <iostream>
#include <queue>
#include <set>
#include <vector>
struct Person {
unsigned int index;
unsigned int candidates;
std::set<int> friends, blocked;
bool operator<(const Person &other) const { return index < other.index; }
};
typedef std::vector<Person> Graph;
typedef std::vector<std::set<int>> Group;
const int N = (int)(1e5 + 10);
void bfs(const Graph &g, bool *visited, std::set<int> &group, int start) {
std::queue<int> q;
q.emplace(start);
while (!q.empty()) {
int cur = q.front();
q.pop();
if (visited[cur]) {
continue;
}
visited[cur] = true;
group.emplace(cur);
for (int person : g[cur].friends) {
if (!visited[person]) {
q.emplace(person);
}
}
}
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
std::cout.tie(nullptr);
#if DEBUG_ON
freopen("input", "r", stdin);
#endif
int n, m, k;
std::cin >> n >> m >> k;
Graph g(n + 1);
for (int i = 0; i < n; ++i) {
g[i].index = i;
}
for (int i = 0; i < m; ++i) {
int u, v;
std::cin >> u >> v;
g[u].friends.emplace(v);
g[v].friends.emplace(u);
}
for (int i = 0; i < k; ++i) {
int u, v;
std::cin >> u >> v;
g[u].blocked.emplace(v);
g[v].blocked.emplace(u);
}
Group groups(n + 1);
int groupIndex = 0;
bool visited[N] = {false};
for (int i = 1; i < n; ++i) {
if (!visited[i]) {
bfs(g, visited, groups[groupIndex++], i);
}
}
for (int i = 0; i < groupIndex; ++i) {
for (int member : groups[i]) {
g[member].candidates = groups[i].size() - (1 + g[member].friends.size());
for (int blocked : g[member].blocked) {
if (groups[i].count(blocked) && !g[member].friends.count(blocked)) {
--g[member].candidates;
}
}
}
}
for (int i = 1; i <= n; ++i) {
std::cout << g[i].candidates << ' ';
}
std::cout << '\n';
return 0;
} | replace | 62 | 63 | 62 | 63 | 0 | |
p02762 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using Graph = vector<vector<int>>;
using block = vector<vector<int>>;
vector<int> num;
vector<int> seen;
int groupsize[50001];
int group = 1; // グループ番号
void dfs(const Graph &G, int v) {
seen[v] = group; // v を訪問済にする
groupsize[group]++;
// v から行ける各頂点 next_v について
for (auto next_v : G[v]) {
if (seen[next_v])
continue; // next_v が探索済だったらスルー
dfs(G, next_v); // 再帰的に探索
}
}
int main() {
int n, m, k;
cin >> n >> m >> k;
int ans = 0;
typedef pair<int, int> pair;
map<pair, int> mp;
Graph G(n);
block bl(n);
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
mp[pair(a, b)] = 1; // 友達
mp[pair(b, a)] = 1;
G[a].push_back(b);
G[b].push_back(a);
}
for (int i = 0; i < k; i++) {
int c, d;
cin >> c >> d;
c--;
d--;
mp[pair(c, d)] = 2; // ブロック
mp[pair(d, c)] = 2;
bl[c].push_back(d);
bl[d].push_back(c);
}
// 頂点 0 をスタートとした探索
seen.assign(n, 0); // 全頂点を「未訪問」に初期化
for (int i = 0; i < n; i++) {
if (seen[i] == 0) {
dfs(G, i);
group++;
}
}
num.assign(n, -1);
for (int i = 0; i < n; i++) {
ans = groupsize[seen[i]] - 1;
for (int j = 0; j < G[i].size(); j++) {
// cout << "[" << bl[i][j] << "]";
if (seen[i] == seen[G[i][j]])
ans--;
}
for (int j = 0; j < bl[i].size(); j++) {
// cout << "[" << bl[i][j] << "]";
if (seen[i] == seen[bl[i][j]])
ans--;
}
cout << ans << " ";
// cout << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using Graph = vector<vector<int>>;
using block = vector<vector<int>>;
vector<int> num;
vector<int> seen;
int groupsize[100001];
int group = 1; // グループ番号
void dfs(const Graph &G, int v) {
seen[v] = group; // v を訪問済にする
groupsize[group]++;
// v から行ける各頂点 next_v について
for (auto next_v : G[v]) {
if (seen[next_v])
continue; // next_v が探索済だったらスルー
dfs(G, next_v); // 再帰的に探索
}
}
int main() {
int n, m, k;
cin >> n >> m >> k;
int ans = 0;
typedef pair<int, int> pair;
map<pair, int> mp;
Graph G(n);
block bl(n);
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
mp[pair(a, b)] = 1; // 友達
mp[pair(b, a)] = 1;
G[a].push_back(b);
G[b].push_back(a);
}
for (int i = 0; i < k; i++) {
int c, d;
cin >> c >> d;
c--;
d--;
mp[pair(c, d)] = 2; // ブロック
mp[pair(d, c)] = 2;
bl[c].push_back(d);
bl[d].push_back(c);
}
// 頂点 0 をスタートとした探索
seen.assign(n, 0); // 全頂点を「未訪問」に初期化
for (int i = 0; i < n; i++) {
if (seen[i] == 0) {
dfs(G, i);
group++;
}
}
num.assign(n, -1);
for (int i = 0; i < n; i++) {
ans = groupsize[seen[i]] - 1;
for (int j = 0; j < G[i].size(); j++) {
// cout << "[" << bl[i][j] << "]";
if (seen[i] == seen[G[i][j]])
ans--;
}
for (int j = 0; j < bl[i].size(); j++) {
// cout << "[" << bl[i][j] << "]";
if (seen[i] == seen[bl[i][j]])
ans--;
}
cout << ans << " ";
// cout << endl;
}
return 0;
}
| replace | 7 | 8 | 7 | 8 | 0 | |
p02762 | C++ | Time Limit Exceeded | #include <algorithm>
#include <bitset>
#include <deque>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#include <limits.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
const int INF = 0x7fffffff;
using lll = long long;
using ull = unsigned long long;
using namespace std;
struct p {
int a;
int b;
};
// int friendList[10001][10001];
// int blockList[10001][10001];
using Graph = vector<vector<int>>;
vector<bool> seen;
struct UnionFind {
vector<int> d;
UnionFind(int n) : d(n + 1, -1) {}
int root(int x) {
if (d[x] < 0) {
return x;
} else {
return root(d[x]);
}
}
bool unite(int x, int y) {
x = root(x);
y = root(y);
if (x == y) {
return false;
} else {
if (size(x) < size(y)) {
swap(x, y);
}
d[y] += d[x];
d[x] = y;
return true;
}
}
bool same(int x, int y) {
if (root(x) == root(y)) {
return true;
} else {
return false;
}
}
int size(int x) { return -d[root(x)]; }
};
void dfs(const Graph &g, int v, UnionFind *uf, int root) {
seen[v] = true;
for (auto next_v : g[v]) {
if (seen[next_v])
continue;
uf->unite(root, next_v);
dfs(g, next_v, uf, root);
}
}
int main() {
lll ii, jj, kk;
vector<int> ret;
int n, m, k;
cin >> n >> m >> k;
vector<struct p> friends(m);
vector<struct p> block(k);
set<int> friendSet[n + 1];
set<int> blockSet[n + 1];
Graph g(n + 1);
seen.resize(n + 1);
int a, b, c, d;
// フレンドリスト
for (ii = 0; ii < m; ii++) {
cin >> a >> b;
struct p pp;
pp.a = a;
pp.b = b;
friends.push_back(pp);
friendSet[a].insert(b);
friendSet[b].insert(a);
g[a].push_back(b);
g[b].push_back(a);
// cout <<"a:" << a << "b" << b << endl;
}
struct p p1;
// 拒否リスト
for (ii = 0; ii < k; ii++) {
cin >> c >> d;
// pp = (p*)malloc(sizeof(struct p));
p1.a = c;
p1.b = d;
// cout <<"c:" << c << "d" << d << endl;
block[ii].a = c;
block[ii].b = d;
// block.push_back(p1);
blockSet[c].insert(d);
blockSet[d].insert(c);
}
// for(ii=0;ii<block.size();ii++){
// cout <<"a:" << block[ii].a << "b" << block[ii].b << endl;
// }
// cout << "serach Friend!" << endl;
vector<set<int>> comb;
int combNum = 0;
UnionFind uf(n);
int root;
for (ii = 1; ii <= n; ii++) {
if (!seen[ii]) {
set<int> s;
root = ii;
dfs(g, ii, &uf, root);
comb.push_back(s);
combNum++;
}
}
// cout << combNum << endl;
int fc[n + 1];
for (ii = 1; ii <= n; ii++) {
// cout << "ii:" << ii << " " << uf.size(n) << " " << endl;
fc[ii] = uf.size(ii) - friendSet[ii].size() - 1;
}
for (ii = 0; ii < k; ii++) {
// cout << "size:" << block.size() << endl;
a = block[ii].a;
b = block[ii].b;
// cout <<"a:" << a << "b" << b << endl;
if (uf.same(a, b)) {
fc[a]--;
fc[b]--;
}
}
for (ii = 1; ii <= n; ii++) {
cout << fc[ii] << " ";
}
// for(ii=1;ii<=n;ii++){
// for(jj=1;jj<=n;jj++){
// if(
// }
// }
//
return 0;
}
| #include <algorithm>
#include <bitset>
#include <deque>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#include <limits.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
const int INF = 0x7fffffff;
using lll = long long;
using ull = unsigned long long;
using namespace std;
struct p {
int a;
int b;
};
// int friendList[10001][10001];
// int blockList[10001][10001];
using Graph = vector<vector<int>>;
vector<bool> seen;
struct UnionFind {
vector<int> d;
UnionFind(int n) : d(n + 1, -1) {}
int root(int x) {
if (d[x] < 0) {
return x;
} else {
return root(d[x]);
}
}
bool unite(int x, int y) {
x = root(x);
y = root(y);
if (x == y) {
return false;
} else {
if (size(x) > size(y)) {
swap(x, y);
}
d[y] += d[x];
d[x] = y;
return true;
}
}
bool same(int x, int y) {
if (root(x) == root(y)) {
return true;
} else {
return false;
}
}
int size(int x) { return -d[root(x)]; }
};
void dfs(const Graph &g, int v, UnionFind *uf, int root) {
seen[v] = true;
for (auto next_v : g[v]) {
if (seen[next_v])
continue;
uf->unite(root, next_v);
dfs(g, next_v, uf, root);
}
}
int main() {
lll ii, jj, kk;
vector<int> ret;
int n, m, k;
cin >> n >> m >> k;
vector<struct p> friends(m);
vector<struct p> block(k);
set<int> friendSet[n + 1];
set<int> blockSet[n + 1];
Graph g(n + 1);
seen.resize(n + 1);
int a, b, c, d;
// フレンドリスト
for (ii = 0; ii < m; ii++) {
cin >> a >> b;
struct p pp;
pp.a = a;
pp.b = b;
friends.push_back(pp);
friendSet[a].insert(b);
friendSet[b].insert(a);
g[a].push_back(b);
g[b].push_back(a);
// cout <<"a:" << a << "b" << b << endl;
}
struct p p1;
// 拒否リスト
for (ii = 0; ii < k; ii++) {
cin >> c >> d;
// pp = (p*)malloc(sizeof(struct p));
p1.a = c;
p1.b = d;
// cout <<"c:" << c << "d" << d << endl;
block[ii].a = c;
block[ii].b = d;
// block.push_back(p1);
blockSet[c].insert(d);
blockSet[d].insert(c);
}
// for(ii=0;ii<block.size();ii++){
// cout <<"a:" << block[ii].a << "b" << block[ii].b << endl;
// }
// cout << "serach Friend!" << endl;
vector<set<int>> comb;
int combNum = 0;
UnionFind uf(n);
int root;
for (ii = 1; ii <= n; ii++) {
if (!seen[ii]) {
set<int> s;
root = ii;
dfs(g, ii, &uf, root);
comb.push_back(s);
combNum++;
}
}
// cout << combNum << endl;
int fc[n + 1];
for (ii = 1; ii <= n; ii++) {
// cout << "ii:" << ii << " " << uf.size(n) << " " << endl;
fc[ii] = uf.size(ii) - friendSet[ii].size() - 1;
}
for (ii = 0; ii < k; ii++) {
// cout << "size:" << block.size() << endl;
a = block[ii].a;
b = block[ii].b;
// cout <<"a:" << a << "b" << b << endl;
if (uf.same(a, b)) {
fc[a]--;
fc[b]--;
}
}
for (ii = 1; ii <= n; ii++) {
cout << fc[ii] << " ";
}
// for(ii=1;ii<=n;ii++){
// for(jj=1;jj<=n;jj++){
// if(
// }
// }
//
return 0;
}
| replace | 54 | 55 | 54 | 55 | TLE | |
p02762 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
int n, m, k;
vector<int> friends[100000];
unordered_set<int> blocks[100000];
bool visited[100000];
unordered_set<int> comp;
int ans[100000];
void dfs(int v) {
visited[v - 1] = 1;
comp.insert(v);
for (auto a : friends[v - 1]) {
if (!visited[a - 1])
dfs(a);
}
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(NULL);
cin >> n >> m >> k;
for (int i = 0; i < n; i++) {
visited[i] = 0;
ans[i] = 0;
}
for (int i = 0; i < m; i++) {
int t1, t2;
cin >> t1 >> t2;
friends[t1 - 1].push_back(t2);
friends[t2 - 1].push_back(t1);
}
for (int i = 0; i < k; i++) {
int t1, t2;
cin >> t1 >> t2;
blocks[t1 - 1].insert(t2);
blocks[t2 - 1].insert(t1);
}
for (int i = 0; i < n; i++) {
comp.clear();
if (!visited[i])
dfs(i + 1);
for (auto a : comp) {
int b = 0;
if (comp.size() <= blocks[a - 1].size()) {
for (const auto &x : comp) {
if (blocks[a - 1].count(x) != 0)
b++;
}
} else {
for (const auto &x : blocks[a - 1]) {
if (comp.count(x) != 0)
b++;
}
}
ans[a - 1] = comp.size() - 1 - b - friends[a - 1].size();
}
}
for (int i = 0; i < n; i++)
cout << ans[i] << " ";
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int n, m, k;
vector<int> friends[100000];
unordered_set<int> blocks[100000];
bool visited[100000];
unordered_set<int> comp;
int ans[100000];
void dfs(int v) {
visited[v - 1] = 1;
comp.insert(v);
for (auto a : friends[v - 1]) {
if (!visited[a - 1])
dfs(a);
}
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(NULL);
cin >> n >> m >> k;
for (int i = 0; i < n; i++) {
visited[i] = 0;
ans[i] = 0;
}
for (int i = 0; i < m; i++) {
int t1, t2;
cin >> t1 >> t2;
friends[t1 - 1].push_back(t2);
friends[t2 - 1].push_back(t1);
}
for (int i = 0; i < k; i++) {
int t1, t2;
cin >> t1 >> t2;
blocks[t1 - 1].insert(t2);
blocks[t2 - 1].insert(t1);
}
for (int i = 0; i < n; i++) {
if (comp.size() != 0)
comp.clear();
if (!visited[i])
dfs(i + 1);
for (auto a : comp) {
int b = 0;
if (comp.size() <= blocks[a - 1].size()) {
for (const auto &x : comp) {
if (blocks[a - 1].count(x) != 0)
b++;
}
} else {
for (const auto &x : blocks[a - 1]) {
if (comp.count(x) != 0)
b++;
}
}
ans[a - 1] = comp.size() - 1 - b - friends[a - 1].size();
}
}
for (int i = 0; i < n; i++)
cout << ans[i] << " ";
return 0;
}
| replace | 47 | 48 | 47 | 49 | TLE | |
p02762 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
vector<int64_t> par(100000);
vector<int64_t> r(100000);
int find(int64_t n) {
if (par.at(n) == n) {
return n;
} else {
return par.at(n) = find(par.at(n));
}
}
void unite(int64_t a, int64_t b) {
int64_t x = find(a);
int64_t y = find(b);
if (x == y) {
return;
}
if (r.at(x) > r.at(y)) {
par.at(y) = x;
} else {
par.at(x) = y;
if (r.at(x) == r.at(y)) {
r.at(y)++;
}
}
}
int main() {
int64_t N, M, K;
cin >> N >> M >> K;
vector<pair<int64_t, int64_t>> A(100000), C(100000);
vector<int64_t> block(100000, 0), num(100000, 0);
for (int64_t i = 0; i < N; i++) {
r.at(i) = 0;
par.at(i) = i;
}
for (int64_t i = 0; i < M; i++) {
cin >> A.at(i).first >> A.at(i).second;
unite(A.at(i).first - 1, A.at(i).second - 1);
block.at(A.at(i).first - 1)++;
block.at(A.at(i).second - 1)++;
}
for (int64_t i = 0; i < K; i++) {
cin >> C.at(i).first >> C.at(i).second;
if (find(C.at(i).first) == find(C.at(i).second)) {
block.at(C.at(i).first - 1)++;
block.at(C.at(i).second - 1)++;
}
}
for (int64_t i = 0; i < N; i++) {
num.at(find(i))++;
}
for (int64_t i = 0; i < N; i++) {
cout << num.at(find(i)) - 1 - block.at(i) << " ";
}
cout << endl;
}
| #include <bits/stdc++.h>
using namespace std;
vector<int64_t> par(100000);
vector<int64_t> r(100000);
int find(int64_t n) {
if (par.at(n) == n) {
return n;
} else {
return par.at(n) = find(par.at(n));
}
}
void unite(int64_t a, int64_t b) {
int64_t x = find(a);
int64_t y = find(b);
if (x == y) {
return;
}
if (r.at(x) > r.at(y)) {
par.at(y) = x;
} else {
par.at(x) = y;
if (r.at(x) == r.at(y)) {
r.at(y)++;
}
}
}
int main() {
int64_t N, M, K;
cin >> N >> M >> K;
vector<pair<int64_t, int64_t>> A(100000), C(100000);
vector<int64_t> block(100000, 0), num(100000, 0);
for (int64_t i = 0; i < N; i++) {
r.at(i) = 0;
par.at(i) = i;
}
for (int64_t i = 0; i < M; i++) {
cin >> A.at(i).first >> A.at(i).second;
unite(A.at(i).first - 1, A.at(i).second - 1);
block.at(A.at(i).first - 1)++;
block.at(A.at(i).second - 1)++;
}
for (int64_t i = 0; i < K; i++) {
cin >> C.at(i).first >> C.at(i).second;
if (find(C.at(i).first - 1) == find(C.at(i).second - 1)) {
block.at(C.at(i).first - 1)++;
block.at(C.at(i).second - 1)++;
}
}
for (int64_t i = 0; i < N; i++) {
num.at(find(i))++;
}
for (int64_t i = 0; i < N; i++) {
cout << num.at(find(i)) - 1 - block.at(i) << " ";
}
cout << endl;
} | replace | 46 | 47 | 46 | 47 | 0 | |
p02762 | C++ | Runtime Error | #include <iostream>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
struct UnionFind {
vector<int> d;
UnionFind(int n) : d(n, -1) {}
int find(int x) {
if (d[x] < 0)
return x;
return d[x] = find(d[x]);
}
bool unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y)
return false;
if (d[x] > d[y])
swap(x, y);
d[x] += d[y];
d[y] = x;
return true;
}
bool same(int x, int y) { return find(x) == find(y); }
int size(int x) { return -d[find(x)]; }
};
int deg[10005];
vector<int> to[10005];
int main() {
int n, m, k;
cin >> n >> m >> k;
UnionFind uf(n);
rep(i, m) {
int a, b;
cin >> a >> b;
--a;
--b;
deg[a]++;
deg[b]++;
uf.unite(a, b);
}
rep(i, k) {
int a, b;
cin >> a >> b;
--a;
--b;
to[a].push_back(b);
to[b].push_back(a);
}
rep(i, n) {
int ans = uf.size(i) - 1 - deg[i];
for (int u : to[i]) {
if (uf.same(i, u))
--ans;
}
printf("%d%c", ans, i == n - 1 ? '\n' : ' ');
}
return 0;
}
| #include <iostream>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
struct UnionFind {
vector<int> d;
UnionFind(int n) : d(n, -1) {}
int find(int x) {
if (d[x] < 0)
return x;
return d[x] = find(d[x]);
}
bool unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y)
return false;
if (d[x] > d[y])
swap(x, y);
d[x] += d[y];
d[y] = x;
return true;
}
bool same(int x, int y) { return find(x) == find(y); }
int size(int x) { return -d[find(x)]; }
};
int deg[100005];
vector<int> to[100005];
int main() {
int n, m, k;
cin >> n >> m >> k;
UnionFind uf(n);
rep(i, m) {
int a, b;
cin >> a >> b;
--a;
--b;
deg[a]++;
deg[b]++;
uf.unite(a, b);
}
rep(i, k) {
int a, b;
cin >> a >> b;
--a;
--b;
to[a].push_back(b);
to[b].push_back(a);
}
rep(i, n) {
int ans = uf.size(i) - 1 - deg[i];
for (int u : to[i]) {
if (uf.same(i, u))
--ans;
}
printf("%d%c", ans, i == n - 1 ? '\n' : ' ');
}
return 0;
}
| replace | 30 | 32 | 30 | 32 | 0 | |
p02762 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
struct UnionFind {
vector<int> d;
UnionFind(int n = 0) : d(n, -1) {}
int find(int x) {
if (d[x] < 0)
return x;
return d[x] = find(d[x]);
}
bool unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y)
return false;
if (d[x] > d[y])
swap(x, y);
d[x] += d[y];
d[y] = x;
return true;
}
bool same(int x, int y) { return find(x) == find(y); }
int size(int x) { return -d[find(x)]; }
};
int deg[100005];
vector<int> to[100005];
int main() {
int n, m, k;
cin >> n >> m >> k;
UnionFind uf(n);
rep(i, m) {
int a, b;
cin >> a >> b;
--a;
--b;
deg[a]++;
deg[b]++;
uf.unite(a, b);
}
rep(i, k) {
int a, b;
cin >> a >> b;
--a;
--b;
to[a].push_back(b);
to[b].push_back(a);
}
rep(i, n) {
int ans = uf.size(i) - 1 - deg[i];
for (int u : to[i]) {
if (uf.same(i, u))
--ans;
}
printf("%d%c", ans, i == n - 1 ? '\n' : ' ');
}
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
struct UnionFind {
vector<int> d;
UnionFind(int n = 0) : d(n, -1) {}
int find(int x) {
if (d[x] < 0)
return x;
return d[x] = find(d[x]);
}
bool unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y)
return false;
if (d[x] > d[y])
swap(x, y);
d[x] += d[y];
d[y] = x;
return true;
}
bool same(int x, int y) { return find(x) == find(y); }
int size(int x) { return -d[find(x)]; }
};
int deg[100005];
vector<int> to[100005];
int main() {
int n, m, k;
cin >> n >> m >> k;
UnionFind uf(n);
rep(i, m) {
int a, b;
cin >> a >> b;
--a;
--b;
deg[a]++;
deg[b]++;
uf.unite(a, b);
}
rep(i, k) {
int a, b;
cin >> a >> b;
--a;
--b;
to[a].push_back(b);
to[b].push_back(a);
}
rep(i, n) {
int ans = uf.size(i) - 1 - deg[i];
for (int u : to[i]) {
if (uf.same(i, u))
--ans;
}
printf("%d%c", ans, i == n - 1 ? '\n' : ' ');
}
return 0;
} | replace | 3 | 5 | 3 | 5 | TLE | |
p02763 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
typedef long long ll;
int main() {
int n;
cin >> n;
string s;
cin >> s;
int q;
cin >> q;
vector<int> tp(q), p1(q), p2(q);
vector<char> p3(q);
rep(i, q) {
cin >> tp.at(i) >> p1.at(i);
if (tp.at(i) == 2)
cin >> p2.at(i);
else
cin >> p3.at(i);
}
vector<set<int>> vs(26);
rep(i, s.size()) { vs.at(s.at(i) - 'a').insert(i + 1); }
rep(i, q) {
if (tp.at(i) == 1) {
rep(j, 26) { vs.at(j).erase(p1.at(i)); }
vs.at(p3.at(i) - 'a').insert(p1.at(i));
} else {
int cnt = 0;
rep(j, 26) {
auto lt = lower_bound(vs.at(j).begin(), vs.at(j).end(), p1.at(i));
if (lt != vs.at(j).end() && *lt <= p2.at(i)) {
cnt++;
}
}
cout << cnt << endl;
}
}
// rep(i,26){
// if(vs.at(i).size() == 0) continue;
// char c = 'a' + i;
// cout << c << ":";
// for(auto x:vs.at(i)){
// cout << x << " ";
// }
// cout << endl;
// }
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
typedef long long ll;
int main() {
int n;
cin >> n;
string s;
cin >> s;
int q;
cin >> q;
vector<int> tp(q), p1(q), p2(q);
vector<char> p3(q);
rep(i, q) {
cin >> tp.at(i) >> p1.at(i);
if (tp.at(i) == 2)
cin >> p2.at(i);
else
cin >> p3.at(i);
}
vector<set<int>> vs(26);
rep(i, s.size()) { vs.at(s.at(i) - 'a').insert(i + 1); }
rep(i, q) {
if (tp.at(i) == 1) {
rep(j, 26) { vs.at(j).erase(p1.at(i)); }
vs.at(p3.at(i) - 'a').insert(p1.at(i));
} else {
int cnt = 0;
rep(j, 26) {
auto lt = vs.at(j).lower_bound(p1.at(i));
if (lt != vs.at(j).end() && *lt <= p2.at(i)) {
cnt++;
}
}
cout << cnt << endl;
}
}
// rep(i,26){
// if(vs.at(i).size() == 0) continue;
// char c = 'a' + i;
// cout << c << ":";
// for(auto x:vs.at(i)){
// cout << x << " ";
// }
// cout << endl;
// }
return 0;
} | replace | 31 | 32 | 31 | 32 | TLE | |
p02763 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
template <typename Monoid = ll> class SegmentTree {
public:
using Monoid_func = function<Monoid(Monoid, Monoid)>;
ll size;
std::vector<Monoid> segment; // 1-indexed 葉ノードは size ~ 2*size-1
Monoid Monoid_unit;
Monoid_func Monoid_calc;
SegmentTree(
ll N, Monoid Monoid_unit = 0,
Monoid_func Monoid_calc = [](ll a, ll b) { return a + b; })
: size(1), Monoid_unit(Monoid_unit), Monoid_calc(Monoid_calc) {
while (size < N)
size <<= 1;
segment.assign(size * 2, Monoid_unit);
}
void set(ll k, Monoid a) { segment[k + size] = a; }
void build() { // 全てのノードを再計算
for (ll k = size - 1; k > 0; k--)
segment[k] = Monoid_calc(segment[k * 2], segment[k * 2 + 1]);
}
void build(std::vector<Monoid> v) {
for (ll k = 0; k < size; k++) {
segment[k + size] = v[k];
}
build();
}
void update_replace(ll k, Monoid a) {
k += size;
segment[k] = a;
while (k >>= 1)
segment[k] = Monoid_calc(segment[k * 2], segment[k * 2 + 1]);
}
void update_add(ll k, Monoid a) {
k += size;
segment[k] = Monoid_calc(segment[k], a);
while (k >>= 1)
segment[k] = Monoid_calc(segment[k * 2], segment[k * 2 + 1]);
}
void update_del(ll k, Monoid a) {
k += size;
segment[k] = Monoid_calc_back(segment[k], a);
while (k >>= 1)
segment[k] = Monoid_calc_back(segment[k * 2], segment[k * 2 + 1]);
}
Monoid query(ll a, ll b) { // [a, b)の演算結果
Monoid l = Monoid_unit, r = Monoid_unit;
for (a += size, b += size; a < b; a >>= 1, b >>= 1) {
if (a % 2 == 1)
l = Monoid_calc(l, segment[a++]);
if (b % 2 == 1)
r = Monoid_calc(segment[--b], r);
}
return Monoid_calc(l, r);
}
Monoid operator[](const ll &k) const { return segment[k + size]; }
};
int main() {
ll n, q;
cin >> n;
string s;
cin >> s;
vector<int> beg(26);
vector<vector<int>> in;
in.clear();
for (auto i : s) {
vector<int> v(26);
v[i - 'a'] = 1;
in.push_back(v);
}
while (in.size() < 26)
in.push_back(beg);
SegmentTree<vector<int>> st(n, beg, [](vector<int> a, vector<int> b) {
vector<int> ans(26);
REP(i, 26) ans[i] = a[i] + b[i];
return ans;
});
st.build(in);
ll num, l, r;
char c;
cin >> q;
REP(i, q) {
cin >> num;
if (num == 1) {
cin >> l >> c;
vector<int> v(26);
v[c - 'a']++;
vector<int> vv = st[l - 1];
int vvv;
REP(j, 26) if (vv[j] != 0) vvv = j;
v[vvv]--;
st.update_add(l - 1, v);
} else {
cin >> l >> r;
vector<int> ans = st.query(l - 1, r);
ll out = 0;
REP(i, 26) out += (ans[i] != 0);
cout << out << endl;
}
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
template <typename Monoid = ll> class SegmentTree {
public:
using Monoid_func = function<Monoid(Monoid, Monoid)>;
ll size;
std::vector<Monoid> segment; // 1-indexed 葉ノードは size ~ 2*size-1
Monoid Monoid_unit;
Monoid_func Monoid_calc;
SegmentTree(
ll N, Monoid Monoid_unit = 0,
Monoid_func Monoid_calc = [](ll a, ll b) { return a + b; })
: size(1), Monoid_unit(Monoid_unit), Monoid_calc(Monoid_calc) {
while (size < N)
size <<= 1;
segment.assign(size * 2, Monoid_unit);
}
void set(ll k, Monoid a) { segment[k + size] = a; }
void build() { // 全てのノードを再計算
for (ll k = size - 1; k > 0; k--)
segment[k] = Monoid_calc(segment[k * 2], segment[k * 2 + 1]);
}
void build(std::vector<Monoid> v) {
for (ll k = 0; k < size; k++) {
segment[k + size] = v[k];
}
build();
}
void update_replace(ll k, Monoid a) {
k += size;
segment[k] = a;
while (k >>= 1)
segment[k] = Monoid_calc(segment[k * 2], segment[k * 2 + 1]);
}
void update_add(ll k, Monoid a) {
k += size;
segment[k] = Monoid_calc(segment[k], a);
while (k >>= 1)
segment[k] = Monoid_calc(segment[k * 2], segment[k * 2 + 1]);
}
void update_del(ll k, Monoid a) {
k += size;
segment[k] = Monoid_calc_back(segment[k], a);
while (k >>= 1)
segment[k] = Monoid_calc_back(segment[k * 2], segment[k * 2 + 1]);
}
Monoid query(ll a, ll b) { // [a, b)の演算結果
Monoid l = Monoid_unit, r = Monoid_unit;
for (a += size, b += size; a < b; a >>= 1, b >>= 1) {
if (a % 2 == 1)
l = Monoid_calc(l, segment[a++]);
if (b % 2 == 1)
r = Monoid_calc(segment[--b], r);
}
return Monoid_calc(l, r);
}
Monoid operator[](const ll &k) const { return segment[k + size]; }
};
int main() {
ll n, q;
cin >> n;
string s;
cin >> s;
vector<int> beg(26);
vector<vector<int>> in;
in.clear();
for (auto i : s) {
vector<int> v(26);
v[i - 'a'] = 1;
in.push_back(v);
}
int size = 1;
while (size < n)
size <<= 1;
while (in.size() < size)
in.push_back(beg);
SegmentTree<vector<int>> st(n, beg, [](vector<int> a, vector<int> b) {
vector<int> ans(26);
REP(i, 26) ans[i] = a[i] + b[i];
return ans;
});
st.build(in);
ll num, l, r;
char c;
cin >> q;
REP(i, q) {
cin >> num;
if (num == 1) {
cin >> l >> c;
vector<int> v(26);
v[c - 'a']++;
vector<int> vv = st[l - 1];
int vvv;
REP(j, 26) if (vv[j] != 0) vvv = j;
v[vvv]--;
st.update_add(l - 1, v);
} else {
cin >> l >> r;
vector<int> ans = st.query(l - 1, r);
ll out = 0;
REP(i, 26) out += (ans[i] != 0);
cout << out << endl;
}
}
return 0;
} | replace | 78 | 79 | 78 | 82 | 0 | |
p02763 | C++ | Runtime Error | #include <bits/stdc++.h>
#define ll long long
#define ld long double
#define fi first
#define se second
#define pb push_back
#define pii pair<int, int>
#define pll pair<long long, long long>
using namespace std;
int BIT[300010][30], n, q, t, l, r, pos, ans;
char ch;
string s;
void updateBIT(int pos, int f, int val) {
while (pos <= n) {
BIT[pos][f] += val;
pos += (pos & (-pos));
}
return;
}
int queryBIT(int pos, int f) {
int myAns = 0;
while (pos > 0) {
myAns += BIT[pos][f];
pos -= (pos & (-pos));
}
return myAns;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> s >> q;
for (int i = 1; i <= n; i++)
updateBIT(i, s[i - 1] - 'a', 1);
while (q--) {
cin >> t;
if (t == 1) {
cin >> pos >> ch;
updateBIT(pos, s[pos - 1] - 'a', -1);
s[pos - 1] = ch;
updateBIT(pos, s[pos - 1] - 'a', 1);
} else {
cin >> l >> r;
ans = 0;
for (int i = 0; i <= 'z' - 'a'; i++)
ans += min(queryBIT(r, i) - queryBIT(l - 1, i), 1);
cout << ans << "\n";
}
}
return 0;
}
| #include <bits/stdc++.h>
#define ll long long
#define ld long double
#define fi first
#define se second
#define pb push_back
#define pii pair<int, int>
#define pll pair<long long, long long>
using namespace std;
int BIT[500010][30], n, q, t, l, r, pos, ans;
char ch;
string s;
void updateBIT(int pos, int f, int val) {
while (pos <= n) {
BIT[pos][f] += val;
pos += (pos & (-pos));
}
return;
}
int queryBIT(int pos, int f) {
int myAns = 0;
while (pos > 0) {
myAns += BIT[pos][f];
pos -= (pos & (-pos));
}
return myAns;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> s >> q;
for (int i = 1; i <= n; i++)
updateBIT(i, s[i - 1] - 'a', 1);
while (q--) {
cin >> t;
if (t == 1) {
cin >> pos >> ch;
updateBIT(pos, s[pos - 1] - 'a', -1);
s[pos - 1] = ch;
updateBIT(pos, s[pos - 1] - 'a', 1);
} else {
cin >> l >> r;
ans = 0;
for (int i = 0; i <= 'z' - 'a'; i++)
ans += min(queryBIT(r, i) - queryBIT(l - 1, i), 1);
cout << ans << "\n";
}
}
return 0;
}
| replace | 10 | 11 | 10 | 11 | 0 | |
p02763 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vll;
#define all(x) (x).begin(), (x).end()
ll inf = LLONG_MAX;
long double pi = M_PI;
void Yes() { cout << "Yes" << endl; }
void No() { cout << "No" << endl; }
void YES() { cout << "YES" << endl; }
void NO() { cout << "NO" << endl; }
int main() {
ll n, q;
string s;
cin >> n >> s >> q;
set<ll> st;
map<char, set<ll>> place;
for (char c = 'a'; c <= 'z'; c++)
place[c] = st;
for (ll i = 0; i < n; i++) {
place[s[i]].insert(i);
}
/*for (ll i = 0; i < 26; i++) {
for (ll j = 0; j < n - 1; j++) {
cout << v[i][j] << " ";
}
cout << v[i][n - 1] << endl;
}*/
for (ll i = 0; i < q; i++) {
ll x;
cin >> x;
if (x == 1) {
ll y;
char c;
cin >> y >> c;
if (s[y - 1] == c)
continue;
place[s[y - 1]].erase(y - 1);
place[c].insert(y - 1);
s[y - 1] = c;
} else {
ll l, r;
cin >> l >> r;
ll cnt = 0;
for (char c = 'a'; c <= 'z'; c++) {
auto itr = lower_bound(place[c].begin(), place[c].end(), l - 1);
if (itr != place[c].end() && *itr < r) {
cnt++;
}
}
cout << cnt << endl;
}
}
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vll;
#define all(x) (x).begin(), (x).end()
ll inf = LLONG_MAX;
long double pi = M_PI;
void Yes() { cout << "Yes" << endl; }
void No() { cout << "No" << endl; }
void YES() { cout << "YES" << endl; }
void NO() { cout << "NO" << endl; }
int main() {
ll n, q;
string s;
cin >> n >> s >> q;
set<ll> st;
map<char, set<ll>> place;
for (char c = 'a'; c <= 'z'; c++)
place[c] = st;
for (ll i = 0; i < n; i++) {
place[s[i]].insert(i);
}
/*for (ll i = 0; i < 26; i++) {
for (ll j = 0; j < n - 1; j++) {
cout << v[i][j] << " ";
}
cout << v[i][n - 1] << endl;
}*/
for (ll i = 0; i < q; i++) {
ll x;
cin >> x;
if (x == 1) {
ll y;
char c;
cin >> y >> c;
if (s[y - 1] == c)
continue;
place[s[y - 1]].erase(y - 1);
place[c].insert(y - 1);
s[y - 1] = c;
} else {
ll l, r;
cin >> l >> r;
ll cnt = 0;
for (char c = 'a'; c <= 'z'; c++) {
auto itr = place[c].lower_bound(l - 1);
if (itr != place[c].end() && *itr < r) {
cnt++;
}
}
cout << cnt << endl;
}
}
} | replace | 53 | 54 | 53 | 54 | TLE | |
p02763 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define Int int64_t
using namespace std;
int main() {
int N, Q;
string s;
cin >> N >> s >> Q;
vector<set<int>> st(26);
for (int i = 0; i < N; ++i) {
st[(int)(s[i] - 'a')].insert(i);
}
for (int i = 0; i < 26; ++i) {
st[i].insert(N);
}
vector<int> ans;
for (int q = 0; q < Q; ++q) {
int t;
cin >> t;
if (t == 1) {
int idx;
char c;
cin >> idx >> c;
--idx;
for (int i = 0; i < 26; ++i) {
if (st[i].count(idx) > 0) {
st[i].erase(idx);
}
if (i == (int)(c - 'a')) {
st[i].insert(idx);
}
}
} else {
int l, r;
cin >> l >> r;
--l;
int cnt = 0;
for (int i = 0; i < 26; ++i) {
cnt += *lower_bound(st[i].begin(), st[i].end(), l) < r;
}
ans.emplace_back(cnt);
}
}
for (int val : ans) {
cout << val << endl;
}
return 0;
}
| #include <bits/stdc++.h>
#define Int int64_t
using namespace std;
int main() {
int N, Q;
string s;
cin >> N >> s >> Q;
vector<set<int>> st(26);
for (int i = 0; i < N; ++i) {
st[(int)(s[i] - 'a')].insert(i);
}
for (int i = 0; i < 26; ++i) {
st[i].insert(N);
}
vector<int> ans;
for (int q = 0; q < Q; ++q) {
int t;
cin >> t;
if (t == 1) {
int idx;
char c;
cin >> idx >> c;
--idx;
for (int i = 0; i < 26; ++i) {
if (st[i].count(idx) > 0) {
st[i].erase(idx);
}
if (i == (int)(c - 'a')) {
st[i].insert(idx);
}
}
} else {
int l, r;
cin >> l >> r;
--l;
int cnt = 0;
for (int i = 0; i < 26; ++i) {
cnt += *st[i].lower_bound(l) < r;
}
ans.emplace_back(cnt);
}
}
for (int val : ans) {
cout << val << endl;
}
return 0;
}
| replace | 40 | 41 | 40 | 41 | TLE | |
p02763 | C++ | Time Limit Exceeded | #include <algorithm>
#include <climits>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <utility>
#include <vector>
using namespace std;
template <class T> ostream &operator<<(ostream &o, const vector<T> &v) {
o << "{";
for (int i = 0; i < (int)v.size(); i++)
o << (i > 0 ? ", " : "") << v[i];
o << "}";
return o;
}
#define debug(v) \
{ cerr << "\033[1;36m[debug]\033[m " << #v << " : " << v << endl; }
#define all(x) (x).begin(), (x).end()
// using int64 = long long;
typedef long long int64;
int main() {
int n;
string s;
cin >> n >> s;
vector<set<int>> alpha(26);
for (int i = 0; i < n; i++)
alpha[s[i] - 'a'].insert(i);
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int type;
cin >> type;
switch (type) {
case 1:
int i;
char c;
cin >> i >> c;
alpha[s[i - 1] - 'a'].erase(i - 1);
alpha[c - 'a'].insert(i - 1);
s[i - 1] = c;
break;
case 2:
int l, r;
cin >> l >> r;
int ans = 0;
for (int i = 0; i < 26; i++) {
auto it = lower_bound(all(alpha[i]), l - 1);
if (it != alpha[i].end() && *it < r)
ans++;
}
cout << ans << endl;
break;
}
}
}
| #include <algorithm>
#include <climits>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <utility>
#include <vector>
using namespace std;
template <class T> ostream &operator<<(ostream &o, const vector<T> &v) {
o << "{";
for (int i = 0; i < (int)v.size(); i++)
o << (i > 0 ? ", " : "") << v[i];
o << "}";
return o;
}
#define debug(v) \
{ cerr << "\033[1;36m[debug]\033[m " << #v << " : " << v << endl; }
#define all(x) (x).begin(), (x).end()
// using int64 = long long;
typedef long long int64;
int main() {
int n;
string s;
cin >> n >> s;
vector<set<int>> alpha(26);
for (int i = 0; i < n; i++)
alpha[s[i] - 'a'].insert(i);
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int type;
cin >> type;
switch (type) {
case 1:
int i;
char c;
cin >> i >> c;
alpha[s[i - 1] - 'a'].erase(i - 1);
alpha[c - 'a'].insert(i - 1);
s[i - 1] = c;
break;
case 2:
int l, r;
cin >> l >> r;
int ans = 0;
for (int i = 0; i < 26; i++) {
auto it = alpha[i].lower_bound(l - 1);
if (it != alpha[i].end() && *it < r)
ans++;
}
cout << ans << endl;
break;
}
}
}
| replace | 54 | 55 | 54 | 55 | TLE | |
p02763 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define int long long int
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<pii> vpii;
typedef vector<vector<int>> vvi;
typedef unordered_map<int, int> uoii;
typedef unordered_map<string, int> uosi;
const int MOD = 1e9 + 7;
const int INF = 1e10;
int n;
const int MAXT = 5e5 + 10;
int tr[26][MAXT];
string s;
void add(int *tr, int x, int v) {
// cout<<"AAA "<<x<<" "<<n<<'\n';
for (int i = x; i <= n; i += i & -i) {
tr[i] += v;
// cout<<"TR "<<tr[i]<<" ";
}
// cout<<'\n';
}
int f(int *tr, int x) {
int ans = 0;
for (int i = x; i > 0; i -= i & -i) {
// cout<<"IN";
ans += tr[i];
}
return ans;
}
int get(int *tr, int l, int r) {
// cout<<"GET "<<n<<'\n';
// cout<<l<<" "<<r<<'\n';
if (l > r)
return 0;
int x = f(tr, r);
int y = f(tr, l - 1);
// cout<<x<<" "<<y<<'\n';
/*
for(int i=0;i<8;i++){
cout<<tr[i]<<" "<<' ';
}
cout<<'\n';*/
return (x - y) >= 1;
}
int32_t main() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
IOS
cin >>
n;
cin >> s;
for (int i = 1; i <= n; i++) {
int x = s[i - 1] - 'a';
add(tr[x], i, 1);
}
int q;
cin >> q;
while (q--) {
int a;
cin >> a;
if (a == 1) {
int l;
char t;
cin >> l >> t;
int x = s[l - 1] - 'a';
int y = t - 'a';
add(tr[x], l, -1);
add(tr[y], l, 1);
s[l - 1] = t;
} else {
int l, r;
cin >> l >> r;
int ans = 0;
for (int i = 0; i < 26; i++) {
// cout<<"IND "<<i<<'\n';
ans += get(tr[i], l, r);
}
cout << ans << '\n';
}
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define int long long int
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<pii> vpii;
typedef vector<vector<int>> vvi;
typedef unordered_map<int, int> uoii;
typedef unordered_map<string, int> uosi;
const int MOD = 1e9 + 7;
const int INF = 1e10;
int n;
const int MAXT = 5e5 + 10;
int tr[26][MAXT];
string s;
void add(int *tr, int x, int v) {
// cout<<"AAA "<<x<<" "<<n<<'\n';
for (int i = x; i <= n; i += i & -i) {
tr[i] += v;
// cout<<"TR "<<tr[i]<<" ";
}
// cout<<'\n';
}
int f(int *tr, int x) {
int ans = 0;
for (int i = x; i > 0; i -= i & -i) {
// cout<<"IN";
ans += tr[i];
}
return ans;
}
int get(int *tr, int l, int r) {
// cout<<"GET "<<n<<'\n';
// cout<<l<<" "<<r<<'\n';
if (l > r)
return 0;
int x = f(tr, r);
int y = f(tr, l - 1);
// cout<<x<<" "<<y<<'\n';
/*
for(int i=0;i<8;i++){
cout<<tr[i]<<" "<<' ';
}
cout<<'\n';*/
return (x - y) >= 1;
}
int32_t main() {
IOS
cin >>
n;
cin >> s;
for (int i = 1; i <= n; i++) {
int x = s[i - 1] - 'a';
add(tr[x], i, 1);
}
int q;
cin >> q;
while (q--) {
int a;
cin >> a;
if (a == 1) {
int l;
char t;
cin >> l >> t;
int x = s[l - 1] - 'a';
int y = t - 'a';
add(tr[x], l, -1);
add(tr[y], l, 1);
s[l - 1] = t;
} else {
int l, r;
cin >> l >> r;
int ans = 0;
for (int i = 0; i < 26; i++) {
// cout<<"IND "<<i<<'\n';
ans += get(tr[i], l, r);
}
cout << ans << '\n';
}
}
return 0;
}
| replace | 64 | 68 | 64 | 65 | 127 | /tmp/bd3b8006-6182-4af6-ab8e-9bea20318a86.out: error while loading shared libraries: libstdc++.so.6: failed to map segment from shared object
|
p02763 | C++ | Runtime Error | #include <bits/stdc++.h>
#define sz(x) (int)x.size()
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
string a;
cin >> a;
set<int> s[26];
for (int i = 0; i < sz(a); i++)
a[i] -= 'a', s[a[i]].insert(i);
int q;
cin >> q;
for (int t, l; q--;) {
cin >> t >> l, l--;
if (t == 1) {
char c;
cin >> c;
s[a[l]].erase(l);
a[l] = c - 'a';
s[a[l]].insert(l);
} else {
int r, ans = 0;
cin >> r;
for (int i = 0; i < 26; i++) {
auto x = s[i].lower_bound(l);
ans += (x != s[i].end() && *x < r);
}
cout << ans << "\n";
}
}
return 0;
}
| #include <bits/stdc++.h>
#define sz(x) (int)x.size()
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
string a;
cin >> a;
set<int> s[26];
for (int i = 0; i < sz(a); i++)
a[i] -= 'a', s[a[i]].insert(i);
int q;
cin >> q;
for (int t, l; q--;) {
cin >> t >> l, l--;
if (t == 1) {
char c;
cin >> c;
s[a[l]].erase(l);
a[l] = c - 'a';
s[a[l]].insert(l);
} else {
int r, ans = 0;
cin >> r;
for (int i = 0; i < 26; i++) {
auto x = s[i].lower_bound(l);
ans += (x != s[i].end() && *x < r);
}
cout << ans << "\n";
}
}
return 0;
}
| insert | 9 | 9 | 9 | 11 | -11 | |
p02763 | C++ | Runtime Error | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define PI 3.14159265359
#define INF 1000100100
#define all(x) (x).begin(), (x).end()
typedef long long ll;
#define P pair<ll, ll>
#define PP pair<P, P>
using namespace std;
int main() {
int n;
cin >> n;
string s;
cin >> s;
int Q;
cin >> Q;
vector<vector<int>> ap(26);
rep(i, n) ap[s[i] - 'a'].push_back(i);
rep(i, Q) {
int a;
cin >> a;
if (a == 1) {
int it;
char next;
cin >> it >> next;
it--;
auto whe = lower_bound(all(ap[s[it] - 'a']), it);
ap[s[it] - 'a'].erase(whe);
if (ap[next - 'a'].empty())
ap[next - 'a'].push_back(it);
else {
whe = lower_bound(all(ap[next - 'a']), it);
whe = ap[next - 'a'].insert(whe - 1, it);
}
s[it] = next;
} else {
int l, r;
cin >> l >> r;
l--;
r--;
int ans = 0;
rep(j, 26) {
if (ap[j].empty())
continue;
auto whe2 = lower_bound(all(ap[j]), l);
if (ap[j][whe2 - ap[j].begin()] <= r &&
whe2 - ap[j].begin() != ap[j].size())
ans++;
}
cout << ans << endl;
}
}
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define PI 3.14159265359
#define INF 1000100100
#define all(x) (x).begin(), (x).end()
typedef long long ll;
#define P pair<ll, ll>
#define PP pair<P, P>
using namespace std;
int main() {
int n;
cin >> n;
string s;
cin >> s;
int Q;
cin >> Q;
vector<vector<int>> ap(26);
rep(i, n) ap[s[i] - 'a'].push_back(i);
rep(i, Q) {
int a;
cin >> a;
if (a == 1) {
int it;
char next;
cin >> it >> next;
it--;
auto whe = lower_bound(all(ap[s[it] - 'a']), it);
ap[s[it] - 'a'].erase(whe);
if (ap[next - 'a'].empty())
ap[next - 'a'].push_back(it);
else {
whe = lower_bound(all(ap[next - 'a']), it);
whe = ap[next - 'a'].insert(whe, it);
}
s[it] = next;
} else {
int l, r;
cin >> l >> r;
l--;
r--;
int ans = 0;
rep(j, 26) {
if (ap[j].empty())
continue;
auto whe2 = lower_bound(all(ap[j]), l);
if (ap[j][whe2 - ap[j].begin()] <= r &&
whe2 - ap[j].begin() != ap[j].size())
ans++;
}
cout << ans << endl;
}
}
return 0;
}
| replace | 33 | 34 | 33 | 34 | 0 | |
p02763 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define repo(i, n) for (int i = 1; i <= n; i++)
#define INF 1001001001
#define INFll 100100100100100
// debug用
#define PrintVec(x) \
for (auto elementPrintVec : x) { \
cout << elementPrintVec << " "; \
} \
cout << endl;
using namespace std;
using ull = unsigned long long;
using ll = long long;
using P = pair<int, int>;
const int mod = 1000000007;
int main() {
int n;
cin >> n;
string s;
cin >> s;
set<int> S[26];
/*
rep(i, 26){
rep(j, n){
if(s[j]-'a'==i){
S[i].insert(j);
}
}
}*/
rep(i, n) { S[s[i] - 'a'].insert(i); }
int q;
cin >> q;
rep(i, q) {
int t;
cin >> t;
if (t == 1) {
int iq;
char cq;
cin >> iq >> cq;
iq--;
S[s[iq] - 'a'].erase(iq);
s[iq] = cq;
S[cq - 'a'].insert(iq);
} else {
int lq, rq;
cin >> lq >> rq;
int ans = 0;
lq--;
rq--;
rep(j, 26) {
auto it = lower_bound(S[j].begin(), S[j].end(), lq);
if (it != S[j].end() && *it <= rq) {
ans++;
}
}
printf("%d\n", ans);
}
}
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define repo(i, n) for (int i = 1; i <= n; i++)
#define INF 1001001001
#define INFll 100100100100100
// debug用
#define PrintVec(x) \
for (auto elementPrintVec : x) { \
cout << elementPrintVec << " "; \
} \
cout << endl;
using namespace std;
using ull = unsigned long long;
using ll = long long;
using P = pair<int, int>;
const int mod = 1000000007;
int main() {
int n;
cin >> n;
string s;
cin >> s;
set<int> S[26];
/*
rep(i, 26){
rep(j, n){
if(s[j]-'a'==i){
S[i].insert(j);
}
}
}*/
rep(i, n) { S[s[i] - 'a'].insert(i); }
int q;
cin >> q;
rep(i, q) {
int t;
cin >> t;
if (t == 1) {
int iq;
char cq;
cin >> iq >> cq;
iq--;
S[s[iq] - 'a'].erase(iq);
s[iq] = cq;
S[cq - 'a'].insert(iq);
} else {
int lq, rq;
cin >> lq >> rq;
int ans = 0;
lq--;
rq--;
rep(j, 26) {
// auto it=lower_bound(S[j].begin(), S[j].end(), lq);
auto it = S[j].lower_bound(lq);
if (it != S[j].end() && *it <= rq) {
ans++;
}
}
printf("%d\n", ans);
}
}
return 0;
}
| replace | 53 | 54 | 53 | 55 | TLE | |
p02763 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
const ll mod = 1e9 + 7;
const ll MAXN = 5e5 + 5;
vector<vector<ll>> t(MAXN, vector<ll>(26, 0));
ll n;
string s;
void build(ll v, ll tl, ll tr) {
if (tl == tr) {
t[v][s[tl] - 'a']++;
} else {
ll tm = (tr - tl) / 2 + tl;
build(2 * v, tl, tm);
build(2 * v + 1, tm + 1, tr);
for (int i = 0; i < 26; i++)
t[v][i] = t[2 * v][i] + t[2 * v + 1][i];
}
}
void update(ll v, ll tl, ll tr, ll pos, char ch) {
if (tl == tr) {
t[v][s[tl] - 'a']--;
t[v][ch - 'a']++;
} else {
ll tm = (tr - tl) / 2 + tl;
if (pos <= tm)
update(2 * v, tl, tm, pos, ch);
else
update(2 * v + 1, tm + 1, tr, pos, ch);
for (int i = 0; i < 26; i++)
t[v][i] = t[2 * v][i] + t[2 * v + 1][i];
}
}
vector<ll> query(ll v, ll tl, ll tr, ll l, ll r) {
if (l > r) {
vector<ll> tmp(26, 0);
return tmp;
}
if (tl == l && tr == r) {
return t[v];
} else {
ll tm = (tr - tl) / 2 + tl;
vector<ll> a = query(2 * v, tl, tm, l, min(r, tm));
vector<ll> b = query(2 * v + 1, tm + 1, tr, max(l, tm + 1), r);
for (int i = 0; i < 26; i++)
a[i] += b[i];
return a;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
cin >> s;
build(1, 0, n - 1);
ll q;
cin >> q;
while (q--) {
int a;
cin >> a;
if (a == 1) {
ll pos;
cin >> pos;
char ch;
cin >> ch;
update(1, 0, n - 1, pos - 1, ch);
s[pos - 1] = ch;
} else {
ll l, r;
cin >> l >> r;
vector<ll> ans = query(1, 0, n - 1, l - 1, r - 1);
ll cnt = 0;
for (int i = 0; i < 26; i++) {
if (ans[i])
cnt++;
}
cout << cnt << '\n';
}
}
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
const ll mod = 1e9 + 7;
const ll MAXN = 5e5 + 5;
vector<vector<ll>> t(4 * MAXN, vector<ll>(26, 0));
ll n;
string s;
void build(ll v, ll tl, ll tr) {
if (tl == tr) {
t[v][s[tl] - 'a']++;
} else {
ll tm = (tr - tl) / 2 + tl;
build(2 * v, tl, tm);
build(2 * v + 1, tm + 1, tr);
for (int i = 0; i < 26; i++)
t[v][i] = t[2 * v][i] + t[2 * v + 1][i];
}
}
void update(ll v, ll tl, ll tr, ll pos, char ch) {
if (tl == tr) {
t[v][s[tl] - 'a']--;
t[v][ch - 'a']++;
} else {
ll tm = (tr - tl) / 2 + tl;
if (pos <= tm)
update(2 * v, tl, tm, pos, ch);
else
update(2 * v + 1, tm + 1, tr, pos, ch);
for (int i = 0; i < 26; i++)
t[v][i] = t[2 * v][i] + t[2 * v + 1][i];
}
}
vector<ll> query(ll v, ll tl, ll tr, ll l, ll r) {
if (l > r) {
vector<ll> tmp(26, 0);
return tmp;
}
if (tl == l && tr == r) {
return t[v];
} else {
ll tm = (tr - tl) / 2 + tl;
vector<ll> a = query(2 * v, tl, tm, l, min(r, tm));
vector<ll> b = query(2 * v + 1, tm + 1, tr, max(l, tm + 1), r);
for (int i = 0; i < 26; i++)
a[i] += b[i];
return a;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
cin >> s;
build(1, 0, n - 1);
ll q;
cin >> q;
while (q--) {
int a;
cin >> a;
if (a == 1) {
ll pos;
cin >> pos;
char ch;
cin >> ch;
update(1, 0, n - 1, pos - 1, ch);
s[pos - 1] = ch;
} else {
ll l, r;
cin >> l >> r;
vector<ll> ans = query(1, 0, n - 1, l - 1, r - 1);
ll cnt = 0;
for (int i = 0; i < 26; i++) {
if (ans[i])
cnt++;
}
cout << cnt << '\n';
}
}
}
| replace | 9 | 10 | 9 | 10 | -6 | terminate called after throwing an instance of 'std::bad_alloc'
what(): std::bad_alloc
|
p02763 | C++ | Runtime Error | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
#define mod 1000000007
#define lim 1000000000000000007
#define lim1 18446744073709551615 // Unsigned
#define sq(a) ((a) * (a))
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define mms(v, i) memset(v, i, sizeof(v))
#define pb push_back
#define pf push_front
#define ppb pop_back
#define ppf pop_front
#define REP(i, a, b) for (int i = a; i <= b; i++)
#define REPN(i, a, b) for (int i = a; i >= b; i--)
using namespace std;
typedef long long int ll;
typedef unsigned long long int ull;
typedef pair<int, int> pi;
typedef pair<ll, ll> PL;
typedef pair<ll, int> PLI;
typedef pair<int, ll> PIL;
typedef pair<int, pair<int, int>> pii;
typedef pair<double, double> pdd;
typedef tree<int, null_type, less<int>, rb_tree_tag,
tree_order_statistics_node_update>
indexed_set;
ll power(ll a, ll b, int m) {
if (b == 0)
return 1;
ll c = power(a, b >> 1, m);
c = (c * c) % m;
if (b & 1)
return (c * a) % m;
return c;
}
ll powerwithoutmod(ll a, ll b) {
if (b == 0)
return 1;
ll c = powerwithoutmod(a, b >> 1);
c = (c * c);
if (b & 1)
return (c * a);
return c;
}
ll gcdll(ll a, ll b) {
if (b == 0)
return a;
return gcdll(b, a % b);
}
int gcd(int a, int b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
// http://xorshift.di.unimi.it/splitmix64.c
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);
}
};
const int N = (int)1e5 + 5;
const int Q = 301;
const int logN = 16;
set<int> pos[26];
string s;
void solve() {
int n, q, t, l, r;
char ch;
cin >> n;
cin >> s;
cin >> q;
REP(i, 1, n) { pos[s[i - 1] - 'a'].insert(i); }
while (q--) {
cin >> t >> l;
if (t == 1) {
cin >> ch;
r = ch - 'a';
pos[s[l - 1] - 'a'].erase(pos[s[l - 1] - 'a'].find(l));
pos[r].insert(l);
} else {
cin >> r;
int ans = 0;
REP(i, 0, 25) {
auto it = pos[i].lower_bound(l);
if (it != pos[i].end() && (*it) <= r) {
ans++;
}
}
cout << ans << "\n";
}
}
}
int main() {
// freopen("output.txt","r",stdin);
// freopen("output.txt","w",stdout);
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int T = 1;
// cin>>T;
REP(TC, 1, T) {
// cout<<"Case #"<<TC<<": ";
solve();
// cout<<"\n";
}
}
| #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
#define mod 1000000007
#define lim 1000000000000000007
#define lim1 18446744073709551615 // Unsigned
#define sq(a) ((a) * (a))
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define mms(v, i) memset(v, i, sizeof(v))
#define pb push_back
#define pf push_front
#define ppb pop_back
#define ppf pop_front
#define REP(i, a, b) for (int i = a; i <= b; i++)
#define REPN(i, a, b) for (int i = a; i >= b; i--)
using namespace std;
typedef long long int ll;
typedef unsigned long long int ull;
typedef pair<int, int> pi;
typedef pair<ll, ll> PL;
typedef pair<ll, int> PLI;
typedef pair<int, ll> PIL;
typedef pair<int, pair<int, int>> pii;
typedef pair<double, double> pdd;
typedef tree<int, null_type, less<int>, rb_tree_tag,
tree_order_statistics_node_update>
indexed_set;
ll power(ll a, ll b, int m) {
if (b == 0)
return 1;
ll c = power(a, b >> 1, m);
c = (c * c) % m;
if (b & 1)
return (c * a) % m;
return c;
}
ll powerwithoutmod(ll a, ll b) {
if (b == 0)
return 1;
ll c = powerwithoutmod(a, b >> 1);
c = (c * c);
if (b & 1)
return (c * a);
return c;
}
ll gcdll(ll a, ll b) {
if (b == 0)
return a;
return gcdll(b, a % b);
}
int gcd(int a, int b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
// http://xorshift.di.unimi.it/splitmix64.c
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);
}
};
const int N = (int)1e5 + 5;
const int Q = 301;
const int logN = 16;
set<int> pos[26];
string s;
void solve() {
int n, q, t, l, r;
char ch;
cin >> n;
cin >> s;
cin >> q;
REP(i, 1, n) { pos[s[i - 1] - 'a'].insert(i); }
while (q--) {
cin >> t >> l;
if (t == 1) {
cin >> ch;
r = ch - 'a';
pos[s[l - 1] - 'a'].erase(l);
s[l - 1] = ch;
pos[r].insert(l);
} else {
cin >> r;
int ans = 0;
REP(i, 0, 25) {
auto it = pos[i].lower_bound(l);
if (it != pos[i].end() && (*it) <= r) {
ans++;
}
}
cout << ans << "\n";
}
}
}
int main() {
// freopen("output.txt","r",stdin);
// freopen("output.txt","w",stdout);
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int T = 1;
// cin>>T;
REP(TC, 1, T) {
// cout<<"Case #"<<TC<<": ";
solve();
// cout<<"\n";
}
}
| replace | 91 | 92 | 91 | 93 | 0 | |
p02763 | C++ | Runtime Error | #include <algorithm>
#include <cassert>
#include <climits>
#include <cmath>
#include <complex>
#include <cstring>
#include <ctime>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <tuple>
using namespace std;
typedef long long ll;
#define _ << " " <<
#define all(X) (X).begin(), (X).end()
#define len(X) (X).size()
#define Pii pair<int, int>
#define Pll pair<ll, ll>
#define Tiii tuple<int, int, int>
#define Tlll tuple<ll, ll, ll>
int f, dat[26][1050000];
void init(int n_, int x) {
f = 1;
while (f < n_)
f *= 2;
f *= 2;
for (int i = 0; i < 2 * f - 1; i++)
dat[x][i] = 0;
}
void add(int k, int x, int v) {
k += f - 1;
dat[x][k] += v;
while (k > 0) {
k = (k - 1) / 2;
dat[x][k] = dat[x][k * 2 + 1] + dat[x][k * 2 + 2];
}
}
int query(int a, int b, int k, int l, int r, int x) {
if (r <= a || b <= l)
return 0;
if (a <= l && r <= b)
return dat[x][k];
else {
int vl = query(a, b, k * 2 + 1, l, (l + r) / 2, x);
int vr = query(a, b, k * 2 + 2, (l + r) / 2, r, x);
return vl + vr;
}
}
int main() {
int n;
char s[500050];
cin >> n >> s;
for (int i = 0; i < 26; i++)
init(n + 10, i);
for (int i = 0; i < n; i++) {
add(i + 1, s[i] - 'a', 1);
}
int q;
cin >> q;
while (q--) {
int t;
cin >> t;
if (t == 1) {
int idx;
char c[1];
cin >> idx >> c[0];
// cerr << c[0] << s[idx - 1] << endl;
if (c[0] != s[idx - 1]) {
add(idx, s[idx - 1] - 'a', -1);
add(idx, c[0] - 'a', 1);
}
s[idx - 1] = c[0];
} else {
int l, r, ans = 0;
cin >> l >> r;
for (int i = 0; i < 26; i++) {
ans += (query(l, r + 1, 0, 0, f, i) > 0);
// cout << query(l, r + 1, 0, 0, f, i);
}
// cout << " ";
cout << ans << endl;
}
}
} | #include <algorithm>
#include <cassert>
#include <climits>
#include <cmath>
#include <complex>
#include <cstring>
#include <ctime>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <tuple>
using namespace std;
typedef long long ll;
#define _ << " " <<
#define all(X) (X).begin(), (X).end()
#define len(X) (X).size()
#define Pii pair<int, int>
#define Pll pair<ll, ll>
#define Tiii tuple<int, int, int>
#define Tlll tuple<ll, ll, ll>
int f, dat[26][1050000];
void init(int n_, int x) {
f = 1;
while (f < n_)
f *= 2;
for (int i = 0; i < 2 * f - 1; i++)
dat[x][i] = 0;
}
void add(int k, int x, int v) {
k += f - 1;
dat[x][k] += v;
while (k > 0) {
k = (k - 1) / 2;
dat[x][k] = dat[x][k * 2 + 1] + dat[x][k * 2 + 2];
}
}
int query(int a, int b, int k, int l, int r, int x) {
if (r <= a || b <= l)
return 0;
if (a <= l && r <= b)
return dat[x][k];
else {
int vl = query(a, b, k * 2 + 1, l, (l + r) / 2, x);
int vr = query(a, b, k * 2 + 2, (l + r) / 2, r, x);
return vl + vr;
}
}
int main() {
int n;
char s[500050];
cin >> n >> s;
for (int i = 0; i < 26; i++)
init(n + 10, i);
for (int i = 0; i < n; i++) {
add(i + 1, s[i] - 'a', 1);
}
int q;
cin >> q;
while (q--) {
int t;
cin >> t;
if (t == 1) {
int idx;
char c[1];
cin >> idx >> c[0];
// cerr << c[0] << s[idx - 1] << endl;
if (c[0] != s[idx - 1]) {
add(idx, s[idx - 1] - 'a', -1);
add(idx, c[0] - 'a', 1);
}
s[idx - 1] = c[0];
} else {
int l, r, ans = 0;
cin >> l >> r;
for (int i = 0; i < 26; i++) {
ans += (query(l, r + 1, 0, 0, f, i) > 0);
// cout << query(l, r + 1, 0, 0, f, i);
}
// cout << " ";
cout << ans << endl;
}
}
} | delete | 29 | 30 | 29 | 29 | -11 | |
p02763 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
typedef long long lli;
// Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools (tips: You
// use the default template now. You can remove this line by using your custom
// template)
int main() {
lli N;
cin >> N;
vector<char> S(N);
set<lli> positions[26];
for (lli i = 0; i < N; ++i) {
cin >> S[i];
positions[S[i] - 'a'].insert(i);
}
lli Q;
cin >> Q;
while (Q-- > 0) {
lli t;
cin >> t;
if (t == 1) {
lli i;
char c;
cin >> i >> c;
--i;
char old = S[i];
S[i] = c;
positions[old - 'a'].erase(i);
positions[c - 'a'].insert(i);
} else {
/* Count stuff */
lli l, r;
cin >> l >> r;
--l;
--r;
int in = 0;
for (int i = 0; i < 26; ++i) {
for (lli it : positions[i]) {
if (it >= l and it <= r) {
++in;
break;
}
}
}
cout << in << endl;
}
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long lli;
// Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools (tips: You
// use the default template now. You can remove this line by using your custom
// template)
int main() {
lli N;
cin >> N;
vector<char> S(N);
set<lli> positions[26];
for (lli i = 0; i < N; ++i) {
cin >> S[i];
positions[S[i] - 'a'].insert(i);
}
lli Q;
cin >> Q;
while (Q-- > 0) {
lli t;
cin >> t;
if (t == 1) {
lli i;
char c;
cin >> i >> c;
--i;
char old = S[i];
S[i] = c;
positions[old - 'a'].erase(i);
positions[c - 'a'].insert(i);
} else {
/* Count stuff */
lli l, r;
cin >> l >> r;
--l;
--r;
int in = 0;
for (int i = 0; i < 26; ++i) {
auto it = positions[i].lower_bound(l);
if (it != positions[i].end() && *it <= r)
++in;
}
cout << in << endl;
}
}
return 0;
}
| replace | 51 | 59 | 51 | 54 | TLE | |
p02763 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
struct SegTree {
int N;
vector<vector<int>> seg;
void init(int n) {
N = 1;
while (N < n)
N <<= 1;
seg = vector<vector<int>>(2 * N, vector<int>(26, 0));
}
void gather(int u) {
for (int i = 0; i < 26; i++)
seg[u][i] = seg[u * 2 + 1][i] + seg[u * 2 + 2][i];
}
void build(int u, int l, int r, vector<char> &a) {
if (r - l == 1) {
if (l >= (int)a.size())
return;
seg[u][a[l] - 'a'] = 1;
return;
}
int m = (l + r) / 2;
build(u * 2 + 1, l, m, a);
build(u * 2 + 2, m, r, a);
gather(u);
}
void update(int idx, int l, int r, int u, int x) {
if (r - l == 1) {
if (idx == l) {
for (int i = 0; i < 26; i++)
seg[u][i] = 0;
seg[u][x] = 1;
}
return;
}
int m = (l + r) / 2;
update(idx, l, m, u * 2 + 1, x);
update(idx, m, r, u * 2 + 2, x);
gather(u);
}
vector<int> query(int a, int b, int u, int l, int r) {
if (r <= a || b <= l) {
vector<int> res(26, 0);
return res;
}
if (a <= l && r <= b)
return seg[u];
int m = (l + r) / 2;
auto res1 = query(a, b, u * 2 + 1, l, m);
auto res2 = query(a, b, u * 2 + 2, m, r);
vector<int> res(26, 0);
for (int i = 0; i < 26; i++)
res[i] = res1[i] + res2[i];
return res;
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<char> a(n);
for (int i = 0; i < n; i++)
cin >> a[i];
SegTree seg;
seg.init(n);
seg.build(0, 0, seg.N, a);
int Q;
cin >> Q;
while (Q--) {
int t;
cin >> t;
if (t == 1) {
int idx;
char c;
cin >> idx >> c;
seg.update(idx - 1, 0, seg.N, 0, c - 'a');
} else {
int l, r;
cin >> l >> r;
l--;
auto res = seg.query(l, r, 0, 0, seg.N);
int cnt = 0;
for (auto i : res) {
if (i >= 1)
cnt += 1;
}
cout << cnt << '\n';
}
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
struct SegTree {
int N;
vector<vector<int>> seg;
void init(int n) {
N = 1;
while (N < n)
N <<= 1;
seg = vector<vector<int>>(2 * N, vector<int>(26, 0));
}
void gather(int u) {
for (int i = 0; i < 26; i++)
seg[u][i] = seg[u * 2 + 1][i] + seg[u * 2 + 2][i];
}
void build(int u, int l, int r, vector<char> &a) {
if (r - l == 1) {
if (l >= (int)a.size())
return;
seg[u][a[l] - 'a'] = 1;
return;
}
int m = (l + r) / 2;
build(u * 2 + 1, l, m, a);
build(u * 2 + 2, m, r, a);
gather(u);
}
void update(int idx, int l, int r, int u, int x) {
if (idx < l || idx >= r)
return;
if (r - l == 1) {
if (idx == l) {
for (int i = 0; i < 26; i++)
seg[u][i] = 0;
seg[u][x] = 1;
}
return;
}
int m = (l + r) / 2;
update(idx, l, m, u * 2 + 1, x);
update(idx, m, r, u * 2 + 2, x);
gather(u);
}
vector<int> query(int a, int b, int u, int l, int r) {
if (r <= a || b <= l) {
vector<int> res(26, 0);
return res;
}
if (a <= l && r <= b)
return seg[u];
int m = (l + r) / 2;
auto res1 = query(a, b, u * 2 + 1, l, m);
auto res2 = query(a, b, u * 2 + 2, m, r);
vector<int> res(26, 0);
for (int i = 0; i < 26; i++)
res[i] = res1[i] + res2[i];
return res;
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<char> a(n);
for (int i = 0; i < n; i++)
cin >> a[i];
SegTree seg;
seg.init(n);
seg.build(0, 0, seg.N, a);
int Q;
cin >> Q;
while (Q--) {
int t;
cin >> t;
if (t == 1) {
int idx;
char c;
cin >> idx >> c;
seg.update(idx - 1, 0, seg.N, 0, c - 'a');
} else {
int l, r;
cin >> l >> r;
l--;
auto res = seg.query(l, r, 0, 0, seg.N);
int cnt = 0;
for (auto i : res) {
if (i >= 1)
cnt += 1;
}
cout << cnt << '\n';
}
}
return 0;
}
| insert | 34 | 34 | 34 | 36 | TLE | |
p02763 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, i, j;
string S;
cin >> N >> S;
vector<set<int>> al(26);
for (i = 0; i < 26; i++) {
al[i] = {N};
}
for (i = 0; i < N; i++) {
al[S[i] - 'a'].insert(i);
}
int Q;
cin >> Q;
for (i = 0; i < Q; i++) {
int a;
cin >> a;
if (a == 1) {
int k;
char c;
cin >> k >> c;
k--;
if (S[k] != c) {
al[S[k] - 'a'].erase(k);
S[k] = c;
al[c - 'a'].insert(k);
}
} else {
int l, r, ans = 0;
cin >> l >> r;
l--;
r--;
for (j = 0; j < 26; j++) {
if (*lower_bound(al[j].begin(), al[j].end(), l) <= r) {
ans++;
}
}
cout << ans << "\n";
}
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, i, j;
string S;
cin >> N >> S;
vector<set<int>> al(26);
for (i = 0; i < 26; i++) {
al[i] = {N};
}
for (i = 0; i < N; i++) {
al[S[i] - 'a'].insert(i);
}
int Q;
cin >> Q;
for (i = 0; i < Q; i++) {
int a;
cin >> a;
if (a == 1) {
int k;
char c;
cin >> k >> c;
k--;
if (S[k] != c) {
al[S[k] - 'a'].erase(k);
S[k] = c;
al[c - 'a'].insert(k);
}
} else {
int l, r, ans = 0;
cin >> l >> r;
l--;
r--;
for (j = 0; j < 26; j++) {
if (*al[j].lower_bound(l) <= r) {
ans++;
}
}
cout << ans << "\n";
}
}
} | replace | 34 | 35 | 34 | 35 | TLE | |
p02763 | C++ | Runtime Error | // #pragma GCC optimize("O3")
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define N 1000000007
#define N2 998244353
#define Nmax 100005
#define INF (ll)1e18
#define pll pair<ll, ll>
#define mp make_pair
#define fi first
#define se second
#define vv vector
#define rep(i, n) rep2(i, 0, n)
#define rep2(i, m, n) for (ll i = m; i < (n); i++)
#define repr(i, n) repr2(i, n, 0)
#define repr2(i, m, n) for (ll i = m; i >= (n); i--)
#define get(n) \
ll(n); \
scanf("%lld", &(n));
#define get2(n, k) \
ll(n), (k); \
scanf("%lld%lld", &(n), &(k));
#define get3(n, m, k) \
ll(n), (m), (k); \
scanf("%lld%lld%lld", &(n), &(m), &(k));
#define gets(s) \
string(s); \
cin >> (s);
#define ALL(c) (c).begin(), (c).end()
#define fill_nums(A, n) \
vector<ll> A((n)); \
for (ll i = 0; i < n; i++) \
scanf("%lld", &A[i]);
#define fill_edges(adj, m) \
for (ll i = 0; i < m; i++) { \
ll a, b; \
scanf("%lld %lld", &a, &b); \
adj[a - 1].pb(b - 1); \
adj[b - 1].pb(a - 1); \
}
#define fill_direct(adj, m) \
for (ll i = 0; i < m; i++) { \
ll a, b; \
scanf("%lld %lld", &a, &b); \
adj[a - 1].pb(b - 1); \
}
#define StarBurstStream \
ios_base::sync_with_stdio(false); \
cin.tie(0); // cout.tie(0);
#define pi 3.1415926535897L
#define db long double /* print with %Lf */
#define EPS 1e-9
#define flu fflush(stdout)
#define imp \
{ \
cout << "No\n"; \
return 0; \
}
#define yup \
{ \
cout << "Yes\n"; \
return 0; \
}
#define debug_vec(vec, n) \
{ \
rep(idxi, n) cout << vec[idxi] << " "; \
cout << "\n"; \
}
#define debug_pvec(vec, n) \
{ \
rep(idxi, n) cout << vec[idxi].fi << "-" << vec[idxi].se << " "; \
cout << "\n"; \
}
#define debug_set(seta) \
{ \
cout << seta.size() << "\n"; \
for (auto idxi : seta) \
cout << idxi << " "; \
cout << "\n"; \
}
#define debug_map(mappa) \
{ \
cout << mappa.size() << "\n"; \
for (auto idxi : mappa) \
cout << idxi.fi << "-" << idxi.se << " "; \
cout << "\n"; \
}
#define debug_vecvec(vec, n) \
{ \
rep(idxi, n) { \
for (auto idxi2 : vec[idxi]) \
cout << idxi2 << " "; \
cout << "\n"; \
} \
}
// LOOK AT THESE BEFORE SUBMISSION
// LOOK AT THESE BEFORE SUBMISSION
// ============================================================
// Nmax value and is index access offset taking it beyond Nmax.
// Precision error in case of real numbers.
// N vs N2 chosen correctly.
// Modulo applied everywhere.
// Flush in case of interactive.
// Don't erase value in multiset.
// Check for array indices out of bound (in pre or suff sums).
// Correct return value for functions.
// Confirm the letter case of yes and no.
// Dont paste code two times in the text file.
// ============================================================
ll tree[4 * Nmax];
ll A[Nmax];
void make_tree(ll idx, ll low, ll high) {
if (low == high) {
tree[idx] = A[low];
return;
}
ll mid = low + (high - low) / 2;
make_tree((idx << 1), low, mid);
make_tree((idx << 1) + 1, mid + 1, high);
tree[idx] = tree[(idx << 1)] | tree[(idx << 1) + 1];
}
ll find(ll idx, ll low, ll high, ll l, ll r) {
if (l > high || r < low)
return 0;
if (l <= low && high <= r)
return tree[idx];
ll mid = low + (high - low) / 2;
if (mid < l)
return find((idx << 1) + 1, mid + 1, high, l, r);
if (r <= mid)
return find((idx << 1), low, mid, l, r);
return find((idx << 1), low, mid, l, r) |
find((idx << 1) + 1, mid + 1, high, l, r);
}
void update(ll idx, ll low, ll high, ll pos, ll val) {
if (low == high) {
A[low] = val;
tree[idx] = val;
return;
}
ll mid = low + (high - low) / 2;
if (pos <= mid)
update((idx << 1), low, mid, pos, val);
else
update((idx << 1) + 1, mid + 1, high, pos, val);
tree[idx] = tree[(idx << 1)] | tree[(idx << 1) + 1];
}
int main() {
memset(tree, 0, sizeof(tree));
memset(A, 0, sizeof(A));
get(n);
gets(s);
rep(i, n) {
A[i] = s[i] - 'a';
A[i] = (ll)1 << A[i];
}
make_tree(1, 0, n - 1);
get(q);
rep(i, q) {
get(a);
if (a == 1) {
get(b);
b--;
gets(c);
int ab = (ll)1 << (c[0] - 'a');
update(1, 0, n - 1, b, ab);
} else {
get2(b, c);
--b;
--c;
ll ans = __builtin_popcount(find(1, 0, n - 1, b, c));
printf("%lld\n", ans);
}
}
return 0;
}
| // #pragma GCC optimize("O3")
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define N 1000000007
#define N2 998244353
#define Nmax 500005
#define INF (ll)1e18
#define pll pair<ll, ll>
#define mp make_pair
#define fi first
#define se second
#define vv vector
#define rep(i, n) rep2(i, 0, n)
#define rep2(i, m, n) for (ll i = m; i < (n); i++)
#define repr(i, n) repr2(i, n, 0)
#define repr2(i, m, n) for (ll i = m; i >= (n); i--)
#define get(n) \
ll(n); \
scanf("%lld", &(n));
#define get2(n, k) \
ll(n), (k); \
scanf("%lld%lld", &(n), &(k));
#define get3(n, m, k) \
ll(n), (m), (k); \
scanf("%lld%lld%lld", &(n), &(m), &(k));
#define gets(s) \
string(s); \
cin >> (s);
#define ALL(c) (c).begin(), (c).end()
#define fill_nums(A, n) \
vector<ll> A((n)); \
for (ll i = 0; i < n; i++) \
scanf("%lld", &A[i]);
#define fill_edges(adj, m) \
for (ll i = 0; i < m; i++) { \
ll a, b; \
scanf("%lld %lld", &a, &b); \
adj[a - 1].pb(b - 1); \
adj[b - 1].pb(a - 1); \
}
#define fill_direct(adj, m) \
for (ll i = 0; i < m; i++) { \
ll a, b; \
scanf("%lld %lld", &a, &b); \
adj[a - 1].pb(b - 1); \
}
#define StarBurstStream \
ios_base::sync_with_stdio(false); \
cin.tie(0); // cout.tie(0);
#define pi 3.1415926535897L
#define db long double /* print with %Lf */
#define EPS 1e-9
#define flu fflush(stdout)
#define imp \
{ \
cout << "No\n"; \
return 0; \
}
#define yup \
{ \
cout << "Yes\n"; \
return 0; \
}
#define debug_vec(vec, n) \
{ \
rep(idxi, n) cout << vec[idxi] << " "; \
cout << "\n"; \
}
#define debug_pvec(vec, n) \
{ \
rep(idxi, n) cout << vec[idxi].fi << "-" << vec[idxi].se << " "; \
cout << "\n"; \
}
#define debug_set(seta) \
{ \
cout << seta.size() << "\n"; \
for (auto idxi : seta) \
cout << idxi << " "; \
cout << "\n"; \
}
#define debug_map(mappa) \
{ \
cout << mappa.size() << "\n"; \
for (auto idxi : mappa) \
cout << idxi.fi << "-" << idxi.se << " "; \
cout << "\n"; \
}
#define debug_vecvec(vec, n) \
{ \
rep(idxi, n) { \
for (auto idxi2 : vec[idxi]) \
cout << idxi2 << " "; \
cout << "\n"; \
} \
}
// LOOK AT THESE BEFORE SUBMISSION
// LOOK AT THESE BEFORE SUBMISSION
// ============================================================
// Nmax value and is index access offset taking it beyond Nmax.
// Precision error in case of real numbers.
// N vs N2 chosen correctly.
// Modulo applied everywhere.
// Flush in case of interactive.
// Don't erase value in multiset.
// Check for array indices out of bound (in pre or suff sums).
// Correct return value for functions.
// Confirm the letter case of yes and no.
// Dont paste code two times in the text file.
// ============================================================
ll tree[4 * Nmax];
ll A[Nmax];
void make_tree(ll idx, ll low, ll high) {
if (low == high) {
tree[idx] = A[low];
return;
}
ll mid = low + (high - low) / 2;
make_tree((idx << 1), low, mid);
make_tree((idx << 1) + 1, mid + 1, high);
tree[idx] = tree[(idx << 1)] | tree[(idx << 1) + 1];
}
ll find(ll idx, ll low, ll high, ll l, ll r) {
if (l > high || r < low)
return 0;
if (l <= low && high <= r)
return tree[idx];
ll mid = low + (high - low) / 2;
if (mid < l)
return find((idx << 1) + 1, mid + 1, high, l, r);
if (r <= mid)
return find((idx << 1), low, mid, l, r);
return find((idx << 1), low, mid, l, r) |
find((idx << 1) + 1, mid + 1, high, l, r);
}
void update(ll idx, ll low, ll high, ll pos, ll val) {
if (low == high) {
A[low] = val;
tree[idx] = val;
return;
}
ll mid = low + (high - low) / 2;
if (pos <= mid)
update((idx << 1), low, mid, pos, val);
else
update((idx << 1) + 1, mid + 1, high, pos, val);
tree[idx] = tree[(idx << 1)] | tree[(idx << 1) + 1];
}
int main() {
memset(tree, 0, sizeof(tree));
memset(A, 0, sizeof(A));
get(n);
gets(s);
rep(i, n) {
A[i] = s[i] - 'a';
A[i] = (ll)1 << A[i];
}
make_tree(1, 0, n - 1);
get(q);
rep(i, q) {
get(a);
if (a == 1) {
get(b);
b--;
gets(c);
int ab = (ll)1 << (c[0] - 'a');
update(1, 0, n - 1, b, ab);
} else {
get2(b, c);
--b;
--c;
ll ans = __builtin_popcount(find(1, 0, n - 1, b, c));
printf("%lld\n", ans);
}
}
return 0;
}
| replace | 7 | 8 | 7 | 8 | 0 | |
p02763 | C++ | Time Limit Exceeded | // SmartCoder
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp> // Including tree_order_statistics_node_update
using namespace __gnu_pbds;
using namespace std;
#define sz(a) int((a).size())
#define pb push_back
#define mp make_pair
#define all(c) (c).begin(), (c).end()
#define tr(c, i) \
for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); i++)
#define present(c, x) ((c).find(x) != (c).end())
#define cpresent(c, x) (find(all(c), x) != (c).end())
#define minei(x) min_element(x.begin(), x.end()) - (x).begin()
#define maxei(x) max_element(x.begin(), x.end()) - (x).begin()
#define LSOne(S) (S & (-S))
#define uns(v) \
sort((v).begin(), (v).end()), v.erase(unique(v.begin(), v.end()), v.end())
#define acusum(x) accumulate(x.begin(), x.end(), 0)
#define acumul(x) accumulate(x.begin(), x.end(), 1, multiplies<int>());
#define bits(x) __builtin_popcount(x)
#define oo INT_MAX
#define inf 1000000000
#define MAXN 100007
#define MOD 1000000007
const double pi = acos(-1.0);
const double eps = 1e-11;
typedef long long ll;
typedef pair<int, int> ii;
typedef vector<ii> vii;
typedef vector<int> vi;
typedef tree<int, null_type, less<int>, rb_tree_tag,
tree_order_statistics_node_update>
indexed_set;
int main() {
std::ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, q, t, indx, l, r;
char ch;
string s;
cin >> n >> s >> q;
map<char, set<int>> cache;
for (int i = 0; i < n; i++) {
cache[s[i]].insert(i);
}
while (q--) {
cin >> t;
if (t == 1) {
cin >> indx >> ch;
indx--;
if (s[indx] == ch)
continue;
cache[s[indx]].erase(indx);
s[indx] = ch;
cache[ch].insert(indx);
} else {
cin >> l >> r;
l--, r--;
int res = 0;
for (auto it : cache) {
auto iter = it.second.upper_bound(l - 1);
if (iter == it.second.end())
continue;
if (*iter <= r)
res++;
}
cout << res << '\n';
}
}
return 0;
}
| // SmartCoder
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp> // Including tree_order_statistics_node_update
using namespace __gnu_pbds;
using namespace std;
#define sz(a) int((a).size())
#define pb push_back
#define mp make_pair
#define all(c) (c).begin(), (c).end()
#define tr(c, i) \
for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); i++)
#define present(c, x) ((c).find(x) != (c).end())
#define cpresent(c, x) (find(all(c), x) != (c).end())
#define minei(x) min_element(x.begin(), x.end()) - (x).begin()
#define maxei(x) max_element(x.begin(), x.end()) - (x).begin()
#define LSOne(S) (S & (-S))
#define uns(v) \
sort((v).begin(), (v).end()), v.erase(unique(v.begin(), v.end()), v.end())
#define acusum(x) accumulate(x.begin(), x.end(), 0)
#define acumul(x) accumulate(x.begin(), x.end(), 1, multiplies<int>());
#define bits(x) __builtin_popcount(x)
#define oo INT_MAX
#define inf 1000000000
#define MAXN 100007
#define MOD 1000000007
const double pi = acos(-1.0);
const double eps = 1e-11;
typedef long long ll;
typedef pair<int, int> ii;
typedef vector<ii> vii;
typedef vector<int> vi;
typedef tree<int, null_type, less<int>, rb_tree_tag,
tree_order_statistics_node_update>
indexed_set;
int main() {
std::ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, q, t, indx, l, r;
char ch;
string s;
cin >> n >> s >> q;
map<char, set<int>> cache;
for (int i = 0; i < n; i++) {
cache[s[i]].insert(i);
}
while (q--) {
cin >> t;
if (t == 1) {
cin >> indx >> ch;
indx--;
if (s[indx] == ch)
continue;
cache[s[indx]].erase(indx);
s[indx] = ch;
cache[ch].insert(indx);
} else {
cin >> l >> r;
l--, r--;
int res = 0;
tr(cache, it) {
auto iter = it->second.upper_bound(l - 1);
if (iter == it->second.end())
continue;
if (*iter <= r)
res++;
}
cout << res << '\n';
}
}
return 0;
}
| replace | 68 | 71 | 68 | 71 | TLE | |
p02763 | C++ | Time Limit Exceeded | #include <algorithm>
#include <bitset>
#include <cassert>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
int N;
string S;
int Q;
cin >> N >> S >> Q;
vector<set<int>> sets(26);
for (int i = 0; i < N; ++i) {
char ch = S[i];
sets[ch - 'a'].insert(i);
}
for (int iter = 0; iter < Q; ++iter) {
int cmd;
cin >> cmd;
if (cmd == 1) {
int i;
char ch;
cin >> i >> ch;
--i;
char old_ch = S[i];
sets[old_ch - 'a'].erase(i);
S[i] = ch;
sets[ch - 'a'].insert(i);
} else {
int l, r;
cin >> l >> r;
--l;
--r;
int ans = 0;
for (char ch = 'a'; ch <= 'z'; ++ch) {
const set<int> &s = sets[ch - 'a'];
auto it = lower_bound(s.begin(), s.end(), l);
if (it != s.end() and *it <= r)
++ans;
}
cout << ans << endl;
}
}
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cassert>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
int N;
string S;
int Q;
cin >> N >> S >> Q;
vector<set<int>> sets(26);
for (int i = 0; i < N; ++i) {
char ch = S[i];
sets[ch - 'a'].insert(i);
}
for (int iter = 0; iter < Q; ++iter) {
int cmd;
cin >> cmd;
if (cmd == 1) {
int i;
char ch;
cin >> i >> ch;
--i;
char old_ch = S[i];
sets[old_ch - 'a'].erase(i);
S[i] = ch;
sets[ch - 'a'].insert(i);
} else {
int l, r;
cin >> l >> r;
--l;
--r;
int ans = 0;
for (char ch = 'a'; ch <= 'z'; ++ch) {
const set<int> &s = sets[ch - 'a'];
// std::lower_bound is O(N)!!
// auto it = lower_bound(s.begin(), s.end(), l);
// std::set::lower_bound is O(log N)
auto it = s.lower_bound(l);
if (it != s.end() and *it <= r)
++ans;
}
cout << ans << endl;
}
}
return 0;
}
| replace | 49 | 50 | 49 | 53 | TLE | |
p02763 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define sz(x) int(x.size())
using namespace std;
typedef long long ll;
// const int INF = 1e8;
const ll INF = 1LL << 60;
typedef pair<int, int> P;
ll N, Q;
string S;
int main() {
cin >> N >> S >> Q;
vector<set<int>> is(26);
rep(i, N) is[S[i] - 'a'].insert(i);
rep(k, Q) {
ll q;
cin >> q;
if (q == 1) {
ll i;
char c;
cin >> i >> c;
i--;
is[S[i] - 'a'].erase(i);
S[i] = c;
is[S[i] - 'a'].insert(i);
} else {
ll l, r;
cin >> l >> r;
l--;
// 文字の種類数を求める
int ans = 0;
rep(j, 26) {
auto it = lower_bound(is[j].begin(), is[j].end(), l);
if (it != is[j].end() && *it < r)
ans++;
}
cout << ans << endl;
}
}
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define sz(x) int(x.size())
using namespace std;
typedef long long ll;
// const int INF = 1e8;
const ll INF = 1LL << 60;
typedef pair<int, int> P;
ll N, Q;
string S;
int main() {
cin >> N >> S >> Q;
vector<set<int>> is(26);
rep(i, N) is[S[i] - 'a'].insert(i);
rep(k, Q) {
ll q;
cin >> q;
if (q == 1) {
ll i;
char c;
cin >> i >> c;
i--;
is[S[i] - 'a'].erase(i);
S[i] = c;
is[S[i] - 'a'].insert(i);
} else {
ll l, r;
cin >> l >> r;
l--;
// 文字の種類数を求める
int ans = 0;
rep(j, 26) {
// auto it = lower_bound(is[j].begin(), is[j].end(), l);
auto it = is[j].lower_bound(l);
if (it != is[j].end() && *it < r)
ans++;
}
cout << ans << endl;
}
}
} | replace | 37 | 38 | 37 | 39 | TLE | |
p02763 | C++ | Runtime Error | #include <bits/stdc++.h>
int ri() {
int n;
scanf("%d", &n);
return n;
}
int main() {
int n = ri();
std::string s;
std::cin >> s;
for (auto &i : s)
i -= 'a';
int q = ri();
std::set<int> pos[26];
for (int i = 0; i < n; i++)
pos[s[i]].insert(i);
for (int i = 0; i < q; i++) {
if (ri() == 1) {
int index = ri() - 1;
std::string s;
std::cin >> s;
int c = s[0] - 'a';
pos[s[index]].erase(index);
pos[s[index] = c].insert(index);
} else {
int l = ri() - 1;
int r = ri();
int cnt = 0;
for (int j = 0; j < 26; j++)
if (pos[j].lower_bound(l) != pos[j].lower_bound(r))
cnt++;
printf("%d\n", cnt);
}
}
return 0;
}
| #include <bits/stdc++.h>
int ri() {
int n;
scanf("%d", &n);
return n;
}
int main() {
int n = ri();
std::string s;
std::cin >> s;
for (auto &i : s)
i -= 'a';
int q = ri();
std::set<int> pos[26];
for (int i = 0; i < n; i++)
pos[s[i]].insert(i);
for (int i = 0; i < q; i++) {
if (ri() == 1) {
int index = ri() - 1;
std::string tmp;
std::cin >> tmp;
int c = tmp[0] - 'a';
pos[s[index]].erase(index);
pos[s[index] = c].insert(index);
} else {
int l = ri() - 1;
int r = ri();
int cnt = 0;
for (int j = 0; j < 26; j++)
if (pos[j].lower_bound(l) != pos[j].lower_bound(r))
cnt++;
printf("%d\n", cnt);
}
}
return 0;
}
| replace | 22 | 25 | 22 | 25 | 0 | |
p02763 | C++ | Runtime Error | #include <algorithm>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <vector>
using namespace std;
// マクロ&定数&関数 ================================================
typedef unsigned int uint;
typedef long long ll;
typedef pair<ll, ll> pll;
typedef vector<int> vint;
typedef vector<ll> vll;
typedef vector<double> vdouble;
typedef vector<bool> vbool;
typedef vector<string> vstring;
typedef vector<pair<int, int>> vpint;
typedef vector<pair<ll, ll>> vpll;
typedef vector<pair<double, double>> vpdouble;
typedef vector<vector<int>> vvint;
typedef vector<vector<ll>> vvll;
typedef vector<vpint> vvpint;
typedef vector<vpll> vvpll;
typedef vector<vector<double>> vvdouble;
typedef vector<vector<string>> vvstring;
typedef vector<vector<bool>> vvbool;
typedef vector<vector<vector<ll>>> vvvll;
const int c_YET = -1;
const int INF = 1e9 + 1;
const ll LLINF = 1e17 + 1;
const int DX[9] = {0, 0, 1, -1, 1, 1, -1, -1, 0}; // 4;４近傍
const int DY[9] = {1, -1, 0, 0, 1, -1, 1, -1, 0}; // 8:８近傍 9:(0,0)を含む
const ll MOD = 1e9 + 7; // 10^9 + 7
const ll MAX = 1e9;
const double PI = 3.14159265358979323846264338327950288;
//---------------------------------------------------------------
// オーバーフローチェック
//---------------------------------------------------------------
bool is_overflow(ll a, ll b) { return ((a * b) / b != a); }
//---------------------------------------------------------------
// 約数列挙
//---------------------------------------------------------------
vll divisor(ll n) {
vll ret;
for (ll i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n)
ret.push_back(n / i);
}
}
sort(begin(ret), end(ret));
return (ret);
}
//---------------------------------------------------------------
// N以下のすべての素数を列挙する(エラトステネスの篩)
//---------------------------------------------------------------
vbool searchSosuu(ll N) {
vbool sosuu; // ←これをグローバル変数にして１度だけ実行する
for (ll i = 0; i < N; i++) {
sosuu.emplace_back(true);
}
sosuu[0] = false;
sosuu[1] = false;
for (ll i = 2; i < N; i++) {
if (sosuu[i]) {
for (ll j = 2; i * j < N; j++) {
sosuu[i * j] = false;
}
}
}
return sosuu;
}
//---------------------------------------------------------------
// 素因数分解 O(√N)
//---------------------------------------------------------------
vpll div_prime(ll n) {
vpll prime_factor;
for (ll i = 2; i * i <= n; i++) {
ll count = 0;
while (n % i == 0) {
count++;
n /= i;
}
if (count) {
pair<ll, ll> temp = {i, count};
prime_factor.emplace_back(temp);
}
}
if (n != 1) {
pair<ll, ll> temp = {n, 1};
prime_factor.emplace_back(temp);
}
return prime_factor;
}
//---------------------------------------------------------------
// 素数判定
//---------------------------------------------------------------
bool is_sosuu(ll N) {
if (N < 2) {
return false;
} else if (N == 2) {
return true;
} else if (N % 2 == 0) {
return false;
}
for (ll i = 3; i <= sqrt(N); i += 2) {
if (N % i == 0) {
return false;
}
}
return true;
}
//---------------------------------------------------------------
// 最大公約数（ユークリッドの互除法）
//---------------------------------------------------------------
ll gcd(ll a, ll b) {
if (a < b) {
ll tmp = a;
a = b;
b = tmp;
}
ll r = a % b;
while (r != 0) {
a = b;
b = r;
r = a % b;
}
return b;
}
//---------------------------------------------------------------
// 最小公倍数
//---------------------------------------------------------------
ll lcm(ll a, ll b) {
ll temp = gcd(a, b);
return temp * (a / temp) * (b / temp);
}
//---------------------------------------------------------------
// 階乗
//---------------------------------------------------------------
ll factorial(ll n) {
if (n <= 1) {
return 1;
}
return (n * (factorial(n - 1))) % MOD;
}
//---------------------------------------------------------------
// 高速コンビネーション計算(前処理:O(N) 計算:O(1))
//---------------------------------------------------------------
// テーブルを作る前処理
ll comb_const = 200005;
vll fac(comb_const), finv(comb_const), inv(comb_const);
bool COMineted = false;
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (ll i = 2; i < comb_const; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
COMineted = true;
}
// 二項係数計算
ll COM(ll n, ll k) {
if (COMineted == false)
COMinit();
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
//---------------------------------------------------------------
// 繰り返し２乗法 base^sisuu
//---------------------------------------------------------------
ll RepeatSquaring(ll base, ll sisuu) {
if (sisuu < 0) {
cout << "RepeatSquaring: 指数が負です!" << endl;
return 0;
}
if (sisuu == 0)
return 1;
if (sisuu % 2 == 0) {
ll t = RepeatSquaring(base, sisuu / 2) % MOD;
return (t * t) % MOD;
}
return base * RepeatSquaring(base, sisuu - 1) % MOD;
}
//---------------------------------------------------------------
// 高速単発コンビネーション計算(O(logN))
//---------------------------------------------------------------
ll fast_com(ll a, ll b) {
ll bunshi = 1;
ll bunbo = 1;
for (ll i = 1; i <= b; i++) {
bunbo *= i;
bunbo %= MOD;
bunshi *= (a - i + 1);
bunshi %= MOD;
}
ll ret = bunshi * RepeatSquaring(bunbo, MOD - 2);
ret %= MOD;
while (ret < 0) {
ret += MOD;
}
return ret;
}
//---------------------------------------------------------------
// 2直線の交差判定(直線(x1, y1)->(x2, y2) と 直線(X1, Y1)->(X2, Y2))
//---------------------------------------------------------------
bool is_cross(ll x1, ll y1, ll x2, ll y2, ll X1, ll Y1, ll X2, ll Y2) {
ll dx_ai = X1 - x1;
ll dy_ai = Y1 - y1;
ll dx_bi = X1 - x2;
ll dy_bi = Y1 - y2;
ll dx_ai2 = X2 - x1;
ll dy_ai2 = Y2 - y1;
ll dx_bi2 = X2 - x2;
ll dy_bi2 = Y2 - y2;
ll si = dx_ai * dy_bi - dy_ai * dx_bi;
ll si2 = dx_ai2 * dy_bi2 - dy_ai2 * dx_bi2;
ll si3 = dx_ai * dy_ai2 - dy_ai * dx_ai2;
ll si4 = dx_bi * dy_bi2 - dy_bi * dx_bi2;
return (si * si2 < 0 && si3 * si4 < 0);
}
//---------------------------------------------------------------
// 最長増加部分列の長さ(O(NlogN))
//---------------------------------------------------------------
ll LSI(vll vec, ll size) {
vll lsi(size + 1); // 長さjを作った時の右端の最小値
for (ll i = 0; i <= size; i++) {
lsi[i] = LLINF;
}
lsi[0] = 0;
lsi[1] = vec[0];
for (ll i = 1; i < size; i++) {
// 初めてvec[i]の方が小さくなるところを探す
auto Iter = lower_bound(lsi.begin(), lsi.end(), vec[i]);
ll idx = Iter - lsi.begin();
if (idx > 0 && lsi[idx - 1] < vec[i]) // 条件文の前半怪しい
{
lsi[idx] = vec[i];
}
}
for (ll i = size; i >= 0; i--) {
if (lsi[i] < LLINF) {
return i;
}
}
}
//---------------------------------------------------------------
// 木の根からの深さ
//---------------------------------------------------------------
vll tree_depth(vvll edge, ll start_node, ll n_node) {
vll dist(n_node, LLINF);
dist[start_node] = 0;
stack<pll> S;
S.push({start_node, 0});
while (!S.empty()) {
ll node = S.top().first;
ll d = S.top().second;
dist[node] = d;
S.pop();
for (int i = 0; i < edge[node].size(); i++) {
if (dist[edge[node][i]] == LLINF) {
S.push({edge[node][i], d + 1});
}
}
}
return dist;
}
//---------------------------------------------------------------
// ワーシャルフロイド法(O(N^3)) 任意の2点間の最短距離
//---------------------------------------------------------------
vvll warshall_floyd(ll n, vvll d) {
for (int k = 0; k < n; k++) { // 経由する頂点
for (int i = 0; i < n; i++) { // 始点
for (int j = 0; j < n; j++) { // 終点
d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}
}
}
return d;
}
//---------------------------------------------------------------
// Union Find
//---------------------------------------------------------------
/*
UnionFind uf(要素の個数);
for(int i = 0;i < 関係の個数; i++)
{
uf.merge(A[i], B[i]);
}
nを含む集合の大きさ = uf.size(n)
nを含む集合の代表者 = uf.root(n)
集合の個数 = uf.n_group
*/
class UnionFind {
public:
vector<ll> par; // 各元の親を表す配列
vector<ll> siz; // 素集合のサイズを表す配列(1 で初期化)
ll n_group; // 集合の数
// Constructor
UnionFind(ll sz_) : par(sz_), siz(sz_, 1LL) {
for (ll i = 0; i < sz_; ++i)
par[i] = i; // 初期では親は自分自身
n_group = sz_;
}
void init(ll sz_) {
par.resize(sz_);
siz.assign(sz_, 1LL); // resize だとなぜか初期化されなかった
for (ll i = 0; i < sz_; ++i)
par[i] = i; // 初期では親は自分自身
}
// Member Function
// Find
ll root(ll x) { // 根の検索
while (par[x] != x) {
x = par[x] = par[par[x]]; // x の親の親を x の親とする
}
return x;
}
// Union(Unite, Merge)
bool merge(ll x, ll y) {
x = root(x);
y = root(y);
if (x == y)
return false;
// merge technique（データ構造をマージするテク．小を大にくっつける）
if (siz[x] < siz[y])
swap(x, y);
siz[x] += siz[y];
par[y] = x;
n_group--;
return true;
}
bool issame(ll x, ll y) { // 連結判定
return root(x) == root(y);
}
ll size(ll x) { // 素集合のサイズ
return siz[root(x)];
}
};
//========================================================================
int main() {
////==================================
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(30);
////==================================
ll N;
cin >> N;
string S;
cin >> S;
ll Q;
cin >> Q;
vvll alp(30);
for (int i = 0; i < 30; i++) {
vll t;
alp[i] = t;
}
for (int i = 0; i < N; i++) {
alp[int(S[i]) - int('a')].emplace_back(i);
}
for (int q = 0; q < Q; q++) {
ll type;
cin >> type;
if (type == 1) {
ll pos;
char change_to;
cin >> pos >> change_to;
pos--;
char change_from = S[pos];
if (change_to == change_from) {
continue;
} else {
// 削除
auto Iter = lower_bound(alp[int(change_from) - int('a')].begin(),
alp[int(change_from) - int('a')].end(), pos);
alp[int(change_from) - int('a')].erase(Iter);
// 追加
Iter = upper_bound(alp[int(change_to) - int('a')].begin(),
alp[int(change_to) - int('a')].end(), pos);
ll idx = Iter - alp[int(change_to) - int('a')].begin();
alp[int(change_to) - int('a')].insert(Iter, pos);
}
} else {
ll start, last;
cin >> start >> last;
start--;
last--;
ll ret = 0;
for (int i = 0; i < 26; i++) {
auto Iter_s = lower_bound(alp[i].begin(), alp[i].end(), start);
auto Iter_l = upper_bound(alp[i].begin(), alp[i].end(), last);
ret += Iter_s != Iter_l;
}
cout << ret << endl;
}
}
}
| #include <algorithm>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <vector>
using namespace std;
// マクロ&定数&関数 ================================================
typedef unsigned int uint;
typedef long long ll;
typedef pair<ll, ll> pll;
typedef vector<int> vint;
typedef vector<ll> vll;
typedef vector<double> vdouble;
typedef vector<bool> vbool;
typedef vector<string> vstring;
typedef vector<pair<int, int>> vpint;
typedef vector<pair<ll, ll>> vpll;
typedef vector<pair<double, double>> vpdouble;
typedef vector<vector<int>> vvint;
typedef vector<vector<ll>> vvll;
typedef vector<vpint> vvpint;
typedef vector<vpll> vvpll;
typedef vector<vector<double>> vvdouble;
typedef vector<vector<string>> vvstring;
typedef vector<vector<bool>> vvbool;
typedef vector<vector<vector<ll>>> vvvll;
const int c_YET = -1;
const int INF = 1e9 + 1;
const ll LLINF = 1e17 + 1;
const int DX[9] = {0, 0, 1, -1, 1, 1, -1, -1, 0}; // 4;４近傍
const int DY[9] = {1, -1, 0, 0, 1, -1, 1, -1, 0}; // 8:８近傍 9:(0,0)を含む
const ll MOD = 1e9 + 7; // 10^9 + 7
const ll MAX = 1e9;
const double PI = 3.14159265358979323846264338327950288;
//---------------------------------------------------------------
// オーバーフローチェック
//---------------------------------------------------------------
bool is_overflow(ll a, ll b) { return ((a * b) / b != a); }
//---------------------------------------------------------------
// 約数列挙
//---------------------------------------------------------------
vll divisor(ll n) {
vll ret;
for (ll i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n)
ret.push_back(n / i);
}
}
sort(begin(ret), end(ret));
return (ret);
}
//---------------------------------------------------------------
// N以下のすべての素数を列挙する(エラトステネスの篩)
//---------------------------------------------------------------
vbool searchSosuu(ll N) {
vbool sosuu; // ←これをグローバル変数にして１度だけ実行する
for (ll i = 0; i < N; i++) {
sosuu.emplace_back(true);
}
sosuu[0] = false;
sosuu[1] = false;
for (ll i = 2; i < N; i++) {
if (sosuu[i]) {
for (ll j = 2; i * j < N; j++) {
sosuu[i * j] = false;
}
}
}
return sosuu;
}
//---------------------------------------------------------------
// 素因数分解 O(√N)
//---------------------------------------------------------------
vpll div_prime(ll n) {
vpll prime_factor;
for (ll i = 2; i * i <= n; i++) {
ll count = 0;
while (n % i == 0) {
count++;
n /= i;
}
if (count) {
pair<ll, ll> temp = {i, count};
prime_factor.emplace_back(temp);
}
}
if (n != 1) {
pair<ll, ll> temp = {n, 1};
prime_factor.emplace_back(temp);
}
return prime_factor;
}
//---------------------------------------------------------------
// 素数判定
//---------------------------------------------------------------
bool is_sosuu(ll N) {
if (N < 2) {
return false;
} else if (N == 2) {
return true;
} else if (N % 2 == 0) {
return false;
}
for (ll i = 3; i <= sqrt(N); i += 2) {
if (N % i == 0) {
return false;
}
}
return true;
}
//---------------------------------------------------------------
// 最大公約数（ユークリッドの互除法）
//---------------------------------------------------------------
ll gcd(ll a, ll b) {
if (a < b) {
ll tmp = a;
a = b;
b = tmp;
}
ll r = a % b;
while (r != 0) {
a = b;
b = r;
r = a % b;
}
return b;
}
//---------------------------------------------------------------
// 最小公倍数
//---------------------------------------------------------------
ll lcm(ll a, ll b) {
ll temp = gcd(a, b);
return temp * (a / temp) * (b / temp);
}
//---------------------------------------------------------------
// 階乗
//---------------------------------------------------------------
ll factorial(ll n) {
if (n <= 1) {
return 1;
}
return (n * (factorial(n - 1))) % MOD;
}
//---------------------------------------------------------------
// 高速コンビネーション計算(前処理:O(N) 計算:O(1))
//---------------------------------------------------------------
// テーブルを作る前処理
ll comb_const = 200005;
vll fac(comb_const), finv(comb_const), inv(comb_const);
bool COMineted = false;
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (ll i = 2; i < comb_const; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
COMineted = true;
}
// 二項係数計算
ll COM(ll n, ll k) {
if (COMineted == false)
COMinit();
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
//---------------------------------------------------------------
// 繰り返し２乗法 base^sisuu
//---------------------------------------------------------------
ll RepeatSquaring(ll base, ll sisuu) {
if (sisuu < 0) {
cout << "RepeatSquaring: 指数が負です!" << endl;
return 0;
}
if (sisuu == 0)
return 1;
if (sisuu % 2 == 0) {
ll t = RepeatSquaring(base, sisuu / 2) % MOD;
return (t * t) % MOD;
}
return base * RepeatSquaring(base, sisuu - 1) % MOD;
}
//---------------------------------------------------------------
// 高速単発コンビネーション計算(O(logN))
//---------------------------------------------------------------
ll fast_com(ll a, ll b) {
ll bunshi = 1;
ll bunbo = 1;
for (ll i = 1; i <= b; i++) {
bunbo *= i;
bunbo %= MOD;
bunshi *= (a - i + 1);
bunshi %= MOD;
}
ll ret = bunshi * RepeatSquaring(bunbo, MOD - 2);
ret %= MOD;
while (ret < 0) {
ret += MOD;
}
return ret;
}
//---------------------------------------------------------------
// 2直線の交差判定(直線(x1, y1)->(x2, y2) と 直線(X1, Y1)->(X2, Y2))
//---------------------------------------------------------------
bool is_cross(ll x1, ll y1, ll x2, ll y2, ll X1, ll Y1, ll X2, ll Y2) {
ll dx_ai = X1 - x1;
ll dy_ai = Y1 - y1;
ll dx_bi = X1 - x2;
ll dy_bi = Y1 - y2;
ll dx_ai2 = X2 - x1;
ll dy_ai2 = Y2 - y1;
ll dx_bi2 = X2 - x2;
ll dy_bi2 = Y2 - y2;
ll si = dx_ai * dy_bi - dy_ai * dx_bi;
ll si2 = dx_ai2 * dy_bi2 - dy_ai2 * dx_bi2;
ll si3 = dx_ai * dy_ai2 - dy_ai * dx_ai2;
ll si4 = dx_bi * dy_bi2 - dy_bi * dx_bi2;
return (si * si2 < 0 && si3 * si4 < 0);
}
//---------------------------------------------------------------
// 最長増加部分列の長さ(O(NlogN))
//---------------------------------------------------------------
ll LSI(vll vec, ll size) {
vll lsi(size + 1); // 長さjを作った時の右端の最小値
for (ll i = 0; i <= size; i++) {
lsi[i] = LLINF;
}
lsi[0] = 0;
lsi[1] = vec[0];
for (ll i = 1; i < size; i++) {
// 初めてvec[i]の方が小さくなるところを探す
auto Iter = lower_bound(lsi.begin(), lsi.end(), vec[i]);
ll idx = Iter - lsi.begin();
if (idx > 0 && lsi[idx - 1] < vec[i]) // 条件文の前半怪しい
{
lsi[idx] = vec[i];
}
}
for (ll i = size; i >= 0; i--) {
if (lsi[i] < LLINF) {
return i;
}
}
}
//---------------------------------------------------------------
// 木の根からの深さ
//---------------------------------------------------------------
vll tree_depth(vvll edge, ll start_node, ll n_node) {
vll dist(n_node, LLINF);
dist[start_node] = 0;
stack<pll> S;
S.push({start_node, 0});
while (!S.empty()) {
ll node = S.top().first;
ll d = S.top().second;
dist[node] = d;
S.pop();
for (int i = 0; i < edge[node].size(); i++) {
if (dist[edge[node][i]] == LLINF) {
S.push({edge[node][i], d + 1});
}
}
}
return dist;
}
//---------------------------------------------------------------
// ワーシャルフロイド法(O(N^3)) 任意の2点間の最短距離
//---------------------------------------------------------------
vvll warshall_floyd(ll n, vvll d) {
for (int k = 0; k < n; k++) { // 経由する頂点
for (int i = 0; i < n; i++) { // 始点
for (int j = 0; j < n; j++) { // 終点
d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}
}
}
return d;
}
//---------------------------------------------------------------
// Union Find
//---------------------------------------------------------------
/*
UnionFind uf(要素の個数);
for(int i = 0;i < 関係の個数; i++)
{
uf.merge(A[i], B[i]);
}
nを含む集合の大きさ = uf.size(n)
nを含む集合の代表者 = uf.root(n)
集合の個数 = uf.n_group
*/
class UnionFind {
public:
vector<ll> par; // 各元の親を表す配列
vector<ll> siz; // 素集合のサイズを表す配列(1 で初期化)
ll n_group; // 集合の数
// Constructor
UnionFind(ll sz_) : par(sz_), siz(sz_, 1LL) {
for (ll i = 0; i < sz_; ++i)
par[i] = i; // 初期では親は自分自身
n_group = sz_;
}
void init(ll sz_) {
par.resize(sz_);
siz.assign(sz_, 1LL); // resize だとなぜか初期化されなかった
for (ll i = 0; i < sz_; ++i)
par[i] = i; // 初期では親は自分自身
}
// Member Function
// Find
ll root(ll x) { // 根の検索
while (par[x] != x) {
x = par[x] = par[par[x]]; // x の親の親を x の親とする
}
return x;
}
// Union(Unite, Merge)
bool merge(ll x, ll y) {
x = root(x);
y = root(y);
if (x == y)
return false;
// merge technique（データ構造をマージするテク．小を大にくっつける）
if (siz[x] < siz[y])
swap(x, y);
siz[x] += siz[y];
par[y] = x;
n_group--;
return true;
}
bool issame(ll x, ll y) { // 連結判定
return root(x) == root(y);
}
ll size(ll x) { // 素集合のサイズ
return siz[root(x)];
}
};
//========================================================================
int main() {
////==================================
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(30);
////==================================
ll N;
cin >> N;
string S;
cin >> S;
ll Q;
cin >> Q;
vvll alp(30);
for (int i = 0; i < 30; i++) {
vll t;
alp[i] = t;
}
for (int i = 0; i < N; i++) {
alp[int(S[i]) - int('a')].emplace_back(i);
}
for (int q = 0; q < Q; q++) {
ll type;
cin >> type;
if (type == 1) {
ll pos;
char change_to;
cin >> pos >> change_to;
pos--;
char change_from = S[pos];
if (change_to == change_from) {
continue;
} else {
// 削除
auto Iter = lower_bound(alp[int(change_from) - int('a')].begin(),
alp[int(change_from) - int('a')].end(), pos);
alp[int(change_from) - int('a')].erase(Iter);
// 追加
Iter = upper_bound(alp[int(change_to) - int('a')].begin(),
alp[int(change_to) - int('a')].end(), pos);
ll idx = Iter - alp[int(change_to) - int('a')].begin();
alp[int(change_to) - int('a')].insert(Iter, pos);
S[pos] = change_to;
}
} else {
ll start, last;
cin >> start >> last;
start--;
last--;
ll ret = 0;
for (int i = 0; i < 26; i++) {
auto Iter_s = lower_bound(alp[i].begin(), alp[i].end(), start);
auto Iter_l = upper_bound(alp[i].begin(), alp[i].end(), last);
ret += Iter_s != Iter_l;
}
cout << ret << endl;
}
}
}
| insert | 467 | 467 | 467 | 469 | 0 | |
p02763 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5;
int n, Q;
char s[N];
class BIT {
public:
vector<int> sum;
void init(int SIZE) { sum.resize(SIZE, 0); }
void ins(const int &x, const int &v) {
for (int i = x; i <= n; i += i & -i)
sum[i] += v;
}
int ask(const int &x) const {
int ans = 0;
for (int i = x; i; i &= i - 1)
ans += sum[i];
return ans;
}
} bit[26];
int main() {
cin >> n;
scanf("%s", s + 1);
for (int i = 0; i < 26; i++)
bit[i].init(n);
for (int i = 1; i <= n; i++)
bit[s[i] - 'a'].ins(i, 1);
scanf("%d", &Q);
while (Q--) {
int op;
scanf("%d", &op);
if (op == 1) {
int x;
char c;
scanf("%d %c", &x, &c);
if (s[x] == c)
continue;
bit[s[x] - 'a'].ins(x, -1);
bit[c - 'a'].ins(x, 1);
s[x] = c;
} else {
int l, r;
scanf("%d%d", &l, &r);
int ans = 0;
for (int i = 0; i < 26; i++)
ans += bit[i].ask(r) - bit[i].ask(l - 1) > 0;
printf("%d\n", ans);
}
}
}
| #include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5;
int n, Q;
char s[N];
class BIT {
public:
vector<int> sum;
void init(int SIZE) { sum.resize(SIZE, 0); }
void ins(const int &x, const int &v) {
for (int i = x; i <= n; i += i & -i)
sum[i] += v;
}
int ask(const int &x) const {
int ans = 0;
for (int i = x; i; i &= i - 1)
ans += sum[i];
return ans;
}
} bit[26];
int main() {
cin >> n;
scanf("%s", s + 1);
for (int i = 0; i < 26; i++)
bit[i].init(n + 1);
for (int i = 1; i <= n; i++)
bit[s[i] - 'a'].ins(i, 1);
scanf("%d", &Q);
while (Q--) {
int op;
scanf("%d", &op);
if (op == 1) {
int x;
char c;
scanf("%d %c", &x, &c);
if (s[x] == c)
continue;
bit[s[x] - 'a'].ins(x, -1);
bit[c - 'a'].ins(x, 1);
s[x] = c;
} else {
int l, r;
scanf("%d%d", &l, &r);
int ans = 0;
for (int i = 0; i < 26; i++)
ans += bit[i].ask(r) - bit[i].ask(l - 1) > 0;
printf("%d\n", ans);
}
}
}
| replace | 24 | 25 | 24 | 25 | 0 | |
p02763 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define MOD (1000000007LL)
using namespace std;
const int denom = 100;
int cntt[500000 / denom][26];
string S;
bool hoge(int n, int l, int r) {
int L = (l + denom) / denom;
int R = (r + 1) / denom;
// cout << L << " " << R << endl;
for (int I = L; I < R; I++) {
if (cntt[I][n] > 0)
return true;
}
for (int i = l; i <= min(r, L * denom); i++) {
// cout << "i: " << i << ", S[i]: " << S[i] << endl;
if (S[i] == n + 'a')
return true;
}
for (int i = max(l, R * denom); i <= r; i++) {
if (S[i] == n + 'a')
return true;
}
// cout << "false" << endl;
return false;
}
int main(void) {
int N;
int Q;
cin >> N >> S >> Q;
for (int i = 0; i < N; i++) {
cntt[i / denom][S[i] - 'a']++;
}
for (int q = 0; q < Q; q++) {
int t;
cin >> t;
if (t == 1) {
int i;
char c;
cin >> i >> c;
i--;
cntt[i / denom][S[i] - 'a']--;
cntt[i / denom][c - 'a']++;
S[i] = c;
}
if (t == 2) {
int ans = 0;
int l, r;
cin >> l >> r;
for (int i = 0; i < 26; i++) {
if (hoge(i, l - 1, r - 1))
ans++;
}
cout << ans << endl;
}
}
// cout << S << endl;
return 0;
}
| #include <bits/stdc++.h>
#define MOD (1000000007LL)
using namespace std;
const int denom = 1000;
int cntt[500000 / denom][26];
string S;
bool hoge(int n, int l, int r) {
int L = (l + denom) / denom;
int R = (r + 1) / denom;
// cout << L << " " << R << endl;
for (int I = L; I < R; I++) {
if (cntt[I][n] > 0)
return true;
}
for (int i = l; i <= min(r, L * denom); i++) {
// cout << "i: " << i << ", S[i]: " << S[i] << endl;
if (S[i] == n + 'a')
return true;
}
for (int i = max(l, R * denom); i <= r; i++) {
if (S[i] == n + 'a')
return true;
}
// cout << "false" << endl;
return false;
}
int main(void) {
int N;
int Q;
cin >> N >> S >> Q;
for (int i = 0; i < N; i++) {
cntt[i / denom][S[i] - 'a']++;
}
for (int q = 0; q < Q; q++) {
int t;
cin >> t;
if (t == 1) {
int i;
char c;
cin >> i >> c;
i--;
cntt[i / denom][S[i] - 'a']--;
cntt[i / denom][c - 'a']++;
S[i] = c;
}
if (t == 2) {
int ans = 0;
int l, r;
cin >> l >> r;
for (int i = 0; i < 26; i++) {
if (hoge(i, l - 1, r - 1))
ans++;
}
cout << ans << endl;
}
}
// cout << S << endl;
return 0;
}
| replace | 6 | 7 | 6 | 7 | TLE | |
p02763 | C++ | Time Limit Exceeded | //----AUTHOR:kkdrummer----/
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/rope>
using namespace __gnu_cxx;
using namespace __gnu_pbds;
using namespace std;
typedef long long ll;
typedef long double ld;
typedef complex<ld> P;
#define X real()
#define Y imag()
ld restant(P p) { return abs(p); }
// polar(x,y) mag=l,arg=y
// typedef unordered_set<ll> usll;
// typedef unordered_multiset<ll> umsll;
typedef multiset<ll> msll;
typedef set<ll> sll;
typedef vector<ll> vll;
typedef pair<ll, ll> pll;
typedef vector<pair<ll, ll>> vpll;
typedef priority_queue<ll> pqll;
typedef vector<int> vi;
typedef set<int> si;
typedef multiset<int> msi;
// typedef unordered_multiset<int> umsi;
// typedef unordered_set<int> usi;
typedef pair<int, int> pi;
typedef vector<pair<int, int>> vpi;
typedef vector<pair<double, double>> vpd;
typedef pair<double, double> pd;
typedef priority_queue<int> pqi;
typedef tree<int, null_type, less<int>, rb_tree_tag,
tree_order_statistics_node_update>
ind_set;
typedef tree<ll, null_type, less<ll>, rb_tree_tag,
tree_order_statistics_node_update>
ind_setll;
#define in insert
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define be begin
#define en end
#define itr iterator
#define io \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define mo 1000000007
#define inf 1000000000000000001
#define ninf -1000000000000000001
#define ima INT_MAX
#define imi INT_MIN
#define oncnt __builtin_popcount
#define zerobegin __builtin_clz
#define zeroend __builtin_ctz
#define parity __builtin_parity
#define all(x) x.be(), x.en()
#define eps 1e-9
const ld pii = 3.14159265359;
inline ll modpow(ll x, ll n) {
if (n == 0)
return 1;
if (n == 1)
return (x % mo);
ll u = (modpow(x, n / 2));
u = (u * u) % mo;
if (n % 2 != 0)
u = (u * x % mo) % mo;
return u;
}
inline ll modinv(ll x) { return modpow(x, mo - 2); }
inline ll mmul(ll a, ll b) {
if (a >= mo)
a = a % mo;
if (b >= mo)
b = b % mo;
if (a * b >= mo)
return (a * b) % mo;
return (a * b);
}
inline ll madd(ll a, ll b) {
if (a >= mo)
a = a % mo;
if (b >= mo)
b = b % mo;
if (a + b >= mo)
return (a + b) % mo;
return (a + b);
}
inline ll msub(ll a, ll b) {
if (a >= mo)
a = a % mo;
if (b >= mo)
b = b % mo;
return ((a - b + mo) % mo);
}
inline ll mdiv(ll a, ll bb) {
if (a >= mo)
a = a % mo;
ll b = modinv(bb);
if (b >= mo)
b = b % mo;
if (a * b >= mo)
return (a * b) % mo;
return (a * b);
}
inline ll gcd(ll a, ll b) { return __gcd(a, b); }
int main() {
io int testcases = 1; // cin>>testcases;
while (testcases--) {
int n;
cin >> n;
string s;
cin >> s;
si pro[26];
for (int i = 0; i < n; i++)
pro[int(s[i]) - 97].insert(i);
int q;
cin >> q;
while (q--) {
int x;
cin >> x;
if (x == 1) {
int id;
char c;
cin >> id >> c;
id--;
if (s[id] != c) {
pro[s[id] - 'a'].erase(id);
s[id] = c;
pro[c - 'a'].insert(id);
}
}
else {
int ql, qr;
cin >> ql >> qr;
ql--;
qr--;
int ans = 0;
for (int i = 0; i < 26; i++) {
si::itr k = lower_bound(all(pro[i]), ql);
if (qr >= *k && k != pro[i].end())
ans++;
}
cout << ans << "\n";
}
}
}
return 0;
}
| //----AUTHOR:kkdrummer----/
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/rope>
using namespace __gnu_cxx;
using namespace __gnu_pbds;
using namespace std;
typedef long long ll;
typedef long double ld;
typedef complex<ld> P;
#define X real()
#define Y imag()
ld restant(P p) { return abs(p); }
// polar(x,y) mag=l,arg=y
// typedef unordered_set<ll> usll;
// typedef unordered_multiset<ll> umsll;
typedef multiset<ll> msll;
typedef set<ll> sll;
typedef vector<ll> vll;
typedef pair<ll, ll> pll;
typedef vector<pair<ll, ll>> vpll;
typedef priority_queue<ll> pqll;
typedef vector<int> vi;
typedef set<int> si;
typedef multiset<int> msi;
// typedef unordered_multiset<int> umsi;
// typedef unordered_set<int> usi;
typedef pair<int, int> pi;
typedef vector<pair<int, int>> vpi;
typedef vector<pair<double, double>> vpd;
typedef pair<double, double> pd;
typedef priority_queue<int> pqi;
typedef tree<int, null_type, less<int>, rb_tree_tag,
tree_order_statistics_node_update>
ind_set;
typedef tree<ll, null_type, less<ll>, rb_tree_tag,
tree_order_statistics_node_update>
ind_setll;
#define in insert
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define be begin
#define en end
#define itr iterator
#define io \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define mo 1000000007
#define inf 1000000000000000001
#define ninf -1000000000000000001
#define ima INT_MAX
#define imi INT_MIN
#define oncnt __builtin_popcount
#define zerobegin __builtin_clz
#define zeroend __builtin_ctz
#define parity __builtin_parity
#define all(x) x.be(), x.en()
#define eps 1e-9
const ld pii = 3.14159265359;
inline ll modpow(ll x, ll n) {
if (n == 0)
return 1;
if (n == 1)
return (x % mo);
ll u = (modpow(x, n / 2));
u = (u * u) % mo;
if (n % 2 != 0)
u = (u * x % mo) % mo;
return u;
}
inline ll modinv(ll x) { return modpow(x, mo - 2); }
inline ll mmul(ll a, ll b) {
if (a >= mo)
a = a % mo;
if (b >= mo)
b = b % mo;
if (a * b >= mo)
return (a * b) % mo;
return (a * b);
}
inline ll madd(ll a, ll b) {
if (a >= mo)
a = a % mo;
if (b >= mo)
b = b % mo;
if (a + b >= mo)
return (a + b) % mo;
return (a + b);
}
inline ll msub(ll a, ll b) {
if (a >= mo)
a = a % mo;
if (b >= mo)
b = b % mo;
return ((a - b + mo) % mo);
}
inline ll mdiv(ll a, ll bb) {
if (a >= mo)
a = a % mo;
ll b = modinv(bb);
if (b >= mo)
b = b % mo;
if (a * b >= mo)
return (a * b) % mo;
return (a * b);
}
inline ll gcd(ll a, ll b) { return __gcd(a, b); }
int main() {
io int testcases = 1; // cin>>testcases;
while (testcases--) {
int n;
cin >> n;
string s;
cin >> s;
si pro[26];
for (int i = 0; i < n; i++)
pro[int(s[i]) - 97].insert(i);
int q;
cin >> q;
while (q--) {
int x;
cin >> x;
if (x == 1) {
int id;
char c;
cin >> id >> c;
id--;
if (s[id] != c) {
pro[s[id] - 'a'].erase(id);
s[id] = c;
pro[c - 'a'].insert(id);
}
}
else {
int ql, qr;
cin >> ql >> qr;
ql--;
qr--;
int ans = 0;
for (int i = 0; i < 26; i++) {
if (pro[i].lower_bound(ql) != pro[i].upper_bound(qr))
ans++;
}
cout << ans << "\n";
}
}
}
return 0;
}
| replace | 148 | 150 | 148 | 149 | TLE | |
p02763 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (i = 0; i < n; ++i)
#define all(v) v.begin(), v.end()
using ll = long long;
int main() {
ll i, j;
ll n;
string s;
cin >> n >> s;
vector<set<ll>> vs(26);
for (i = 0; i < n; ++i) {
char tmp = s.at(i);
vs.at(tmp - 'a').insert(i);
}
vector<char> ss(n);
for (i = 0; i < n; ++i) {
ss.at(i) = s.at(i);
}
ll q;
cin >> q;
for (i = 0; i < q; ++i) {
ll com;
cin >> com;
if (com == 1) {
ll ind;
char c;
cin >> ind >> c;
--ind;
/**
char tmp = ss.at(ind);
ss.at(ind) = c;
vs.at(tmp - 'a').erase(ind);
vs.at(c - 'a').insert(ind);
**/
rep(j, 26) { vs.at(j).erase(ind); }
vs.at(c - 'a').insert(ind);
} else {
ll l, r;
cin >> l >> r;
ll ans = 0;
rep(j, 26) {
auto it1 = lower_bound(all(vs.at(j)), l - 1);
auto it2 = lower_bound(all(vs.at(j)), r);
if (it1 != it2)
++ans;
}
/**
rep(j,26){
auto it = vs.at(j).lower_bound(l-1);
if(it != vs.at(j).end()){
if(*it < r) ++ans;
}
}
**/
cout << ans << endl;
}
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (i = 0; i < n; ++i)
#define all(v) v.begin(), v.end()
using ll = long long;
int main() {
ll i, j;
ll n;
string s;
cin >> n >> s;
vector<set<ll>> vs(26);
for (i = 0; i < n; ++i) {
char tmp = s.at(i);
vs.at(tmp - 'a').insert(i);
}
vector<char> ss(n);
for (i = 0; i < n; ++i) {
ss.at(i) = s.at(i);
}
ll q;
cin >> q;
for (i = 0; i < q; ++i) {
ll com;
cin >> com;
if (com == 1) {
ll ind;
char c;
cin >> ind >> c;
--ind;
/**
char tmp = ss.at(ind);
ss.at(ind) = c;
vs.at(tmp - 'a').erase(ind);
vs.at(c - 'a').insert(ind);
**/
rep(j, 26) { vs.at(j).erase(ind); }
vs.at(c - 'a').insert(ind);
} else {
ll l, r;
cin >> l >> r;
ll ans = 0;
rep(j, 26) {
auto it1 = vs.at(j).lower_bound(l - 1);
auto it2 = vs.at(j).lower_bound(r);
if (it1 != it2)
++ans;
}
/**
rep(j,26){
auto it = vs.at(j).lower_bound(l-1);
if(it != vs.at(j).end()){
if(*it < r) ++ans;
}
}
**/
cout << ans << endl;
}
}
return 0;
} | replace | 44 | 46 | 44 | 46 | TLE | |
p02763 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define sz(x) int(x.size())
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const ll INF = 1LL << 60;
ll N, Q;
string S;
// map<int, set<ll>> mp;
vector<set<int>> mp(26);
int main() {
// set<ll> v = {2, 4, 5, 7};
// auto it = v.lower_bound(5);
// cout << *it << endl;
// v.erase(it);
// rep(i, v.size()) {
// cout << v[i] << " ";
// }
// return 0;
cin >> N >> S >> Q;
rep(i, S.size()) { mp[S[i] - 'a'].insert(i); }
// cout << (upper_bound(v.begin(), v.end(), 5) - v.begin()) -
// (lower_bound(v.begin(), v.end(), 4) - v.begin()) << endl; for (auto m : mp)
// {
// cout << m.first << endl;
// cout << " ";
// for (auto s : m.second) {
// cout << s << " ";
// }
// cout << endl;
// }
rep(k, Q) {
ll t;
cin >> t;
if (t == 1) {
ll i;
char c;
cin >> i >> c;
i--;
// // idx 消す
// for (int j = 0; j < 26; j++) {
// set<ll> target = mp[j];
// // auto idx = find(target.begin(), target.end(), i);
// if (target.count(i)) {
// // cout << "erase" << endl;
// // cout << *idx << endl;
// target.erase(i);
// mp[j] = target;
// break;
// }
// }
// i文字めを消す
mp[S[i] - 'a'].erase(i);
S[i] = c;
// idx 挿入
mp[c - 'a'].insert(i);
} else {
ll l, r;
cin >> l >> r;
l--;
r--;
ll ans = 0;
for (int j = 0; j < 26; j++) {
set<int> s = mp[j];
auto it = s.lower_bound(l);
if (it != s.end() && *it <= r) {
ans++;
};
// ll tmp = (upper_bound(v.begin(), v.end(), r) - v.begin()) -
// (lower_bound(v.begin(), v.end(), l) - v.begin()); if (tmp > 0) {
// ans++;
// }
}
cout << ans << endl;
}
}
// for (auto m : mp) {
// cout << m.first << endl;
// cout << " ";
// for (auto s : m.second) {
// cout << s << " ";
// }
// cout << endl;
// }
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define sz(x) int(x.size())
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const ll INF = 1LL << 60;
ll N, Q;
string S;
// map<int, set<ll>> mp;
vector<set<int>> mp(26);
int main() {
// set<ll> v = {2, 4, 5, 7};
// auto it = v.lower_bound(5);
// cout << *it << endl;
// v.erase(it);
// rep(i, v.size()) {
// cout << v[i] << " ";
// }
// return 0;
cin >> N >> S >> Q;
rep(i, S.size()) { mp[S[i] - 'a'].insert(i); }
// cout << (upper_bound(v.begin(), v.end(), 5) - v.begin()) -
// (lower_bound(v.begin(), v.end(), 4) - v.begin()) << endl; for (auto m : mp)
// {
// cout << m.first << endl;
// cout << " ";
// for (auto s : m.second) {
// cout << s << " ";
// }
// cout << endl;
// }
rep(k, Q) {
ll t;
cin >> t;
if (t == 1) {
ll i;
char c;
cin >> i >> c;
i--;
// // idx 消す
// for (int j = 0; j < 26; j++) {
// set<ll> target = mp[j];
// // auto idx = find(target.begin(), target.end(), i);
// if (target.count(i)) {
// // cout << "erase" << endl;
// // cout << *idx << endl;
// target.erase(i);
// mp[j] = target;
// break;
// }
// }
// i文字めを消す
mp[S[i] - 'a'].erase(i);
S[i] = c;
// idx 挿入
mp[c - 'a'].insert(i);
} else {
ll l, r;
cin >> l >> r;
l--;
r--;
ll ans = 0;
for (int j = 0; j < 26; j++) {
auto it = mp[j].lower_bound(l);
if (it != mp[j].end() && *it <= r) {
ans++;
};
// ll tmp = (upper_bound(v.begin(), v.end(), r) - v.begin()) -
// (lower_bound(v.begin(), v.end(), l) - v.begin()); if (tmp > 0) {
// ans++;
// }
}
cout << ans << endl;
}
}
// for (auto m : mp) {
// cout << m.first << endl;
// cout << " ";
// for (auto s : m.second) {
// cout << s << " ";
// }
// cout << endl;
// }
} | replace | 74 | 77 | 74 | 76 | TLE | |
p02763 | C++ | Runtime Error | // 失敗するからこそ
// そこから立ち向かって行く強さがあってそんな強さが本当の強さだと私は思うから
#ifdef DAIJOBU
#include "/home/v-o_o-v/deb.h"
#define deb(x...) \
cerr << "[" << #x << "] = ["; \
_print(x)
#else
#include <bits/stdc++.h>
#define deb(x...)
#endif
using namespace std;
#define mp make_pair
#define mt make_tuple
#define fi first
#define se second
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define forn(i, n) for (int i = 0; i < (int)(n); ++i)
#define for1(i, n) for (int i = 1; i <= (int)(n); ++i)
#define ford(i, n) for (int i = (int)(n)-1; i >= 0; --i)
#define fore(i, a, b) for (int i = (int)(a); i <= (int)(b); ++i)
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<pii> vpi;
typedef long long lint;
typedef double ld;
const int maxn = 1e5 + 100;
vector<vector<int>> tree(maxn, vector<int>(26, 0));
void add(int in, int id, int del) {
while (in < maxn) {
// deb("inf loop");
tree[in][id] += del;
in += (in & -in);
}
}
vi sum(int in) {
vi ret(26, 0);
while (in) {
forn(i, 26) ret[i] += tree[in][i];
in -= (in & -in);
}
return ret;
}
int rsum(int l, int r) {
vi R = sum(r);
vi L = sum(l - 1);
forn(i, 26) R[i] -= L[i];
int ans = 0;
forn(i, 26) if (R[i]) ans++;
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
string s;
cin >> s;
for1(i, s.size()) { add(i, s[i - 1] - 'a', 1); }
int q;
cin >> q;
while (q--) {
int op;
cin >> op;
if (op == 1) {
int pos;
char c;
cin >> pos >> c;
// pos--;
add(pos, s[pos - 1] - 'a', -1);
add(pos, c - 'a', 1);
s[pos - 1] = c;
} else {
int l, r;
cin >> l >> r;
cout << rsum(l, r) << '\n';
}
}
return 0;
}
// Write Here
| // 失敗するからこそ
// そこから立ち向かって行く強さがあってそんな強さが本当の強さだと私は思うから
#ifdef DAIJOBU
#include "/home/v-o_o-v/deb.h"
#define deb(x...) \
cerr << "[" << #x << "] = ["; \
_print(x)
#else
#include <bits/stdc++.h>
#define deb(x...)
#endif
using namespace std;
#define mp make_pair
#define mt make_tuple
#define fi first
#define se second
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define forn(i, n) for (int i = 0; i < (int)(n); ++i)
#define for1(i, n) for (int i = 1; i <= (int)(n); ++i)
#define ford(i, n) for (int i = (int)(n)-1; i >= 0; --i)
#define fore(i, a, b) for (int i = (int)(a); i <= (int)(b); ++i)
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<pii> vpi;
typedef long long lint;
typedef double ld;
const int maxn = 5e5 + 100;
vector<vector<int>> tree(maxn, vector<int>(26, 0));
void add(int in, int id, int del) {
while (in < maxn) {
// deb("inf loop");
tree[in][id] += del;
in += (in & -in);
}
}
vi sum(int in) {
vi ret(26, 0);
while (in) {
forn(i, 26) ret[i] += tree[in][i];
in -= (in & -in);
}
return ret;
}
int rsum(int l, int r) {
vi R = sum(r);
vi L = sum(l - 1);
forn(i, 26) R[i] -= L[i];
int ans = 0;
forn(i, 26) if (R[i]) ans++;
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
string s;
cin >> s;
for1(i, s.size()) { add(i, s[i - 1] - 'a', 1); }
int q;
cin >> q;
while (q--) {
int op;
cin >> op;
if (op == 1) {
int pos;
char c;
cin >> pos >> c;
// pos--;
add(pos, s[pos - 1] - 'a', -1);
add(pos, c - 'a', 1);
s[pos - 1] = c;
} else {
int l, r;
cin >> l >> r;
cout << rsum(l, r) << '\n';
}
}
return 0;
}
// Write Here
| replace | 34 | 35 | 34 | 35 | 0 | |
p02763 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pli = pair<ll, int>;
using Graph = vector<vector<int>>;
const int MOD = 1e9 + 7;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, Q;
string S;
cin >> N >> S >> Q;
vector<set<int>> pos(26);
for (int i = 0; i < N; ++i)
pos[S[i] - 'a'].insert(i);
for (int i = 0; i < Q; ++i) {
int n;
cin >> n;
if (n == 1) {
int a;
char c;
cin >> a >> c;
a--;
pos[S[a] - 'a'].erase(a);
pos[c - 'a'].insert(a);
S[a] = c;
} else {
int a, b;
cin >> a >> b;
a--, b--;
int cnt = 0;
for (int j = 0; j < 26; ++j) {
auto itr = lower_bound(pos[j].begin(), pos[j].end(), a);
if (itr != pos[j].end())
cnt += (*itr <= b);
}
cout << cnt << '\n';
}
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pli = pair<ll, int>;
using Graph = vector<vector<int>>;
const int MOD = 1e9 + 7;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, Q;
string S;
cin >> N >> S >> Q;
vector<set<int>> pos(26);
for (int i = 0; i < N; ++i)
pos[S[i] - 'a'].insert(i);
for (int i = 0; i < Q; ++i) {
int n;
cin >> n;
if (n == 1) {
int a;
char c;
cin >> a >> c;
a--;
pos[S[a] - 'a'].erase(a);
pos[c - 'a'].insert(a);
S[a] = c;
} else {
int a, b;
cin >> a >> b;
a--, b--;
int cnt = 0;
for (int j = 0; j < 26; ++j) {
auto itr = pos[j].lower_bound(a);
if (itr != pos[j].end())
cnt += (*itr <= b);
}
cout << cnt << '\n';
}
}
return 0;
}
| replace | 39 | 40 | 39 | 40 | TLE | |
p02763 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
#define all(x) (x).begin(), (x).end()
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
string S;
cin >> S;
vector<vector<int>> v(26);
for (int i = 0; i < N; i++) {
v[S[i] - 'a'].push_back(i);
}
int Q;
cin >> Q;
for (int k = 0; k < Q; k++) {
int type;
cin >> type;
if (type == 1) {
int i;
cin >> i;
i--;
char c;
cin >> c;
if (S[i] == c)
continue;
int j = S[i] - 'a';
v[j].erase(lower_bound(all(v[j]), i));
j = c - 'a';
v[j].insert(lower_bound(all(v[j]), i), i);
} else {
int l, r;
cin >> l >> r;
l--;
r--;
int ans = 0;
for (int i = 0; i < 26; i++) {
if (v[i].empty())
continue;
int index = lower_bound(all(v[i]), l) - v[i].begin();
if (index < v[i].size() && v[i][index] <= r)
ans++;
}
cout << ans << "\n";
}
}
} | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
#define all(x) (x).begin(), (x).end()
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
string S;
cin >> S;
vector<vector<int>> v(26);
for (int i = 0; i < N; i++) {
v[S[i] - 'a'].push_back(i);
}
int Q;
cin >> Q;
for (int k = 0; k < Q; k++) {
int type;
cin >> type;
if (type == 1) {
int i;
cin >> i;
i--;
char c;
cin >> c;
if (S[i] == c)
continue;
int j = S[i] - 'a';
v[j].erase(lower_bound(all(v[j]), i));
S[i] = c;
j = c - 'a';
v[j].insert(lower_bound(all(v[j]), i), i);
} else {
int l, r;
cin >> l >> r;
l--;
r--;
int ans = 0;
for (int i = 0; i < 26; i++) {
if (v[i].empty())
continue;
int index = lower_bound(all(v[i]), l) - v[i].begin();
if (index < v[i].size() && v[i][index] <= r)
ans++;
}
cout << ans << "\n";
}
}
} | insert | 34 | 34 | 34 | 35 | 0 | |
p02763 | C++ | Memory Limit Exceeded | // g++ -Wall -Wextra -pedantic -std=c++17 -O3 -Wshadow -Wformat=2 -Wfloat-equal
// -Wconversion -Wlogical-op -Wcast-qual -Wcast-align -D_GLIBCXX_DEBUG
// -D_GLIBCXX_DEBUG_PEDANTIC contest.cpp
#include <bits/stdc++.h>
// #define _GLIBCXX_DEBUG 1
// #define _GLIBCXX_DEBUG_PEDANTIC 1
// #define _FORTIFY_SOURCE 2
using namespace std;
#define int long long
#define ff first
#define ss second
#define all(x) (x).begin(), (x).end()
#define sz(x) (int)(x.size())
#define PI 3.1415926535897932384626433832795
int MOD = 1e9 + 7;
int powmod(int a, int l, int md) {
a %= md;
int res = 1;
while (l) {
if (l & 1)
res = res * a % md;
l /= 2;
a = a * a % md;
}
return res;
}
int binpow(int a, int l) {
int res = 1;
while (l) {
if (l & 1)
res = res * a;
l /= 2;
a = a * a;
}
return res;
}
int invmod(int a, int md) { return powmod(a, md - 2, md); }
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef vector<int> vi;
typedef pair<int, int> ii;
typedef vector<ii> vii;
typedef vector<ll> vl;
typedef pair<ll, ll> pll;
typedef vector<pair<ll, ll>> vll;
#define pb push_back
int __set(int b, int i) { return b | (1LL << i); } // set ith bit
int __unset(int b, int i) { return b & (~(1UL << i)); }
int __check(int b, int i) { return b & (1LL << i); } // returns 0 if ith bit is
// 0
int mulmod(int a, int b, int md) { return ((a % md) * (b % md)) % md; }
int addmod(int a, int b, int md) { return (a + b) % md; }
int submod(int a, int b, int md) { return (((a - b) % md) + md) % md; }
int divmod(int a, int b, int md) {
return mulmod(a, powmod(b, md - 2, md), md);
} // if md is prime;
const ll inf = 0xFFFFFFFFFFFFFFFL; // very large number
priority_queue<int, vector<int>, greater<int>> pq; // for min priority_queue
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
clock_t time_p = clock();
void time() {
time_p = clock() - time_p;
cerr << "Time Taken : " << (float)(time_p) / CLOCKS_PER_SEC << "\n";
}
class SegmentTree {
private:
int n;
vii st;
vi lz;
vi a;
void merge(int node) { st[node].ss = st[2 * node].ss + st[2 * node + 1].ss; }
void build(int node, int lo, int hi) {
if (lo == hi) {
st[node] = {lo, a[lo]};
return;
}
build(2 * node, lo, (lo + hi) / 2);
build(2 * node + 1, (lo + hi) / 2 + 1, hi);
merge(node);
}
void propagate(int node, int l, int r) {
if (l != r) {
lz[2 * node] += lz[node];
lz[2 * node + 1] += lz[node];
}
st[node].ss += (r - l + 1) * (lz[node]);
lz[node] = 0;
}
void update(int node, int l, int r, int lo, int hi, int val) {
if (lz[node] != 0)
propagate(node, l, r);
if (hi < l || lo > r)
return;
if (hi >= r && lo <= l) {
lz[node] += val;
propagate(node, l, r);
return;
}
update(2 * node, l, (l + r) / 2, lo, hi, val);
update(2 * node + 1, (l + r) / 2 + 1, r, lo, hi, val);
merge(node);
}
ii rmq(int node, int l, int r, int lo, int hi) {
// cout<<l<<" "<<r<<" "<<lo<<" "<<hi<<endl;
if (lz[node] != 0)
propagate(node, l, r);
if (hi < l || lo > r)
return {-1, 0};
if (hi >= r && lo <= l)
return st[node];
ii d1 = rmq(2 * node, l, (l + r) / 2, lo, hi);
ii d2 = rmq(2 * node + 1, (l + r) / 2 + 1, r, lo, hi);
return {-1, d1.ss + d2.ss};
}
public:
SegmentTree(vi &__a) {
n = __a.size();
a = __a;
st.assign(4 * n, {0, 0});
lz.assign(4 * n, 0);
build(1, 0, n - 1);
}
void Update(int l, int r, int val) { return update(1, 0, n - 1, l, r, val); }
ii RMQ(int l, int r) { return rmq(1, 0, n - 1, l, r); }
};
signed main(void) {
IOS;
int n;
cin >> n;
string s;
cin >> s;
vector<SegmentTree> vs;
vi a(n, 0);
for (int i = 0; i < 26; i++) {
SegmentTree st(a);
vs.pb(st);
}
for (int i = 0; i < n; i++) {
vs[s[i] - 'a'].Update(i, i, 1);
}
int q;
cin >> q;
while (q--) {
int ty;
cin >> ty;
if (ty == 2) {
int r, l;
cin >> l >> r;
r--;
l--;
int ans = 0;
for (int i = 0; i < 26; i++) {
if (vs[i].RMQ(l, r).ss > 0) {
// cout<<i<<" "<<vs[i].RMQ(l,r).ss<<endl;
ans++;
}
}
cout << ans << endl;
} else {
int id;
char c;
cin >> id >> c;
id--;
vs[c - 'a'].Update(id, id, 1);
vs[s[id] - 'a'].Update(id, id, -1);
s[id] = c;
}
}
time();
return 0;
} | // g++ -Wall -Wextra -pedantic -std=c++17 -O3 -Wshadow -Wformat=2 -Wfloat-equal
// -Wconversion -Wlogical-op -Wcast-qual -Wcast-align -D_GLIBCXX_DEBUG
// -D_GLIBCXX_DEBUG_PEDANTIC contest.cpp
#include <bits/stdc++.h>
// #define _GLIBCXX_DEBUG 1
// #define _GLIBCXX_DEBUG_PEDANTIC 1
// #define _FORTIFY_SOURCE 2
using namespace std;
// #define int long long
#define ff first
#define ss second
#define all(x) (x).begin(), (x).end()
#define sz(x) (int)(x.size())
#define PI 3.1415926535897932384626433832795
int MOD = 1e9 + 7;
int powmod(int a, int l, int md) {
a %= md;
int res = 1;
while (l) {
if (l & 1)
res = res * a % md;
l /= 2;
a = a * a % md;
}
return res;
}
int binpow(int a, int l) {
int res = 1;
while (l) {
if (l & 1)
res = res * a;
l /= 2;
a = a * a;
}
return res;
}
int invmod(int a, int md) { return powmod(a, md - 2, md); }
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef vector<int> vi;
typedef pair<int, int> ii;
typedef vector<ii> vii;
typedef vector<ll> vl;
typedef pair<ll, ll> pll;
typedef vector<pair<ll, ll>> vll;
#define pb push_back
int __set(int b, int i) { return b | (1LL << i); } // set ith bit
int __unset(int b, int i) { return b & (~(1UL << i)); }
int __check(int b, int i) { return b & (1LL << i); } // returns 0 if ith bit is
// 0
int mulmod(int a, int b, int md) { return ((a % md) * (b % md)) % md; }
int addmod(int a, int b, int md) { return (a + b) % md; }
int submod(int a, int b, int md) { return (((a - b) % md) + md) % md; }
int divmod(int a, int b, int md) {
return mulmod(a, powmod(b, md - 2, md), md);
} // if md is prime;
const ll inf = 0xFFFFFFFFFFFFFFFL; // very large number
priority_queue<int, vector<int>, greater<int>> pq; // for min priority_queue
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
clock_t time_p = clock();
void time() {
time_p = clock() - time_p;
cerr << "Time Taken : " << (float)(time_p) / CLOCKS_PER_SEC << "\n";
}
class SegmentTree {
private:
int n;
vii st;
vi lz;
vi a;
void merge(int node) { st[node].ss = st[2 * node].ss + st[2 * node + 1].ss; }
void build(int node, int lo, int hi) {
if (lo == hi) {
st[node] = {lo, a[lo]};
return;
}
build(2 * node, lo, (lo + hi) / 2);
build(2 * node + 1, (lo + hi) / 2 + 1, hi);
merge(node);
}
void propagate(int node, int l, int r) {
if (l != r) {
lz[2 * node] += lz[node];
lz[2 * node + 1] += lz[node];
}
st[node].ss += (r - l + 1) * (lz[node]);
lz[node] = 0;
}
void update(int node, int l, int r, int lo, int hi, int val) {
if (lz[node] != 0)
propagate(node, l, r);
if (hi < l || lo > r)
return;
if (hi >= r && lo <= l) {
lz[node] += val;
propagate(node, l, r);
return;
}
update(2 * node, l, (l + r) / 2, lo, hi, val);
update(2 * node + 1, (l + r) / 2 + 1, r, lo, hi, val);
merge(node);
}
ii rmq(int node, int l, int r, int lo, int hi) {
// cout<<l<<" "<<r<<" "<<lo<<" "<<hi<<endl;
if (lz[node] != 0)
propagate(node, l, r);
if (hi < l || lo > r)
return {-1, 0};
if (hi >= r && lo <= l)
return st[node];
ii d1 = rmq(2 * node, l, (l + r) / 2, lo, hi);
ii d2 = rmq(2 * node + 1, (l + r) / 2 + 1, r, lo, hi);
return {-1, d1.ss + d2.ss};
}
public:
SegmentTree(vi &__a) {
n = __a.size();
a = __a;
st.assign(4 * n, {0, 0});
lz.assign(4 * n, 0);
build(1, 0, n - 1);
}
void Update(int l, int r, int val) { return update(1, 0, n - 1, l, r, val); }
ii RMQ(int l, int r) { return rmq(1, 0, n - 1, l, r); }
};
signed main(void) {
IOS;
int n;
cin >> n;
string s;
cin >> s;
vector<SegmentTree> vs;
vi a(n, 0);
for (int i = 0; i < 26; i++) {
SegmentTree st(a);
vs.pb(st);
}
for (int i = 0; i < n; i++) {
vs[s[i] - 'a'].Update(i, i, 1);
}
int q;
cin >> q;
while (q--) {
int ty;
cin >> ty;
if (ty == 2) {
int r, l;
cin >> l >> r;
r--;
l--;
int ans = 0;
for (int i = 0; i < 26; i++) {
if (vs[i].RMQ(l, r).ss > 0) {
// cout<<i<<" "<<vs[i].RMQ(l,r).ss<<endl;
ans++;
}
}
cout << ans << endl;
} else {
int id;
char c;
cin >> id >> c;
id--;
vs[c - 'a'].Update(id, id, 1);
vs[s[id] - 'a'].Update(id, id, -1);
s[id] = c;
}
}
time();
return 0;
} | replace | 11 | 12 | 11 | 12 | MLE | |
p02763 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
long long n;
vector<vector<long long>> BIT(30, vector<long long>(n + 10));
void add(long long c, long long i, long long x) {
while (i <= n) {
BIT[c][i] += x;
i += i & -i;
}
}
long long csum(long long c, long long i) {
long long count = 0;
while (i > 0) {
count += BIT[c][i];
i -= i & -i;
}
return count;
}
long long sum(long long c, long long l, long long r) {
return csum(c, r) - csum(c, l - 1);
}
int main() {
cin >> n;
string s;
cin >> s;
for (int i = 0; i < n; i++) {
long long c = int(s[i] - 'a');
add(c, i + 1, 1);
}
long long q;
cin >> q;
for (int i = 0; i < q; i++) {
int b;
cin >> b;
if (b == 1) {
long long I;
char h;
cin >> I >> h;
long long c = int(s[I - 1] - 'a');
add(c, I, -1);
c = int(h - 'a');
add(c, I, 1);
s[I - 1] = h;
} else {
long long l, r;
cin >> l >> r;
long long ans = 0;
for (int i = 0; i < 26; i++) {
long long co = sum(i, l, r);
if (co != 0) {
ans++;
}
}
cout << ans << endl;
}
}
return 0;
} | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
long long n;
vector<vector<long long>> BIT(30, vector<long long>(500050));
void add(long long c, long long i, long long x) {
while (i <= n) {
BIT[c][i] += x;
i += i & -i;
}
}
long long csum(long long c, long long i) {
long long count = 0;
while (i > 0) {
count += BIT[c][i];
i -= i & -i;
}
return count;
}
long long sum(long long c, long long l, long long r) {
return csum(c, r) - csum(c, l - 1);
}
int main() {
cin >> n;
string s;
cin >> s;
for (int i = 0; i < n; i++) {
long long c = int(s[i] - 'a');
add(c, i + 1, 1);
}
long long q;
cin >> q;
for (int i = 0; i < q; i++) {
int b;
cin >> b;
if (b == 1) {
long long I;
char h;
cin >> I >> h;
long long c = int(s[I - 1] - 'a');
add(c, I, -1);
c = int(h - 'a');
add(c, I, 1);
s[I - 1] = h;
} else {
long long l, r;
cin >> l >> r;
long long ans = 0;
for (int i = 0; i < 26; i++) {
long long co = sum(i, l, r);
if (co != 0) {
ans++;
}
}
cout << ans << endl;
}
}
return 0;
} | replace | 17 | 18 | 17 | 18 | 0 | |
p02763 | C++ | Runtime Error | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
const int INF = 1001001001;
int main() {
int n, q;
string s;
cin >> n >> q >> s;
vector<set<int>> is(26);
rep(i, n) is[s[i] - 'a'].insert(i);
rep(qi, q) {
int ty;
cin >> ty;
if (ty == 1) {
int i;
char c;
cin >> i >> c;
i--;
is[s[i] - 'a'].erase(i);
s[i] = c;
is[s[i] - 'a'].insert(i);
}
if (ty == 2) {
int l, r;
cin >> l >> r;
l--;
int ans = 0;
rep(i, 26) {
auto iter = is[i].lower_bound(l);
if (iter != is[i].end() && *iter < r)
ans++;
}
cout << ans << endl;
}
}
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
const int INF = 1001001001;
int main() {
int n, q;
string s;
cin >> n >> s >> q;
vector<set<int>> is(26);
rep(i, n) is[s[i] - 'a'].insert(i);
rep(qi, q) {
int ty;
cin >> ty;
if (ty == 1) {
int i;
char c;
cin >> i >> c;
i--;
is[s[i] - 'a'].erase(i);
s[i] = c;
is[s[i] - 'a'].insert(i);
}
if (ty == 2) {
int l, r;
cin >> l >> r;
l--;
int ans = 0;
rep(i, 26) {
auto iter = is[i].lower_bound(l);
if (iter != is[i].end() && *iter < r)
ans++;
}
cout << ans << endl;
}
}
return 0;
} | replace | 11 | 12 | 11 | 12 | -11 | |
p02763 | C++ | Time Limit Exceeded | #include <algorithm>
#include <complex>
#include <cstdint>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <time.h>
#include <utility>
#include <vector>
using namespace std;
using pii = pair<int, int>;
using ll = long long;
using ld = long double;
#define pb push_back
#define mp make_pair
#define sc second
#define fr first
#define stpr setprecision
#define cYES cout << "YES" << endl
#define cNO cout << "NO" << endl
#define cYes cout << "Yes" << endl
#define cNo cout << "No" << endl
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define Rep(i, a, b) for (ll i = (a); i < (b); ++i)
#define rrep(i, n) for (ll i = n - 1; i >= 0; i--)
#define rRep(i, a, b) for (ll i = a; i >= b; i--)
#define crep(i) for (char i = 'a'; i <= 'z'; ++i)
#define psortsecond(A, N) \
sort(A, A + N, \
[](const pii &a, const pii &b) { return a.second < b.second; });
#define ALL(x) (x).begin(), (x).end()
#define debug(v) \
cout << #v << ":"; \
for (auto x : v) { \
cout << x << ' '; \
} \
cout << endl;
#define endl '\n'
int ctoi(const char c) {
if ('0' <= c && c <= '9')
return (c - '0');
return -1;
}
ll gcd(ll a, ll b) { return (b == 0 ? a : gcd(b, a % b)); }
ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
constexpr ll MOD = 1000000007;
constexpr ll INF = 1000000011;
constexpr ll MOD2 = 998244353;
constexpr ll LINF = 1001002003004005006ll;
constexpr ld EPS = 10e-8;
template <class T, class U> inline bool chmax(T &lhs, const U &rhs) {
if (lhs < rhs) {
lhs = rhs;
return 1;
}
return 0;
}
template <class T, class U> inline bool chmin(T &lhs, const U &rhs) {
if (lhs > rhs) {
lhs = rhs;
return 1;
}
return 0;
}
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &&x : v)
is >> x;
return is;
}
template <typename T, typename U>
istream &operator>>(istream &is, pair<T, U> &p) {
is >> p.first;
is >> p.second;
return is;
}
template <typename T, typename U>
ostream &operator>>(ostream &os, const pair<T, U> &p) {
os << p.first << ' ' << p.second;
return os;
}
template <class T> ostream &operator<<(ostream &os, vector<T> &v) {
for (auto i = begin(v); i != end(v); ++i) {
if (i != begin(v))
os << ' ';
os << *i;
}
return os;
}
int main() {
int N, Q, com, A, B;
string S;
vector<set<int>> ST(26);
cin >> N >> S >> Q;
rep(i, N) {
int X = S[i] - 'a';
ST[X].insert(i);
}
rep(i, Q) {
cin >> com;
if (com == 1) {
char C;
cin >> A >> C;
A--;
int X = C - 'a';
int Y = S[A] - 'a';
ST[Y].erase(A);
ST[X].insert(A);
S[A] = C;
} else {
cin >> A >> B;
A--;
B--;
int Z = 0;
rep(i, 26) {
if (lower_bound(ALL(ST[i]), A) != upper_bound(ALL(ST[i]), B)) {
Z++;
}
}
cout << Z << endl;
}
}
} | #include <algorithm>
#include <complex>
#include <cstdint>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <time.h>
#include <utility>
#include <vector>
using namespace std;
using pii = pair<int, int>;
using ll = long long;
using ld = long double;
#define pb push_back
#define mp make_pair
#define sc second
#define fr first
#define stpr setprecision
#define cYES cout << "YES" << endl
#define cNO cout << "NO" << endl
#define cYes cout << "Yes" << endl
#define cNo cout << "No" << endl
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define Rep(i, a, b) for (ll i = (a); i < (b); ++i)
#define rrep(i, n) for (ll i = n - 1; i >= 0; i--)
#define rRep(i, a, b) for (ll i = a; i >= b; i--)
#define crep(i) for (char i = 'a'; i <= 'z'; ++i)
#define psortsecond(A, N) \
sort(A, A + N, \
[](const pii &a, const pii &b) { return a.second < b.second; });
#define ALL(x) (x).begin(), (x).end()
#define debug(v) \
cout << #v << ":"; \
for (auto x : v) { \
cout << x << ' '; \
} \
cout << endl;
#define endl '\n'
int ctoi(const char c) {
if ('0' <= c && c <= '9')
return (c - '0');
return -1;
}
ll gcd(ll a, ll b) { return (b == 0 ? a : gcd(b, a % b)); }
ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
constexpr ll MOD = 1000000007;
constexpr ll INF = 1000000011;
constexpr ll MOD2 = 998244353;
constexpr ll LINF = 1001002003004005006ll;
constexpr ld EPS = 10e-8;
template <class T, class U> inline bool chmax(T &lhs, const U &rhs) {
if (lhs < rhs) {
lhs = rhs;
return 1;
}
return 0;
}
template <class T, class U> inline bool chmin(T &lhs, const U &rhs) {
if (lhs > rhs) {
lhs = rhs;
return 1;
}
return 0;
}
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &&x : v)
is >> x;
return is;
}
template <typename T, typename U>
istream &operator>>(istream &is, pair<T, U> &p) {
is >> p.first;
is >> p.second;
return is;
}
template <typename T, typename U>
ostream &operator>>(ostream &os, const pair<T, U> &p) {
os << p.first << ' ' << p.second;
return os;
}
template <class T> ostream &operator<<(ostream &os, vector<T> &v) {
for (auto i = begin(v); i != end(v); ++i) {
if (i != begin(v))
os << ' ';
os << *i;
}
return os;
}
int main() {
int N, Q, com, A, B;
string S;
vector<set<int>> ST(26);
cin >> N >> S >> Q;
rep(i, N) {
int X = S[i] - 'a';
ST[X].insert(i);
}
rep(i, Q) {
cin >> com;
if (com == 1) {
char C;
cin >> A >> C;
A--;
int X = C - 'a';
int Y = S[A] - 'a';
ST[Y].erase(A);
ST[X].insert(A);
S[A] = C;
} else {
cin >> A >> B;
A--;
B--;
int Z = 0;
rep(i, 26) {
if (ST[i].lower_bound(A) != ST[i].upper_bound(B)) {
Z++;
}
}
cout << Z << endl;
}
}
} | replace | 126 | 127 | 126 | 127 | TLE | |
p02763 | C++ | Runtime Error | // fahadmd16
#include <algorithm>
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define pf push_front
#define eb emplace_back
#define mp make_pair
#define ff first
#define ss second
#define db double
#define pll pair<ll, ll>
#define pdb pair<db, db>
#define ALL(a) (a).begin(), (a).end()
#define IOS \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
#define forn(i, n) for (int i = 0; i < int(n); i++)
#define forn1(i, n) for (int i = 1; i < int(n); i++)
#define fornab(i, a, b) for (int i = a; i < b; i++)
#define clr(x) memset(x, 0, sizeof(x))
#define count_bit(x) __builtin_popcount(x)
#define endl "\n"
#define trace1(x) cout << #x << ": " << x << endl
#define trace2(x, y) cout << #x << ": " << x << " | " << #y << ": " << y << endl
#define trace3(x, y, z) \
cout << #x << ":" << x << " | " << #y << ": " << y << " | " << #z << ": " \
<< z << endl
#define trace4(a, b, c, d) \
cout << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": " \
<< c << " | " << #d << ": " << d << endl
#define trace5(a, b, c, d, e) \
cout << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": " \
<< c << " | " << #d << ": " << d << " | " << #e << ": " << e << endl
#define trace6(a, b, c, d, e, f) \
cout << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": " \
<< c << " | " << #d << ": " << d << " | " << #e << ": " << e << " | " \
<< #f << ": " << f << endl
#define trace(v) \
for (auto it = v.begin(); it != v.end(); it++) \
cout << *it << " "; \
cout << endl;
#define eps 1e-12
#define nedl endl
const ll size = 805;
const ll mod = 1e9 + 7;
ll power(ll n, ll k) {
ll ans = 1;
while (k) {
if (k & 1)
ans = (ans * n) % mod;
k /= 2;
n = (n * n) % mod;
}
return ans;
}
ll BIT[26][500002] = {0};
void update(ll letter, ll i, ll inc, ll n) {
while (i <= n) {
BIT[letter][i] += inc;
i += (i & (-i));
}
}
ll query(ll letter, ll i) {
ll sum = 0;
while (i > 0) {
sum += BIT[letter][i];
i -= (i & (-i));
}
return sum;
}
int main() {
IOS;
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
ll t = 1; // cin>>t;
while (t--) {
ll n;
cin >> n;
string s;
cin >> s;
forn(i, n) { update(s[i] - 'a', i + 1, 1, n); }
ll q;
cin >> q;
// trace1(q);
while (q--) {
ll x1;
cin >> x1;
if (x1 == 1) {
// trace1(x1);
ll x2;
char x3;
cin >> x2 >> x3;
int letter = s[x2 - 1] - 'a';
s[x2 - 1] = x3;
update(letter, x2, -1, n);
update(x3 - 'a', x2, 1, n);
} else {
// trace1(x1);
ll l, r;
cin >> l >> r;
ll c = 0;
forn(i, 26) {
ll gg = query(i, r) - query(i, l - 1);
if (gg)
c++;
}
cout << c << endl;
}
}
}
return 0;
}
| // fahadmd16
#include <algorithm>
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define pf push_front
#define eb emplace_back
#define mp make_pair
#define ff first
#define ss second
#define db double
#define pll pair<ll, ll>
#define pdb pair<db, db>
#define ALL(a) (a).begin(), (a).end()
#define IOS \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
#define forn(i, n) for (int i = 0; i < int(n); i++)
#define forn1(i, n) for (int i = 1; i < int(n); i++)
#define fornab(i, a, b) for (int i = a; i < b; i++)
#define clr(x) memset(x, 0, sizeof(x))
#define count_bit(x) __builtin_popcount(x)
#define endl "\n"
#define trace1(x) cout << #x << ": " << x << endl
#define trace2(x, y) cout << #x << ": " << x << " | " << #y << ": " << y << endl
#define trace3(x, y, z) \
cout << #x << ":" << x << " | " << #y << ": " << y << " | " << #z << ": " \
<< z << endl
#define trace4(a, b, c, d) \
cout << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": " \
<< c << " | " << #d << ": " << d << endl
#define trace5(a, b, c, d, e) \
cout << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": " \
<< c << " | " << #d << ": " << d << " | " << #e << ": " << e << endl
#define trace6(a, b, c, d, e, f) \
cout << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": " \
<< c << " | " << #d << ": " << d << " | " << #e << ": " << e << " | " \
<< #f << ": " << f << endl
#define trace(v) \
for (auto it = v.begin(); it != v.end(); it++) \
cout << *it << " "; \
cout << endl;
#define eps 1e-12
#define nedl endl
const ll size = 805;
const ll mod = 1e9 + 7;
ll power(ll n, ll k) {
ll ans = 1;
while (k) {
if (k & 1)
ans = (ans * n) % mod;
k /= 2;
n = (n * n) % mod;
}
return ans;
}
ll BIT[26][500002] = {0};
void update(ll letter, ll i, ll inc, ll n) {
while (i <= n) {
BIT[letter][i] += inc;
i += (i & (-i));
}
}
ll query(ll letter, ll i) {
ll sum = 0;
while (i > 0) {
sum += BIT[letter][i];
i -= (i & (-i));
}
return sum;
}
int main() {
IOS;
// #ifndef ONLINE_JUDGE
// freopen("input.txt","r",stdin);
// freopen("output.txt","w",stdout);
// #endif
ll t = 1; // cin>>t;
while (t--) {
ll n;
cin >> n;
string s;
cin >> s;
forn(i, n) { update(s[i] - 'a', i + 1, 1, n); }
ll q;
cin >> q;
// trace1(q);
while (q--) {
ll x1;
cin >> x1;
if (x1 == 1) {
// trace1(x1);
ll x2;
char x3;
cin >> x2 >> x3;
int letter = s[x2 - 1] - 'a';
s[x2 - 1] = x3;
update(letter, x2, -1, n);
update(x3 - 'a', x2, 1, n);
} else {
// trace1(x1);
ll l, r;
cin >> l >> r;
ll c = 0;
forn(i, 26) {
ll gg = query(i, r) - query(i, l - 1);
if (gg)
c++;
}
cout << c << endl;
}
}
}
return 0;
}
| replace | 81 | 85 | 81 | 85 | 127 | /tmp/e1e6d343-11b0-4821-94a9-11faa618277b.out: error while loading shared libraries: libstdc++.so.6: failed to map segment from shared object
|
p02763 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <iostream>
#include <queue>
#include <vector>
#define int long long
#define REP(i, n) for (int i = 0; i < n; i++)
#define pb push_back
#define MOD 1000000007
#define IDE 0
using namespace std;
const int MAX_N = 1 << 17;
int segtr_size, dat[2 * MAX_N - 1];
void init(int n_) {
segtr_size = 1;
while (segtr_size < n_)
segtr_size *= 2;
REP(i, 2 * segtr_size - 1) dat[i] = IDE;
}
int segfunc(int l, int m) { return l | m; }
// k番目の値(0-indexed)をaに変更
void update(int k, int a) {
k += segtr_size - 1;
dat[k] = a;
while (k > 0) {
k = (k - 1) / 2;
dat[k] = segfunc(dat[k * 2 + 1], dat[k * 2 + 2]);
}
}
int find(int k) { return dat[k + segtr_size - 1]; }
int query(int a, int b, int k, int l, int r) {
// cout << "query: " << a << b << k << l << r << "\n";
if (r <= a || b <= l)
return IDE;
if (a <= l && r <= b)
return dat[k];
else {
int vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
int vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return segfunc(vl, vr);
}
}
int alp_to_int(char c) {
// cout << c << " " << (int)(c - 'a') << "\n";
return (int)(c - 'a');
}
int count(int segtrval) {
int retval = 0;
REP(i, 26) { retval += (segtrval >> i) % 2; }
// cout << segtrval << " " << retval << "\n";
return retval;
}
signed main() {
// cin.tie(0);
// ios::sync_with_stdio(false);
int n, q;
cin >> n;
init(n);
vector<char> s(n);
REP(i, n) {
char st;
cin >> st;
s[i] = st;
update(i, (1LL << alp_to_int(st)));
}
cin >> q;
REP(_, q) {
int qtype;
cin >> qtype;
if (qtype == 1) {
int i;
char c;
cin >> i >> c;
int c_int = alp_to_int(c);
update(i - 1, 1LL << c_int);
} else {
int l, r;
cin >> l >> r;
cout << count(query(l - 1, r, 0, 0, segtr_size)) << "\n";
}
}
return 0;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <queue>
#include <vector>
#define int long long
#define REP(i, n) for (int i = 0; i < n; i++)
#define pb push_back
#define MOD 1000000007
#define IDE 0
using namespace std;
const int MAX_N = 1 << 20;
int segtr_size, dat[2 * MAX_N - 1];
void init(int n_) {
segtr_size = 1;
while (segtr_size < n_)
segtr_size *= 2;
REP(i, 2 * segtr_size - 1) dat[i] = IDE;
}
int segfunc(int l, int m) { return l | m; }
// k番目の値(0-indexed)をaに変更
void update(int k, int a) {
k += segtr_size - 1;
dat[k] = a;
while (k > 0) {
k = (k - 1) / 2;
dat[k] = segfunc(dat[k * 2 + 1], dat[k * 2 + 2]);
}
}
int find(int k) { return dat[k + segtr_size - 1]; }
int query(int a, int b, int k, int l, int r) {
// cout << "query: " << a << b << k << l << r << "\n";
if (r <= a || b <= l)
return IDE;
if (a <= l && r <= b)
return dat[k];
else {
int vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
int vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return segfunc(vl, vr);
}
}
int alp_to_int(char c) {
// cout << c << " " << (int)(c - 'a') << "\n";
return (int)(c - 'a');
}
int count(int segtrval) {
int retval = 0;
REP(i, 26) { retval += (segtrval >> i) % 2; }
// cout << segtrval << " " << retval << "\n";
return retval;
}
signed main() {
// cin.tie(0);
// ios::sync_with_stdio(false);
int n, q;
cin >> n;
init(n);
vector<char> s(n);
REP(i, n) {
char st;
cin >> st;
s[i] = st;
update(i, (1LL << alp_to_int(st)));
}
cin >> q;
REP(_, q) {
int qtype;
cin >> qtype;
if (qtype == 1) {
int i;
char c;
cin >> i >> c;
int c_int = alp_to_int(c);
update(i - 1, 1LL << c_int);
} else {
int l, r;
cin >> l >> r;
cout << count(query(l - 1, r, 0, 0, segtr_size)) << "\n";
}
}
return 0;
} | replace | 13 | 14 | 13 | 14 | 0 | |
p02763 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define REP(i, n) for (int i = 1; i <= n; i++)
typedef long long ll;
int main() {
int n, q;
string s;
cin >> n >> s >> q;
vector<set<int>> S(26);
rep(i, n) { S[s[i] - 'a'].insert(i); }
rep(iq, q) {
int q;
cin >> q;
if (q == 1) {
int i;
char c;
cin >> i >> c;
i--;
S[s[i] - 'a'].erase(i);
s[i] = c;
S[s[i] = 'a'].insert(i);
} else if (q == 2) {
int l, r;
cin >> l >> r;
l--;
r--;
int ans = 0;
rep(j, 26) {
auto itr = S[j].lower_bound(l);
if (itr != S[j].end() && *itr <= r)
ans++;
}
cout << ans << endl;
}
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define REP(i, n) for (int i = 1; i <= n; i++)
typedef long long ll;
int main() {
int n, q;
string s;
cin >> n >> s >> q;
vector<set<int>> S(26);
rep(i, n) { S[s[i] - 'a'].insert(i); }
rep(iq, q) {
int q;
cin >> q;
if (q == 1) {
int i;
char c;
cin >> i >> c;
i--;
S[s[i] - 'a'].erase(i);
s[i] = c;
S[s[i] - 'a'].insert(i);
} else if (q == 2) {
int l, r;
cin >> l >> r;
l--;
r--;
int ans = 0;
rep(j, 26) {
auto itr = S[j].lower_bound(l);
if (itr != S[j].end() && *itr <= r)
ans++;
}
cout << ans << endl;
}
}
return 0;
}
| replace | 22 | 23 | 22 | 23 | -11 | |
p02763 | C++ | Time Limit Exceeded | /**
* code generated by JHelper
* More info: https://github.com/AlexeyDmitriev/JHelper
* @author champon
*/
#include <fstream>
#include <iostream>
#include <bits/stdc++.h>
#define se cout << "test ok" << endl;
#define sp << " " <<
using namespace std;
using ll = long long;
using ld = long double;
const ll mod = ll(1e9) + 7;
const ll inf = ll(5e18);
template <typename T1, typename T2> ll ceill(T1 a, T2 b) {
return (a + b - 1) / b;
}
void ans(bool b, ostream &out = cout) { out << (b ? "Yes" : "No") << endl; }
void ans2(bool b, ostream &out = cout) { out << (b ? "YES" : "NO") << endl; }
template <typename T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
fill((T *)array, (T *)(array + N), val);
}
int dx[] = {1, 0, -1, 0, 1, -1, 1, -1};
int dy[] = {0, 1, 0, -1, 1, -1, -1, 1};
#ifndef INCLUDE_DEBUG_HPP
#define INCLUDE_DEBUG_HPP
#include <iostream>
#include <map>
#include <vector>
using namespace std;
namespace dbg {
using ll = long long;
class Debug {
public:
Debug() {}
template <typename T> void vd(vector<T> vec);
template <typename T> void vd2(vector<vector<T>> vec);
template <typename T> void ad(T *arr, ll n);
template <typename T, size_t N> void ad2(T (&arr)[N], ll n);
template <typename T> void md(T mp);
};
template <typename T> void Debug::vd(vector<T> vec) {
for (auto vv : vec)
cout << vv << " ";
cout << endl;
}
template <typename T> void Debug::vd2(vector<vector<T>> vec) {
for (auto vv : vec)
for (auto vvv : vv)
cout << vvv << " ";
cout << endl;
}
template <typename T> void Debug::ad(T *arr, ll n) {
for (int i = 0; i <= n; i++)
cout << arr[i] << " ";
cout << endl;
}
template <typename T, size_t N> void Debug::ad2(T (&arr)[N], ll n) {
for (int i = 0; i <= N; i++)
for (int j = 0; j <= n; j++)
cout << arr[i][j] << " ";
cout << endl;
}
template <typename T> void Debug::md(T mp) {
cout << "key : value" << endl;
for (auto const &m : mp)
cout << m.first << " : " << m.second << endl;
cout << endl;
}
} // namespace dbg
#endif // INCLUDE_DEBUG_HPP
using dbg::Debug;
Debug debug;
class ESimpleStringQueries {
public:
void solve(std::istream &in, std::ostream &out) {
ll n, q;
string s;
in >> n >> s >> q;
set<int> c[26];
for (int i = 0; i < n; i++) {
c[s[i] - 'a'].insert(i);
}
for (int qi = 0; qi < q; qi++) {
int op;
in >> op;
if (op == 1) {
int iq;
char cq;
in >> iq >> cq;
iq--;
c[s[iq] - 'a'].erase(iq);
c[cq - 'a'].insert(iq);
s[iq] = cq;
continue;
}
int l, r;
in >> l >> r;
l--;
r--;
int cnt = 0;
for (int i = 0; i < 26; i++) {
auto itr = lower_bound(c[i].begin(), c[i].end(), l);
if (itr != c[i].end() && *itr <= r)
cnt++;
}
out << cnt << endl;
}
}
};
int main() {
ESimpleStringQueries solver;
std::istream &in(std::cin);
std::ostream &out(std::cout);
solver.solve(in, out);
return 0;
}
| /**
* code generated by JHelper
* More info: https://github.com/AlexeyDmitriev/JHelper
* @author champon
*/
#include <fstream>
#include <iostream>
#include <bits/stdc++.h>
#define se cout << "test ok" << endl;
#define sp << " " <<
using namespace std;
using ll = long long;
using ld = long double;
const ll mod = ll(1e9) + 7;
const ll inf = ll(5e18);
template <typename T1, typename T2> ll ceill(T1 a, T2 b) {
return (a + b - 1) / b;
}
void ans(bool b, ostream &out = cout) { out << (b ? "Yes" : "No") << endl; }
void ans2(bool b, ostream &out = cout) { out << (b ? "YES" : "NO") << endl; }
template <typename T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
fill((T *)array, (T *)(array + N), val);
}
int dx[] = {1, 0, -1, 0, 1, -1, 1, -1};
int dy[] = {0, 1, 0, -1, 1, -1, -1, 1};
#ifndef INCLUDE_DEBUG_HPP
#define INCLUDE_DEBUG_HPP
#include <iostream>
#include <map>
#include <vector>
using namespace std;
namespace dbg {
using ll = long long;
class Debug {
public:
Debug() {}
template <typename T> void vd(vector<T> vec);
template <typename T> void vd2(vector<vector<T>> vec);
template <typename T> void ad(T *arr, ll n);
template <typename T, size_t N> void ad2(T (&arr)[N], ll n);
template <typename T> void md(T mp);
};
template <typename T> void Debug::vd(vector<T> vec) {
for (auto vv : vec)
cout << vv << " ";
cout << endl;
}
template <typename T> void Debug::vd2(vector<vector<T>> vec) {
for (auto vv : vec)
for (auto vvv : vv)
cout << vvv << " ";
cout << endl;
}
template <typename T> void Debug::ad(T *arr, ll n) {
for (int i = 0; i <= n; i++)
cout << arr[i] << " ";
cout << endl;
}
template <typename T, size_t N> void Debug::ad2(T (&arr)[N], ll n) {
for (int i = 0; i <= N; i++)
for (int j = 0; j <= n; j++)
cout << arr[i][j] << " ";
cout << endl;
}
template <typename T> void Debug::md(T mp) {
cout << "key : value" << endl;
for (auto const &m : mp)
cout << m.first << " : " << m.second << endl;
cout << endl;
}
} // namespace dbg
#endif // INCLUDE_DEBUG_HPP
using dbg::Debug;
Debug debug;
class ESimpleStringQueries {
public:
void solve(std::istream &in, std::ostream &out) {
ll n, q;
string s;
in >> n >> s >> q;
set<int> c[26];
for (int i = 0; i < n; i++) {
c[s[i] - 'a'].insert(i);
}
for (int qi = 0; qi < q; qi++) {
int op;
in >> op;
if (op == 1) {
int iq;
char cq;
in >> iq >> cq;
iq--;
c[s[iq] - 'a'].erase(iq);
c[cq - 'a'].insert(iq);
s[iq] = cq;
continue;
}
int l, r;
in >> l >> r;
l--;
r--;
int cnt = 0;
for (int i = 0; i < 26; i++) {
auto itr = c[i].lower_bound(l);
if (itr != c[i].end() && *itr <= r)
cnt++;
}
out << cnt << endl;
}
}
};
int main() {
ESimpleStringQueries solver;
std::istream &in(std::cin);
std::ostream &out(std::cout);
solver.solve(in, out);
return 0;
}
| replace | 135 | 136 | 135 | 136 | TLE | |
p02763 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
set<int> st[30];
vector<char> s(n + 3);
for (int i = 1; i <= n; i++) {
cin >> s[i];
st[s[i] - 'a'].insert(i);
}
int q;
cin >> q;
for (int i = 1; i <= q; i++) {
int t;
cin >> t;
if (t == 1) {
int x;
char ch;
cin >> x >> ch;
st[s[i] - 'a'].erase(x);
st[ch - 'a'].insert(x);
s[x] = ch;
} else {
int l, r;
cin >> l >> r;
int cnt = 0;
for (int i = 0; i < 26; i++) {
if (st[i].lower_bound(l) != st[i].upper_bound(r)) {
cnt++;
}
}
cout << cnt << '\n';
}
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
set<int> st[30];
vector<char> s(n + 3);
for (int i = 1; i <= n; i++) {
cin >> s[i];
st[s[i] - 'a'].insert(i);
}
int q;
cin >> q;
for (int i = 1; i <= q; i++) {
int t;
cin >> t;
if (t == 1) {
int x;
char ch;
cin >> x >> ch;
st[s[x] - 'a'].erase(x);
st[ch - 'a'].insert(x);
s[x] = ch;
} else {
int l, r;
cin >> l >> r;
int cnt = 0;
for (int i = 0; i < 26; i++) {
if (st[i].lower_bound(l) != st[i].upper_bound(r)) {
cnt++;
}
}
cout << cnt << '\n';
}
}
return 0;
} | replace | 20 | 21 | 20 | 21 | 0 | |
p02763 | C++ | Time Limit Exceeded | #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdint>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
namespace utils {
#define ALL(x) begin(x), end(x)
#define RALL(x) rbegin(x), rend(x)
template <class T, class Compare>
using p_queue = priority_queue<T, vector<T>, Compare>;
template <class T> using min_queue = p_queue<T, greater<T>>;
template <class T> using max_queue = p_queue<T, less<T>>;
template <class T> inline bool UPMIN(T &X, const T &A) {
if (X > A) {
X = A;
return true;
}
return false;
}
template <class T> inline bool UPMAX(T &X, const T &A) {
if (X < A) {
X = A;
return true;
}
return false;
}
template <class T> vector<T> VEC(int n, T t) { return vector<T>(n, t); }
template <class... Ts> auto VEC(int n, Ts... ts) {
return vector<decltype(VEC(ts...))>(n, VEC(ts...));
}
template <class S, class T> istream &operator>>(istream &is, tuple<S, T> &t) {
return is >> get<0>(t) >> get<1>(t);
}
template <class S, class T, class U>
istream &operator>>(istream &is, tuple<S, T, U> &t) {
return is >> get<0>(t) >> get<1>(t) >> get<2>(t);
}
template <class S, class T>
ostream &operator<<(ostream &os, const tuple<S, T> &t) {
return os << get<0>(t) << ' ' << get<1>(t);
}
template <class S, class T, class U>
ostream &operator<<(ostream &os, const tuple<S, T, U> &t) {
return os << get<0>(t) << ' ' << get<1>(t) << ' ' << get<2>(t);
}
template <class T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &&x : v) {
is >> x;
}
return is;
}
template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
auto p = v.begin();
assert(p != v.end());
os << *p++;
while (p != v.end()) {
os << ' ' << *p++;
}
return os;
}
template <class T>
ostream &operator<<(ostream &os, const vector<vector<T>> &v) {
auto p = v.begin();
assert(p != v.end());
os << *p++;
while (p != v.end()) {
os << '\n' << *p++;
}
return os;
}
template <class... Ts>
ostream &operator<<(ostream &os, const vector<tuple<Ts...>> &v) {
auto p = v.begin();
assert(p != v.end());
os << *p++;
while (p != v.end()) {
os << '\n' << *p++;
}
return os;
}
constexpr long long INFLL = 1'000'000'000'000'000'000ll;
constexpr int INF = 1'000'000'000;
constexpr double PI = 3.14'159'265'358'973;
constexpr double EPS = 1e-10;
} // namespace utils
using namespace utils;
template <class Monoid> class SegmentTree {
using Func = std::function<Monoid(Monoid, Monoid)>;
int N;
std::vector<Monoid> segment;
const Func op;
const Monoid id;
bool dirty_flag;
public:
// id : op = max なら -INT_MAX
SegmentTree(int n, const Func biop, const Monoid &M1)
: op(biop), id(M1), dirty_flag(false) {
N = 1;
while (N < n)
N *= 2;
segment.assign(2 * N, id);
}
void set(int k, const Monoid &a) {
dirty_flag = true;
segment[k + N] = a;
}
void build() {
for (int k = N - 1; k > 0; --k) {
segment[k] = op(segment[2 * k], segment[2 * k + 1]);
} // end k
dirty_flag = false;
}
void update(int k, const Monoid &a) {
k += N;
segment[k] = a;
while (k /= 2) {
segment[k] = op(segment[k * 2], segment[k * 2 + 1]);
}
}
// -> op [a,b)
Monoid query(unsigned a, unsigned b) {
if (dirty_flag)
build();
dirty_flag = false;
Monoid L = id, R = id;
for (a += N, b += N; a < b; a >>= 1u, b >>= 1u) {
if (a & 1u)
L = op(L, segment[a++]);
if (b & 1u)
R = op(segment[--b], R);
} // end i
return op(L, R);
}
Monoid operator[](const int &k) const { return segment[k + N]; }
};
class solver {
istream &is;
ostream &os;
public:
solver(istream &I, ostream &O) : is(I), os(O) {}
int N, Q;
string S;
bool input() {
is >> N >> S >> Q;
return !!is;
}
void run();
};
int main(int argc, char *argv[]) {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << setprecision(16) << scientific;
#ifdef XELMH
string test_cases = "test_B.txt";
cerr << test_cases << " -->" << endl;
auto fs = fstream(test_cases, fstream::in);
int loop = 0;
while (fs) {
loop++;
cout << '#' << loop << "#------\n";
solver(fs, cout).run();
}
if (loop <= 1) {
cout << "===" << endl;
while (cin)
solver(cin, cout).run();
}
#else
solver(cin, cout).run();
#endif
return 0;
}
void solver::run() {
if (!input())
return;
using alset = bitset<30>;
SegmentTree<alset> seg(
N, [](alset a, alset b) { return a | b; }, 0);
vector<alset> als;
als.reserve('z' - 'a' + 1);
for (int al = 0; al < 'z' - 'a' + 1; ++al) {
als.emplace_back(1 << al);
} // end al
for (int i = 0; i < N; ++i) {
seg.set(i, als[S[i] - 'a']);
} // end i
for (int i = 0; i < Q; ++i) {
int q;
is >> q;
if (q == 1) {
int x;
char c;
is >> x >> c;
seg.set(x - 1, als[c - 'a']);
} else {
int l, r;
is >> l >> r;
auto an = seg.query(l - 1, r);
os << an.count() << endl;
}
} // end i
}
| #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdint>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
namespace utils {
#define ALL(x) begin(x), end(x)
#define RALL(x) rbegin(x), rend(x)
template <class T, class Compare>
using p_queue = priority_queue<T, vector<T>, Compare>;
template <class T> using min_queue = p_queue<T, greater<T>>;
template <class T> using max_queue = p_queue<T, less<T>>;
template <class T> inline bool UPMIN(T &X, const T &A) {
if (X > A) {
X = A;
return true;
}
return false;
}
template <class T> inline bool UPMAX(T &X, const T &A) {
if (X < A) {
X = A;
return true;
}
return false;
}
template <class T> vector<T> VEC(int n, T t) { return vector<T>(n, t); }
template <class... Ts> auto VEC(int n, Ts... ts) {
return vector<decltype(VEC(ts...))>(n, VEC(ts...));
}
template <class S, class T> istream &operator>>(istream &is, tuple<S, T> &t) {
return is >> get<0>(t) >> get<1>(t);
}
template <class S, class T, class U>
istream &operator>>(istream &is, tuple<S, T, U> &t) {
return is >> get<0>(t) >> get<1>(t) >> get<2>(t);
}
template <class S, class T>
ostream &operator<<(ostream &os, const tuple<S, T> &t) {
return os << get<0>(t) << ' ' << get<1>(t);
}
template <class S, class T, class U>
ostream &operator<<(ostream &os, const tuple<S, T, U> &t) {
return os << get<0>(t) << ' ' << get<1>(t) << ' ' << get<2>(t);
}
template <class T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &&x : v) {
is >> x;
}
return is;
}
template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
auto p = v.begin();
assert(p != v.end());
os << *p++;
while (p != v.end()) {
os << ' ' << *p++;
}
return os;
}
template <class T>
ostream &operator<<(ostream &os, const vector<vector<T>> &v) {
auto p = v.begin();
assert(p != v.end());
os << *p++;
while (p != v.end()) {
os << '\n' << *p++;
}
return os;
}
template <class... Ts>
ostream &operator<<(ostream &os, const vector<tuple<Ts...>> &v) {
auto p = v.begin();
assert(p != v.end());
os << *p++;
while (p != v.end()) {
os << '\n' << *p++;
}
return os;
}
constexpr long long INFLL = 1'000'000'000'000'000'000ll;
constexpr int INF = 1'000'000'000;
constexpr double PI = 3.14'159'265'358'973;
constexpr double EPS = 1e-10;
} // namespace utils
using namespace utils;
template <class Monoid> class SegmentTree {
using Func = std::function<Monoid(Monoid, Monoid)>;
int N;
std::vector<Monoid> segment;
const Func op;
const Monoid id;
bool dirty_flag;
public:
// id : op = max なら -INT_MAX
SegmentTree(int n, const Func biop, const Monoid &M1)
: op(biop), id(M1), dirty_flag(false) {
N = 1;
while (N < n)
N *= 2;
segment.assign(2 * N, id);
}
void set(int k, const Monoid &a) {
dirty_flag = true;
segment[k + N] = a;
}
void build() {
for (int k = N - 1; k > 0; --k) {
segment[k] = op(segment[2 * k], segment[2 * k + 1]);
} // end k
dirty_flag = false;
}
void update(int k, const Monoid &a) {
k += N;
segment[k] = a;
while (k /= 2) {
segment[k] = op(segment[k * 2], segment[k * 2 + 1]);
}
}
// -> op [a,b)
Monoid query(unsigned a, unsigned b) {
if (dirty_flag)
build();
dirty_flag = false;
Monoid L = id, R = id;
for (a += N, b += N; a < b; a >>= 1u, b >>= 1u) {
if (a & 1u)
L = op(L, segment[a++]);
if (b & 1u)
R = op(segment[--b], R);
} // end i
return op(L, R);
}
Monoid operator[](const int &k) const { return segment[k + N]; }
};
class solver {
istream &is;
ostream &os;
public:
solver(istream &I, ostream &O) : is(I), os(O) {}
int N, Q;
string S;
bool input() {
is >> N >> S >> Q;
return !!is;
}
void run();
};
int main(int argc, char *argv[]) {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << setprecision(16) << scientific;
#ifdef XELMH
string test_cases = "test_B.txt";
cerr << test_cases << " -->" << endl;
auto fs = fstream(test_cases, fstream::in);
int loop = 0;
while (fs) {
loop++;
cout << '#' << loop << "#------\n";
solver(fs, cout).run();
}
if (loop <= 1) {
cout << "===" << endl;
while (cin)
solver(cin, cout).run();
}
#else
solver(cin, cout).run();
#endif
return 0;
}
void solver::run() {
if (!input())
return;
using alset = bitset<30>;
SegmentTree<alset> seg(
N, [](alset a, alset b) { return a | b; }, 0);
vector<alset> als;
als.reserve('z' - 'a' + 1);
for (int al = 0; al < 'z' - 'a' + 1; ++al) {
als.emplace_back(1 << al);
} // end al
for (int i = 0; i < N; ++i) {
seg.set(i, als[S[i] - 'a']);
} // end i
for (int i = 0; i < Q; ++i) {
int q;
is >> q;
if (q == 1) {
int x;
char c;
is >> x >> c;
seg.update(x - 1, als[c - 'a']);
} else {
int l, r;
is >> l >> r;
auto an = seg.query(l - 1, r);
os << an.count() << endl;
}
} // end i
}
| replace | 248 | 249 | 248 | 249 | TLE | |
p02763 | C++ | Memory Limit Exceeded | #include <algorithm>
#include <bitset>
#include <cmath>
#include <ctype.h>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iostream>
#include <istream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <time.h>
#include <unordered_map>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define REP(i, a, b) for (int i = a; i < (b); ++i)
#define all(x) (x).begin(), (x).end()
#define pint pair<int, int>
#define SEG_LEN (1 << 23)
const int INF = 1000000007;
const long double EPS = 1e-15;
const long double PI = acos(-1);
typedef long long ll;
using namespace std;
using Graph = vector<vector<int>>;
using Graph_weighted = vector<vector<pair<int, int>>>;
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return (a * b) / gcd(a, b); }
ll ceil(const ll a, const ll b) { return (a + b - 1) / b; }
template <class T> class segment_tree_Max {
private:
vector<long long> seg;
int seg_size = SEG_LEN * 2;
public:
segment_tree_Max() {
seg.resize(seg_size);
for (int i = 0; i < seg_size; i++)
seg[i] = -INF;
}
void update(int ind, int n) {
ind += SEG_LEN;
seg[ind] = n;
while (true) {
ind /= 2;
if (ind == 0)
break;
seg[ind] = max(seg[ind * 2], seg[ind * 2 + 1]);
}
}
long long Max(int l, int r) {
l += SEG_LEN;
r += SEG_LEN + 1;
long long ans = -INF;
while (l < r) {
if (l % 2 == 1) {
ans = max(seg[l], ans);
l++;
}
if (l >= r)
break;
l /= 2;
if (r % 2 == 1) {
ans = max(seg[r - 1], ans);
r--;
}
r /= 2;
}
if (ans == -INF)
return 0;
return ans;
}
};
int main() {
int n, q;
string s;
cin >> n >> s >> q;
vector<segment_tree_Max<ll>> seg(26);
rep(i, n) seg[s[i] - 'a'].update(i, 1);
rep(i, q) {
int type;
cin >> type;
if (type == 1) {
int ind;
char c;
cin >> ind >> c;
ind--;
seg[s[ind] - 'a'].update(ind, 0);
seg[c - 'a'].update(ind, 1);
s[ind] = c;
}
if (type == 2) {
ll tmp = 0;
int l, r;
cin >> l >> r;
l--, r--;
rep(j, 26) tmp += seg[j].Max(l, r);
cout << tmp << endl;
}
}
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cmath>
#include <ctype.h>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iostream>
#include <istream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <time.h>
#include <unordered_map>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define REP(i, a, b) for (int i = a; i < (b); ++i)
#define all(x) (x).begin(), (x).end()
#define pint pair<int, int>
#define SEG_LEN (1 << 20)
const int INF = 1000000007;
const long double EPS = 1e-15;
const long double PI = acos(-1);
typedef long long ll;
using namespace std;
using Graph = vector<vector<int>>;
using Graph_weighted = vector<vector<pair<int, int>>>;
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return (a * b) / gcd(a, b); }
ll ceil(const ll a, const ll b) { return (a + b - 1) / b; }
template <class T> class segment_tree_Max {
private:
vector<long long> seg;
int seg_size = SEG_LEN * 2;
public:
segment_tree_Max() {
seg.resize(seg_size);
for (int i = 0; i < seg_size; i++)
seg[i] = -INF;
}
void update(int ind, int n) {
ind += SEG_LEN;
seg[ind] = n;
while (true) {
ind /= 2;
if (ind == 0)
break;
seg[ind] = max(seg[ind * 2], seg[ind * 2 + 1]);
}
}
long long Max(int l, int r) {
l += SEG_LEN;
r += SEG_LEN + 1;
long long ans = -INF;
while (l < r) {
if (l % 2 == 1) {
ans = max(seg[l], ans);
l++;
}
if (l >= r)
break;
l /= 2;
if (r % 2 == 1) {
ans = max(seg[r - 1], ans);
r--;
}
r /= 2;
}
if (ans == -INF)
return 0;
return ans;
}
};
int main() {
int n, q;
string s;
cin >> n >> s >> q;
vector<segment_tree_Max<ll>> seg(26);
rep(i, n) seg[s[i] - 'a'].update(i, 1);
rep(i, q) {
int type;
cin >> type;
if (type == 1) {
int ind;
char c;
cin >> ind >> c;
ind--;
seg[s[ind] - 'a'].update(ind, 0);
seg[c - 'a'].update(ind, 1);
s[ind] = c;
}
if (type == 2) {
ll tmp = 0;
int l, r;
cin >> l >> r;
l--, r--;
rep(j, 26) tmp += seg[j].Max(l, r);
cout << tmp << endl;
}
}
return 0;
}
| replace | 27 | 28 | 27 | 28 | MLE | |
p02763 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <forward_list>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <utility>
#include <vector>
#define rep(i, s, g) for ((i) = (s); (i) < (g); ++(i))
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
const ll MOD = 1e9 + 7;
const ll INF = (1ll << 60);
int n;
vector<bitset<26>> seg(1000100);
string s;
void init(int n_) {
n = 1;
while (n < n_) {
n *= 2;
}
}
void update(int i, char x) {
seg[i + n - 1].reset(s[i] - 'a');
s[i] = x;
seg[i + n - 1].set(s[i] - 'a');
i += n - 1;
while (i > 0) {
i = (i - 1) / 2;
seg[i] = seg[2 * i + 1] | seg[2 * i + 2];
}
}
bitset<26> query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l) {
bitset<26> bit(0ll);
return bit;
}
if (a <= l && r <= b) {
return seg[k];
} else {
bitset<26> bit1 = query(a, b, 2 * k + 1, l, (l + r) / 2);
bitset<26> bit2 = query(a, b, 2 * k + 2, (l + r) / 2, r);
return bit1 | bit2;
}
}
int main(void) {
int q;
int i, j;
int n_;
vector<int> ans;
cin >> n_ >> s >> q;
init(n_);
rep(i, 0, n_) { update(i, s[i]); }
init(n_);
rep(i, 0, q) {
int x;
cin >> x;
if (x == 1) {
int iq;
char c;
cin >> iq >> c;
iq--;
update(iq, c);
} else {
int l, r;
int an = 0;
cin >> l >> r;
l--;
bitset<26> bit = query(l, r, 0, 0, n);
an = bit.count();
ans.push_back(an);
}
}
for (auto &z : ans) {
cout << z << endl;
}
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <forward_list>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <utility>
#include <vector>
#define rep(i, s, g) for ((i) = (s); (i) < (g); ++(i))
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
const ll MOD = 1e9 + 7;
const ll INF = (1ll << 60);
int n;
vector<bitset<26>> seg(2000100);
string s;
void init(int n_) {
n = 1;
while (n < n_) {
n *= 2;
}
}
void update(int i, char x) {
seg[i + n - 1].reset(s[i] - 'a');
s[i] = x;
seg[i + n - 1].set(s[i] - 'a');
i += n - 1;
while (i > 0) {
i = (i - 1) / 2;
seg[i] = seg[2 * i + 1] | seg[2 * i + 2];
}
}
bitset<26> query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l) {
bitset<26> bit(0ll);
return bit;
}
if (a <= l && r <= b) {
return seg[k];
} else {
bitset<26> bit1 = query(a, b, 2 * k + 1, l, (l + r) / 2);
bitset<26> bit2 = query(a, b, 2 * k + 2, (l + r) / 2, r);
return bit1 | bit2;
}
}
int main(void) {
int q;
int i, j;
int n_;
vector<int> ans;
cin >> n_ >> s >> q;
init(n_);
rep(i, 0, n_) { update(i, s[i]); }
init(n_);
rep(i, 0, q) {
int x;
cin >> x;
if (x == 1) {
int iq;
char c;
cin >> iq >> c;
iq--;
update(iq, c);
} else {
int l, r;
int an = 0;
cin >> l >> r;
l--;
bitset<26> bit = query(l, r, 0, 0, n);
an = bit.count();
ans.push_back(an);
}
}
for (auto &z : ans) {
cout << z << endl;
}
} | replace | 21 | 22 | 21 | 22 | 0 | |
p02763 | C++ | Runtime Error | // 目標:セグメント木でACしたい
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int VAL = 'z' - 'a' + 1;
const int MAX_N = 100100;
set<int> st[VAL];
char S[MAX_N];
int N, Q;
vector<int> res;
int main() {
scanf("%d", &N);
scanf("%s", S);
for (int i = 0; i < VAL; ++i) {
st[i].clear();
st[i].insert(N);
}
for (int i = 0; i < N; ++i) {
st[S[i] - 'a'].insert(i);
}
scanf("%d", &Q);
for (int i = 0; i < Q; ++i) {
int a, l, r;
scanf("%d %d", &a, &l);
--l;
if (a == 1) {
char tmp[2];
scanf("%s", tmp);
st[S[l] - 'a'].erase(l);
st[tmp[0] - 'a'].insert(l);
S[l] = tmp[0];
} else {
scanf("%d", &r);
--r;
int ans = 0;
for (int j = 0; j < VAL; ++j) {
auto itr = st[j].lower_bound(l);
if (*itr <= r)
++ans;
}
res.push_back(ans);
}
}
for (auto &p : res)
printf("%d\n", p);
return 0;
} | // 目標:セグメント木でACしたい
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int VAL = 'z' - 'a' + 1;
const int MAX_N = 500100;
set<int> st[VAL];
char S[MAX_N];
int N, Q;
vector<int> res;
int main() {
scanf("%d", &N);
scanf("%s", S);
for (int i = 0; i < VAL; ++i) {
st[i].clear();
st[i].insert(N);
}
for (int i = 0; i < N; ++i) {
st[S[i] - 'a'].insert(i);
}
scanf("%d", &Q);
for (int i = 0; i < Q; ++i) {
int a, l, r;
scanf("%d %d", &a, &l);
--l;
if (a == 1) {
char tmp[2];
scanf("%s", tmp);
st[S[l] - 'a'].erase(l);
st[tmp[0] - 'a'].insert(l);
S[l] = tmp[0];
} else {
scanf("%d", &r);
--r;
int ans = 0;
for (int j = 0; j < VAL; ++j) {
auto itr = st[j].lower_bound(l);
if (*itr <= r)
++ans;
}
res.push_back(ans);
}
}
for (auto &p : res)
printf("%d\n", p);
return 0;
} | replace | 6 | 7 | 6 | 7 | 0 | |
p02763 | C++ | Time Limit Exceeded | #include <algorithm>
#include <iostream>
#include <set>
#include <string>
#include <vector>
using namespace std;
int main() {
int n, q;
string s;
vector<set<int>> A(26);
cin >> n >> s >> q;
for (int i = 0; i < n; i++) {
A[s[i] - 'a'].insert(i);
}
for (int i = 0; i < q; i++) {
int x;
cin >> x;
if (x == 1) {
int y;
char c;
cin >> y >> c;
y--;
A[s[y] - 'a'].erase(y);
A[c - 'a'].insert(y);
s[y] = c;
} else {
int l, r;
cin >> l >> r;
l--;
r--;
int ans = 0;
for (int i = 0; i < 26; i++) {
auto it = lower_bound(A[i].begin(), A[i].end(), l);
if (it != A[i].end() && *it <= r) {
ans++;
}
}
printf("%d\n", ans);
}
}
return 0;
} | #include <algorithm>
#include <iostream>
#include <set>
#include <string>
#include <vector>
using namespace std;
int main() {
int n, q;
string s;
vector<set<int>> A(26);
cin >> n >> s >> q;
for (int i = 0; i < n; i++) {
A[s[i] - 'a'].insert(i);
}
for (int i = 0; i < q; i++) {
int x;
cin >> x;
if (x == 1) {
int y;
char c;
cin >> y >> c;
y--;
A[s[y] - 'a'].erase(y);
A[c - 'a'].insert(y);
s[y] = c;
} else {
int l, r;
cin >> l >> r;
l--;
r--;
int ans = 0;
for (int i = 0; i < 26; i++) {
auto it = A[i].lower_bound(l);
if (it != A[i].end() && *it <= r) {
ans++;
}
}
printf("%d\n", ans);
}
}
return 0;
} | replace | 37 | 38 | 37 | 38 | TLE | |
p02763 | C++ | Runtime Error | #include <bits/stdc++.h>
#define DEBUG if (0)
#define lli long long int
#define ldouble long double
using namespace std;
const int maxN = 5e5;
int n;
char s[maxN + 1];
int segtree[26][maxN];
void build(int k, int i = 1, int lo = 0, int hi = n - 1) {
if (lo == hi) {
segtree[k][i] = (s[lo] - 'a') == k;
return;
}
int mid = (lo + hi) >> 1;
build(k, 2 * i, lo, mid), build(k, 2 * i + 1, mid + 1, hi);
segtree[k][i] = segtree[k][2 * i] + segtree[k][2 * i + 1];
}
int query(int k, int qlo, int qhi, int i = 1, int lo = 0, int hi = n - 1) {
if (hi < qlo || lo > qhi)
return 0;
if (lo >= qlo && hi <= qhi)
return segtree[k][i];
int mid = (lo + hi) >> 1;
return query(k, qlo, qhi, 2 * i, lo, mid) +
query(k, qlo, qhi, 2 * i + 1, mid + 1, hi);
}
void update(int k, int pos, int diff, int i = 1, int lo = 0, int hi = n - 1) {
if (lo == hi) {
segtree[k][i] += diff;
return;
}
int mid = (lo + hi) >> 1;
if (pos <= mid)
update(k, pos, diff, 2 * i, lo, mid);
else
update(k, pos, diff, 2 * i + 1, mid + 1, hi);
segtree[k][i] = segtree[k][2 * i] + segtree[k][2 * i + 1];
}
int main() {
while (scanf("%d", &n) != EOF) {
scanf(" %s", s);
for (int i = 0; i < 26; i++)
build(i);
int q;
scanf("%d", &q);
while (q--) {
int op;
scanf("%d", &op);
if (op == 1) {
int i;
char c;
scanf("%d %c", &i, &c);
i--;
if (s[i] != c) {
update(s[i] - 'a', i, -1);
update(c - 'a', i, 1);
s[i] = c;
}
} else {
int l, r;
scanf("%d %d", &l, &r);
l--, r--;
int ans = 0;
for (int i = 0; i < 26; i++)
ans += query(i, l, r) > 0;
printf("%d\n", ans);
}
}
}
return 0;
} | #include <bits/stdc++.h>
#define DEBUG if (0)
#define lli long long int
#define ldouble long double
using namespace std;
const int maxN = 5e5;
int n;
char s[maxN + 1];
int segtree[26][4 * maxN];
void build(int k, int i = 1, int lo = 0, int hi = n - 1) {
if (lo == hi) {
segtree[k][i] = (s[lo] - 'a') == k;
return;
}
int mid = (lo + hi) >> 1;
build(k, 2 * i, lo, mid), build(k, 2 * i + 1, mid + 1, hi);
segtree[k][i] = segtree[k][2 * i] + segtree[k][2 * i + 1];
}
int query(int k, int qlo, int qhi, int i = 1, int lo = 0, int hi = n - 1) {
if (hi < qlo || lo > qhi)
return 0;
if (lo >= qlo && hi <= qhi)
return segtree[k][i];
int mid = (lo + hi) >> 1;
return query(k, qlo, qhi, 2 * i, lo, mid) +
query(k, qlo, qhi, 2 * i + 1, mid + 1, hi);
}
void update(int k, int pos, int diff, int i = 1, int lo = 0, int hi = n - 1) {
if (lo == hi) {
segtree[k][i] += diff;
return;
}
int mid = (lo + hi) >> 1;
if (pos <= mid)
update(k, pos, diff, 2 * i, lo, mid);
else
update(k, pos, diff, 2 * i + 1, mid + 1, hi);
segtree[k][i] = segtree[k][2 * i] + segtree[k][2 * i + 1];
}
int main() {
while (scanf("%d", &n) != EOF) {
scanf(" %s", s);
for (int i = 0; i < 26; i++)
build(i);
int q;
scanf("%d", &q);
while (q--) {
int op;
scanf("%d", &op);
if (op == 1) {
int i;
char c;
scanf("%d %c", &i, &c);
i--;
if (s[i] != c) {
update(s[i] - 'a', i, -1);
update(c - 'a', i, 1);
s[i] = c;
}
} else {
int l, r;
scanf("%d %d", &l, &r);
l--, r--;
int ans = 0;
for (int i = 0; i < 26; i++)
ans += query(i, l, r) > 0;
printf("%d\n", ans);
}
}
}
return 0;
} | replace | 10 | 11 | 10 | 11 | 0 | |
p02763 | C++ | Runtime Error | /**
* author: zjsdut
* created: 2020/03/29 21:58:23
**/
#include <bits/stdc++.h>
using namespace std;
struct fast_ios {
fast_ios() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
};
} fast_ios_;
template <typename A, typename B> bool chkmin(A &a, const B &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
template <typename A, typename B> bool chkmax(A &a, const B &b) {
if (b > a) {
a = b;
return true;
}
return false;
}
template <typename T> istream &operator>>(istream &stream, vector<T> &vec) {
for (auto &x : vec)
stream >> x;
return stream;
}
void scan() {}
template <class T, class... Args> void scan(T &a, Args &...rest) {
cin >> a;
scan(rest...);
}
using ll = long long;
using vl = vector<ll>;
using vb = vector<bool>;
using vi = vector<int>;
using pii = pair<int, int>;
template <typename T> using vv = vector<vector<T>>;
#define rng(i, a, b) for (int i = (int)(a); i < (int)(b); ++i)
#define up(i, a, b) for (int i = int(a); i <= int(b); ++i)
#define down(i, b, a) for (int i = int(b); i >= int(a); i--)
#define TOKENPASTE(x, y) x##y
#define TOKENPASTE2(x, y) TOKENPASTE(x, y)
#define rep(n) \
for (int TOKENPASTE2(_iter_, __LINE__) = 0, \
TOKENPASTE2(_num_, __LINE__) = (int)(n); \
TOKENPASTE2(_iter_, __LINE__) < TOKENPASTE2(_num_, __LINE__); \
++TOKENPASTE2(_iter_, __LINE__))
#define FOR(x, cont) for (const auto &x : cont)
#define For(x, cont) for (auto &x : cont)
#define all(x) begin(x), end(x)
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define ep emplace
#define SZ(x) (int)(x).size()
#define UNIQ(vec) (vec).erase(unique(all(vec)), end(vec))
#define LB(cont, x) int(lower_bound(all(cont), x) - begin(cont))
#define UB(cont, x) int(upper_bound(all(cont), x) - begin(cont))
template <typename T>
ostream &operator<<(ostream &stream, const vector<T> &vec) {
if (!vec.empty()) {
stream << vec[0];
for (size_t i = 1; i != vec.size(); ++i)
stream << ' ' << vec[i];
}
return stream;
}
template <typename T> void print(const vector<T> &t) { cout << t << '\n'; }
template <typename T> void print(const vector<vector<T>> &t) {
for (const auto &row : t) {
print(row);
}
}
template <typename T> void print(const T &t) { cout << t << ' '; }
template <typename T, typename... Args>
void print(const T &t, const Args &...rest) {
print(t);
print(rest...);
}
template <typename T> void println(const T &t) { cout << t << '\n'; }
template <typename T, typename... Args>
void println(const T &t, const Args &...rest) {
print(t);
println(rest...);
}
template <typename T> class BIT {
// 0-indexed
vector<T> a;
using BinOp = function<T(T, T)>;
BinOp bin_op;
const T init;
public:
explicit BIT(
int n, BinOp op = [](T x, T y) { return x + y; }, T init = T{})
: bin_op(op), init(init), a(n, init) {}
T prefix(int x) const {
auto res = init;
while (x >= 0) {
res = bin_op(a[x], res);
x = (x & (x + 1)) - 1;
}
return res;
}
void modify(int x, T v) {
while (x < SZ(a)) {
a[x] = bin_op(a[x], v);
x |= (x + 1);
}
}
void clear() { fill(a.begin(), a.end(), init); }
};
// debug code by tourist
string to_string(const string &s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A, typename B> string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A> string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail> void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
#if defined LOCAL && !defined DUIPAI
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
int main() {
#if defined LOCAL && !defined DUIPAI
ifstream in("in.txt");
cin.rdbuf(in.rdbuf());
#endif
int n;
string s;
scan(n, s);
vector<BIT<int>> a(26, BIT<int>(n));
rng(i, 0, n) { a[s[i] - 'a'].modify(i, 1); }
int q;
scan(q);
rep(q) {
int t;
scan(t);
if (t == 1) {
int i;
char c;
scan(i, c);
--i;
a[c - 'a'].modify(i, 1);
a[s[i] - 'a'].modify(i, -1);
s[i] = c;
debug(s);
} else {
int l, r;
scan(l, r);
--l, --r;
int ans = 0;
debug(s);
rng(i, 0, n) { ans += a[i].prefix(r) - a[i].prefix(l - 1) > 0; }
println(ans);
}
}
return 0;
} | /**
* author: zjsdut
* created: 2020/03/29 21:58:23
**/
#include <bits/stdc++.h>
using namespace std;
struct fast_ios {
fast_ios() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
};
} fast_ios_;
template <typename A, typename B> bool chkmin(A &a, const B &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
template <typename A, typename B> bool chkmax(A &a, const B &b) {
if (b > a) {
a = b;
return true;
}
return false;
}
template <typename T> istream &operator>>(istream &stream, vector<T> &vec) {
for (auto &x : vec)
stream >> x;
return stream;
}
void scan() {}
template <class T, class... Args> void scan(T &a, Args &...rest) {
cin >> a;
scan(rest...);
}
using ll = long long;
using vl = vector<ll>;
using vb = vector<bool>;
using vi = vector<int>;
using pii = pair<int, int>;
template <typename T> using vv = vector<vector<T>>;
#define rng(i, a, b) for (int i = (int)(a); i < (int)(b); ++i)
#define up(i, a, b) for (int i = int(a); i <= int(b); ++i)
#define down(i, b, a) for (int i = int(b); i >= int(a); i--)
#define TOKENPASTE(x, y) x##y
#define TOKENPASTE2(x, y) TOKENPASTE(x, y)
#define rep(n) \
for (int TOKENPASTE2(_iter_, __LINE__) = 0, \
TOKENPASTE2(_num_, __LINE__) = (int)(n); \
TOKENPASTE2(_iter_, __LINE__) < TOKENPASTE2(_num_, __LINE__); \
++TOKENPASTE2(_iter_, __LINE__))
#define FOR(x, cont) for (const auto &x : cont)
#define For(x, cont) for (auto &x : cont)
#define all(x) begin(x), end(x)
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define ep emplace
#define SZ(x) (int)(x).size()
#define UNIQ(vec) (vec).erase(unique(all(vec)), end(vec))
#define LB(cont, x) int(lower_bound(all(cont), x) - begin(cont))
#define UB(cont, x) int(upper_bound(all(cont), x) - begin(cont))
template <typename T>
ostream &operator<<(ostream &stream, const vector<T> &vec) {
if (!vec.empty()) {
stream << vec[0];
for (size_t i = 1; i != vec.size(); ++i)
stream << ' ' << vec[i];
}
return stream;
}
template <typename T> void print(const vector<T> &t) { cout << t << '\n'; }
template <typename T> void print(const vector<vector<T>> &t) {
for (const auto &row : t) {
print(row);
}
}
template <typename T> void print(const T &t) { cout << t << ' '; }
template <typename T, typename... Args>
void print(const T &t, const Args &...rest) {
print(t);
print(rest...);
}
template <typename T> void println(const T &t) { cout << t << '\n'; }
template <typename T, typename... Args>
void println(const T &t, const Args &...rest) {
print(t);
println(rest...);
}
template <typename T> class BIT {
// 0-indexed
vector<T> a;
using BinOp = function<T(T, T)>;
BinOp bin_op;
const T init;
public:
explicit BIT(
int n, BinOp op = [](T x, T y) { return x + y; }, T init = T{})
: bin_op(op), init(init), a(n, init) {}
T prefix(int x) const {
auto res = init;
while (x >= 0) {
res = bin_op(a[x], res);
x = (x & (x + 1)) - 1;
}
return res;
}
void modify(int x, T v) {
while (x < SZ(a)) {
a[x] = bin_op(a[x], v);
x |= (x + 1);
}
}
void clear() { fill(a.begin(), a.end(), init); }
};
// debug code by tourist
string to_string(const string &s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A, typename B> string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A> string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail> void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
#if defined LOCAL && !defined DUIPAI
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
int main() {
#if defined LOCAL && !defined DUIPAI
ifstream in("in.txt");
cin.rdbuf(in.rdbuf());
#endif
int n;
string s;
scan(n, s);
vector<BIT<int>> a(26, BIT<int>(n));
rng(i, 0, n) { a[s[i] - 'a'].modify(i, 1); }
int q;
scan(q);
rep(q) {
int t;
scan(t);
if (t == 1) {
int i;
char c;
scan(i, c);
--i;
a[c - 'a'].modify(i, 1);
a[s[i] - 'a'].modify(i, -1);
s[i] = c;
debug(s);
} else {
int l, r;
scan(l, r);
--l, --r;
int ans = 0;
debug(s);
rng(i, 0, 26) { ans += a[i].prefix(r) - a[i].prefix(l - 1) > 0; }
println(ans);
}
}
return 0;
} | replace | 204 | 205 | 204 | 205 | 0 | |
p02763 | C++ | Runtime Error | #define fast ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0)
#include <bits/stdc++.h>
#define pll pair<ll, ll>
#define vi vector<int>
#define ld long double
#define ll long long
#define pb push_back
#define mid (l + r) / 2
#define S second
#define F first
using namespace std;
int n, q;
string s;
vi tree[500009];
void build(int node, int l, int r) {
if (l == r) {
for (int i = 0; i < 26; i++)
tree[node].pb(0);
tree[node][s[l] - 'a'] = 1;
return;
}
build(node * 2, l, mid);
build(node * 2 + 1, mid + 1, r);
for (int i = 0; i < 26; i++) {
tree[node].pb(0);
tree[node][i] = tree[node * 2][i];
tree[node][i] += tree[node * 2 + 1][i];
}
}
void upd(int node, int l, int r, int k, char z) {
if (l == r) {
tree[node][s[l] - 'a'] = 0;
s[l] = z;
tree[node][s[l] - 'a'] = 1;
return;
}
if (k <= mid)
upd(node * 2, l, mid, k, z);
else
upd(node * 2 + 1, mid + 1, r, k, z);
for (int i = 0; i < 26; i++) {
tree[node][i] = tree[node * 2][i];
tree[node][i] += tree[node * 2 + 1][i];
}
}
vi query(int node, int l, int r, int s, int e) {
if (s <= l && e >= r)
return tree[node];
if (s <= mid && e > mid) {
vi a = query(node * 2, l, mid, s, e);
vi b = query(node * 2 + 1, mid + 1, r, s, e);
vi ret;
for (int i = 0; i < 26; i++) {
ret.pb(0);
ret[i] = a[i] + b[i];
}
return ret;
}
if (s <= mid)
return query(node * 2, l, mid, s, e);
return query(node * 2 + 1, mid + 1, r, s, e);
}
int main() {
fast, cin >> n >> s >> q;
build(1, 0, n - 1);
while (q--) {
int t;
cin >> t;
if (t == 1) {
int id;
char z;
cin >> id >> z, id--;
upd(1, 0, n - 1, id, z);
} else {
int l, r;
cin >> l >> r;
l--;
r--;
vi v = query(1, 0, n - 1, l, r);
int curr = 0;
for (int i = 0; i < 26; i++) {
curr += (v[i] > 0);
}
cout << curr << endl;
}
}
}
| #define fast ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0)
#include <bits/stdc++.h>
#define pll pair<ll, ll>
#define vi vector<int>
#define ld long double
#define ll long long
#define pb push_back
#define mid (l + r) / 2
#define S second
#define F first
using namespace std;
int n, q;
string s;
vi tree[2000009];
void build(int node, int l, int r) {
if (l == r) {
for (int i = 0; i < 26; i++)
tree[node].pb(0);
tree[node][s[l] - 'a'] = 1;
return;
}
build(node * 2, l, mid);
build(node * 2 + 1, mid + 1, r);
for (int i = 0; i < 26; i++) {
tree[node].pb(0);
tree[node][i] = tree[node * 2][i];
tree[node][i] += tree[node * 2 + 1][i];
}
}
void upd(int node, int l, int r, int k, char z) {
if (l == r) {
tree[node][s[l] - 'a'] = 0;
s[l] = z;
tree[node][s[l] - 'a'] = 1;
return;
}
if (k <= mid)
upd(node * 2, l, mid, k, z);
else
upd(node * 2 + 1, mid + 1, r, k, z);
for (int i = 0; i < 26; i++) {
tree[node][i] = tree[node * 2][i];
tree[node][i] += tree[node * 2 + 1][i];
}
}
vi query(int node, int l, int r, int s, int e) {
if (s <= l && e >= r)
return tree[node];
if (s <= mid && e > mid) {
vi a = query(node * 2, l, mid, s, e);
vi b = query(node * 2 + 1, mid + 1, r, s, e);
vi ret;
for (int i = 0; i < 26; i++) {
ret.pb(0);
ret[i] = a[i] + b[i];
}
return ret;
}
if (s <= mid)
return query(node * 2, l, mid, s, e);
return query(node * 2 + 1, mid + 1, r, s, e);
}
int main() {
fast, cin >> n >> s >> q;
build(1, 0, n - 1);
while (q--) {
int t;
cin >> t;
if (t == 1) {
int id;
char z;
cin >> id >> z, id--;
upd(1, 0, n - 1, id, z);
} else {
int l, r;
cin >> l >> r;
l--;
r--;
vi v = query(1, 0, n - 1, l, r);
int curr = 0;
for (int i = 0; i < 26; i++) {
curr += (v[i] > 0);
}
cout << curr << endl;
}
}
}
| replace | 13 | 14 | 13 | 14 | 0 | |
p02763 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define pb push_back
#define ff first
#define ss second
#define assign(x, val) memset(x, val, sizeof(x))
#define motherfucker \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
#define all(x) (x).begin(), (x).end()
#define for0(i, n) for (ll i = 0; i < n; ++i)
#define for1(i, n) for (ll i = 1; i <= n; ++i)
#define ford(i, n) for (ll i = n; i >= 1; --i)
#define forg(i, a, b) for (ll i = a; i < b; ++i)
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<pii> vpi;
typedef pair<ll, ll> pll;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<pll> vpl;
long long mod = 1000000007;
const long double PI = (long double)(3.1415926535897932384626433832795);
inline void yes() { cout << "YES\n"; }
inline void no() { cout << "NO\n"; }
inline void notposs() { cout << -1 << endl; }
bool tests = 0;
void solve() {
int n;
cin >> n;
string s;
cin >> s;
set<int> se[26];
for0(i, n) { se[s[i] - 'a'].insert(i); }
int q;
cin >> q;
while (q--) {
int x;
cin >> x;
--x;
if (x) {
int l, r;
cin >> l >> r;
--l;
--r;
int ans = 0;
for (auto x : se) {
if (x.lower_bound(l) != x.end() && *x.lower_bound(l) <= r) {
ans++;
}
}
cout << ans << endl;
} else {
int x;
char c;
cin >> x >> c;
--x;
se[s[x] - 'a'].erase(x);
s[x] = c;
se[c - 'a'].insert(x);
}
}
}
int main() {
motherfucker ll t = 1;
if (tests)
cin >> t;
for0(i, t) { solve(); }
return 0;
}
| #include <bits/stdc++.h>
#define pb push_back
#define ff first
#define ss second
#define assign(x, val) memset(x, val, sizeof(x))
#define motherfucker \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
#define all(x) (x).begin(), (x).end()
#define for0(i, n) for (ll i = 0; i < n; ++i)
#define for1(i, n) for (ll i = 1; i <= n; ++i)
#define ford(i, n) for (ll i = n; i >= 1; --i)
#define forg(i, a, b) for (ll i = a; i < b; ++i)
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<pii> vpi;
typedef pair<ll, ll> pll;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<pll> vpl;
long long mod = 1000000007;
const long double PI = (long double)(3.1415926535897932384626433832795);
inline void yes() { cout << "YES\n"; }
inline void no() { cout << "NO\n"; }
inline void notposs() { cout << -1 << endl; }
bool tests = 0;
void solve() {
int n;
cin >> n;
string s;
cin >> s;
set<int> se[26];
for0(i, n) { se[s[i] - 'a'].insert(i); }
int q;
cin >> q;
while (q--) {
int x;
cin >> x;
--x;
if (x) {
int l, r;
cin >> l >> r;
--l;
--r;
int ans = 0;
for (auto &x : se) {
if (x.lower_bound(l) != x.end() && *x.lower_bound(l) <= r) {
ans++;
}
}
cout << ans << endl;
} else {
int x;
char c;
cin >> x >> c;
--x;
se[s[x] - 'a'].erase(x);
s[x] = c;
se[c - 'a'].insert(x);
}
}
}
int main() {
motherfucker ll t = 1;
if (tests)
cin >> t;
for0(i, t) { solve(); }
return 0;
}
| replace | 50 | 51 | 50 | 51 | TLE | |
p02763 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
// https://atcoder.jp/contests/abc157/submissions/10486180
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N, Q;
string S;
cin >> N >> S >> Q;
vector<int> A(N);
for (int i = 0; i < N; ++i) {
A[i] = 1 << (S[i] - 'a');
}
int x, l, r, i;
char c;
while (Q--) {
cin >> x;
if (x == 1) {
cin >> i >> c;
i--;
A[i] = 1 << (c - 'a');
} else {
cin >> l >> r;
int ans = 0;
for (int i = l - 1; i < r; i++)
ans |= A[i];
cout << __builtin_popcount(ans) << '\n';
}
}
} | #include <iostream>
#include <vector>
using namespace std;
// https://atcoder.jp/contests/abc157/submissions/10486180
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N, Q;
string S;
cin >> N >> S >> Q;
vector<int> A(N);
for (int i = 0; i < N; ++i) {
A[i] = 1 << (S[i] - 'a');
}
int x, l, r, i;
char c;
while (Q--) {
cin >> x;
if (x == 1) {
cin >> i >> c;
i--;
A[i] = 1 << (c - 'a');
} else {
cin >> l >> r;
int ans = 0;
for (int i = l - 1; i < r; i++)
ans |= A[i];
cout << __builtin_popcount(ans) << '\n';
}
}
} | replace | 0 | 1 | 0 | 2 | TLE | |
p02763 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef pair<int, int> pii;
typedef pair<int, pii> p;
typedef long long ll;
typedef pair<ll, ll> pll;
int dy[] = {1, 0, -1, 0};
int dx[] = {0, 1, 0, -1};
const int MAXN = 100000;
const int MAXE = 100000;
const int MAXV = 10000;
const ll INF = 2e9;
const ll MOD = 1e9 + 7;
struct edge {
int to;
int cost;
};
int main() {
int N;
cin >> N;
string S;
cin >> S;
int Q;
cin >> Q;
vector<set<int>> st(26);
for (int i = 0; i < N; ++i) {
st[S[i] - 'a'].insert(i);
}
for (int i = 0; i < 26; ++i)
st[i].insert(INF);
while (Q--) {
int t;
cin >> t;
if (t == 1) {
int i;
char c;
cin >> i >> c;
i--;
st[S[i] - 'a'].erase(i);
S[i] = c;
st[S[i] - 'a'].insert(i);
} else {
int l, r;
cin >> l >> r;
l--;
r--;
int ans = 0;
for (int i = 0; i < 26; ++i) {
int j = *lower_bound(st[i].begin(), st[i].end(), l);
if (j <= r)
ans++;
}
cout << ans << endl;
}
}
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef pair<int, int> pii;
typedef pair<int, pii> p;
typedef long long ll;
typedef pair<ll, ll> pll;
int dy[] = {1, 0, -1, 0};
int dx[] = {0, 1, 0, -1};
const int MAXN = 100000;
const int MAXE = 100000;
const int MAXV = 10000;
const ll INF = 2e9;
const ll MOD = 1e9 + 7;
struct edge {
int to;
int cost;
};
int main() {
int N;
cin >> N;
string S;
cin >> S;
int Q;
cin >> Q;
vector<set<int>> st(26);
for (int i = 0; i < N; ++i) {
st[S[i] - 'a'].insert(i);
}
for (int i = 0; i < 26; ++i)
st[i].insert(INF);
while (Q--) {
int t;
cin >> t;
if (t == 1) {
int i;
char c;
cin >> i >> c;
i--;
st[S[i] - 'a'].erase(i);
S[i] = c;
st[S[i] - 'a'].insert(i);
} else {
int l, r;
cin >> l >> r;
l--;
r--;
int ans = 0;
for (int i = 0; i < 26; ++i) {
int j = *st[i].lower_bound(l);
if (j <= r)
ans++;
}
cout << ans << endl;
}
}
return 0;
} | replace | 59 | 60 | 59 | 60 | TLE | |
p02763 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int N, Q;
char S[500010];
set<int> s[26];
set<int>::iterator v[500010];
int main() {
scanf("%d%s%d", &N, S, &Q);
for (int i = 0; i < N; i++) {
v[i] = s[S[i] - 'a'].insert(i).first;
}
for (; Q; Q--) {
int a;
scanf("%d", &a);
if (a == 1) {
int i;
char c;
scanf("%d %c", &i, &c);
i--;
s[S[i] - 'a'].erase(v[i]);
S[i] = c;
v[i] = s[S[i] - 'a'].insert(i).first;
} else {
int l, r;
scanf("%d%d", &l, &r);
l--, r--;
int x = 0;
for (int j = 0; j < 26; j++) {
auto ll = lower_bound(s[j].begin(), s[j].end(), l);
if (ll != s[j].end() && (*ll) <= r) {
x++;
}
}
printf("%d\n", x);
}
}
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int N, Q;
char S[500010];
set<int> s[26];
set<int>::iterator v[500010];
int main() {
scanf("%d%s%d", &N, S, &Q);
for (int i = 0; i < N; i++) {
v[i] = s[S[i] - 'a'].insert(i).first;
}
for (; Q; Q--) {
int a;
scanf("%d", &a);
if (a == 1) {
int i;
char c;
scanf("%d %c", &i, &c);
i--;
s[S[i] - 'a'].erase(v[i]);
S[i] = c;
v[i] = s[S[i] - 'a'].insert(i).first;
} else {
int l, r;
scanf("%d%d", &l, &r);
l--, r--;
int x = 0;
for (int j = 0; j < 26; j++) {
auto ll = s[j].lower_bound(l);
if (ll != s[j].end() && (*ll) <= r) {
x++;
}
}
printf("%d\n", x);
}
}
} | replace | 29 | 30 | 29 | 30 | TLE | |
p02763 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
int main() {
int n, q;
string s;
cin >> n >> s >> q;
vector<set<int>> se(26);
rep(i, n) se[s[i] - 'a'].insert(i);
rep(i, q) {
int a, b;
cin >> a >> b;
b--;
if (a == 1) {
char c;
cin >> c;
se[s[b] - 'a'].erase(b);
s[b] = c;
se[s[b] - 'a'].insert(b);
} else {
int c;
cin >> c;
c--;
int ans = 0;
rep(j, 26) {
if (lower_bound(se[j].begin(), se[j].end(), b) == se[j].end())
continue;
if (*lower_bound(se[j].begin(), se[j].end(), b) <= c)
ans++;
}
printf("%d\n", ans);
}
}
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
int main() {
int n, q;
string s;
cin >> n >> s >> q;
vector<set<int>> se(26);
rep(i, n) se[s[i] - 'a'].insert(i);
rep(i, q) {
int a, b;
cin >> a >> b;
b--;
if (a == 1) {
char c;
cin >> c;
se[s[b] - 'a'].erase(b);
s[b] = c;
se[s[b] - 'a'].insert(b);
} else {
int c;
cin >> c;
c--;
int ans = 0;
rep(j, 26) {
auto it = se[j].lower_bound(b);
if (*it <= c && it != se[j].end())
ans++;
}
printf("%d\n", ans);
}
}
} | replace | 27 | 30 | 27 | 29 | TLE | |
p02763 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define ar array
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
template <typename T>
using oset =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
#define vt vector
#define pb push_back
#define all(c) (c).begin(), (c).end()
#define sz(x) (int)(x).size()
#define F_OR(i, a, b, s) \
for (int i = (a); (s) > 0 ? i < (b) : i > (b); i += (s))
#define F_OR1(e) F_OR(i, 0, e, 1)
#define F_OR2(i, e) F_OR(i, 0, e, 1)
#define F_OR3(i, b, e) F_OR(i, b, e, 1)
#define F_OR4(i, b, e, s) F_OR(i, b, e, s)
#define GET5(a, b, c, d, e, ...) e
#define F_ORC(...) GET5(__VA_ARGS__, F_OR4, F_OR3, F_OR2, F_OR1)
#define FOR(...) F_ORC(__VA_ARGS__)(__VA_ARGS__)
#define EACH(x, a) for (auto &x : a)
template <class T> bool umin(T &a, const T &b) { return b < a ? a = b, 1 : 0; }
template <class T> bool umax(T &a, const T &b) { return a < b ? a = b, 1 : 0; }
ll FIRSTTRUE(function<bool(ll)> f, ll lb, ll rb) {
while (lb < rb) {
ll mb = (lb + rb) / 2;
f(mb) ? rb = mb : lb = mb + 1;
}
return lb;
}
ll LASTTRUE(function<bool(ll)> f, ll lb, ll rb) {
while (lb < rb) {
ll mb = (lb + rb + 1) / 2;
f(mb) ? lb = mb : rb = mb - 1;
}
return lb;
}
template <class A> void read(vt<A> &v);
template <class A, size_t S> void read(ar<A, S> &a);
template <class T> void read(T &x) { cin >> x; }
void read(double &d) {
string t;
read(t);
d = stod(t);
}
void read(long double &d) {
string t;
read(t);
d = stold(t);
}
template <class H, class... T> void read(H &h, T &...t) {
read(h);
read(t...);
}
template <class A> void read(vt<A> &x) {
EACH(a, x)
read(a);
}
template <class A, size_t S> void read(array<A, S> &x) {
EACH(a, x)
read(a);
}
string to_string(char c) { return string(1, c); }
string to_string(bool b) { return b ? "true" : "false"; }
string to_string(const char *s) { return string(s); }
string to_string(string s) { return s; }
string to_string(vt<bool> v) {
string res;
FOR(sz(v))
res += char('0' + v[i]);
return res;
}
template <size_t S> string to_string(bitset<S> b) {
string res;
FOR(S)
res += char('0' + b[i]);
return res;
}
template <class T> string to_string(T v) {
bool f = 1;
string res;
EACH(x, v) {
if (!f)
res += ' ';
f = 0;
res += to_string(x);
}
return res;
}
template <class A> void write(A x) { cout << to_string(x); }
template <class H, class... T> void write(const H &h, const T &...t) {
write(h);
write(t...);
}
void print() { write("\n"); }
template <class H, class... T> void print(const H &h, const T &...t) {
write(h);
if (sizeof...(t))
write(' ');
print(t...);
}
void DBG() { cerr << "]" << endl; }
template <class H, class... T> void DBG(H h, T... t) {
cerr << to_string(h);
if (sizeof...(t))
cerr << ", ";
DBG(t...);
}
#ifdef _DEBUG
#define dbg(...) \
cerr << "LINE(" << __LINE__ << ") -> [" << #__VA_ARGS__ << "]: [", \
DBG(__VA_ARGS__)
#else
#define dbg(...) 0
#endif
template <class T> void offset(ll o, T &x) { x += o; }
template <class T> void offset(ll o, vt<T> &x) {
EACH(a, x)
offset(o, a);
}
template <class T, size_t S> void offset(ll o, ar<T, S> &x) {
EACH(a, x)
offset(o, a);
}
mt19937 mt_rng(chrono::steady_clock::now().time_since_epoch().count());
ll randint(ll a, ll b) { return uniform_int_distribution<ll>(a, b)(mt_rng); }
template <class T, class U> void vti(vt<T> &v, U x, size_t n) {
v = vt<T>(n, x);
}
template <class T, class U> void vti(vt<T> &v, U x, size_t n, size_t m...) {
v = vt<T>(n);
EACH(a, v)
vti(a, x, m);
}
const int d4i[4] = {-1, 0, 1, 0}, d4j[4] = {0, 1, 0, -1};
const int d8i[8] = {-1, -1, 0, 1, 1, 1, 0, -1},
d8j[8] = {0, 1, 1, 1, 0, -1, -1, -1};
void solve() {
int n, q;
string s;
cin >> n;
cin >> s;
cin >> q;
set<int> st[26];
int type, a, b;
char c;
FOR(n) { st[s[i] - 'a'].insert(i); }
while (q--) {
cin >> type;
cin >> a;
if (type == 1) {
--a;
cin >> c;
} else {
cin >> b;
--a, --b;
}
if (type == 1) {
st[s[a] - 'a'].erase(a);
s[a] = c;
st[s[a] - 'a'].insert(a);
} else {
int ans = 0;
FOR(j, 0, 26) {
auto it = lower_bound(st[j].begin(), st[j].end(), a);
if (it == st[j].end())
continue;
else if ((*it) <= b)
ans++;
}
cout << ans << endl;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
solve();
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define ar array
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
template <typename T>
using oset =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
#define vt vector
#define pb push_back
#define all(c) (c).begin(), (c).end()
#define sz(x) (int)(x).size()
#define F_OR(i, a, b, s) \
for (int i = (a); (s) > 0 ? i < (b) : i > (b); i += (s))
#define F_OR1(e) F_OR(i, 0, e, 1)
#define F_OR2(i, e) F_OR(i, 0, e, 1)
#define F_OR3(i, b, e) F_OR(i, b, e, 1)
#define F_OR4(i, b, e, s) F_OR(i, b, e, s)
#define GET5(a, b, c, d, e, ...) e
#define F_ORC(...) GET5(__VA_ARGS__, F_OR4, F_OR3, F_OR2, F_OR1)
#define FOR(...) F_ORC(__VA_ARGS__)(__VA_ARGS__)
#define EACH(x, a) for (auto &x : a)
template <class T> bool umin(T &a, const T &b) { return b < a ? a = b, 1 : 0; }
template <class T> bool umax(T &a, const T &b) { return a < b ? a = b, 1 : 0; }
ll FIRSTTRUE(function<bool(ll)> f, ll lb, ll rb) {
while (lb < rb) {
ll mb = (lb + rb) / 2;
f(mb) ? rb = mb : lb = mb + 1;
}
return lb;
}
ll LASTTRUE(function<bool(ll)> f, ll lb, ll rb) {
while (lb < rb) {
ll mb = (lb + rb + 1) / 2;
f(mb) ? lb = mb : rb = mb - 1;
}
return lb;
}
template <class A> void read(vt<A> &v);
template <class A, size_t S> void read(ar<A, S> &a);
template <class T> void read(T &x) { cin >> x; }
void read(double &d) {
string t;
read(t);
d = stod(t);
}
void read(long double &d) {
string t;
read(t);
d = stold(t);
}
template <class H, class... T> void read(H &h, T &...t) {
read(h);
read(t...);
}
template <class A> void read(vt<A> &x) {
EACH(a, x)
read(a);
}
template <class A, size_t S> void read(array<A, S> &x) {
EACH(a, x)
read(a);
}
string to_string(char c) { return string(1, c); }
string to_string(bool b) { return b ? "true" : "false"; }
string to_string(const char *s) { return string(s); }
string to_string(string s) { return s; }
string to_string(vt<bool> v) {
string res;
FOR(sz(v))
res += char('0' + v[i]);
return res;
}
template <size_t S> string to_string(bitset<S> b) {
string res;
FOR(S)
res += char('0' + b[i]);
return res;
}
template <class T> string to_string(T v) {
bool f = 1;
string res;
EACH(x, v) {
if (!f)
res += ' ';
f = 0;
res += to_string(x);
}
return res;
}
template <class A> void write(A x) { cout << to_string(x); }
template <class H, class... T> void write(const H &h, const T &...t) {
write(h);
write(t...);
}
void print() { write("\n"); }
template <class H, class... T> void print(const H &h, const T &...t) {
write(h);
if (sizeof...(t))
write(' ');
print(t...);
}
void DBG() { cerr << "]" << endl; }
template <class H, class... T> void DBG(H h, T... t) {
cerr << to_string(h);
if (sizeof...(t))
cerr << ", ";
DBG(t...);
}
#ifdef _DEBUG
#define dbg(...) \
cerr << "LINE(" << __LINE__ << ") -> [" << #__VA_ARGS__ << "]: [", \
DBG(__VA_ARGS__)
#else
#define dbg(...) 0
#endif
template <class T> void offset(ll o, T &x) { x += o; }
template <class T> void offset(ll o, vt<T> &x) {
EACH(a, x)
offset(o, a);
}
template <class T, size_t S> void offset(ll o, ar<T, S> &x) {
EACH(a, x)
offset(o, a);
}
mt19937 mt_rng(chrono::steady_clock::now().time_since_epoch().count());
ll randint(ll a, ll b) { return uniform_int_distribution<ll>(a, b)(mt_rng); }
template <class T, class U> void vti(vt<T> &v, U x, size_t n) {
v = vt<T>(n, x);
}
template <class T, class U> void vti(vt<T> &v, U x, size_t n, size_t m...) {
v = vt<T>(n);
EACH(a, v)
vti(a, x, m);
}
const int d4i[4] = {-1, 0, 1, 0}, d4j[4] = {0, 1, 0, -1};
const int d8i[8] = {-1, -1, 0, 1, 1, 1, 0, -1},
d8j[8] = {0, 1, 1, 1, 0, -1, -1, -1};
void solve() {
int n, q;
string s;
cin >> n;
cin >> s;
cin >> q;
set<int> st[26];
int type, a, b;
char c;
FOR(n) { st[s[i] - 'a'].insert(i); }
while (q--) {
cin >> type;
cin >> a;
if (type == 1) {
--a;
cin >> c;
} else {
cin >> b;
--a, --b;
}
if (type == 1) {
st[s[a] - 'a'].erase(a);
s[a] = c;
st[s[a] - 'a'].insert(a);
} else {
int ans = 0;
FOR(j, 0, 26) {
auto it = st[j].lower_bound(a);
if (it == st[j].end())
continue;
else if ((*it) <= b)
ans++;
}
cout << ans << endl;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
solve();
}
| replace | 184 | 185 | 184 | 185 | TLE | |
p02763 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define sz(x) int(x.size())
#define ALL(c) (c).begin(), (c).end()
#define SUM(x) std::accumulate(ALL(x), 0LL)
#define MIN(v) *std::min_element(v.begin(), v.end())
#define MAX(v) *std::max_element(v.begin(), v.end())
#define EXIST(v, x) (std::find(v.begin(), v.end(), x) != v.end())
#define FORV(i, v) for (auto i = v.begin(); i != v.end(); i++)
using namespace std;
using ll = long long;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
const int INF = 1001001001;
const long long INFL = LLONG_MAX / 3;
const double eps = (1e-9);
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n;
cin >> n;
string s;
cin >> s;
vector<set<int>> pos(26, set<int>());
rep(i, n) {
char c = s[i] - 'a';
pos[c].insert(i);
}
ll q;
cin >> q;
rep(i, q) {
int cmd;
cin >> cmd;
if (cmd == 1) {
int idx;
cin >> idx;
idx--;
char c;
cin >> c;
pos[s[idx] - 'a'].erase(idx);
pos[c - 'a'].insert(idx);
s[idx] = c;
} else {
int l, r;
cin >> l >> r;
l--;
r--;
int ans = 0;
for (auto &v : pos) {
auto itr = lower_bound(ALL(v), l);
if (itr == v.end())
continue;
if (*itr <= r)
ans++;
}
cout << ans << endl;
}
}
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define sz(x) int(x.size())
#define ALL(c) (c).begin(), (c).end()
#define SUM(x) std::accumulate(ALL(x), 0LL)
#define MIN(v) *std::min_element(v.begin(), v.end())
#define MAX(v) *std::max_element(v.begin(), v.end())
#define EXIST(v, x) (std::find(v.begin(), v.end(), x) != v.end())
#define FORV(i, v) for (auto i = v.begin(); i != v.end(); i++)
using namespace std;
using ll = long long;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
const int INF = 1001001001;
const long long INFL = LLONG_MAX / 3;
const double eps = (1e-9);
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n;
cin >> n;
string s;
cin >> s;
vector<set<int>> pos(26, set<int>());
rep(i, n) {
char c = s[i] - 'a';
pos[c].insert(i);
}
ll q;
cin >> q;
rep(i, q) {
int cmd;
cin >> cmd;
if (cmd == 1) {
int idx;
cin >> idx;
idx--;
char c;
cin >> c;
pos[s[idx] - 'a'].erase(idx);
pos[c - 'a'].insert(idx);
s[idx] = c;
} else {
int l, r;
cin >> l >> r;
l--;
r--;
int ans = 0;
for (auto &v : pos) {
auto itr = v.lower_bound(l);
if (itr == v.end())
continue;
if (*itr <= r)
ans++;
}
cout << ans << endl;
}
}
return 0;
}
| replace | 66 | 67 | 66 | 67 | TLE | |
p02763 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define endl "\n"
#define pb push_back
#define fi first
#define se second
#define rep(i, n) for (ll i = 0; i < n; i++)
#define per(i, n) for (ll i = n - 1; i >= 0; i--)
#define rep1(i, n) for (ll i = 1; i <= n; i++)
#define per1(i, n) for (ll i = n; i >= 1; i--)
const int N = 1e5;
ll a[N][27];
void update(ll x, ll id, ll val) {
for (; x < N; x += (x & -x))
a[x][id] += val;
}
ll query(ll x, ll id) {
ll ans = 0;
for (; x; x -= x & (-x))
ans += a[x][id];
return ans;
}
void solve() {
ll i, j, n, m, k, x, y, z;
cin >> n;
string s;
char c;
cin >> s;
rep(i, n) { update(i + 1, s[i] - 'a', 1); }
ll q;
cin >> q;
while (q--) {
cin >> x >> y;
if (x == 1) {
cin >> c;
if (s[y - 1] != c) {
update(y, s[y - 1] - 'a', -1);
s[y - 1] = c;
update(y, s[y - 1] - 'a', 1);
}
} else {
cin >> z;
ll ans = 0;
rep(i, 26) {
if (query(z, i) - query(y - 1, i))
ans++;
}
cout << ans << endl;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
// cin >> t;
while (t--) {
solve();
cout << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define endl "\n"
#define pb push_back
#define fi first
#define se second
#define rep(i, n) for (ll i = 0; i < n; i++)
#define per(i, n) for (ll i = n - 1; i >= 0; i--)
#define rep1(i, n) for (ll i = 1; i <= n; i++)
#define per1(i, n) for (ll i = n; i >= 1; i--)
const int N = 1e6;
ll a[N][27];
void update(ll x, ll id, ll val) {
for (; x < N; x += (x & -x))
a[x][id] += val;
}
ll query(ll x, ll id) {
ll ans = 0;
for (; x; x -= x & (-x))
ans += a[x][id];
return ans;
}
void solve() {
ll i, j, n, m, k, x, y, z;
cin >> n;
string s;
char c;
cin >> s;
rep(i, n) { update(i + 1, s[i] - 'a', 1); }
ll q;
cin >> q;
while (q--) {
cin >> x >> y;
if (x == 1) {
cin >> c;
if (s[y - 1] != c) {
update(y, s[y - 1] - 'a', -1);
s[y - 1] = c;
update(y, s[y - 1] - 'a', 1);
}
} else {
cin >> z;
ll ans = 0;
rep(i, 26) {
if (query(z, i) - query(y - 1, i))
ans++;
}
cout << ans << endl;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
// cin >> t;
while (t--) {
solve();
cout << endl;
}
}
| replace | 11 | 12 | 11 | 12 | 0 | |
p02763 | C++ | Runtime Error | #include <bits/stdc++.h>
using ll = long long;
using namespace std;
#define rep(i, n) for (int i = 0, i##_len = (int)(n); i < i##_len; i++)
#define reps(i, n) for (int i = 1, i##_len = (int)(n); i <= i##_len; i++)
#define rrep(i, n) for (int i = ((int)(n)-1); i >= 0; i--)
#define rreps(i, n) for (int i = ((int)(n)); i > 0; i--)
#define repi(i, x) \
for (auto i = (x).begin(), i##_fin = (x).end(); i != i##_fin; i++)
#define all(x) (x).begin(), (x).end()
#define F first
#define S second
#define mp make_pair
#define pb push_back
#define solve(a) ((a) ? "Yes" : "No")
typedef vector<int> Vi;
typedef vector<Vi> VVi;
typedef pair<int, int> Pi;
typedef vector<Pi> VPi;
typedef vector<long long> V;
typedef vector<V> VV;
typedef pair<long long, long long> P;
typedef vector<P> VP;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const long long INFLL = 1LL << 60;
const int INF = 1 << 30;
const double PI = acos(-1);
// SegmentTree
template <class T> class SegmentTree {
vector<T> seg;
public:
int size; // size of segmenttree
T init;
SegmentTree(int _legth, T _init = 0) {
size = 1;
init = _init;
while (size <= _legth) {
size <<= 1;
}
seg.assign(size << 1, init);
}
T get(int index) { return seg[size + index]; }
void show() {
rep(i, size * 2) { clog << seg[i] << " "; }
clog << endl;
}
// change value
void update(int index, T value) {
seg[size + index] = value;
int ter = index + size;
while (ter != 1) {
ter /= 2;
seg[ter] = upquary(ter * 2);
} // show();
}
T findquary(int left, int right, int index, int atStart, int atStop) {
if ((left <= atStart) and (atStop <= right)) { // 対象範囲に完全に囲まれる
return seg[index];
}
if ((atStop <= left) or (right < atStart)) { // 対象範囲に全く関わらない
return init;
}
if (index >= size) { // 範囲外・子がいない
return seg[index];
}
// 対象に一部が含まれる
T aL = findquary(left, right, index * 2, atStart,
atStart + (atStop - atStart) / 2);
T aR = findquary(left, right, index * 2 + 1,
atStart + (atStop - atStart) / 2, atStop);
return max(aL, aR);
}
T upquary(int index) { // q1
return max(seg[index], seg[index + 1]);
}
T find(int l, int r) { // q2
T res = seg[size + l];
res = findquary(l, r, 1, 0, size);
return res;
}
};
int main() {
int n;
string s;
int ans = 0;
cin >> n >> s;
vector<SegmentTree<int>> dis('z' - 'a' + 1, SegmentTree<int>(s.size(), 0));
rep(i, s.size()) {
dis[s[i] - 'a'].update(i, 1);
// dis[s[i]-'a'].show();
}
int q;
char c;
int l, r, id, at;
cin >> q;
rep(i, q) {
cin >> id;
if (id == 1) {
cin >> at >> c;
at--;
dis[s[at]].update(at, 0);
dis[c - 'a'].update(at, 1);
s[at] = c;
// dis[c-'a'].show();
} else if (id == 2) {
// clog<<"2:: "<<endl;
cin >> l >> r;
l--;
r--;
ans = 0;
rep(j, 'z' - 'a' + 1) {
// clog << (j + 'a') << " ::";
// clog << dis[j].find(l, r) << endl;
ans += dis[j].find(l, r);
}
cout << ans << endl;
}
}
// cout<<ans<<endl;
} | #include <bits/stdc++.h>
using ll = long long;
using namespace std;
#define rep(i, n) for (int i = 0, i##_len = (int)(n); i < i##_len; i++)
#define reps(i, n) for (int i = 1, i##_len = (int)(n); i <= i##_len; i++)
#define rrep(i, n) for (int i = ((int)(n)-1); i >= 0; i--)
#define rreps(i, n) for (int i = ((int)(n)); i > 0; i--)
#define repi(i, x) \
for (auto i = (x).begin(), i##_fin = (x).end(); i != i##_fin; i++)
#define all(x) (x).begin(), (x).end()
#define F first
#define S second
#define mp make_pair
#define pb push_back
#define solve(a) ((a) ? "Yes" : "No")
typedef vector<int> Vi;
typedef vector<Vi> VVi;
typedef pair<int, int> Pi;
typedef vector<Pi> VPi;
typedef vector<long long> V;
typedef vector<V> VV;
typedef pair<long long, long long> P;
typedef vector<P> VP;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const long long INFLL = 1LL << 60;
const int INF = 1 << 30;
const double PI = acos(-1);
// SegmentTree
template <class T> class SegmentTree {
vector<T> seg;
public:
int size; // size of segmenttree
T init;
SegmentTree(int _legth, T _init = 0) {
size = 1;
init = _init;
while (size <= _legth) {
size <<= 1;
}
seg.assign(size << 1, init);
}
T get(int index) { return seg[size + index]; }
void show() {
rep(i, size * 2) { clog << seg[i] << " "; }
clog << endl;
}
// change value
void update(int index, T value) {
seg[size + index] = value;
int ter = index + size;
while (ter != 1) {
ter /= 2;
seg[ter] = upquary(ter * 2);
} // show();
}
T findquary(int left, int right, int index, int atStart, int atStop) {
if ((left <= atStart) and (atStop <= right)) { // 対象範囲に完全に囲まれる
return seg[index];
}
if ((atStop <= left) or (right < atStart)) { // 対象範囲に全く関わらない
return init;
}
if (index >= size) { // 範囲外・子がいない
return seg[index];
}
// 対象に一部が含まれる
T aL = findquary(left, right, index * 2, atStart,
atStart + (atStop - atStart) / 2);
T aR = findquary(left, right, index * 2 + 1,
atStart + (atStop - atStart) / 2, atStop);
return max(aL, aR);
}
T upquary(int index) { // q1
return max(seg[index], seg[index + 1]);
}
T find(int l, int r) { // q2
T res = seg[size + l];
res = findquary(l, r, 1, 0, size);
return res;
}
};
int main() {
int n;
string s;
int ans = 0;
cin >> n >> s;
vector<SegmentTree<int>> dis('z' - 'a' + 1, SegmentTree<int>(s.size(), 0));
rep(i, s.size()) {
dis[s[i] - 'a'].update(i, 1);
// dis[s[i]-'a'].show();
}
int q;
char c;
int l, r, id, at;
cin >> q;
rep(i, q) {
cin >> id;
if (id == 1) {
cin >> at >> c;
at--;
dis[s[at] - 'a'].update(at, 0);
dis[c - 'a'].update(at, 1);
s[at] = c;
// dis[c-'a'].show();
} else if (id == 2) {
// clog<<"2:: "<<endl;
cin >> l >> r;
l--;
r--;
ans = 0;
rep(j, 'z' - 'a' + 1) {
// clog << (j + 'a') << " ::";
// clog << dis[j].find(l, r) << endl;
ans += dis[j].find(l, r);
}
cout << ans << endl;
}
}
// cout<<ans<<endl;
} | replace | 115 | 116 | 115 | 116 | -11 | |
p02763 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define INF 1LL << 62
#define inf 1000000007
int main() {
ll n;
string s;
vector<set<ll>> a(26);
cin >> n >> s;
ll m;
cin >> m;
for (ll i = 0; i < n; i++) {
ll now = s[i] - 'a';
a[now].insert(i);
// cout <<now<< " "<<i<<endl;
}
for (ll i = 0; i < m; i++) {
ll now;
cin >> now;
// cout << now<<" ";
if (now == 2) {
ll cnt = 0;
ll l, r;
cin >> l >> r;
l--;
r--;
for (ll j = 0; j < 26; j++) {
auto itr = lower_bound(a[j].begin(), a[j].end(), l);
// cout << *itr<< "itr"<<j<<"j"<<endl;
if (itr != a[j].end() && *itr <= r) {
cnt++;
}
}
cout << cnt << endl;
}
if (now == 1) {
ll l;
char t;
cin >> l >> t;
l--;
ll nex = t - 'a';
ll be = s[l] - 'a';
if (nex == be) {
continue;
}
s[l] = t;
a[be].erase(l);
a[nex].insert(l);
}
}
// your code goes here
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define INF 1LL << 62
#define inf 1000000007
int main() {
ll n;
string s;
vector<set<ll>> a(26);
cin >> n >> s;
ll m;
cin >> m;
for (ll i = 0; i < n; i++) {
ll now = s[i] - 'a';
a[now].insert(i);
// cout <<now<< " "<<i<<endl;
}
for (ll i = 0; i < m; i++) {
ll now;
cin >> now;
// cout << now<<" ";
if (now == 2) {
ll cnt = 0;
ll l, r;
cin >> l >> r;
l--;
r--;
for (ll j = 0; j < 26; j++) {
auto itr = a[j].lower_bound(l);
// cout << *itr<< "itr"<<j<<"j"<<endl;
if (itr != a[j].end() && *itr <= r) {
cnt++;
}
}
cout << cnt << endl;
}
if (now == 1) {
ll l;
char t;
cin >> l >> t;
l--;
ll nex = t - 'a';
ll be = s[l] - 'a';
if (nex == be) {
continue;
}
s[l] = t;
a[be].erase(l);
a[nex].insert(l);
}
}
// your code goes here
return 0;
}
| replace | 29 | 30 | 29 | 30 | TLE | |
p02763 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int tree[1000001];
string s;
void build(int node, int start, int end) {
if (start == end) {
int r;
r = s[start - 1] - 'a';
tree[node] = 1 << r;
} else {
int mid;
mid = (start + end) / 2;
build(2 * node, start, mid);
build(2 * node + 1, mid + 1, end);
tree[node] = tree[2 * node] | tree[2 * node + 1];
}
}
void update(int node, int start, int end, int idx, char val) {
if (start == end and start == idx) {
s[idx - 1] = val;
int r;
r = val - 'a';
tree[node] = 1 << r;
} else {
int mid = (start + end) / 2;
if (idx > mid) {
update(2 * node + 1, mid + 1, end, idx, val);
} else {
update(2 * node, start, mid, idx, val);
}
tree[node] = tree[2 * node] | tree[2 * node + 1];
}
}
int query(int node, int start, int end, int l, int r) {
if (l > end or r < start) {
return 0;
} else if (l <= start and r >= end) {
return tree[node];
} else {
int mid;
mid = (start + end) / 2;
int p1 = query(2 * node, start, mid, l, r);
int p2 = query(2 * node + 1, mid + 1, end, l, r);
return p1 | p2;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
cin >> s;
int q;
cin >> q;
build(1, 1, n);
for (int i = 0; i < q; i++) {
int r;
cin >> r;
if (r == 1) {
int w;
char c;
cin >> w >> c;
update(1, 1, n, w, c);
} else {
int l, r;
cin >> l >> r;
int ans = query(1, 1, n, l, r);
int cc = 0;
while (ans > 0) {
int er;
er = ans & 1;
cc += er;
ans = ans >> 1;
}
cout << cc << "\n";
}
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int tree[3000000];
string s;
void build(int node, int start, int end) {
if (start == end) {
int r;
r = s[start - 1] - 'a';
tree[node] = 1 << r;
} else {
int mid;
mid = (start + end) / 2;
build(2 * node, start, mid);
build(2 * node + 1, mid + 1, end);
tree[node] = tree[2 * node] | tree[2 * node + 1];
}
}
void update(int node, int start, int end, int idx, char val) {
if (start == end and start == idx) {
s[idx - 1] = val;
int r;
r = val - 'a';
tree[node] = 1 << r;
} else {
int mid = (start + end) / 2;
if (idx > mid) {
update(2 * node + 1, mid + 1, end, idx, val);
} else {
update(2 * node, start, mid, idx, val);
}
tree[node] = tree[2 * node] | tree[2 * node + 1];
}
}
int query(int node, int start, int end, int l, int r) {
if (l > end or r < start) {
return 0;
} else if (l <= start and r >= end) {
return tree[node];
} else {
int mid;
mid = (start + end) / 2;
int p1 = query(2 * node, start, mid, l, r);
int p2 = query(2 * node + 1, mid + 1, end, l, r);
return p1 | p2;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
cin >> s;
int q;
cin >> q;
build(1, 1, n);
for (int i = 0; i < q; i++) {
int r;
cin >> r;
if (r == 1) {
int w;
char c;
cin >> w >> c;
update(1, 1, n, w, c);
} else {
int l, r;
cin >> l >> r;
int ans = query(1, 1, n, l, r);
int cc = 0;
while (ans > 0) {
int er;
er = ans & 1;
cc += er;
ans = ans >> 1;
}
cout << cc << "\n";
}
}
return 0;
}
| replace | 2 | 3 | 2 | 3 | 0 | |
p02763 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
const int NEUTRO = 0;
struct segmentTree {
const int NEUTRO = 0;
int n;
vector<int> st;
void init(int _) {
n = 5 * _;
st.resize(n + 1000);
for (int i = 0; i < n; ++i)
st[i] = 0;
}
void update(int pos, int value) {
for (st[pos += n] = value; pos > 1; pos >>= 1)
st[pos >> 1] = st[pos] + st[pos ^ 1];
}
// interval[l,r)
int query(int l, int r) {
int ans = NEUTRO;
r++;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1)
ans += st[l++];
if (r & 1)
ans += st[--r];
}
return ans;
}
};
segmentTree st[30];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, q;
string s;
cin >> n >> s;
for (int i = 0; i < 30; ++i)
st[i].init(n);
for (int i = 0; i < (int)s.size(); ++i) {
st[s[i] - 'a'].update(i, 1);
}
cin >> q;
while (q--) {
int c;
cin >> c;
if (c == 1) {
int p;
char x;
cin >> p >> x;
p--;
char cur = s[p];
st[cur - 'a'].update(p, 0);
s[p] = x;
st[x - 'a'].update(p, 1);
} else {
int ans = 0;
int l, r;
cin >> l >> r;
l--, r--;
for (int i = 0; i < 30; ++i)
ans += st[i].query(l, r) != 0;
cout << ans << "\n";
}
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const int NEUTRO = 0;
struct segmentTree {
const int NEUTRO = 0;
int n;
vector<int> st;
void init(int _) {
n = _;
st.resize(5 * n);
}
void update(int pos, int value) {
for (st[pos += n] = value; pos > 1; pos >>= 1)
st[pos >> 1] = st[pos] + st[pos ^ 1];
}
// interval[l,r)
int query(int l, int r) {
int ans = NEUTRO;
r++;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1)
ans += st[l++];
if (r & 1)
ans += st[--r];
}
return ans;
}
};
segmentTree st[30];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, q;
string s;
cin >> n >> s;
for (int i = 0; i < 30; ++i)
st[i].init(n);
for (int i = 0; i < (int)s.size(); ++i) {
st[s[i] - 'a'].update(i, 1);
}
cin >> q;
while (q--) {
int c;
cin >> c;
if (c == 1) {
int p;
char x;
cin >> p >> x;
p--;
char cur = s[p];
st[cur - 'a'].update(p, 0);
s[p] = x;
st[x - 'a'].update(p, 1);
} else {
int ans = 0;
int l, r;
cin >> l >> r;
l--, r--;
for (int i = 0; i < 30; ++i)
ans += st[i].query(l, r) != 0;
cout << ans << "\n";
}
}
return 0;
}
| replace | 10 | 15 | 10 | 12 | 0 | |
p02763 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cassert>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; ++i)
#define all(x) (x).begin(), (x).end()
signed main() {
int n, q;
string s;
cin >> n >> s >> q;
set<int> pos[26];
rep(i, s.size()) { pos[s[i] - 'a'].insert(i + 1); }
rep(i, q) {
int t;
cin >> t;
if (t == 1) {
int in;
char c;
cin >> in >> c;
pos[s[in - 1] - 'a'].erase(in);
pos[c - 'a'].insert(in);
s[in - 1] = c;
} else {
int l, r;
cin >> l >> r;
int ans = 0;
rep(j, 26) {
if (auto it = lower_bound(all(pos[j]), l);
it != pos[j].end() && *it <= r)
++ans;
}
cout << ans << endl;
}
}
return 0;
}
| #include <algorithm>
#include <cassert>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; ++i)
#define all(x) (x).begin(), (x).end()
signed main() {
int n, q;
string s;
cin >> n >> s >> q;
set<int> pos[26];
rep(i, s.size()) { pos[s[i] - 'a'].insert(i + 1); }
rep(i, q) {
int t;
cin >> t;
if (t == 1) {
int in;
char c;
cin >> in >> c;
pos[s[in - 1] - 'a'].erase(in);
pos[c - 'a'].insert(in);
s[in - 1] = c;
} else {
int l, r;
cin >> l >> r;
int ans = 0;
rep(j, 26) {
if (auto it = pos[j].lower_bound(l); it != pos[j].end() && *it <= r)
++ans;
}
cout << ans << endl;
}
}
return 0;
} | replace | 44 | 46 | 44 | 45 | TLE | |
p02763 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define repl(i, l, r) for (ll i = (l); i < (r); i++)
#define per(i, n) for (ll i = n - 1; i >= 0; i--)
#define perl(i, r, l) for (ll i = r - 1; i >= l; i--)
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define ins insert
#define pqueue(x) priority_queue<x, vector<x>, greater<x>>
#define all(x) (x).begin(), (x).end()
#define CST(x) cout << fixed << setprecision(x)
#define vtpl(x, y, z) vector<tuple<x, y, z>>
#define rev(x) reverse(x);
using ll = long long;
using vl = vector<ll>;
using vvl = vector<vector<ll>>;
using pl = pair<ll, ll>;
using vpl = vector<pl>;
using vvpl = vector<vpl>;
const ll MOD = 1000000007;
const ll MOD9 = 998244353;
const int inf = 1e9 + 10;
const ll INF = 4e18;
const ll dy[8] = {1, 0, -1, 0, 1, 1, -1, -1};
const ll dx[8] = {0, -1, 0, 1, 1, -1, 1, -1};
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int main() {
ll n;
cin >> n;
string s;
cin >> s;
vector<set<ll>> v(26);
rep(i, n) {
ll a = s[i] - 'a';
v[a].ins(i);
}
ll q;
cin >> q;
rep(i, q) {
ll type;
cin >> type;
if (type == 1) {
ll b;
cin >> b;
b--;
char c;
cin >> c;
v[s[b] - 'a'].erase(b);
v[c - 'a'].insert(b);
s[b] = c;
} else {
ll b, c;
cin >> b >> c;
b--;
c--;
ll k = 0;
rep(j, 26) {
auto iter = lower_bound(all(v[j]), b);
if (iter != v[j].end()) {
if (*iter <= c)
k++;
}
}
cout << k << endl;
}
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define repl(i, l, r) for (ll i = (l); i < (r); i++)
#define per(i, n) for (ll i = n - 1; i >= 0; i--)
#define perl(i, r, l) for (ll i = r - 1; i >= l; i--)
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define ins insert
#define pqueue(x) priority_queue<x, vector<x>, greater<x>>
#define all(x) (x).begin(), (x).end()
#define CST(x) cout << fixed << setprecision(x)
#define vtpl(x, y, z) vector<tuple<x, y, z>>
#define rev(x) reverse(x);
using ll = long long;
using vl = vector<ll>;
using vvl = vector<vector<ll>>;
using pl = pair<ll, ll>;
using vpl = vector<pl>;
using vvpl = vector<vpl>;
const ll MOD = 1000000007;
const ll MOD9 = 998244353;
const int inf = 1e9 + 10;
const ll INF = 4e18;
const ll dy[8] = {1, 0, -1, 0, 1, 1, -1, -1};
const ll dx[8] = {0, -1, 0, 1, 1, -1, 1, -1};
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int main() {
ll n;
cin >> n;
string s;
cin >> s;
vector<set<ll>> v(26);
rep(i, n) {
ll a = s[i] - 'a';
v[a].ins(i);
}
ll q;
cin >> q;
rep(i, q) {
ll type;
cin >> type;
if (type == 1) {
ll b;
cin >> b;
b--;
char c;
cin >> c;
v[s[b] - 'a'].erase(b);
v[c - 'a'].insert(b);
s[b] = c;
} else {
ll b, c;
cin >> b >> c;
b--;
c--;
ll k = 0;
rep(j, 26) {
auto iter = v[j].lower_bound(b);
if (iter != v[j].end()) {
if (*iter <= c)
k++;
}
}
cout << k << endl;
}
}
return 0;
} | replace | 73 | 74 | 73 | 74 | TLE | |
p02763 | C++ | Time Limit Exceeded |
#include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const ll MOD_CONST = 1000000007;
const ll BIG_NUM = 1000000000000000000;
const int BIG_INT = 1000000000;
int main() {
int n, q;
string s;
cin >> n >> s >> q;
vector<set<int>> v(26);
for (int i = 0; i < n; i++) {
v[s[i] - 'a'].insert(i);
}
for (int i = 0; i < q; i++) {
int a;
cin >> a;
if (a == 1) {
int id;
char c;
cin >> id >> c;
id--;
int num = s[id] - 'a';
s[id] = c;
c -= 'a';
v[num].erase(id);
v[c].insert(id);
} else {
int l, r;
cin >> l >> r;
l--;
r--;
int cnt = 0;
for (int j = 0; j < 26; j++) {
auto it = lower_bound(v[j].begin(), v[j].end(), l);
if (it != v[j].end() && *it <= r) {
cnt++;
}
}
cout << cnt << endl;
}
}
}
|
#include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const ll MOD_CONST = 1000000007;
const ll BIG_NUM = 1000000000000000000;
const int BIG_INT = 1000000000;
int main() {
int n, q;
string s;
cin >> n >> s >> q;
vector<set<int>> v(26);
for (int i = 0; i < n; i++) {
v[s[i] - 'a'].insert(i);
}
for (int i = 0; i < q; i++) {
int a;
cin >> a;
if (a == 1) {
int id;
char c;
cin >> id >> c;
id--;
int num = s[id] - 'a';
s[id] = c;
c -= 'a';
v[num].erase(id);
v[c].insert(id);
} else {
int l, r;
cin >> l >> r;
l--;
r--;
int cnt = 0;
for (int j = 0; j < 26; j++) {
auto it = v[j].lower_bound(l);
if (it != v[j].end() && *it <= r) {
cnt++;
}
}
cout << cnt << endl;
}
}
}
| replace | 60 | 61 | 60 | 61 | TLE | |
p02763 | C++ | Runtime Error | // #include <tourist>
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> p;
const int INF = 1e9;
const ll LINF = ll(1e18) + 1;
const int MOD = 1000000007;
const int dx[4] = {0, 1, 0, -1}, dy[4] = {-1, 0, 1, 0};
const int Dx[8] = {0, 1, 1, 1, 0, -1, -1, -1},
Dy[8] = {-1, -1, 0, 1, 1, 1, 0, -1};
#define yes cout << "Yes" << endl
#define YES cout << "YES" << endl
#define no cout << "No" << endl
#define NO cout << "NO" << endl
#define rep(i, n) for (int i = 0; i < n; i++)
#define ALL(v) v.begin(), v.end()
#define debug(v) \
cout << #v << ":"; \
for (auto x : v) { \
cout << x << ' '; \
} \
cout << endl;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
// cout<<fixed<<setprecision(15);有効数字15桁
//-std=c++14
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
int n, m;
vector<int> a;
// 区間和
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
int N, Q;
struct LazySegmentTree {
private:
int n;
vector<ll> node, lazy;
public:
LazySegmentTree(vector<ll> v) {
int sz = (int)v.size();
n = 1;
while (n < sz)
n *= 2;
node.resize(2 * n - 1);
lazy.resize(2 * n - 1, 0);
for (int i = 0; i < sz; i++)
node[i + n - 1] = v[i];
for (int i = n - 2; i >= 0; i--)
node[i] = node[i * 2 + 1] + node[i * 2 + 2];
}
void eval(int k, int l, int r) {
if (lazy[k] != 0) {
node[k] += lazy[k];
if (r - l > 1) {
lazy[2 * k + 1] += lazy[k] / 2;
lazy[2 * k + 2] += lazy[k] / 2;
}
lazy[k] = 0;
}
}
void add(int a, int b, ll x, int k = 0, int l = 0, int r = -1) {
if (r < 0)
r = n;
eval(k, l, r);
if (b <= l || r <= a)
return;
if (a <= l && r <= b) {
lazy[k] += (r - l) * x;
eval(k, l, r);
} else {
add(a, b, x, 2 * k + 1, l, (l + r) / 2);
add(a, b, x, 2 * k + 2, (l + r) / 2, r);
node[k] = node[2 * k + 1] + node[2 * k + 2];
}
}
ll getsum(int a, int b, int k = 0, int l = 0, int r = -1) {
if (r < 0)
r = n;
eval(k, l, r);
if (b <= l || r <= a)
return 0;
if (a <= l && r <= b)
return node[k];
ll vl = getsum(a, b, 2 * k + 1, l, (l + r) / 2);
ll vr = getsum(a, b, 2 * k + 2, (l + r) / 2, r);
return vl + vr;
}
};
string s;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> s;
vector<LazySegmentTree> seg(26, LazySegmentTree(vector<ll>(n + 2, 0)));
for (int i = 0; i < n; i++) {
int j = s[i] - 'a';
seg[j].add(i, n, 1);
}
cin >> m;
vector<int> ans;
for (int i = 0; i < m; i++) {
int flag;
cin >> flag;
if (flag == 1) {
int temp;
char temp1;
cin >> temp >> temp1;
temp--;
char temp2 = s[temp];
int j = temp1 - 'a';
int j1 = temp2 - 'a';
s[i] = temp1;
seg[j].add(temp, n, 1);
seg[j1].add(temp, n, -1);
} else {
int temp;
int temp1;
cin >> temp >> temp1;
temp--;
temp1--;
int count = 0;
// cout<<s<<"\n";
for (int j = 0; j < 26; j++) {
int sum =
seg[j].getsum(temp1, temp1 + 1) - seg[j].getsum(temp - 1, temp);
// cout<<sum<<" ";
if (sum > 0) {
count++;
}
}
// cout<<"\n";
ans.push_back(count);
}
}
rep(i, ans.size()) { cout << ans[i] << "\n"; }
}
| // #include <tourist>
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> p;
const int INF = 1e9;
const ll LINF = ll(1e18) + 1;
const int MOD = 1000000007;
const int dx[4] = {0, 1, 0, -1}, dy[4] = {-1, 0, 1, 0};
const int Dx[8] = {0, 1, 1, 1, 0, -1, -1, -1},
Dy[8] = {-1, -1, 0, 1, 1, 1, 0, -1};
#define yes cout << "Yes" << endl
#define YES cout << "YES" << endl
#define no cout << "No" << endl
#define NO cout << "NO" << endl
#define rep(i, n) for (int i = 0; i < n; i++)
#define ALL(v) v.begin(), v.end()
#define debug(v) \
cout << #v << ":"; \
for (auto x : v) { \
cout << x << ' '; \
} \
cout << endl;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
// cout<<fixed<<setprecision(15);有効数字15桁
//-std=c++14
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
int n, m;
vector<int> a;
// 区間和
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
int N, Q;
struct LazySegmentTree {
private:
int n;
vector<ll> node, lazy;
public:
LazySegmentTree(vector<ll> v) {
int sz = (int)v.size();
n = 1;
while (n < sz)
n *= 2;
node.resize(2 * n - 1);
lazy.resize(2 * n - 1, 0);
for (int i = 0; i < sz; i++)
node[i + n - 1] = v[i];
for (int i = n - 2; i >= 0; i--)
node[i] = node[i * 2 + 1] + node[i * 2 + 2];
}
void eval(int k, int l, int r) {
if (lazy[k] != 0) {
node[k] += lazy[k];
if (r - l > 1) {
lazy[2 * k + 1] += lazy[k] / 2;
lazy[2 * k + 2] += lazy[k] / 2;
}
lazy[k] = 0;
}
}
void add(int a, int b, ll x, int k = 0, int l = 0, int r = -1) {
if (r < 0)
r = n;
eval(k, l, r);
if (b <= l || r <= a)
return;
if (a <= l && r <= b) {
lazy[k] += (r - l) * x;
eval(k, l, r);
} else {
add(a, b, x, 2 * k + 1, l, (l + r) / 2);
add(a, b, x, 2 * k + 2, (l + r) / 2, r);
node[k] = node[2 * k + 1] + node[2 * k + 2];
}
}
ll getsum(int a, int b, int k = 0, int l = 0, int r = -1) {
if (r < 0)
r = n;
eval(k, l, r);
if (b <= l || r <= a)
return 0;
if (a <= l && r <= b)
return node[k];
ll vl = getsum(a, b, 2 * k + 1, l, (l + r) / 2);
ll vr = getsum(a, b, 2 * k + 2, (l + r) / 2, r);
return vl + vr;
}
};
string s;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> s;
vector<LazySegmentTree> seg(26, LazySegmentTree(vector<ll>(n + 2, 0)));
for (int i = 0; i < n; i++) {
int j = s[i] - 'a';
seg[j].add(i, n, 1);
}
cin >> m;
vector<int> ans;
for (int i = 0; i < m; i++) {
int flag;
cin >> flag;
if (flag == 1) {
int temp;
char temp1;
cin >> temp >> temp1;
temp--;
char temp2 = s[temp];
int j = temp1 - 'a';
int j1 = temp2 - 'a';
s[temp] = temp1;
seg[j].add(temp, n, 1);
seg[j1].add(temp, n, -1);
} else {
int temp;
int temp1;
cin >> temp >> temp1;
temp--;
temp1--;
int count = 0;
// cout<<s<<"\n";
for (int j = 0; j < 26; j++) {
int sum =
seg[j].getsum(temp1, temp1 + 1) - seg[j].getsum(temp - 1, temp);
// cout<<sum<<" ";
if (sum > 0) {
count++;
}
}
// cout<<"\n";
ans.push_back(count);
}
}
rep(i, ans.size()) { cout << ans[i] << "\n"; }
}
| replace | 133 | 134 | 133 | 134 | 0 | |
p02763 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using namespace std;
// segtree code from : https://codeforces.com/blog/entry/18051
const int N = 1e5 + 5; // limit for array size
const int AL = 26; // alphabet size
int n; // array size
int t[AL][2 * N];
void build() { // build the tree
for (int i = 0; i < AL; i++) {
for (int j = n - 1; j > 0; --j)
t[i][j] = t[i][j << 1] + t[i][j << 1 | 1];
}
}
void modify(int p, int v) { // set value at position p
int o_p = p;
for (int i = 0; i < AL; i++) {
p = o_p;
if (i == v)
continue;
for (t[i][p += n] = 0; p > 1; p >>= 1)
t[i][p >> 1] = t[i][p] + t[i][p ^ 1];
}
p = o_p;
for (t[v][p += n] = 1; p > 1; p >>= 1)
t[v][p >> 1] = t[v][p] + t[v][p ^ 1];
}
int query(int l, int r) { // sum on interval [l, r)
int ans = 0;
int o_l = l, o_r = r;
for (int i = 0; i < AL; i++) {
int res = 0;
l = o_l;
r = o_r;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1)
res += t[i][l++];
if (r & 1)
res += t[i][--r];
}
if (res > 0)
++ans;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
string s;
cin >> s;
for (int i = 0; i < n; i++) {
int v = s[i] - 'a';
t[v][n + i] = 1;
}
build();
int q;
cin >> q;
while (q--) {
int x, l, r;
cin >> x >> l;
if (x == 1) {
char c;
cin >> c;
int v = c - 'a';
modify(l - 1, v);
} else {
cin >> r;
cout << query(l - 1, r) << "\n";
}
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using namespace std;
// segtree code from : https://codeforces.com/blog/entry/18051
const int N = 5e5 + 5; // limit for array size
const int AL = 26; // alphabet size
int n; // array size
int t[AL][2 * N];
void build() { // build the tree
for (int i = 0; i < AL; i++) {
for (int j = n - 1; j > 0; --j)
t[i][j] = t[i][j << 1] + t[i][j << 1 | 1];
}
}
void modify(int p, int v) { // set value at position p
int o_p = p;
for (int i = 0; i < AL; i++) {
p = o_p;
if (i == v)
continue;
for (t[i][p += n] = 0; p > 1; p >>= 1)
t[i][p >> 1] = t[i][p] + t[i][p ^ 1];
}
p = o_p;
for (t[v][p += n] = 1; p > 1; p >>= 1)
t[v][p >> 1] = t[v][p] + t[v][p ^ 1];
}
int query(int l, int r) { // sum on interval [l, r)
int ans = 0;
int o_l = l, o_r = r;
for (int i = 0; i < AL; i++) {
int res = 0;
l = o_l;
r = o_r;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1)
res += t[i][l++];
if (r & 1)
res += t[i][--r];
}
if (res > 0)
++ans;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
string s;
cin >> s;
for (int i = 0; i < n; i++) {
int v = s[i] - 'a';
t[v][n + i] = 1;
}
build();
int q;
cin >> q;
while (q--) {
int x, l, r;
cin >> x >> l;
if (x == 1) {
char c;
cin >> c;
int v = c - 'a';
modify(l - 1, v);
} else {
cin >> r;
cout << query(l - 1, r) << "\n";
}
}
return 0;
} | replace | 7 | 8 | 7 | 8 | 0 | |
p02763 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <utility>
#include <vector>
typedef long long ll;
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
ll intpow(int n, int m) {
if (m == 0)
return 1;
return n * intpow(n, m - 1);
}
ll gcd(ll n, ll m) {
n = max(n, m);
m = min(n, m);
if (n % m == 0)
return m;
return gcd(m, n % m);
}
ll lcm(ll n, ll m) { return n * m / gcd(n, m); }
const int inf = 2147483647;
int n;
bool node[1000000][26];
void init(int n_) {
while (n < n_)
n *= 2;
rep(i, 2 * n - 1) { rep(j, 26) node[i][j] = 0; }
}
void update(int i, char a, char b) {
i += n - 1;
int m1 = a - 97;
int m2 = b - 97;
node[i][m1] = 0;
node[i][m2] = 1;
while (i > 0) {
i = (i - 1) / 2;
node[i][m1] = node[i * 2 + 1][m1] || node[i * 2 + 2][m1];
node[i][m2] = node[i * 2 + 1][m2] || node[i * 2 + 2][m2];
}
}
int query(int a, int b, int k, int l, int r, int c) {
if (r <= a || b <= l)
return 0;
if (a <= l && r <= b)
return node[k][c];
else {
bool vl = query(a, b, k * 2 + 1, l, (l + r) / 2, c);
bool vr = query(a, b, k * 2 + 2, (l + r) / 2, r, c);
return vl || vr;
}
}
int main() {
int N, q;
cin >> N;
string s;
cin >> s;
cin >> q;
n = 1;
init(s.size());
rep(i, s.size()) update(i, 'a', s[i]);
rep(i, q) {
int type;
cin >> type;
if (type == 1) {
int j;
char c;
cin >> j >> c;
j--;
update(j, s[j], c);
s.replace(j, 1, 1, c);
}
if (type == 2) {
int l, r;
cin >> l >> r;
int sum = 0;
rep(j, 26) sum += query(l - 1, r, 0, 0, n, j);
cout << sum << endl;
}
}
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <utility>
#include <vector>
typedef long long ll;
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
ll intpow(int n, int m) {
if (m == 0)
return 1;
return n * intpow(n, m - 1);
}
ll gcd(ll n, ll m) {
n = max(n, m);
m = min(n, m);
if (n % m == 0)
return m;
return gcd(m, n % m);
}
ll lcm(ll n, ll m) { return n * m / gcd(n, m); }
const int inf = 2147483647;
int n;
bool node[2000000][26];
void init(int n_) {
while (n < n_)
n *= 2;
rep(i, 2 * n - 1) { rep(j, 26) node[i][j] = 0; }
}
void update(int i, char a, char b) {
i += n - 1;
int m1 = a - 97;
int m2 = b - 97;
node[i][m1] = 0;
node[i][m2] = 1;
while (i > 0) {
i = (i - 1) / 2;
node[i][m1] = node[i * 2 + 1][m1] || node[i * 2 + 2][m1];
node[i][m2] = node[i * 2 + 1][m2] || node[i * 2 + 2][m2];
}
}
int query(int a, int b, int k, int l, int r, int c) {
if (r <= a || b <= l)
return 0;
if (a <= l && r <= b)
return node[k][c];
else {
bool vl = query(a, b, k * 2 + 1, l, (l + r) / 2, c);
bool vr = query(a, b, k * 2 + 2, (l + r) / 2, r, c);
return vl || vr;
}
}
int main() {
int N, q;
cin >> N;
string s;
cin >> s;
cin >> q;
n = 1;
init(s.size());
rep(i, s.size()) update(i, 'a', s[i]);
rep(i, q) {
int type;
cin >> type;
if (type == 1) {
int j;
char c;
cin >> j >> c;
j--;
update(j, s[j], c);
s.replace(j, 1, 1, c);
}
if (type == 2) {
int l, r;
cin >> l >> r;
int sum = 0;
rep(j, 26) sum += query(l - 1, r, 0, 0, n, j);
cout << sum << endl;
}
}
} | replace | 27 | 28 | 27 | 28 | 0 | |
p02763 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define BIT(n) (1LL << (n))
#define BITF(n, i) (((n) >> (i)) & 1)
#define REP(i, n) for (int i = 0; i < n; i++)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define REPI(i, x) for (int i = 1; i <= x; i++)
#define FORI(i, m, n) for (int i = m; i <= n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define REPZ(i, x) for (int i = 0; i <= x; i++)
#define FORA(i, n) for (auto &&i : n)
#define POW(a, b) ((int)(pow(a, b) + .5))
#define MODULO(a, b) (((a) % (b)) < 0 ? (a) % (b) + (b) : (a) % (b))
#define DUMPOUT cerr
// vector
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
for (T &x : vec)
is >> x;
return is;
}
// pair
template <typename T, typename U>
ostream &operator<<(ostream &os, pair<T, U> &pair_var) {
os << "(" << pair_var.first << ", " << pair_var.second << ")";
return os;
}
// vector
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "{";
REP(i, (int)vec.size())
os << vec[i] << (i + 1 == (int)vec.size() ? "" : ", ");
os << "}";
return os;
}
// map
template <typename T, typename U>
ostream &operator<<(ostream &os, map<T, U> &map_var) {
os << "{";
FORA(itr, map_var) {
os << *itr;
itr++;
if (itr != map_var.end())
os << ", ";
itr--;
}
os << "}";
return os;
}
// set
template <typename T> ostream &operator<<(ostream &os, set<T> &set_var) {
os << "{";
FORA(itr, set_var) {
os << *itr;
itr++;
if (itr != set_var.end())
os << ", ";
itr--;
}
os << "}";
return os;
}
void dump_func() { DUMPOUT << endl; }
template <class Head, class... Tail>
void dump_func(Head &&head, Tail &&...tail) {
DUMPOUT << head;
if (sizeof...(Tail) > 0)
DUMPOUT << ", ";
dump_func(std::move(tail)...);
}
#ifdef DEBUG_
#define DEB
#define DUMP(...) \
DUMPOUT << " " << string(#__VA_ARGS__) << ": " \
<< "[" << to_string(__LINE__) << ":" << __FUNCTION__ << "]" << endl \
<< " ", \
dump_func(__VA_ARGS__)
#define PRINTARR(x, y) \
cerr << #x << "=\n"; \
for (auto itr = x; itr != y; itr++) \
cerr << *itr << " "; \
cerr << endl;
#define PRINTARR2(x, i0, i1) \
cerr << #x << "=\n"; \
for (int ii0 = 0; ii0 < i0; ii0++) { \
for (int ii1 = 0; ii1 < i1; ii1++) \
cerr << x[ii0][ii1] << " "; \
cerr << endl; \
}
#else
#define DEB if (false)
#define DUMP(...)
#define PRINTARR(x, y)
#define PRINTARR2(x, i0, i1)
#endif
#define ALL(v) v.begin(), v.end()
#define fst first
#define snd second
#define mp make_pair
#define pb push_back
#define epb emplace_back
#define int long long
#define pint pair<int, int>
#define ld long double
using namespace std;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T> using vec = std::vector<T>;
template <class T> void print(const T &x) { cout << x << "\n"; }
const int MOD = 1000000007, INF0 = 1061109567, INF = INF0 * INF0;
const double EPS = 1e-10, PI = acos(-1.0);
const int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
/*
[&] { return;
}();下のスラッシュを2つ追加しただけ.上のスラッシュを2つにすれば外れる.
//*/
// http://drken1215.hatenablog.com/entry/2018/09/08/011500
/*
実装では木を1-indexedの配列で表現している。
ノードkについて,親ノードはk2,子ノードは2k,2k+1である。
SegmentTree(n,f,M1):=サイズnの初期化。ここでfは2つの区間の要素をマージする二項演算,M1はモノイドの単位元である。
set(k,x):=k番目の要素にxを代入する。
build():=セグメント木を構築する。
query(a,b):=区間[a,b)に対して二項演算した結果を返す。
update(k,x):=k番目の要素をxに変更する。
operator[k]:=k番目の要素を返す。
find_first(a,check):=[a,x)がcheckを満たす最初の要素位置xを返す。
find_last(b,check):=[x,b)がcheckを満たす最後の要素位置xを返す。*/
template <typename Monoid> struct SegmentTree {
using F = function<Monoid(Monoid, Monoid)>;
int sz;
vector<Monoid> seg;
const F f;
const Monoid M1;
SegmentTree(int n, const F f, const Monoid &M1) : f(f), M1(M1) {
sz = 1;
while (sz < n)
sz <<= 1;
seg.assign(2 * sz, M1);
}
void set(int k, const Monoid &x) { seg[k + sz] = x; }
void build() {
for (int k = sz - 1; k > 0; k--) {
seg[k] = f(seg[2 * k + 0], seg[2 * k + 1]);
}
}
void update(int k, const Monoid &x) {
k += sz;
seg[k] = x;
while (k >>= 1) {
seg[k] = f(seg[2 * k + 0], seg[2 * k + 1]);
}
}
Monoid query(int a, int b) {
Monoid L = M1, R = M1;
for (a += sz, b += sz; a < b; a >>= 1, b >>= 1) {
if (a & 1)
L = f(L, seg[a++]);
if (b & 1)
R = f(seg[--b], R);
}
return f(L, R);
}
Monoid operator[](const int &k) const { return seg[k + sz]; }
template <typename C>
int find_subtree(int a, const C &check, Monoid &M, bool type) {
while (a < sz) {
Monoid nxt = type ? f(seg[2 * a + type], M) : f(M, seg[2 * a + type]);
if (check(nxt))
a = 2 * a + type;
else
M = nxt, a = 2 * a + 1 - type;
}
return a - sz;
}
template <typename C> int find_first(int a, const C &check) {
Monoid L = M1;
if (a <= 0) {
if (check(f(L, seg[1])))
return find_subtree(1, check, L, false);
return -1;
}
int b = sz;
for (a += sz, b += sz; a < b; a >>= 1, b >>= 1) {
if (a & 1) {
Monoid nxt = f(L, seg[a]);
if (check(nxt))
return find_subtree(a, check, L, false);
L = nxt;
++a;
}
}
return -1;
}
template <typename C> int find_last(int b, const C &check) {
Monoid R = M1;
if (b >= sz) {
if (check(f(seg[1], R)))
return find_subtree(1, check, R, true);
return -1;
}
int a = sz;
for (b += sz; a < b; a >>= 1, b >>= 1) {
if (b & 1) {
Monoid nxt = f(seg[--b], R);
if (check(nxt))
return find_subtree(b, check, R, true);
R = nxt;
}
}
return -1;
}
};
#define MAXN 200100
signed main() {
cin.tie(0), ios::sync_with_stdio(false);
cout << fixed << setprecision(12);
int N, Q;
string S;
cin >> N >> S >> Q;
SegmentTree<int> seg(
MAXN, [](int a, int b) { return a | b; },
0ll); // INT_MAX =>min(a,INT_MAX)=min(INT_MAX,a)=aより
seg.build();
REP(i, N) {
int pos = BIT(S[i] - 'a');
seg.update(i + 1, pos);
}
// return 0;
int p, q;
REP(i, Q) {
cin >> p >> q;
if (p == 1) {
char r;
cin >> r;
int pos = BIT(r - 'a');
// S[q] = r;
seg.update(q, pos);
} else if (p == 2) {
int r;
cin >> r;
r++;
int ret = seg.query(q, r);
// REP(j, 26){int pos = upper_bound(a[j], a[j] +)} print(cnt);
print(__builtin_popcountll(ret));
}
}
} | #include <bits/stdc++.h>
using namespace std;
#define BIT(n) (1LL << (n))
#define BITF(n, i) (((n) >> (i)) & 1)
#define REP(i, n) for (int i = 0; i < n; i++)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define REPI(i, x) for (int i = 1; i <= x; i++)
#define FORI(i, m, n) for (int i = m; i <= n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define REPZ(i, x) for (int i = 0; i <= x; i++)
#define FORA(i, n) for (auto &&i : n)
#define POW(a, b) ((int)(pow(a, b) + .5))
#define MODULO(a, b) (((a) % (b)) < 0 ? (a) % (b) + (b) : (a) % (b))
#define DUMPOUT cerr
// vector
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
for (T &x : vec)
is >> x;
return is;
}
// pair
template <typename T, typename U>
ostream &operator<<(ostream &os, pair<T, U> &pair_var) {
os << "(" << pair_var.first << ", " << pair_var.second << ")";
return os;
}
// vector
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "{";
REP(i, (int)vec.size())
os << vec[i] << (i + 1 == (int)vec.size() ? "" : ", ");
os << "}";
return os;
}
// map
template <typename T, typename U>
ostream &operator<<(ostream &os, map<T, U> &map_var) {
os << "{";
FORA(itr, map_var) {
os << *itr;
itr++;
if (itr != map_var.end())
os << ", ";
itr--;
}
os << "}";
return os;
}
// set
template <typename T> ostream &operator<<(ostream &os, set<T> &set_var) {
os << "{";
FORA(itr, set_var) {
os << *itr;
itr++;
if (itr != set_var.end())
os << ", ";
itr--;
}
os << "}";
return os;
}
void dump_func() { DUMPOUT << endl; }
template <class Head, class... Tail>
void dump_func(Head &&head, Tail &&...tail) {
DUMPOUT << head;
if (sizeof...(Tail) > 0)
DUMPOUT << ", ";
dump_func(std::move(tail)...);
}
#ifdef DEBUG_
#define DEB
#define DUMP(...) \
DUMPOUT << " " << string(#__VA_ARGS__) << ": " \
<< "[" << to_string(__LINE__) << ":" << __FUNCTION__ << "]" << endl \
<< " ", \
dump_func(__VA_ARGS__)
#define PRINTARR(x, y) \
cerr << #x << "=\n"; \
for (auto itr = x; itr != y; itr++) \
cerr << *itr << " "; \
cerr << endl;
#define PRINTARR2(x, i0, i1) \
cerr << #x << "=\n"; \
for (int ii0 = 0; ii0 < i0; ii0++) { \
for (int ii1 = 0; ii1 < i1; ii1++) \
cerr << x[ii0][ii1] << " "; \
cerr << endl; \
}
#else
#define DEB if (false)
#define DUMP(...)
#define PRINTARR(x, y)
#define PRINTARR2(x, i0, i1)
#endif
#define ALL(v) v.begin(), v.end()
#define fst first
#define snd second
#define mp make_pair
#define pb push_back
#define epb emplace_back
#define int long long
#define pint pair<int, int>
#define ld long double
using namespace std;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T> using vec = std::vector<T>;
template <class T> void print(const T &x) { cout << x << "\n"; }
const int MOD = 1000000007, INF0 = 1061109567, INF = INF0 * INF0;
const double EPS = 1e-10, PI = acos(-1.0);
const int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
/*
[&] { return;
}();下のスラッシュを2つ追加しただけ.上のスラッシュを2つにすれば外れる.
//*/
// http://drken1215.hatenablog.com/entry/2018/09/08/011500
/*
実装では木を1-indexedの配列で表現している。
ノードkについて,親ノードはk2,子ノードは2k,2k+1である。
SegmentTree(n,f,M1):=サイズnの初期化。ここでfは2つの区間の要素をマージする二項演算,M1はモノイドの単位元である。
set(k,x):=k番目の要素にxを代入する。
build():=セグメント木を構築する。
query(a,b):=区間[a,b)に対して二項演算した結果を返す。
update(k,x):=k番目の要素をxに変更する。
operator[k]:=k番目の要素を返す。
find_first(a,check):=[a,x)がcheckを満たす最初の要素位置xを返す。
find_last(b,check):=[x,b)がcheckを満たす最後の要素位置xを返す。*/
template <typename Monoid> struct SegmentTree {
using F = function<Monoid(Monoid, Monoid)>;
int sz;
vector<Monoid> seg;
const F f;
const Monoid M1;
SegmentTree(int n, const F f, const Monoid &M1) : f(f), M1(M1) {
sz = 1;
while (sz < n)
sz <<= 1;
seg.assign(2 * sz, M1);
}
void set(int k, const Monoid &x) { seg[k + sz] = x; }
void build() {
for (int k = sz - 1; k > 0; k--) {
seg[k] = f(seg[2 * k + 0], seg[2 * k + 1]);
}
}
void update(int k, const Monoid &x) {
k += sz;
seg[k] = x;
while (k >>= 1) {
seg[k] = f(seg[2 * k + 0], seg[2 * k + 1]);
}
}
Monoid query(int a, int b) {
Monoid L = M1, R = M1;
for (a += sz, b += sz; a < b; a >>= 1, b >>= 1) {
if (a & 1)
L = f(L, seg[a++]);
if (b & 1)
R = f(seg[--b], R);
}
return f(L, R);
}
Monoid operator[](const int &k) const { return seg[k + sz]; }
template <typename C>
int find_subtree(int a, const C &check, Monoid &M, bool type) {
while (a < sz) {
Monoid nxt = type ? f(seg[2 * a + type], M) : f(M, seg[2 * a + type]);
if (check(nxt))
a = 2 * a + type;
else
M = nxt, a = 2 * a + 1 - type;
}
return a - sz;
}
template <typename C> int find_first(int a, const C &check) {
Monoid L = M1;
if (a <= 0) {
if (check(f(L, seg[1])))
return find_subtree(1, check, L, false);
return -1;
}
int b = sz;
for (a += sz, b += sz; a < b; a >>= 1, b >>= 1) {
if (a & 1) {
Monoid nxt = f(L, seg[a]);
if (check(nxt))
return find_subtree(a, check, L, false);
L = nxt;
++a;
}
}
return -1;
}
template <typename C> int find_last(int b, const C &check) {
Monoid R = M1;
if (b >= sz) {
if (check(f(seg[1], R)))
return find_subtree(1, check, R, true);
return -1;
}
int a = sz;
for (b += sz; a < b; a >>= 1, b >>= 1) {
if (b & 1) {
Monoid nxt = f(seg[--b], R);
if (check(nxt))
return find_subtree(b, check, R, true);
R = nxt;
}
}
return -1;
}
};
#define MAXN 500100
signed main() {
cin.tie(0), ios::sync_with_stdio(false);
cout << fixed << setprecision(12);
int N, Q;
string S;
cin >> N >> S >> Q;
SegmentTree<int> seg(
MAXN, [](int a, int b) { return a | b; },
0ll); // INT_MAX =>min(a,INT_MAX)=min(INT_MAX,a)=aより
seg.build();
REP(i, N) {
int pos = BIT(S[i] - 'a');
seg.update(i + 1, pos);
}
// return 0;
int p, q;
REP(i, Q) {
cin >> p >> q;
if (p == 1) {
char r;
cin >> r;
int pos = BIT(r - 'a');
// S[q] = r;
seg.update(q, pos);
} else if (p == 2) {
int r;
cin >> r;
r++;
int ret = seg.query(q, r);
// REP(j, 26){int pos = upper_bound(a[j], a[j] +)} print(cnt);
print(__builtin_popcountll(ret));
}
}
} | replace | 236 | 237 | 236 | 237 | 0 | |
p02763 | C++ | Runtime Error | #include "bits/stdc++.h"
using namespace std;
set<int> tp[26];
void rem(int a, int pos) {
assert(tp[a].find(pos) != tp[a].end());
tp[a].erase(pos);
}
void add(int a, int pos) { tp[a].insert(pos); }
int cdis(int l, int r) {
int c = 0;
for (int i = 0; i < 26; i++) {
set<int>::iterator e = tp[i].lower_bound(l);
if (e != tp[i].end() && *e <= r)
c++;
}
return c;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, q;
string s;
cin >> n >> s >> q;
for (int i = 0; i < n; i++) {
tp[s[i] - 'a'].insert(i);
}
for (int T = 0; T < q; T++) {
int t;
cin >> t;
if (t == 1) {
int i;
string t;
cin >> i >> t;
i--;
rem(s[i] - 'a', i);
add(t[0] - 'a', i);
} else {
int l, r;
cin >> l >> r;
l--;
r--;
cout << cdis(l, r) << endl;
}
}
}
| #include "bits/stdc++.h"
using namespace std;
set<int> tp[26];
void rem(int a, int pos) {
assert(tp[a].find(pos) != tp[a].end());
tp[a].erase(pos);
}
void add(int a, int pos) { tp[a].insert(pos); }
int cdis(int l, int r) {
int c = 0;
for (int i = 0; i < 26; i++) {
set<int>::iterator e = tp[i].lower_bound(l);
if (e != tp[i].end() && *e <= r)
c++;
}
return c;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, q;
string s;
cin >> n >> s >> q;
for (int i = 0; i < n; i++) {
tp[s[i] - 'a'].insert(i);
}
for (int T = 0; T < q; T++) {
int t;
cin >> t;
if (t == 1) {
int i;
string t;
cin >> i >> t;
i--;
rem(s[i] - 'a', i);
add(t[0] - 'a', i);
s[i] = t[0];
// cout << s << endl;
} else {
int l, r;
cin >> l >> r;
l--;
r--;
cout << cdis(l, r) << endl;
}
}
}
| insert | 49 | 49 | 49 | 51 | 0 | |
p02763 | C++ | Runtime Error | #include <bits/stdc++.h>
#define int long long
#define ll long long
#define fi first
#define se second
using namespace std;
typedef pair<int, int> ii;
const ll siz = 1e5 + 10;
const ll SIZ = 1e6 + 10;
const ll mod = 1e9 + 7;
const ll maxx = 2e9;
const ll MAXX = 1e18;
int n, q, t;
string s;
int tree[26][siz];
void updatePos(int letter, int pos, int val) {
for (int i = pos; i < siz; i += i & -i)
tree[letter][i] += val;
}
int getSum(int letter, int pos) {
int sum = 0;
for (int i = pos; i > 0; i -= i & -i)
sum += tree[letter][i];
return sum;
}
int getSumRange(int letter, int start, int finish) {
return getSum(letter, finish) - getSum(letter, start - 1);
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
// freopen ("IN_4.INP", "r", stdin);
// freopen ("OUT_4.OUT", "w", stdout);
cin >> n >> s >> q;
for (int i = 1; i <= n; i++)
updatePos(s[i - 1] - 'a', i, 1);
while (q--) {
cin >> t;
if (t == 1) {
int p;
char c;
cin >> p >> c;
updatePos(s[p - 1] - 'a', p, -1);
s[p - 1] = c;
updatePos(c - 'a', p, 1);
} else {
int l, r;
cin >> l >> r;
int ans = 0;
for (int i = 0; i < 26; i++)
ans += (getSumRange(i, l, r) > 0);
cout << ans << "\n";
}
}
return 0;
}
| #include <bits/stdc++.h>
#define int long long
#define ll long long
#define fi first
#define se second
using namespace std;
typedef pair<int, int> ii;
const ll siz = 5e5 + 10;
const ll SIZ = 1e6 + 10;
const ll mod = 1e9 + 7;
const ll maxx = 2e9;
const ll MAXX = 1e18;
int n, q, t;
string s;
int tree[26][siz];
void updatePos(int letter, int pos, int val) {
for (int i = pos; i < siz; i += i & -i)
tree[letter][i] += val;
}
int getSum(int letter, int pos) {
int sum = 0;
for (int i = pos; i > 0; i -= i & -i)
sum += tree[letter][i];
return sum;
}
int getSumRange(int letter, int start, int finish) {
return getSum(letter, finish) - getSum(letter, start - 1);
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
// freopen ("IN_4.INP", "r", stdin);
// freopen ("OUT_4.OUT", "w", stdout);
cin >> n >> s >> q;
for (int i = 1; i <= n; i++)
updatePos(s[i - 1] - 'a', i, 1);
while (q--) {
cin >> t;
if (t == 1) {
int p;
char c;
cin >> p >> c;
updatePos(s[p - 1] - 'a', p, -1);
s[p - 1] = c;
updatePos(c - 'a', p, 1);
} else {
int l, r;
cin >> l >> r;
int ans = 0;
for (int i = 0; i < 26; i++)
ans += (getSumRange(i, l, r) > 0);
cout << ans << "\n";
}
}
return 0;
}
| replace | 8 | 9 | 8 | 9 | 0 | |
p02763 | C++ | Runtime Error |
#include <algorithm>
#include <functional>
#include <iomanip> //! for setprecision(10)
#include <iostream>
#include <math.h>
#include <string>
#include <vector>
#include <cstring>
#include <map>
#include <queue>
#include <set>
#include <utility>
using namespace std;
typedef long long LL;
#define dump(c) \
{ \
for (auto it = c.begin(); it != c.end(); ++it) \
if (it == c.begin()) \
cout << *it; \
else \
cout << ' ' << *it; \
cout << endl; \
}
#define rep(i, n) for (int i = 0; i < (n); ++i)
const int MOD = 1000000007;
template <typename T> struct BIT {
int n;
int mod;
std::vector<T> d;
BIT(int n = 500001, int mod = 0) : n(n), mod(mod), d(n + 1) {}
void add(int i, T x = 1) {
for (i++; i <= n; i += i & -i) {
d[i] += x;
if (mod) {
d[i] %= mod;
}
}
}
T sum(int i) {
T x = 0;
for (i++; i; i -= i & -i) {
x += d[i];
if (mod) {
x %= mod;
}
}
return x;
}
};
BIT<int> bit[26]; //! bit for a to z
int main() {
cin.tie(0);
ios::sync_with_stdio(0);
int N;
string S;
cin >> N >> S;
rep(i, N) {
int a = (S[i] - 'a');
bit[a].add(i + 1);
}
int Q;
cin >> Q;
rep(i, Q) {
int t;
cin >> t;
if (t == 1) {
int j;
string c;
cin >> j >> c;
if (S[j - 1] != c[0]) {
bit[c[0] - 'a'].add(j);
bit[S[j - 1]].add(j, -1);
}
} else if (t == 2) {
int l, r;
cin >> l >> r;
int cnt = 0;
rep(a, 26) {
int occ = bit[a].sum(r) - bit[a].sum(l - 1);
if (0 < occ) {
++cnt;
}
}
cout << cnt << '\n';
}
}
cout << endl;
return 0;
}
|
#include <algorithm>
#include <functional>
#include <iomanip> //! for setprecision(10)
#include <iostream>
#include <math.h>
#include <string>
#include <vector>
#include <cstring>
#include <map>
#include <queue>
#include <set>
#include <utility>
using namespace std;
typedef long long LL;
#define dump(c) \
{ \
for (auto it = c.begin(); it != c.end(); ++it) \
if (it == c.begin()) \
cout << *it; \
else \
cout << ' ' << *it; \
cout << endl; \
}
#define rep(i, n) for (int i = 0; i < (n); ++i)
const int MOD = 1000000007;
template <typename T> struct BIT {
int n;
int mod;
std::vector<T> d;
BIT(int n = 500001, int mod = 0) : n(n), mod(mod), d(n + 1) {}
void add(int i, T x = 1) {
for (i++; i <= n; i += i & -i) {
d[i] += x;
if (mod) {
d[i] %= mod;
}
}
}
T sum(int i) {
T x = 0;
for (i++; i; i -= i & -i) {
x += d[i];
if (mod) {
x %= mod;
}
}
return x;
}
};
BIT<int> bit[26]; //! bit for a to z
int main() {
cin.tie(0);
ios::sync_with_stdio(0);
int N;
string S;
cin >> N >> S;
rep(i, N) {
int a = (S[i] - 'a');
bit[a].add(i + 1);
}
int Q;
cin >> Q;
rep(i, Q) {
int t;
cin >> t;
if (t == 1) {
int j;
string c;
cin >> j >> c;
if (S[j - 1] != c[0]) {
int from = S[j - 1] - 'a';
int to = c[0] - 'a';
bit[from].add(j, -1);
bit[to].add(j);
S[j - 1] = c[0];
}
} else if (t == 2) {
int l, r;
cin >> l >> r;
int cnt = 0;
rep(a, 26) {
int occ = bit[a].sum(r) - bit[a].sum(l - 1);
if (0 < occ) {
++cnt;
}
}
cout << cnt << '\n';
}
}
cout << endl;
return 0;
}
| replace | 84 | 86 | 84 | 89 | 0 | |
p02763 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int N, Q;
string S;
cin >> N >> S >> Q;
vector<set<int>> vsi(26);
for (int i = 0; i < S.size(); ++i) {
vsi[S[i] - 'a'].insert(i);
}
for (int i = 0; i < Q; ++i) {
int t;
cin >> t;
if (t == 1) {
int p;
char c;
cin >> p >> c;
p--;
char sc = S[p];
vsi[sc - 'a'].erase(p);
S[p] = c;
vsi[c - 'a'].insert(p);
} else {
int l, r;
cin >> l >> r;
l--;
r--;
int ans = 0;
for (char c = 'a'; c <= 'z'; ++c) {
auto it = lower_bound(vsi[c - 'a'].begin(), vsi[c - 'a'].end(), l);
if (it != vsi[c - 'a'].end() && *it <= r)
++ans;
}
cout << ans << endl;
}
}
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int N, Q;
string S;
cin >> N >> S >> Q;
vector<set<int>> vsi(26);
for (int i = 0; i < S.size(); ++i) {
vsi[S[i] - 'a'].insert(i);
}
for (int i = 0; i < Q; ++i) {
int t;
cin >> t;
if (t == 1) {
int p;
char c;
cin >> p >> c;
p--;
char sc = S[p];
vsi[sc - 'a'].erase(p);
S[p] = c;
vsi[c - 'a'].insert(p);
} else {
int l, r;
cin >> l >> r;
l--;
r--;
int ans = 0;
for (char c = 0; c < 26; ++c) {
auto it = vsi[c].lower_bound(l);
if (it != vsi[c].end() && *it <= r)
ans++;
}
cout << ans << endl;
}
}
}
| replace | 34 | 38 | 34 | 38 | TLE | |
p02763 | C++ | Runtime Error | /**
* author : 𝒌𝒚𝒐𝒎𝒖𝒌𝒚𝒐𝒎𝒖𝒑𝒖𝒓𝒊𝒏
* created : 2020-03-02 04:41:18
**/
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <chrono>
#include <cmath>
#include <complex>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using int64 = long long;
template <class T>
using binary_heap = std::priority_queue<T, std::vector<T>, std::greater<T>>;
template <class T>
std::ostream &operator<<(std::ostream &os, const std::vector<T> &vec) {
os << '{';
size_t n = vec.size();
for (size_t i = 0; i < n; ++i) {
os << vec[i];
if (i != n - 1)
os << ',';
}
os << '}';
return os;
}
template <class T, class U>
std::ostream &operator<<(std::ostream &os, const std::pair<T, U> &p) {
return os << '{' << p.first << " " << p.second << '}';
}
template <class T, class U>
std::ostream &operator<<(std::ostream &os, const std::map<T, U> &mp) {
os << '{';
for (auto it = mp.begin(); it != mp.end(); ++it) {
os << '{' << it->first << ':' << it->second << '}';
if (it != --mp.end())
os << ',';
}
os << '}';
return os;
}
template <class T>
std::ostream &operator<<(std::ostream &os, const std::set<T> &st) {
os << '{';
for (auto it = st.begin(); it != st.end(); ++it) {
os << *it;
if (it != --st.end())
os << ',';
}
os << '}';
return os;
}
template <class T>
std::istream &operator>>(std::istream &is, std::vector<T> &vec) {
size_t n = vec.size();
for (size_t i = 0; i < n; ++i)
is >> vec[i];
return is;
}
#define all(_) begin(_), end(_)
#define rall(_) rbegin(_), rend(_)
#ifdef LOCAL
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]: ", debug_out(__VA_ARGS__)
#else
#define debug(...) 1728
#endif
void debug_out() { std::cerr << '\n'; }
template <class Head, class... Tail>
void debug_out(Head &&head, Tail &&...tail) {
std::cerr << head;
if (sizeof...(Tail) != 0)
std::cerr << ", ";
debug_out(std::forward<Tail>(tail)...);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
string s;
cin >> s;
vector<set<int>> vs(26);
for (int i = 0; i < n; ++i) {
int pos = s[i] - 'a';
vs[pos].insert(i);
}
int q;
cin >> q;
for (int i = 0; i < q; ++i) {
int op;
cin >> op;
if (op == 1) {
int pos;
cin >> pos;
--pos;
char next;
cin >> next;
if (s[pos] == next)
continue;
char cur = s[i];
s[pos] = next;
vs[cur - 'a'].erase(pos);
vs[next - 'a'].insert(pos);
} else {
int ans = 0;
int l, r;
cin >> l >> r;
--l;
--r;
for (int j = 0; j < 26; ++j) {
auto it = vs[j].lower_bound(l);
if (it == vs[j].end())
continue;
ans += *it <= r;
}
cout << ans << '\n';
}
}
return 0;
} | /**
* author : 𝒌𝒚𝒐𝒎𝒖𝒌𝒚𝒐𝒎𝒖𝒑𝒖𝒓𝒊𝒏
* created : 2020-03-02 04:41:18
**/
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <chrono>
#include <cmath>
#include <complex>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using int64 = long long;
template <class T>
using binary_heap = std::priority_queue<T, std::vector<T>, std::greater<T>>;
template <class T>
std::ostream &operator<<(std::ostream &os, const std::vector<T> &vec) {
os << '{';
size_t n = vec.size();
for (size_t i = 0; i < n; ++i) {
os << vec[i];
if (i != n - 1)
os << ',';
}
os << '}';
return os;
}
template <class T, class U>
std::ostream &operator<<(std::ostream &os, const std::pair<T, U> &p) {
return os << '{' << p.first << " " << p.second << '}';
}
template <class T, class U>
std::ostream &operator<<(std::ostream &os, const std::map<T, U> &mp) {
os << '{';
for (auto it = mp.begin(); it != mp.end(); ++it) {
os << '{' << it->first << ':' << it->second << '}';
if (it != --mp.end())
os << ',';
}
os << '}';
return os;
}
template <class T>
std::ostream &operator<<(std::ostream &os, const std::set<T> &st) {
os << '{';
for (auto it = st.begin(); it != st.end(); ++it) {
os << *it;
if (it != --st.end())
os << ',';
}
os << '}';
return os;
}
template <class T>
std::istream &operator>>(std::istream &is, std::vector<T> &vec) {
size_t n = vec.size();
for (size_t i = 0; i < n; ++i)
is >> vec[i];
return is;
}
#define all(_) begin(_), end(_)
#define rall(_) rbegin(_), rend(_)
#ifdef LOCAL
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]: ", debug_out(__VA_ARGS__)
#else
#define debug(...) 1728
#endif
void debug_out() { std::cerr << '\n'; }
template <class Head, class... Tail>
void debug_out(Head &&head, Tail &&...tail) {
std::cerr << head;
if (sizeof...(Tail) != 0)
std::cerr << ", ";
debug_out(std::forward<Tail>(tail)...);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
string s;
cin >> s;
vector<set<int>> vs(26);
for (int i = 0; i < n; ++i) {
int pos = s[i] - 'a';
vs[pos].insert(i);
}
int q;
cin >> q;
for (int i = 0; i < q; ++i) {
int op;
cin >> op;
if (op == 1) {
int pos;
cin >> pos;
--pos;
char next;
cin >> next;
if (s[pos] == next)
continue;
char cur = s[pos];
s[pos] = next;
vs[cur - 'a'].erase(pos);
vs[next - 'a'].insert(pos);
} else {
int ans = 0;
int l, r;
cin >> l >> r;
--l;
--r;
for (int j = 0; j < 26; ++j) {
auto it = vs[j].lower_bound(l);
if (it == vs[j].end())
continue;
ans += *it <= r;
}
cout << ans << '\n';
}
}
return 0;
} | replace | 123 | 124 | 123 | 124 | 0 | |
p02763 | C++ | Runtime Error | #pragma GCC optimize("O3")
#pragma GCC target("avx")
// #include<bits/stdc++.h>
#include <cstdio>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep1(i, n) for (int i = 1; i <= (n); i++)
#define co(x) cout << (x) << "\n"
#define cosp(x) cout << (x) << " "
#define ce(x) cerr << (x) << "\n"
#define cesp(x) cerr << (x) << " "
#define pb push_back
#define mp make_pair
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
#define Would
#define you
#define please
const int AS = 500000;
char cn[AS], *ci = cn, ct;
inline int getint() {
int A = 0;
while ((ct = *ci++) >= '0')
A = A * 10 + ct - '0';
return A;
}
char *di = cn;
int dat[2 * AS];
int main() {
// cin.tie(0);
// ios::sync_with_stdio(false);
int N = 0;
while ((ct = getchar_unlocked()) >= '0')
N = N * 10 + ct - '0';
fread(cn, 1, N + 1, stdin);
auto da = dat + AS;
rep(i, N) *da++ = (1 << *ci++ - 'a');
da = dat + AS - 1;
for (auto db = dat + AS * 2 - 1; da > dat; da--)
*da = *db-- | *db--;
ci = cn;
fread(cn, 1, AS, stdin);
int Q = getint();
rep(j, Q) {
char q = *ci++;
ci++;
if (q == '1') {
int i = getint() - 1 + AS;
for (dat[i] = 1 << *ci++ - 'a'; i > 1; i >>= 1)
dat[i >> 1] = dat[i] | dat[i ^ 1];
ci++;
} else {
int ret = 0;
for (int l = getint() - 1 + AS, r = getint() + AS; l < r;
l >>= 1, r >>= 1) {
if (l & 1)
ret |= dat[l++];
if (r & 1)
ret |= dat[--r];
}
int kotae = __builtin_popcount(ret);
int ue = kotae / 10;
if (ue)
*di++ = ue + '0';
*di++ = kotae - ue * 10 + '0';
*di++ = '\n';
}
}
fwrite(cn, 1, di - cn, stdout);
Would you please return 0;
} | #pragma GCC optimize("O3")
#pragma GCC target("avx")
// #include<bits/stdc++.h>
#include <cstdio>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep1(i, n) for (int i = 1; i <= (n); i++)
#define co(x) cout << (x) << "\n"
#define cosp(x) cout << (x) << " "
#define ce(x) cerr << (x) << "\n"
#define cesp(x) cerr << (x) << " "
#define pb push_back
#define mp make_pair
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
#define Would
#define you
#define please
const int AS = 500001;
char cn[AS], *ci = cn, ct;
inline int getint() {
int A = 0;
while ((ct = *ci++) >= '0')
A = A * 10 + ct - '0';
return A;
}
char *di = cn;
int dat[2 * AS];
int main() {
// cin.tie(0);
// ios::sync_with_stdio(false);
int N = 0;
while ((ct = getchar_unlocked()) >= '0')
N = N * 10 + ct - '0';
fread(cn, 1, N + 1, stdin);
auto da = dat + AS;
rep(i, N) *da++ = (1 << *ci++ - 'a');
da = dat + AS - 1;
for (auto db = dat + AS * 2 - 1; da > dat; da--)
*da = *db-- | *db--;
ci = cn;
fread(cn, 1, AS, stdin);
int Q = getint();
rep(j, Q) {
char q = *ci++;
ci++;
if (q == '1') {
int i = getint() - 1 + AS;
for (dat[i] = 1 << *ci++ - 'a'; i > 1; i >>= 1)
dat[i >> 1] = dat[i] | dat[i ^ 1];
ci++;
} else {
int ret = 0;
for (int l = getint() - 1 + AS, r = getint() + AS; l < r;
l >>= 1, r >>= 1) {
if (l & 1)
ret |= dat[l++];
if (r & 1)
ret |= dat[--r];
}
int kotae = __builtin_popcount(ret);
int ue = kotae / 10;
if (ue)
*di++ = ue + '0';
*di++ = kotae - ue * 10 + '0';
*di++ = '\n';
}
}
fwrite(cn, 1, di - cn, stdout);
Would you please return 0;
} | replace | 20 | 21 | 20 | 21 | 0 | |
p02763 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#include <cmath>
#include <iostream>
#include <string>
#include <unordered_map>
#include <unordered_set>
using namespace std;
#define ll long long
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define FOR(i, a, b) for (ll i = (a); i < (b); i++)
#define FORR(i, a, b) for (ll i = (a); i <= (b); i++)
#define repR(i, n) for (ll i = n; i >= 0; i--)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define F first
#define S second
#define pb push_back
#define pu push
#define COUT(x) cout << (x) << endl
#define PQ priority_queue<ll>
#define PQR priority_queue<ll, vector<ll>, greater<ll>>
#define YES(n) cout << ((n) ? "YES" : "NO") << endl
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl
#define mp make_pair
#define maxs(x, y) (x = max(x, y))
#define mins(x, y) (x = min(x, y))
#define sz(x) (int)(x).size()
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const ll MOD = 1000000007LL;
const ll INF = 1LL << 60;
using vll = vector<ll>;
using vb = vector<bool>;
using vvb = vector<vb>;
using vvll = vector<vll>;
using vstr = vector<string>;
using pll = pair<ll, ll>;
using vc = vector<char>;
using vvc = vector<vc>;
ll dx[4] = {0, 1, 0, -1};
ll dy[4] = {1, 0, -1, 0};
int main() {
ll n;
string s;
cin >> n >> s;
ll q;
cin >> q;
vector<set<ll>> p(26);
rep(i, n) { p[s[i] - 'a'].insert(i); }
rep(i, q) {
ll k;
cin >> k;
if (k == 1) {
ll d;
char r;
cin >> d >> r;
d--;
p[s[d] - 'a'].erase(d);
s[d] = r;
p[s[d] - 'a'].insert(d);
} else {
ll l, r;
cin >> l >> r;
l--;
ll ans = 0;
rep(j, 26) {
auto it = lower_bound(all(p[j]), l);
if (it != p[j].end() && *it < r) {
ans++;
}
}
COUT(ans);
}
}
}
| #include <bits/stdc++.h>
#include <cmath>
#include <iostream>
#include <string>
#include <unordered_map>
#include <unordered_set>
using namespace std;
#define ll long long
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define FOR(i, a, b) for (ll i = (a); i < (b); i++)
#define FORR(i, a, b) for (ll i = (a); i <= (b); i++)
#define repR(i, n) for (ll i = n; i >= 0; i--)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define F first
#define S second
#define pb push_back
#define pu push
#define COUT(x) cout << (x) << endl
#define PQ priority_queue<ll>
#define PQR priority_queue<ll, vector<ll>, greater<ll>>
#define YES(n) cout << ((n) ? "YES" : "NO") << endl
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl
#define mp make_pair
#define maxs(x, y) (x = max(x, y))
#define mins(x, y) (x = min(x, y))
#define sz(x) (int)(x).size()
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const ll MOD = 1000000007LL;
const ll INF = 1LL << 60;
using vll = vector<ll>;
using vb = vector<bool>;
using vvb = vector<vb>;
using vvll = vector<vll>;
using vstr = vector<string>;
using pll = pair<ll, ll>;
using vc = vector<char>;
using vvc = vector<vc>;
ll dx[4] = {0, 1, 0, -1};
ll dy[4] = {1, 0, -1, 0};
int main() {
ll n;
string s;
cin >> n >> s;
ll q;
cin >> q;
vector<set<ll>> p(26);
rep(i, n) { p[s[i] - 'a'].insert(i); }
rep(i, q) {
ll k;
cin >> k;
if (k == 1) {
ll d;
char r;
cin >> d >> r;
d--;
p[s[d] - 'a'].erase(d);
s[d] = r;
p[s[d] - 'a'].insert(d);
} else {
ll l, r;
cin >> l >> r;
l--;
ll ans = 0;
rep(j, 26) {
auto it = p[j].lower_bound(l);
if (it != p[j].end() && *it < r) {
ans++;
}
}
COUT(ans);
}
}
}
| replace | 66 | 67 | 66 | 67 | TLE | |
p02763 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0), ios::sync_with_stdio(false);
int n, Q;
string s;
cin >> n >> s >> Q;
vector<set<int>> st(26);
for (int i = 0; i < n; ++i) {
st.at(s.at(i) - 'a').insert(i);
}
for (int i = 0; i < Q; ++i) {
int q;
cin >> q;
if (q == 1) {
int j;
char c;
cin >> j >> c;
--j;
st.at(s.at(j) - 'a').erase(j);
s.at(j) = c;
st.at(s.at(j) - 'a').insert(j);
} else {
int l, r;
cin >> l >> r;
--l;
int ans = 0;
for (int j = 0; j < 26; ++j) {
if (!st.at(j).size())
continue;
auto itr = lower_bound(st.at(j).begin(), st.at(j).end(), l);
if (itr != st.at(j).end() && *itr < r)
++ans;
}
cout << ans << "\n"s;
}
}
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0), ios::sync_with_stdio(false);
int n, Q;
string s;
cin >> n >> s >> Q;
vector<set<int>> st(26);
for (int i = 0; i < n; ++i) {
st.at(s.at(i) - 'a').insert(i);
}
for (int i = 0; i < Q; ++i) {
int q;
cin >> q;
if (q == 1) {
int j;
char c;
cin >> j >> c;
--j;
st.at(s.at(j) - 'a').erase(j);
s.at(j) = c;
st.at(s.at(j) - 'a').insert(j);
} else {
int l, r;
cin >> l >> r;
--l;
int ans = 0;
for (int j = 0; j < 26; ++j) {
if (!st.at(j).size())
continue;
auto itr = st.at(j).lower_bound(l);
if (itr != st.at(j).end() && *itr < r)
++ans;
}
cout << ans << "\n"s;
}
}
}
| replace | 31 | 32 | 31 | 32 | TLE | |
p02763 | C++ | Time Limit Exceeded | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
using vvl = vector<vl>;
using vb = vector<bool>;
using vvb = vector<vb>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define rep(i, s, n) for (int i = (int)(s); i < (int)(n); i++)
ll INF = 1ll << 60;
int main() {
int n, Q;
string s;
vector<set<int>> st(26);
cin >> n;
getchar();
rep(i, 0, n) {
char c = getchar();
s.push_back(c);
st[c - 'a'].insert(i);
}
getchar();
cin >> Q;
rep(tmp, 0, Q) {
int q;
cin >> q;
q--;
if (q) {
int l, r;
cin >> l >> r;
l--;
r--;
int ans = 0;
rep(i, 0, 26) {
auto itr = lower_bound(st[i].begin(), st[i].end(), l);
if (itr != st[i].end() && *itr <= r)
ans++;
}
cout << ans << "\n";
} else {
int i;
char c;
cin >> i >> c;
i--;
if (s[i] == c)
continue;
st[s[i] - 'a'].erase(i);
s[i] = c;
st[c - 'a'].insert(i);
}
}
return 0;
} | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
using vvl = vector<vl>;
using vb = vector<bool>;
using vvb = vector<vb>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define rep(i, s, n) for (int i = (int)(s); i < (int)(n); i++)
ll INF = 1ll << 60;
int main() {
int n, Q;
string s;
vector<set<int>> st(26);
cin >> n;
getchar();
rep(i, 0, n) {
char c = getchar();
s.push_back(c);
st[c - 'a'].insert(i);
}
getchar();
cin >> Q;
rep(tmp, 0, Q) {
int q;
cin >> q;
q--;
if (q) {
int l, r;
cin >> l >> r;
l--;
r--;
int ans = 0;
rep(i, 0, 26) {
auto itr = st[i].lower_bound(l);
if (itr != st[i].end() && *itr <= r)
ans++;
}
cout << ans << "\n";
} else {
int i;
char c;
cin >> i >> c;
i--;
if (s[i] == c)
continue;
st[s[i] - 'a'].erase(i);
s[i] = c;
st[c - 'a'].insert(i);
}
}
return 0;
} | replace | 41 | 42 | 41 | 42 | TLE | |
p02763 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int n, m;
int f[26][500001];
char a[500001];
int lowbit(int x) { return x & (-x); }
void build() {
for (int i = 0; i < 26; i++)
for (int j = 1; j <= n; j++)
if (lowbit(j) <= n)
f[i][j + lowbit(j)] += f[i][j];
}
void change(int x, int y, int z) {
while (x <= n) {
f[y][x] += z;
x += lowbit(x);
}
}
int find(int x, int y) {
int tot = 0;
while (y) {
tot += f[x][y];
y -= lowbit(y);
}
return tot;
}
int ask(int l, int r) {
int ans = 0;
for (int i = 0; i < 26; i++)
if (find(i, r) - find(i, l - 1) > 0)
ans++;
return ans;
}
void A() {
int x;
char y;
scanf("%d", &x);
y = getchar();
while (y > 'z' || y < 'a')
y = getchar();
if (a[x] != y) {
change(x, a[x] - 'a', -1);
a[x] = y;
change(x, a[x] - 'a', 1);
}
}
void B() {
int l, r;
scanf("%d%d", &l, &r);
printf("%d\n", ask(l, r));
}
signed main() {
int x;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
a[i] = getchar();
while (a[i] > 'z' || a[i] < 'a')
a[i] = getchar();
f[a[i] - 'a'][i] = 1;
}
build();
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
scanf("%d", &x);
if (x == 1)
A();
else
B();
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int n, m;
int f[26][5000001];
char a[5000001];
int lowbit(int x) { return x & (-x); }
void build() {
for (int i = 0; i < 26; i++)
for (int j = 1; j <= n; j++)
if (lowbit(j) <= n)
f[i][j + lowbit(j)] += f[i][j];
}
void change(int x, int y, int z) {
while (x <= n) {
f[y][x] += z;
x += lowbit(x);
}
}
int find(int x, int y) {
int tot = 0;
while (y) {
tot += f[x][y];
y -= lowbit(y);
}
return tot;
}
int ask(int l, int r) {
int ans = 0;
for (int i = 0; i < 26; i++)
if (find(i, r) - find(i, l - 1) > 0)
ans++;
return ans;
}
void A() {
int x;
char y;
scanf("%d", &x);
y = getchar();
while (y > 'z' || y < 'a')
y = getchar();
if (a[x] != y) {
change(x, a[x] - 'a', -1);
a[x] = y;
change(x, a[x] - 'a', 1);
}
}
void B() {
int l, r;
scanf("%d%d", &l, &r);
printf("%d\n", ask(l, r));
}
signed main() {
int x;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
a[i] = getchar();
while (a[i] > 'z' || a[i] < 'a')
a[i] = getchar();
f[a[i] - 'a'][i] = 1;
}
build();
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
scanf("%d", &x);
if (x == 1)
A();
else
B();
}
return 0;
} | replace | 3 | 5 | 3 | 5 | 0 | |
p02763 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using lint = long long;
const lint mod = 1e9 + 7;
#define all(x) (x).begin(), (x).end()
#define bitcount(n) __builtin_popcountl((lint)(n))
#define fcout cout << fixed << setprecision(15)
#define highest(x) (63 - __builtin_clzl(x))
template <class T> inline void YES(T condition) {
if (condition)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
template <class T> inline void Yes(T condition) {
if (condition)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
template <class T = string, class U = char>
int character_count(T text, U character) {
int ans = 0;
for (U i : text) {
ans += (i == character);
}
return ans;
}
lint power(lint base, lint exponent, lint module) {
if (exponent % 2) {
return power(base, exponent - 1, module) * base % module;
} else if (exponent) {
lint root_ans = power(base, exponent / 2, module);
return root_ans * root_ans % module;
} else {
return 1;
}
}
struct position {
int y, x;
};
position mv[4] = {
{0, -1},
{1, 0},
{0, 1},
{-1, 0}}; // double euclidean(position first, position second){ return
// sqrt((second.x - first.x) * (second.x - first.x) + (second.y -
// first.y) * (second.y - first.y)); }
template <class T, class U> string to_string(pair<T, U> x) {
return to_string(x.first) + "," + to_string(x.second);
}
string to_string(string x) { return x; }
template <class itr> void array_output(itr start, itr goal) {
string ans;
for (auto i = start; i != goal; i++)
ans += to_string(*i) + " ";
if (!ans.empty())
ans.pop_back();
cout << ans << endl;
}
template <class itr> void cins(itr first, itr last) {
for (auto i = first; i != last; i++) {
cin >> (*i);
}
}
template <class T> T gcd(T a, T b) {
if (a && b) {
return gcd(min(a, b), max(a, b) % min(a, b));
} else {
return a;
}
}
template <class T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
struct combination {
vector<lint> fact, inv;
combination(int sz) : fact(sz + 1), inv(sz + 1) {
fact[0] = 1;
for (int i = 1; i <= sz; i++) {
fact[i] = fact[i - 1] * i % mod;
}
inv[sz] = power(fact[sz], mod - 2, mod);
for (int i = sz - 1; i >= 0; i--) {
inv[i] = inv[i + 1] * (i + 1) % mod;
}
}
lint C(int p, int q) const {
if (q < 0 || p < q)
return 0;
return (fact[p] * inv[q] % mod * inv[p - q] % mod);
}
};
template <class itr> bool next_sequence(itr first, itr last, int max_bound) {
itr now = last;
while (now != first) {
now--;
(*now)++;
if ((*now) == max_bound) {
(*now) = 0;
} else {
return true;
}
}
return false;
}
template <typename Monoid> struct SegmentTree {
using F = function<Monoid(Monoid, Monoid)>;
int sz;
vector<Monoid> seg;
const F f;
const Monoid M1;
SegmentTree(int n, const F f, const Monoid &M1) : f(f), M1(M1) {
sz = 1;
while (sz < n)
sz <<= 1;
seg.assign(2 * sz, M1);
}
void set(int k, const Monoid &x) { seg[k + sz] = x; }
void build() {
for (int k = sz - 1; k > 0; k--) {
seg[k] = f(seg[2 * k + 0], seg[2 * k + 1]);
}
}
void update(int k, const Monoid &x) {
k += sz;
seg[k] = x;
while (k >>= 1) {
seg[k] = f(seg[2 * k + 0], seg[2 * k + 1]);
}
}
Monoid query(int a, int b) {
Monoid L = M1, R = M1;
for (a += sz, b += sz; a < b; a >>= 1, b >>= 1) {
if (a & 1)
L = f(L, seg[a++]);
if (b & 1)
R = f(seg[--b], R);
}
return f(L, R);
}
Monoid operator[](const int &k) const { return seg[k + sz]; }
};
vector<SegmentTree<int>> seg;
int main() {
int N, Q;
string S;
cin >> N >> S >> Q;
seg = vector<SegmentTree<int>>(26,
SegmentTree<int>(
N, [](int a, int b) { return a + b; }, 0));
for (int i = 0; i < N; i++) {
seg[S[i] - 'a'].set(i, 1);
}
for (int i = 0; i < 26; i++) {
seg[i].build();
}
for (int i = 0; i < Q; i++) {
int t;
cin >> t;
if (t == 1) {
int p;
char q;
cin >> p >> q;
p--;
seg[S[i] - 'a'].update(p, 0);
seg[q - 'a'].update(p, 1);
S[p] = q;
} else {
int l, r;
cin >> l >> r;
l--;
int ans = 0;
for (int j = 0; j < 26; j++) {
ans += !!seg[j].query(l, r);
}
cout << ans << endl;
}
}
}
| #include <bits/stdc++.h>
using namespace std;
using lint = long long;
const lint mod = 1e9 + 7;
#define all(x) (x).begin(), (x).end()
#define bitcount(n) __builtin_popcountl((lint)(n))
#define fcout cout << fixed << setprecision(15)
#define highest(x) (63 - __builtin_clzl(x))
template <class T> inline void YES(T condition) {
if (condition)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
template <class T> inline void Yes(T condition) {
if (condition)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
template <class T = string, class U = char>
int character_count(T text, U character) {
int ans = 0;
for (U i : text) {
ans += (i == character);
}
return ans;
}
lint power(lint base, lint exponent, lint module) {
if (exponent % 2) {
return power(base, exponent - 1, module) * base % module;
} else if (exponent) {
lint root_ans = power(base, exponent / 2, module);
return root_ans * root_ans % module;
} else {
return 1;
}
}
struct position {
int y, x;
};
position mv[4] = {
{0, -1},
{1, 0},
{0, 1},
{-1, 0}}; // double euclidean(position first, position second){ return
// sqrt((second.x - first.x) * (second.x - first.x) + (second.y -
// first.y) * (second.y - first.y)); }
template <class T, class U> string to_string(pair<T, U> x) {
return to_string(x.first) + "," + to_string(x.second);
}
string to_string(string x) { return x; }
template <class itr> void array_output(itr start, itr goal) {
string ans;
for (auto i = start; i != goal; i++)
ans += to_string(*i) + " ";
if (!ans.empty())
ans.pop_back();
cout << ans << endl;
}
template <class itr> void cins(itr first, itr last) {
for (auto i = first; i != last; i++) {
cin >> (*i);
}
}
template <class T> T gcd(T a, T b) {
if (a && b) {
return gcd(min(a, b), max(a, b) % min(a, b));
} else {
return a;
}
}
template <class T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
struct combination {
vector<lint> fact, inv;
combination(int sz) : fact(sz + 1), inv(sz + 1) {
fact[0] = 1;
for (int i = 1; i <= sz; i++) {
fact[i] = fact[i - 1] * i % mod;
}
inv[sz] = power(fact[sz], mod - 2, mod);
for (int i = sz - 1; i >= 0; i--) {
inv[i] = inv[i + 1] * (i + 1) % mod;
}
}
lint C(int p, int q) const {
if (q < 0 || p < q)
return 0;
return (fact[p] * inv[q] % mod * inv[p - q] % mod);
}
};
template <class itr> bool next_sequence(itr first, itr last, int max_bound) {
itr now = last;
while (now != first) {
now--;
(*now)++;
if ((*now) == max_bound) {
(*now) = 0;
} else {
return true;
}
}
return false;
}
template <typename Monoid> struct SegmentTree {
using F = function<Monoid(Monoid, Monoid)>;
int sz;
vector<Monoid> seg;
const F f;
const Monoid M1;
SegmentTree(int n, const F f, const Monoid &M1) : f(f), M1(M1) {
sz = 1;
while (sz < n)
sz <<= 1;
seg.assign(2 * sz, M1);
}
void set(int k, const Monoid &x) { seg[k + sz] = x; }
void build() {
for (int k = sz - 1; k > 0; k--) {
seg[k] = f(seg[2 * k + 0], seg[2 * k + 1]);
}
}
void update(int k, const Monoid &x) {
k += sz;
seg[k] = x;
while (k >>= 1) {
seg[k] = f(seg[2 * k + 0], seg[2 * k + 1]);
}
}
Monoid query(int a, int b) {
Monoid L = M1, R = M1;
for (a += sz, b += sz; a < b; a >>= 1, b >>= 1) {
if (a & 1)
L = f(L, seg[a++]);
if (b & 1)
R = f(seg[--b], R);
}
return f(L, R);
}
Monoid operator[](const int &k) const { return seg[k + sz]; }
};
vector<SegmentTree<int>> seg;
int main() {
int N, Q;
string S;
cin >> N >> S >> Q;
seg = vector<SegmentTree<int>>(26,
SegmentTree<int>(
N, [](int a, int b) { return a + b; }, 0));
for (int i = 0; i < N; i++) {
seg[S[i] - 'a'].set(i, 1);
}
for (int i = 0; i < 26; i++) {
seg[i].build();
}
for (int i = 0; i < Q; i++) {
int t;
cin >> t;
if (t == 1) {
int p;
char q;
cin >> p >> q;
p--;
seg[S[p] - 'a'].update(p, 0);
seg[q - 'a'].update(p, 1);
S[p] = q;
} else {
int l, r;
cin >> l >> r;
l--;
int ans = 0;
for (int j = 0; j < 26; j++) {
ans += !!seg[j].query(l, r);
}
cout << ans << endl;
}
}
}
| replace | 174 | 175 | 174 | 175 | 0 | |
p02763 | C++ | Runtime Error | #pragma region template
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using vi = vector<int>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vvvll = vector<vvll>;
using vld = vector<ld>;
using vvld = vector<vld>;
using vvvld = vector<vvld>;
using vs = vector<string>;
using pll = pair<ll, ll>;
using vp = vector<pll>;
template <typename T> using pqrev = priority_queue<T, vector<T>, greater<T>>;
#define rep(i, n) for (ll i = 0, i##_end = (n); i < i##_end; i++)
#define repb(i, n) for (ll i = (n)-1; i >= 0; i--)
#define repr(i, a, b) for (ll i = (a), i##_end = (b); i < i##_end; i++)
#define reprb(i, a, b) for (ll i = (b)-1, i##_end = (a); i >= i##_end; i--)
#define ALL(a) (a).begin(), (a).end()
#define SZ(x) ((ll)(x).size())
//*
constexpr ll MOD = 1e9 + 7;
/*/
constexpr ll MOD = 998244353;
//*/
constexpr ll INF = 1e+18;
constexpr ld EPS = 1e-12L;
constexpr ld PI = 3.14159265358979323846L;
constexpr ll GCD(ll a, ll b) { return b ? GCD(b, a % b) : a; }
constexpr ll LCM(ll a, ll b) { return a / GCD(a, b) * b; }
template <typename S, typename T> inline bool chmax(S &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename S, typename T> inline bool chmin(S &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
#ifdef OJ_LOCAL
#include "dump.hpp"
#else
#define dump(...) ((void)0)
#endif
template <typename T> bool print_(const T &a) {
cout << a;
return true;
}
template <typename T> bool print_(const vector<T> &vec) {
for (auto &a : vec) {
cout << a;
if (&a != &vec.back()) {
cout << " ";
}
}
return false;
}
template <typename T> bool print_(const vector<vector<T>> &vv) {
for (auto &v : vv) {
for (auto &a : v) {
cout << a;
if (&a != &v.back()) {
cout << " ";
}
}
if (&v != &vv.back()) {
cout << "\n";
}
}
return false;
}
void print() { cout << "\n"; }
template <typename Head, typename... Tail>
void print(Head &&head, Tail &&...tail) {
bool f = print_(head);
if (sizeof...(tail) != 0) {
cout << (f ? " " : "\n");
}
print(forward<Tail>(tail)...);
}
#pragma endregion
// Binary Indexed Tree 1-indexed
struct BIT {
ll n;
vector<ll> bit;
BIT(ll n) : n(n), bit(n + 1, 0) {}
void add(ll a, ll w) {
for (; a <= n; a += a & -a) {
bit[a] += w;
}
}
// v: 1-indexed, size = n+1
void build(const vector<ll> &v) {
n = (ll)v.size() - 1;
bit = v;
ll unit = 1;
while (unit * 2 <= n) {
for (int i = unit * 2; i <= n; i += unit * 2) {
bit[i] += bit[i - unit];
}
unit <<= 1;
}
}
ll sum(ll a) {
ll ret = 0;
for (; a > 0; a -= a & -a) {
ret += bit[a];
}
return ret;
}
// [a, b]
ll sum(ll a, ll b) { return sum(b) - sum(a - 1); }
};
// Binary Indexed Tree 0-indexed
struct BIT0 {
ll n;
vector<ll> bit;
BIT0(ll n) : n(n), bit(n, 0) {}
void add(ll a, ll w) {
for (; a < n; a |= a + 1) {
bit[a] += w;
}
}
// v: 0-indexed, size = n
void build(const vector<ll> &v) {
n = v.size();
bit = v;
ll unit = 1;
while (unit * 2 < n) {
for (int i = unit * 2 - 1; i < n; i += unit * 2) {
bit[i] += bit[i - unit];
}
unit <<= 1;
}
}
ll sum(ll a) {
ll ret = 0;
for (; a >= 0; a = (a & (a + 1)) - 1) {
ret += bit[a];
}
return ret;
}
// [a, b]
ll sum(ll a, ll b) { return sum(b) - sum(a - 1); }
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
ll n;
cin >> n;
string s;
cin >> s;
ll q;
cin >> q;
vector<BIT> b(26, BIT(n));
rep(i, n) { b[s[i] - 'a'].add(i + 1, 1); }
while (q--) {
ll ty;
cin >> ty;
if (ty == 1) {
ll idx;
cin >> idx;
idx--;
char c;
cin >> c;
b[s[idx] - 'a'].add(idx + 1, -1);
assert(b[s[idx] - 'a'].sum(idx + 1, idx + 1) == 0);
b[c - 'a'].add(idx + 1, 1);
assert(b[c - 'a'].sum(idx + 1, idx + 1) == 1);
} else {
ll l, r;
cin >> l >> r;
ll ans = 0;
rep(i, 26) {
ans += (b[i].sum(l, r) > 0);
// ans += b[i].sum(l, r);
}
print(ans);
}
}
}
| #pragma region template
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using vi = vector<int>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vvvll = vector<vvll>;
using vld = vector<ld>;
using vvld = vector<vld>;
using vvvld = vector<vvld>;
using vs = vector<string>;
using pll = pair<ll, ll>;
using vp = vector<pll>;
template <typename T> using pqrev = priority_queue<T, vector<T>, greater<T>>;
#define rep(i, n) for (ll i = 0, i##_end = (n); i < i##_end; i++)
#define repb(i, n) for (ll i = (n)-1; i >= 0; i--)
#define repr(i, a, b) for (ll i = (a), i##_end = (b); i < i##_end; i++)
#define reprb(i, a, b) for (ll i = (b)-1, i##_end = (a); i >= i##_end; i--)
#define ALL(a) (a).begin(), (a).end()
#define SZ(x) ((ll)(x).size())
//*
constexpr ll MOD = 1e9 + 7;
/*/
constexpr ll MOD = 998244353;
//*/
constexpr ll INF = 1e+18;
constexpr ld EPS = 1e-12L;
constexpr ld PI = 3.14159265358979323846L;
constexpr ll GCD(ll a, ll b) { return b ? GCD(b, a % b) : a; }
constexpr ll LCM(ll a, ll b) { return a / GCD(a, b) * b; }
template <typename S, typename T> inline bool chmax(S &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename S, typename T> inline bool chmin(S &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
#ifdef OJ_LOCAL
#include "dump.hpp"
#else
#define dump(...) ((void)0)
#endif
template <typename T> bool print_(const T &a) {
cout << a;
return true;
}
template <typename T> bool print_(const vector<T> &vec) {
for (auto &a : vec) {
cout << a;
if (&a != &vec.back()) {
cout << " ";
}
}
return false;
}
template <typename T> bool print_(const vector<vector<T>> &vv) {
for (auto &v : vv) {
for (auto &a : v) {
cout << a;
if (&a != &v.back()) {
cout << " ";
}
}
if (&v != &vv.back()) {
cout << "\n";
}
}
return false;
}
void print() { cout << "\n"; }
template <typename Head, typename... Tail>
void print(Head &&head, Tail &&...tail) {
bool f = print_(head);
if (sizeof...(tail) != 0) {
cout << (f ? " " : "\n");
}
print(forward<Tail>(tail)...);
}
#pragma endregion
// Binary Indexed Tree 1-indexed
struct BIT {
ll n;
vector<ll> bit;
BIT(ll n) : n(n), bit(n + 1, 0) {}
void add(ll a, ll w) {
for (; a <= n; a += a & -a) {
bit[a] += w;
}
}
// v: 1-indexed, size = n+1
void build(const vector<ll> &v) {
n = (ll)v.size() - 1;
bit = v;
ll unit = 1;
while (unit * 2 <= n) {
for (int i = unit * 2; i <= n; i += unit * 2) {
bit[i] += bit[i - unit];
}
unit <<= 1;
}
}
ll sum(ll a) {
ll ret = 0;
for (; a > 0; a -= a & -a) {
ret += bit[a];
}
return ret;
}
// [a, b]
ll sum(ll a, ll b) { return sum(b) - sum(a - 1); }
};
// Binary Indexed Tree 0-indexed
struct BIT0 {
ll n;
vector<ll> bit;
BIT0(ll n) : n(n), bit(n, 0) {}
void add(ll a, ll w) {
for (; a < n; a |= a + 1) {
bit[a] += w;
}
}
// v: 0-indexed, size = n
void build(const vector<ll> &v) {
n = v.size();
bit = v;
ll unit = 1;
while (unit * 2 < n) {
for (int i = unit * 2 - 1; i < n; i += unit * 2) {
bit[i] += bit[i - unit];
}
unit <<= 1;
}
}
ll sum(ll a) {
ll ret = 0;
for (; a >= 0; a = (a & (a + 1)) - 1) {
ret += bit[a];
}
return ret;
}
// [a, b]
ll sum(ll a, ll b) { return sum(b) - sum(a - 1); }
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
ll n;
cin >> n;
string s;
cin >> s;
ll q;
cin >> q;
vector<BIT> b(26, BIT(n));
rep(i, n) { b[s[i] - 'a'].add(i + 1, 1); }
while (q--) {
ll ty;
cin >> ty;
if (ty == 1) {
ll idx;
cin >> idx;
idx--;
char c;
cin >> c;
b[s[idx] - 'a'].add(idx + 1, -1);
assert(b[s[idx] - 'a'].sum(idx + 1, idx + 1) == 0);
s[idx] = c;
b[c - 'a'].add(idx + 1, 1);
assert(b[c - 'a'].sum(idx + 1, idx + 1) == 1);
} else {
ll l, r;
cin >> l >> r;
ll ans = 0;
rep(i, 26) {
ans += (b[i].sum(l, r) > 0);
// ans += b[i].sum(l, r);
}
print(ans);
}
}
}
| insert | 181 | 181 | 181 | 182 | 0 | |
p02763 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define NL endl
#define pi 2.0 * acos(0.0)
#define mod 1e9 + 7
#define FOR(i, j, n) for (ll i = j; i < n; i++)
#define RFOR(i, j, n) for (ll i = j; i >= n; i--)
#define fastIO \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
typedef long long int ll;
typedef unsigned long long ull;
typedef long double ld;
set<ll> cset[30];
int main() {
fastIO;
ll n, q, a, b, c, pos, ans = 0;
string s;
char d, curr;
cin >> n >> s >> q;
FOR(i, 0, n) { cset[s[i] - 'a'].insert(i + 1); }
FOR(i, 0, 26) { cset[i].insert(1e18); }
while (q--) {
cin >> a;
if (a == 1) {
cin >> b >> d;
curr = s[b - 1];
cset[curr - 'a'].erase(b);
cset[d - 'a'].insert(b);
s[b - 1] = d;
} else {
cin >> b >> c;
ans = 0;
FOR(i, 0, 26) {
if (cset[i].size()) {
auto lower = lower_bound(cset[i].begin(), cset[i].end(), b);
if (*lower == 1e18) {
} else {
ll val = *lower;
if (val >= b && val <= c)
ans++;
}
}
}
cout << ans << endl;
}
}
}
| #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define NL endl
#define pi 2.0 * acos(0.0)
#define mod 1e9 + 7
#define FOR(i, j, n) for (ll i = j; i < n; i++)
#define RFOR(i, j, n) for (ll i = j; i >= n; i--)
#define fastIO \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
typedef long long int ll;
typedef unsigned long long ull;
typedef long double ld;
set<ll> cset[30];
int main() {
fastIO;
ll n, q, a, b, c, pos, ans = 0;
string s;
char d, curr;
cin >> n >> s >> q;
FOR(i, 0, n) { cset[s[i] - 'a'].insert(i + 1); }
FOR(i, 0, 26) { cset[i].insert(1e18); }
while (q--) {
cin >> a;
if (a == 1) {
cin >> b >> d;
curr = s[b - 1];
cset[curr - 'a'].erase(b);
cset[d - 'a'].insert(b);
s[b - 1] = d;
} else {
cin >> b >> c;
ans = 0;
FOR(i, 0, 26) {
if (cset[i].size()) {
auto lower = cset[i].lower_bound(b);
if (*lower == 1e18) {
} else {
ll val = *lower;
if (val >= b && val <= c)
ans++;
}
}
}
cout << ans << endl;
}
}
}
| replace | 42 | 43 | 42 | 43 | TLE | |
p02763 | C++ | Time Limit Exceeded | #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <functional>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <vector>
#define _USE_MATH_DEFINES
#include <bitset>
#include <deque>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <set>
using namespace std;
typedef long long ll;
#define rep(i, a, b) for (auto i = a; i < b; i++)
#define all(_x) _x.begin(), _x.end()
#define r_sort(_x) sort(_x.begin(), _x.end(), std::greater<int>())
#define vec_cnt(_a, _n) (upper_bound(all(_a), _n) - lower_bound(all(_a), _n))
#define vec_unique(_a) _a.erase(std::unique(all(_a)), _a.end());
#define vvec vector<vector<ll>>
ll gcd(ll a, ll b) { return a % b == 0 ? b : gcd(b, a % b); }
ll lcm(ll a, ll b) { return (a / gcd(a, b)) * b; }
#define INF 1 << 30
const int mod = 1000000007;
ll power(ll x, ll p) {
ll a = 1;
while (p > 0) {
if (p % 2 == 0) {
x *= x;
p /= 2;
} else {
a *= x;
p--;
}
}
return a;
}
ll mpower(ll x, ll p) {
ll a = 1;
while (p > 0) {
if (p % 2 == 0) {
x = x * x % mod;
p /= 2;
} else {
a = a * x % mod;
p--;
}
}
return a;
}
ll c(ll n, ll k) {
ll a = 1;
rep(i, 1, k) {
a *= n - i + 1;
a /= i;
}
return a;
}
ll mc(ll n, ll m) {
ll k = 1, l = 1;
rep(i, n - m + 1, n + 1) k = k * i % mod;
rep(i, 1, m + 1) l = l * i % mod;
l = mpower(l, mod - 2);
return k * l % mod;
}
int main(void) {
int n, q, a, b, c;
char ch;
string s;
cin >> n >> s >> q;
vector<set<int>> pos(26);
rep(i, 0, n) { pos[s[i] - 'a'].insert(i + 1); }
rep(i, 0, q) {
cin >> a >> b;
if (a == 1) {
cin >> ch;
rep(i2, 0, 26) {
if (pos[i2].find(b) != pos[i2].end()) {
pos[i2].erase(b);
pos[ch - 'a'].insert(b);
break;
}
}
} else {
int cnt = 0;
cin >> c;
rep(i2, 0, 26) {
auto it = lower_bound(all(pos[i2]), b);
if (it != pos[i2].end() && *it <= c)
cnt++;
}
printf("%d\n", cnt);
}
}
return 0;
}
| #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <functional>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <vector>
#define _USE_MATH_DEFINES
#include <bitset>
#include <deque>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <set>
using namespace std;
typedef long long ll;
#define rep(i, a, b) for (auto i = a; i < b; i++)
#define all(_x) _x.begin(), _x.end()
#define r_sort(_x) sort(_x.begin(), _x.end(), std::greater<int>())
#define vec_cnt(_a, _n) (upper_bound(all(_a), _n) - lower_bound(all(_a), _n))
#define vec_unique(_a) _a.erase(std::unique(all(_a)), _a.end());
#define vvec vector<vector<ll>>
ll gcd(ll a, ll b) { return a % b == 0 ? b : gcd(b, a % b); }
ll lcm(ll a, ll b) { return (a / gcd(a, b)) * b; }
#define INF 1 << 30
const int mod = 1000000007;
ll power(ll x, ll p) {
ll a = 1;
while (p > 0) {
if (p % 2 == 0) {
x *= x;
p /= 2;
} else {
a *= x;
p--;
}
}
return a;
}
ll mpower(ll x, ll p) {
ll a = 1;
while (p > 0) {
if (p % 2 == 0) {
x = x * x % mod;
p /= 2;
} else {
a = a * x % mod;
p--;
}
}
return a;
}
ll c(ll n, ll k) {
ll a = 1;
rep(i, 1, k) {
a *= n - i + 1;
a /= i;
}
return a;
}
ll mc(ll n, ll m) {
ll k = 1, l = 1;
rep(i, n - m + 1, n + 1) k = k * i % mod;
rep(i, 1, m + 1) l = l * i % mod;
l = mpower(l, mod - 2);
return k * l % mod;
}
int main(void) {
int n, q, a, b, c;
char ch;
string s;
cin >> n >> s >> q;
vector<set<int>> pos(26);
rep(i, 0, n) { pos[s[i] - 'a'].insert(i + 1); }
rep(i, 0, q) {
cin >> a >> b;
if (a == 1) {
cin >> ch;
rep(i2, 0, 26) {
if (pos[i2].find(b) != pos[i2].end()) {
pos[i2].erase(b);
pos[ch - 'a'].insert(b);
break;
}
}
} else {
int cnt = 0;
cin >> c;
rep(i2, 0, 26) {
auto it = pos[i2].lower_bound(b);
if (it != pos[i2].end() && *it <= c)
cnt++;
}
printf("%d\n", cnt);
}
}
return 0;
}
| replace | 93 | 94 | 93 | 94 | TLE | |
p02763 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define RNG(i, from, to) for (int i = (from); i < (int)(to); i++)
#define gcd(i, j) __gcd((i), (j))
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<ll> vecll;
template <typename S, typename T> string to_string(pair<S, T> p) {
return "(" + to_string(p.first) + "," + to_string(p.second) + ")";
}
template <typename T> string to_string(T p[2]) {
return "[" + to_string(p[0]) + "," + to_string(p[1]) + "]";
}
template <typename T> void println(T e) { cout << to_string(e) << endl; }
template <typename T> void println(const vector<T> &v) {
cout << "[";
for (const auto &e : v) {
cout << to_string(e) << ",";
}
cout << "]";
cout << endl;
}
template <typename T> void println(const vector<vector<T>> &vv) {
for (const auto &v : vv) {
println(v);
}
}
template <typename Iter> void println(Iter first, Iter last) {
for (auto it = first; it != last; it++) {
cout << *it << " ";
};
cout << endl;
}
template <typename T> T mod_pow(T x, T n, const T &p) {
T ret = 1;
while (n > 0) {
if (n & 1)
(ret *= x) %= p;
(x *= x) %= p;
n >>= 1;
}
return ret;
}
template <typename T> T mod_inv(T x, const T &p) {
return mod_pow(x, p - 2, p);
}
const ll DVSR = 1e9 + 7;
int N, Q;
string S;
vector<set<int>> st;
int main(int argc, char const *argv[]) {
cin >> N >> S >> Q;
st.assign(26, set<int>());
REP(i, N) st[S[i] - 'a'].insert(i);
REP(i, Q) {
int ty;
cin >> ty;
if (ty == 1) {
int j;
cin >> j;
j--;
char c;
cin >> c;
st[S[j] - 'a'].erase(j);
st[c - 'a'].insert(j);
S[j] = c;
} else {
int l, r;
cin >> l >> r;
l--;
int cnt = 0;
for (auto s : st) {
auto lower = s.lower_bound(l);
cnt += lower != s.end() && *lower < r;
}
cout << cnt << endl;
}
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define RNG(i, from, to) for (int i = (from); i < (int)(to); i++)
#define gcd(i, j) __gcd((i), (j))
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<ll> vecll;
template <typename S, typename T> string to_string(pair<S, T> p) {
return "(" + to_string(p.first) + "," + to_string(p.second) + ")";
}
template <typename T> string to_string(T p[2]) {
return "[" + to_string(p[0]) + "," + to_string(p[1]) + "]";
}
template <typename T> void println(T e) { cout << to_string(e) << endl; }
template <typename T> void println(const vector<T> &v) {
cout << "[";
for (const auto &e : v) {
cout << to_string(e) << ",";
}
cout << "]";
cout << endl;
}
template <typename T> void println(const vector<vector<T>> &vv) {
for (const auto &v : vv) {
println(v);
}
}
template <typename Iter> void println(Iter first, Iter last) {
for (auto it = first; it != last; it++) {
cout << *it << " ";
};
cout << endl;
}
template <typename T> T mod_pow(T x, T n, const T &p) {
T ret = 1;
while (n > 0) {
if (n & 1)
(ret *= x) %= p;
(x *= x) %= p;
n >>= 1;
}
return ret;
}
template <typename T> T mod_inv(T x, const T &p) {
return mod_pow(x, p - 2, p);
}
const ll DVSR = 1e9 + 7;
int N, Q;
string S;
vector<set<int>> st;
int main(int argc, char const *argv[]) {
cin >> N >> S >> Q;
st.assign(26, set<int>());
REP(i, N) st[S[i] - 'a'].insert(i);
REP(i, Q) {
int ty;
cin >> ty;
if (ty == 1) {
int j;
cin >> j;
j--;
char c;
cin >> c;
st[S[j] - 'a'].erase(j);
st[c - 'a'].insert(j);
S[j] = c;
} else {
int l, r;
cin >> l >> r;
l--;
int cnt = 0;
REP(j, 26) {
auto lower = st[j].lower_bound(l);
cnt += lower != st[j].end() && *lower < r;
}
cout << cnt << endl;
}
}
return 0;
} | replace | 74 | 77 | 74 | 77 | TLE | |
p02763 | C++ | Runtime Error | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
#define _LL long long
#define rep(i, n) for (_LL i = 0; i < (_LL)(n); i++)
int main() {
int n;
cin >> n;
string s;
cin >> s;
set<int> *pos = new set<int>[26];
rep(i, n) pos[s[i] - 'a'].insert(i);
int q;
cin >> q;
rep(k, q) {
int t;
cin >> t;
if (t == 1) {
int i;
char c;
cin >> i >> c;
i--;
if (s[i] != c) {
pos[s[i] - 'a'].erase(pos[s[i] - 'a'].find(i));
pos[c - 'a'].insert(i);
}
} else {
int l, r;
cin >> l >> r;
int ans = 0;
l--;
r--;
rep(j, 26) {
auto itr = pos[j].lower_bound(l);
if (itr != pos[j].end() && *itr <= r)
ans++;
}
cout << ans << endl;
}
}
} | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
#define _LL long long
#define rep(i, n) for (_LL i = 0; i < (_LL)(n); i++)
int main() {
int n;
cin >> n;
string s;
cin >> s;
set<int> *pos = new set<int>[26];
rep(i, n) pos[s[i] - 'a'].insert(i);
int q;
cin >> q;
rep(k, q) {
int t;
cin >> t;
if (t == 1) {
int i;
char c;
cin >> i >> c;
i--;
if (s[i] != c) {
pos[s[i] - 'a'].erase(pos[s[i] - 'a'].find(i));
pos[c - 'a'].insert(i);
s[i] = c;
}
} else {
int l, r;
cin >> l >> r;
int ans = 0;
l--;
r--;
rep(j, 26) {
auto itr = pos[j].lower_bound(l);
if (itr != pos[j].end() && *itr <= r)
ans++;
}
cout << ans << endl;
}
}
} | insert | 26 | 26 | 26 | 27 | 0 | |
p02763 | C++ | Runtime Error | #define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define ALL(v) v.begin(), v.end()
typedef long long ll;
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1 << 17;
int N, dat[2 * MAX - 1];
// 初期化
void init(int n) {
N = 1;
while (N < n)
N *= 2;
for (int i = 0; i < 2 * N - 1; i++)
dat[i] = 0;
}
// k番目(0-index)をaに変更
void update(int k, int a) {
k += N - 1;
dat[k] = 1 << a;
while (k > 0) {
k = (k - 1) / 2;
dat[k] = dat[k * 2 + 1] | dat[k * 2 + 2];
}
}
//[a,b)なので0-indexならa--,b--;
int query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return 0;
if (a <= l && r <= b)
return dat[k];
int vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
int vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return vl | vr;
}
int main() {
int n, q;
string s;
cin >> n >> s >> q;
init(n);
rep(i, n) { update(i, s[i] - 'a'); }
int c, a, b;
char d;
rep(i, q) {
cin >> c;
if (c == 1) {
cin >> a >> d;
a--;
update(a, d - 'a');
} else {
cin >> a >> b;
a--, b--;
cout << __builtin_popcount(query(a, b + 1, 0, 0, N)) << endl;
}
}
return 0;
} | #define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define ALL(v) v.begin(), v.end()
typedef long long ll;
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1 << 20;
int N, dat[2 * MAX - 1];
// 初期化
void init(int n) {
N = 1;
while (N < n)
N *= 2;
for (int i = 0; i < 2 * N - 1; i++)
dat[i] = 0;
}
// k番目(0-index)をaに変更
void update(int k, int a) {
k += N - 1;
dat[k] = 1 << a;
while (k > 0) {
k = (k - 1) / 2;
dat[k] = dat[k * 2 + 1] | dat[k * 2 + 2];
}
}
//[a,b)なので0-indexならa--,b--;
int query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return 0;
if (a <= l && r <= b)
return dat[k];
int vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
int vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return vl | vr;
}
int main() {
int n, q;
string s;
cin >> n >> s >> q;
init(n);
rep(i, n) { update(i, s[i] - 'a'); }
int c, a, b;
char d;
rep(i, q) {
cin >> c;
if (c == 1) {
cin >> a >> d;
a--;
update(a, d - 'a');
} else {
cin >> a >> b;
a--, b--;
cout << __builtin_popcount(query(a, b + 1, 0, 0, N)) << endl;
}
}
return 0;
} | replace | 7 | 8 | 7 | 8 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.