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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
p02246
|
C++
|
Runtime Error
|
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
#define MAX_T 50
#define WIDTH 2400
pair<int, vector<vector<int>>> E[MAX_T][WIDTH], D[WIDTH];
vector<vector<int>> X;
int hantei(vector<vector<int>> a) {
int sum = 0;
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
int Num = (a[i][j] + 15) % 16;
if (a[i][j] == 0)
continue;
sum += abs(i - (Num / 4)) + abs(j - (Num % 4));
}
}
return sum;
}
int main() {
for (int i = 0; i < 4; i++) {
vector<int> FF;
for (int j = 0; j < 4; j++) {
int p;
cin >> p;
FF.push_back(p);
}
X.push_back(FF);
}
E[0][0] = make_pair(hantei(X), X);
for (int i = 0; i < MAX_T; i++) {
int CNT = 0;
if (E[i][0].first == 0) {
cout << i << endl;
break;
}
for (int j = 0; j < WIDTH; j++) {
if (E[i][j].second.size() == 0)
break;
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
vector<vector<int>> H = E[i][j].second;
int I = E[i][j].first;
int C = 0;
for (int k = 0; k < 16; k++) {
if (H[k / 4][k % 4] == 0) {
C = k;
}
}
for (int k = 0; k < 4; k++) {
vector<vector<int>> J = H;
int Ex = (C / 4) + dx[k], Ey = (C % 4) + dy[k];
if (Ex < 0 || Ex > 3 || Ey < 0 || Ey > 3)
continue;
swap(J[C / 4][C % 4], J[Ex][Ey]);
D[CNT] = make_pair(hantei(J), J);
CNT++;
}
}
sort(D, D + CNT);
E[i + 1][0] = D[0];
int cnt2 = 1;
for (int k = 1; k < CNT; k++) {
if (D[k - 1] == D[k])
continue;
E[i + 1][cnt2] = D[k];
cnt2++;
}
}
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
#define MAX_T 50
#define WIDTH 9600
pair<int, vector<vector<int>>> E[MAX_T][WIDTH], D[WIDTH];
vector<vector<int>> X;
int hantei(vector<vector<int>> a) {
int sum = 0;
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
int Num = (a[i][j] + 15) % 16;
if (a[i][j] == 0)
continue;
sum += abs(i - (Num / 4)) + abs(j - (Num % 4));
}
}
return sum;
}
int main() {
for (int i = 0; i < 4; i++) {
vector<int> FF;
for (int j = 0; j < 4; j++) {
int p;
cin >> p;
FF.push_back(p);
}
X.push_back(FF);
}
E[0][0] = make_pair(hantei(X), X);
for (int i = 0; i < MAX_T; i++) {
int CNT = 0;
if (E[i][0].first == 0) {
cout << i << endl;
break;
}
for (int j = 0; j < WIDTH; j++) {
if (E[i][j].second.size() == 0)
break;
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
vector<vector<int>> H = E[i][j].second;
int I = E[i][j].first;
int C = 0;
for (int k = 0; k < 16; k++) {
if (H[k / 4][k % 4] == 0) {
C = k;
}
}
for (int k = 0; k < 4; k++) {
vector<vector<int>> J = H;
int Ex = (C / 4) + dx[k], Ey = (C % 4) + dy[k];
if (Ex < 0 || Ex > 3 || Ey < 0 || Ey > 3)
continue;
swap(J[C / 4][C % 4], J[Ex][Ey]);
D[CNT] = make_pair(hantei(J), J);
CNT++;
}
}
sort(D, D + CNT);
E[i + 1][0] = D[0];
int cnt2 = 1;
for (int k = 1; k < CNT; k++) {
if (D[k - 1] == D[k])
continue;
E[i + 1][cnt2] = D[k];
cnt2++;
}
}
return 0;
}
|
replace
| 5 | 6 | 5 | 6 |
0
| |
p02246
|
C++
|
Memory Limit Exceeded
|
#include <array>
#include <cmath>
#include <iostream>
#include <queue>
#include <set>
#include <vector>
using namespace std;
const int N = 4;
const int N2 = N * N;
int MDT[N2][N2];
struct Puzzle {
array<char, N2> board;
int empty;
int cost;
int rank;
bool operator<(const Puzzle &other) const {
return cost + rank > other.cost + other.rank;
}
};
int distance(const Puzzle &p) {
int d = 0;
for (int i = 0; i < N2; ++i) {
d += MDT[i][p.board[i] - 1];
}
return d;
}
const vector<array<int, 2>> dir = {
{-1, 0}, // left
{0, -1}, // up
{1, 0}, // right
{0, 1}, // down
};
int astar(Puzzle start) {
auto puzzle_less = [](const Puzzle &a, const Puzzle &b) {
for (int i = 0; i < N2; ++i) {
if (a.board[i] != b.board[i])
return a.board[i] < b.board[i];
}
return false;
};
Puzzle ans;
set<Puzzle, decltype(puzzle_less)> visited(puzzle_less);
priority_queue<Puzzle> Q;
Q.push(start);
while (!Q.empty()) {
auto u = Q.top();
Q.pop();
if (u.rank == 0) {
return u.cost;
}
visited.insert(u);
auto sx = u.empty % N;
auto sy = u.empty / N;
for (auto &d : dir) {
auto tx = sx + d[0];
auto ty = sy + d[1];
if (tx < 0 || ty < 0 || tx >= N || ty >= N) {
continue;
}
auto v = u;
auto k = tx + ty * N;
swap(v.board[v.empty], v.board[k]);
v.empty = k;
v.rank = distance(v);
if (visited.find(v) == visited.end()) {
++v.cost;
Q.push(v);
}
}
}
return -1;
}
int main() {
for (int i = 0; i < N2; ++i) {
for (int j = 0; j < N2; ++j) {
// iからjへのマンハッタン距離
MDT[i][j] = abs(i / N - j / N) + abs(i % N - j % N);
}
}
Puzzle start;
for (int i = 0; i < N2; ++i) {
int x;
cin >> x;
start.board[i] = x;
if (x == 0) {
start.board[i] = N2;
start.empty = i;
}
}
start.cost = 0;
start.rank = distance(start);
cout << astar(start) << endl;
return 0;
}
|
#include <array>
#include <cmath>
#include <iostream>
#include <queue>
#include <set>
#include <vector>
using namespace std;
const int N = 4;
const int N2 = N * N;
int MDT[N2][N2];
struct Puzzle {
array<char, N2> board;
int empty;
int cost;
int rank;
bool operator<(const Puzzle &other) const {
return cost + rank > other.cost + other.rank;
}
};
int distance(const Puzzle &p) {
int d = 0;
for (int i = 0; i < N2; ++i) {
if (p.board[i] == N2)
continue;
d += MDT[i][p.board[i] - 1];
}
return d;
}
const vector<array<int, 2>> dir = {
{-1, 0}, // left
{0, -1}, // up
{1, 0}, // right
{0, 1}, // down
};
int astar(Puzzle start) {
auto puzzle_less = [](const Puzzle &a, const Puzzle &b) {
for (int i = 0; i < N2; ++i) {
if (a.board[i] != b.board[i])
return a.board[i] < b.board[i];
}
return false;
};
Puzzle ans;
set<Puzzle, decltype(puzzle_less)> visited(puzzle_less);
priority_queue<Puzzle> Q;
Q.push(start);
while (!Q.empty()) {
auto u = Q.top();
Q.pop();
if (u.rank == 0) {
return u.cost;
}
visited.insert(u);
auto sx = u.empty % N;
auto sy = u.empty / N;
for (auto &d : dir) {
auto tx = sx + d[0];
auto ty = sy + d[1];
if (tx < 0 || ty < 0 || tx >= N || ty >= N) {
continue;
}
auto v = u;
auto k = tx + ty * N;
swap(v.board[v.empty], v.board[k]);
v.empty = k;
v.rank = distance(v);
if (visited.find(v) == visited.end()) {
++v.cost;
Q.push(v);
}
}
}
return -1;
}
int main() {
for (int i = 0; i < N2; ++i) {
for (int j = 0; j < N2; ++j) {
// iからjへのマンハッタン距離
MDT[i][j] = abs(i / N - j / N) + abs(i % N - j % N);
}
}
Puzzle start;
for (int i = 0; i < N2; ++i) {
int x;
cin >> x;
start.board[i] = x;
if (x == 0) {
start.board[i] = N2;
start.empty = i;
}
}
start.cost = 0;
start.rank = distance(start);
cout << astar(start) << endl;
return 0;
}
|
insert
| 28 | 28 | 28 | 30 |
MLE
| |
p02246
|
C++
|
Runtime Error
|
#include <assert.h>
#include <iostream>
#include <stdio.h>
#include <vector>
#include <algorithm>
#include <climits>
#include <cmath>
#include <set>
#include <stack>
#include <string>
#define N 4
#define N2 16
using namespace std;
// const int N = 4;
// const int N2 = 16;
static const int dx[4] = {0, -1, 0, 1};
static const int dy[4] = {1, 0, -1, 0};
static const char dir[4] = {'r', 'u', 'l', 'd'};
typedef struct Node {
int puzzle[N2];
int space;
int md;
int depth;
int pre;
} Node;
Node s_node;
Node cur_n;
int md[N2][N2];
int ans;
int get_md_sum(int *puzzle) {
int sum = 0;
for (int i = 0; i < N2; ++i) {
if (puzzle[i] == N2)
continue;
sum += md[i][puzzle[i] - 1];
}
return sum;
}
void set_md() {
for (int i = 0; i < N2; ++i) {
for (int j = 0; j < N2; ++j) {
md[i][j] = abs(i / N - j / N) + abs(i % N - j % N);
}
}
}
void input_table() {
s_node = Node();
int in[N2];
for (int i = 0; i < N2; ++i) {
int tmp;
scanf("%d", tmp);
// cin >> tmp;
if (tmp == 0) {
tmp = N2;
s_node.space = i;
}
s_node.puzzle[i] = tmp;
}
set_md();
s_node.md = get_md_sum(s_node.puzzle);
s_node.depth = 0;
s_node.pre = -10;
}
bool dfs(int limit) {
stack<Node> st;
st.push(s_node);
while (!st.empty()) {
Node cur_n = st.top();
st.pop();
if (cur_n.md == 0) {
ans = cur_n.depth;
return true;
}
if (cur_n.depth + cur_n.md > limit)
continue;
int s_x = cur_n.space / N;
int s_y = cur_n.space % N;
for (int i = 0; i < 4; ++i) {
Node next_n = cur_n;
int new_x = s_x + dx[i];
int new_y = s_y + dy[i];
if (new_x < 0 || new_y < 0 || new_x >= N || new_y >= N)
continue;
if (max(cur_n.pre, i) - min(cur_n.pre, i) == 2)
continue;
// incremental manhattan distance
next_n.md -= md[new_x * N + new_y][next_n.puzzle[new_x * N + new_y] - 1];
next_n.md += md[s_x * N + s_y][next_n.puzzle[new_x * N + new_y] - 1];
swap(next_n.puzzle[new_x * N + new_y], next_n.puzzle[s_x * N + s_y]);
next_n.space = new_x * N + new_y;
// assert(get_md_sum(new_n.puzzle) == new_n.md);
// return dfs(new_n, depth+1, i);
next_n.depth++;
if (cur_n.depth + cur_n.md > limit)
continue;
next_n.pre = i;
st.push(next_n);
if (next_n.md == 0) {
ans = next_n.depth;
return true;
}
}
}
return false;
}
void ida_star() {
for (int limit = s_node.md; limit < 1000; ++limit, ++limit) {
// path.resize(limit);
cur_n = s_node;
if (dfs(limit)) {
printf("%d\n", limit);
return;
}
}
}
int main() {
input_table();
ida_star();
}
|
#include <assert.h>
#include <iostream>
#include <stdio.h>
#include <vector>
#include <algorithm>
#include <climits>
#include <cmath>
#include <set>
#include <stack>
#include <string>
#define N 4
#define N2 16
using namespace std;
// const int N = 4;
// const int N2 = 16;
static const int dx[4] = {0, -1, 0, 1};
static const int dy[4] = {1, 0, -1, 0};
static const char dir[4] = {'r', 'u', 'l', 'd'};
typedef struct Node {
int puzzle[N2];
int space;
int md;
int depth;
int pre;
} Node;
Node s_node;
Node cur_n;
int md[N2][N2];
int ans;
int get_md_sum(int *puzzle) {
int sum = 0;
for (int i = 0; i < N2; ++i) {
if (puzzle[i] == N2)
continue;
sum += md[i][puzzle[i] - 1];
}
return sum;
}
void set_md() {
for (int i = 0; i < N2; ++i) {
for (int j = 0; j < N2; ++j) {
md[i][j] = abs(i / N - j / N) + abs(i % N - j % N);
}
}
}
void input_table() {
s_node = Node();
int in[N2];
for (int i = 0; i < N2; ++i) {
int tmp;
scanf("%d", &tmp);
// cin >> tmp;
if (tmp == 0) {
tmp = N2;
s_node.space = i;
}
s_node.puzzle[i] = tmp;
}
set_md();
s_node.md = get_md_sum(s_node.puzzle);
s_node.depth = 0;
s_node.pre = -10;
}
bool dfs(int limit) {
stack<Node> st;
st.push(s_node);
while (!st.empty()) {
Node cur_n = st.top();
st.pop();
if (cur_n.md == 0) {
ans = cur_n.depth;
return true;
}
if (cur_n.depth + cur_n.md > limit)
continue;
int s_x = cur_n.space / N;
int s_y = cur_n.space % N;
for (int i = 0; i < 4; ++i) {
Node next_n = cur_n;
int new_x = s_x + dx[i];
int new_y = s_y + dy[i];
if (new_x < 0 || new_y < 0 || new_x >= N || new_y >= N)
continue;
if (max(cur_n.pre, i) - min(cur_n.pre, i) == 2)
continue;
// incremental manhattan distance
next_n.md -= md[new_x * N + new_y][next_n.puzzle[new_x * N + new_y] - 1];
next_n.md += md[s_x * N + s_y][next_n.puzzle[new_x * N + new_y] - 1];
swap(next_n.puzzle[new_x * N + new_y], next_n.puzzle[s_x * N + s_y]);
next_n.space = new_x * N + new_y;
// assert(get_md_sum(new_n.puzzle) == new_n.md);
// return dfs(new_n, depth+1, i);
next_n.depth++;
if (cur_n.depth + cur_n.md > limit)
continue;
next_n.pre = i;
st.push(next_n);
if (next_n.md == 0) {
ans = next_n.depth;
return true;
}
}
}
return false;
}
void ida_star() {
for (int limit = s_node.md; limit < 1000; ++limit, ++limit) {
// path.resize(limit);
cur_n = s_node;
if (dfs(limit)) {
printf("%d\n", limit);
return;
}
}
}
int main() {
input_table();
ida_star();
}
|
replace
| 60 | 61 | 60 | 61 |
-11
| |
p02246
|
C++
|
Time Limit Exceeded
|
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
#define MAX_T 50
#define WIDTH 21000
pair<int, vector<vector<int>>> E[MAX_T][WIDTH], D[WIDTH];
vector<vector<int>> X;
int hantei(vector<vector<int>> a) {
int sum = 0;
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
int Num = (a[i][j] + 15) % 16;
if (a[i][j] == 0)
continue;
sum += abs(i - (Num / 4)) + abs(j - (Num % 4));
}
}
return sum;
}
int main() {
for (int i = 0; i < 4; i++) {
vector<int> FF;
for (int j = 0; j < 4; j++) {
int p;
cin >> p;
FF.push_back(p);
}
X.push_back(FF);
}
E[0][0] = make_pair(hantei(X), X);
for (int i = 0; i < MAX_T; i++) {
int CNT = 0;
if (E[i][0].first == 0) {
cout << i << endl;
break;
}
for (int j = 0; j < WIDTH; j++) {
if (E[i][j].second.size() == 0)
break;
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
vector<vector<int>> H = E[i][j].second;
int I = E[i][j].first;
int C = 0;
for (int k = 0; k < 16; k++) {
if (H[k / 4][k % 4] == 0) {
C = k;
}
}
for (int k = 0; k < 4; k++) {
vector<vector<int>> J = H;
int Ex = (C / 4) + dx[k], Ey = (C % 4) + dy[k];
if (Ex < 0 || Ex > 3 || Ey < 0 || Ey > 3)
continue;
swap(J[C / 4][C % 4], J[Ex][Ey]);
D[CNT] = make_pair(hantei(J), J);
CNT++;
}
}
sort(D, D + CNT);
E[i + 1][0] = D[0];
int cnt2 = 1;
for (int k = 1; k < CNT; k++) {
if (D[k - 1] == D[k])
continue;
E[i + 1][cnt2] = D[k];
cnt2++;
}
}
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
#define MAX_T 50
#define WIDTH 20000
pair<int, vector<vector<int>>> E[MAX_T][WIDTH], D[WIDTH];
vector<vector<int>> X;
int hantei(vector<vector<int>> a) {
int sum = 0;
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
int Num = (a[i][j] + 15) % 16;
if (a[i][j] == 0)
continue;
sum += abs(i - (Num / 4)) + abs(j - (Num % 4));
}
}
return sum;
}
int main() {
for (int i = 0; i < 4; i++) {
vector<int> FF;
for (int j = 0; j < 4; j++) {
int p;
cin >> p;
FF.push_back(p);
}
X.push_back(FF);
}
E[0][0] = make_pair(hantei(X), X);
for (int i = 0; i < MAX_T; i++) {
int CNT = 0;
if (E[i][0].first == 0) {
cout << i << endl;
break;
}
for (int j = 0; j < WIDTH; j++) {
if (E[i][j].second.size() == 0)
break;
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
vector<vector<int>> H = E[i][j].second;
int I = E[i][j].first;
int C = 0;
for (int k = 0; k < 16; k++) {
if (H[k / 4][k % 4] == 0) {
C = k;
}
}
for (int k = 0; k < 4; k++) {
vector<vector<int>> J = H;
int Ex = (C / 4) + dx[k], Ey = (C % 4) + dy[k];
if (Ex < 0 || Ex > 3 || Ey < 0 || Ey > 3)
continue;
swap(J[C / 4][C % 4], J[Ex][Ey]);
D[CNT] = make_pair(hantei(J), J);
CNT++;
}
}
sort(D, D + CNT);
E[i + 1][0] = D[0];
int cnt2 = 1;
for (int k = 1; k < CNT; k++) {
if (D[k - 1] == D[k])
continue;
E[i + 1][cnt2] = D[k];
cnt2++;
}
}
return 0;
}
|
replace
| 5 | 6 | 5 | 6 |
TLE
| |
p02247
|
C++
|
Runtime Error
|
// ALDS1_14_A
#include <iostream>
#include <string>
using namespace std;
int main() {
string T, P;
cin >> T;
cin >> P;
for (int i = 0; i <= T.length() - P.length(); i++)
if (T.substr(i, P.length()) == P)
cout << i << endl;
return 0;
}
|
// ALDS1_14_A
#include <iostream>
#include <string>
using namespace std;
int main() {
string T, P;
cin >> T;
cin >> P;
if (T.length() >= P.length())
for (int i = 0; i <= T.length() - P.length(); i++)
if (T.substr(i, P.length()) == P)
cout << i << endl;
return 0;
}
|
replace
| 11 | 14 | 11 | 15 |
0
| |
p02247
|
C++
|
Runtime Error
|
#include <iostream>
#include <string>
using namespace std;
int main() {
string a, b;
int tmp;
cin >> a >> b;
for (int i = 0; i < a.size() - b.size() + 1; i++) {
if (a[i] == b[0]) {
tmp = 1;
for (int j = 0; j < b.size(); j++)
if (a[i + j] != b[j]) {
tmp = 0;
break;
}
if (tmp)
cout << i << endl;
}
}
return 0;
}
|
#include <iostream>
#include <string>
using namespace std;
int main() {
string a, b;
int tmp;
cin >> a >> b;
if (a.size() < b.size())
return 0;
for (int i = 0; i < a.size() - b.size() + 1; i++) {
if (a[i] == b[0]) {
tmp = 1;
for (int j = 0; j < b.size(); j++)
if (a[i + j] != b[j]) {
tmp = 0;
break;
}
if (tmp)
cout << i << endl;
}
}
return 0;
}
|
insert
| 8 | 8 | 8 | 10 |
0
| |
p02247
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
#define rep(i, a, n) for (int i = a; i < n; i++)
#define repb(i, a, b) for (int i = a; i >= b; i--)
#define all(a) a.begin(), a.end()
#define int long long
using namespace std;
typedef pair<int, int> P;
struct RollingHash {
typedef long long ll;
typedef pair<ll, ll> pll;
ll base1;
ll base2;
ll mod1;
ll mod2;
vector<ll> hash1;
vector<ll> hash2;
vector<ll> pow1;
vector<ll> pow2;
RollingHash()
: base1(1009), base2(1007), mod1(1000000007), mod2(1000000009) {}
void init(const string &s) {
int n = s.size();
hash1.assign(n + 1, 0);
hash2.assign(n + 1, 0);
pow1.assign(n + 1, 1);
pow2.assign(n + 1, 1);
for (int i = 0; i < n; i++) {
hash1[i + 1] = (hash1[i] + s[i]) * base1 % mod1;
hash2[i + 1] = (hash2[i] + s[i]) * base2 % mod2;
pow1[i + 1] = pow1[i] * base1 % mod1;
pow2[i + 1] = pow2[i] * base2 % mod2;
}
}
//[l, r)
pll get(int l, int r) {
ll t1 = ((hash1[r] - hash1[l] * pow1[r - l]) % mod1 + mod1) % mod1;
ll t2 = ((hash2[r] - hash2[l] * pow2[r - l]) % mod2 + mod2) % mod2;
return make_pair(t1, t2);
}
RollingHash::pll concat(pll h1, pll h2, int h2_len) {
return make_pair((h1.first * pow1[h2_len] + h2.first) % mod1,
(h1.second * pow2[h2_len] + h2.second) % mod2);
}
};
signed main() {
string s, t;
cin >> s >> t;
RollingHash rs, rt;
rs.init(s);
rt.init(t);
P p = rt.get(0, t.size());
rep(i, 0, s.size() - t.size() + 1) {
P q = rs.get(i, i + t.size());
if (p.first == q.first && p.second == q.second) {
cout << i << endl;
}
}
}
|
#include <bits/stdc++.h>
#define rep(i, a, n) for (int i = a; i < n; i++)
#define repb(i, a, b) for (int i = a; i >= b; i--)
#define all(a) a.begin(), a.end()
#define int long long
using namespace std;
typedef pair<int, int> P;
struct RollingHash {
typedef long long ll;
typedef pair<ll, ll> pll;
ll base1;
ll base2;
ll mod1;
ll mod2;
vector<ll> hash1;
vector<ll> hash2;
vector<ll> pow1;
vector<ll> pow2;
RollingHash()
: base1(1009), base2(1007), mod1(1000000007), mod2(1000000009) {}
void init(const string &s) {
int n = s.size();
hash1.assign(n + 1, 0);
hash2.assign(n + 1, 0);
pow1.assign(n + 1, 1);
pow2.assign(n + 1, 1);
for (int i = 0; i < n; i++) {
hash1[i + 1] = (hash1[i] + s[i]) * base1 % mod1;
hash2[i + 1] = (hash2[i] + s[i]) * base2 % mod2;
pow1[i + 1] = pow1[i] * base1 % mod1;
pow2[i + 1] = pow2[i] * base2 % mod2;
}
}
//[l, r)
pll get(int l, int r) {
ll t1 = ((hash1[r] - hash1[l] * pow1[r - l]) % mod1 + mod1) % mod1;
ll t2 = ((hash2[r] - hash2[l] * pow2[r - l]) % mod2 + mod2) % mod2;
return make_pair(t1, t2);
}
RollingHash::pll concat(pll h1, pll h2, int h2_len) {
return make_pair((h1.first * pow1[h2_len] + h2.first) % mod1,
(h1.second * pow2[h2_len] + h2.second) % mod2);
}
};
signed main() {
string s, t;
cin >> s >> t;
if (s.size() < t.size())
return 0;
RollingHash rs, rt;
rs.init(s);
rt.init(t);
P p = rt.get(0, t.size());
rep(i, 0, s.size() - t.size() + 1) {
P q = rs.get(i, i + t.size());
if (p.first == q.first && p.second == q.second) {
cout << i << endl;
}
}
}
|
insert
| 55 | 55 | 55 | 57 |
0
| |
p02247
|
C++
|
Runtime Error
|
#include <iostream>
int main() {
std::ios_base::sync_with_stdio(false);
std::string a;
std::string b;
std::cin >> a;
std::cin >> b;
bool match = false;
for (int i = 0; i <= (a.size() - b.size()); i++) {
match = true;
for (int j = 0; j < b.size(); j++) {
if (a[i + j] != b[j]) {
match = false;
break;
}
}
if (match) {
std::cout << i << std::endl;
}
}
return 0;
}
|
#include <iostream>
int main() {
std::ios_base::sync_with_stdio(false);
std::string a;
std::string b;
std::cin >> a;
std::cin >> b;
bool match = false;
if (a.size() < b.size()) {
return 0;
}
for (int i = 0; i <= (a.size() - b.size()); i++) {
match = true;
for (int j = 0; j < b.size(); j++) {
if (a[i + j] != b[j]) {
match = false;
break;
}
}
if (match) {
std::cout << i << std::endl;
}
}
return 0;
}
|
insert
| 12 | 12 | 12 | 16 |
0
| |
p02247
|
C++
|
Runtime Error
|
#include <iostream>
#include <vector>
using namespace std;
int main(int argc, char *argv[]) {
int count = 0;
vector<int> index;
string a, b;
cin >> a >> b;
for (int i = 0; i <= a.size() - b.size(); i++) {
if (a.substr(i, b.size()) == b) {
count++;
index.push_back(i);
}
}
if (count != 0) {
for (int i : index)
cout << i << endl;
}
}
|
#include <iostream>
#include <vector>
using namespace std;
int main(int argc, char *argv[]) {
int count = 0;
vector<int> index;
string a, b;
cin >> a >> b;
if (a.size() < b.size())
return 0;
for (int i = 0; i <= a.size() - b.size(); i++) {
if (a.substr(i, b.size()) == b) {
count++;
index.push_back(i);
}
}
if (count != 0) {
for (int i : index)
cout << i << endl;
}
}
|
insert
| 8 | 8 | 8 | 10 |
0
| |
p02247
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string t, p;
cin >> t >> p;
for (int i = 0; i < t.size() - p.size() + 1; i++) {
int f = 0;
for (int j = 0; j < p.size(); j++)
if (t[i + j] != p[j])
f = 1;
if (f)
continue;
cout << i << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string t, p;
cin >> t >> p;
if (t.size() >= p.size())
for (int i = 0; i < t.size() - p.size() + 1; i++) {
int f = 0;
for (int j = 0; j < p.size(); j++)
if (t[i + j] != p[j])
f = 1;
if (f)
continue;
cout << i << endl;
}
return 0;
}
|
replace
| 5 | 14 | 5 | 15 |
0
| |
p02247
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
void brute_force(string T, string P) {
const char *Tc = T.c_str();
const char *Pc = P.c_str();
int i, j;
for (i = 0; i < T.length() - P.length() + 1; i++) {
for (j = 0; j < P.length(); j++) {
if (Tc[i + j] != Pc[j])
break;
if (j == P.length() - 1)
cout << i << endl;
}
}
}
int main() {
string T, P;
cin >> T >> P;
brute_force(T, P);
return 0;
}
|
#include <algorithm>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
void brute_force(string T, string P) {
const char *Tc = T.c_str();
const char *Pc = P.c_str();
int i, j;
for (i = 0; i < (int)T.length() - (int)P.length() + 1; i++) {
for (j = 0; j < P.length(); j++) {
if (Tc[i + j] != Pc[j])
break;
if (j == P.length() - 1)
cout << i << endl;
}
}
}
int main() {
string T, P;
cin >> T >> P;
brute_force(T, P);
return 0;
}
|
replace
| 19 | 20 | 19 | 20 |
0
| |
p02247
|
C++
|
Runtime Error
|
#include <iostream>
#include <string>
using namespace std;
string s, t;
int main() {
cin >> s >> t;
for (int i = 0; i < s.size() - t.size() + 1; i++) {
for (int j = 0; j < t.size(); j++) {
if (s[i + j] != t[j]) {
break;
}
if (j == t.size() - 1 && s[i + j] == t[j]) {
cout << i << endl;
}
}
}
return 0;
}
|
#include <iostream>
#include <string>
using namespace std;
string s, t;
int main() {
cin >> s >> t;
if (s.size() < t.size()) {
return 0;
}
for (int i = 0; i < s.size() - t.size() + 1; i++) {
for (int j = 0; j < t.size(); j++) {
if (s[i + j] != t[j]) {
break;
}
if (j == t.size() - 1 && s[i + j] == t[j]) {
cout << i << endl;
}
}
}
return 0;
}
|
insert
| 8 | 8 | 8 | 11 |
0
| |
p02247
|
C++
|
Runtime Error
|
#include <iostream>
#include <string>
using namespace std;
int main() {
string S, T;
cin >> S >> T;
for (int i = 0; i <= S.size() - T.size(); i++) {
if (T == S.substr(i, T.size())) {
cout << i << endl;
}
}
return 0;
}
|
#include <iostream>
#include <string>
using namespace std;
int main() {
string S, T;
cin >> S >> T;
if (S.size() >= T.size()) {
for (int i = 0; i <= S.size() - T.size(); i++) {
if (T == S.substr(i, T.size())) {
cout << i << endl;
}
}
}
return 0;
}
|
replace
| 10 | 13 | 10 | 15 |
0
| |
p02247
|
C++
|
Time Limit Exceeded
|
#include <iostream>
#include <string>
#define rep(i, n) for (int i = 0; i < n; ++i)
using namespace std;
int main(void) {
string t;
string p;
cin >> t;
cin >> p;
rep(i, t.size() - p.size() + 1) {
rep(j, p.size()) {
if (i + j >= t.size() || t[i + j] != p[j])
break;
;
if (j == p.size() - 1) {
cout << i << endl;
}
}
}
return 0;
}
|
#include <iostream>
#include <string>
#define rep(i, n) for (int i = 0; i < n; ++i)
using namespace std;
int main(void) {
string t;
string p;
cin >> t;
cin >> p;
rep(i, (int)t.size() - (int)p.size() + 1) {
rep(j, p.size()) {
if (i + j >= t.size() || t[i + j] != p[j])
break;
;
if (j == p.size() - 1) {
cout << i << endl;
}
}
}
return 0;
}
|
replace
| 11 | 12 | 11 | 12 |
TLE
| |
p02247
|
C++
|
Runtime Error
|
#include <algorithm>
#include <bitset>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> i_i;
typedef pair<long long, int> ll_i;
typedef pair<double, int> d_i;
typedef pair<long long, long long> ll_ll;
typedef pair<double, double> d_d;
typedef vector<int> Vint;
#define PI 3.141592653589793238462643383279
#define mod 1000000007LL
#define rep(i, n) for (i = 0; i < n; ++i)
#define rep1(i, n) for (i = 1; i < n; ++i)
#define rep2d(i, j, n) \
for (i = 0; i < n; ++i) \
for (j = i + 1; j < n; ++j)
#define per(i, n) for (i = n - 1; i > -1; --i)
#define int(x) \
int x; \
scanf("%d", &x)
#define int2(x, y) \
int x, y; \
scanf("%d%d", &x, &y)
#define int3(x, y, z) \
int x, y, z; \
scanf("%d%d%d", &x, &y, &z)
#define int4(v, x, y, z) \
int v, x, y, z; \
scanf("%d%d%d%d", &v, &x, &y, &z)
#define int5(v, w, x, y, z) \
int v, w, x, y, z; \
scanf("%d%d%d%d%d", &v, &w, &x, &y, &z)
#define scn(n, a) rep(i, n) cin >> a[i]
#define sc2n(n, a, b) rep(i, n) cin >> a[i] >> b[i]
#define pri(x) cout << x << "\n"
#define pri2(x, y) cout << x << " " << y << "\n"
#define pri3(x, y, z) cout << x << " " << y << " " << z << "\n"
#define pb push_back
#define mp make_pair
#define all(a) (a).begin(), (a).end()
#define endl "\n"
#define kabe puts("---------------------------")
#define kara puts("")
#define debug(x) cout << " --- " << x << "\n"
#define debug2(x, y) cout << " --- " << x << " " << y << "\n"
#define debug3(x, y, z) cout << " --- " << x << " " << y << " " << z << "\n"
#define X first
#define Y second
#define eps 0.0001
#define prid(x) printf("%.15lf\n", x)
signed main(void) {
int i, j, k;
for (int testcase = 0; testcase < 1234567; testcase++) {
string t, p;
cin >> t >> p;
rep(i, t.size() - p.size() + 1) if (t.substr(i, p.size()) == p) pri(i);
/*/
//*/
break;
}
return 0;
}
|
#include <algorithm>
#include <bitset>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> i_i;
typedef pair<long long, int> ll_i;
typedef pair<double, int> d_i;
typedef pair<long long, long long> ll_ll;
typedef pair<double, double> d_d;
typedef vector<int> Vint;
#define PI 3.141592653589793238462643383279
#define mod 1000000007LL
#define rep(i, n) for (i = 0; i < n; ++i)
#define rep1(i, n) for (i = 1; i < n; ++i)
#define rep2d(i, j, n) \
for (i = 0; i < n; ++i) \
for (j = i + 1; j < n; ++j)
#define per(i, n) for (i = n - 1; i > -1; --i)
#define int(x) \
int x; \
scanf("%d", &x)
#define int2(x, y) \
int x, y; \
scanf("%d%d", &x, &y)
#define int3(x, y, z) \
int x, y, z; \
scanf("%d%d%d", &x, &y, &z)
#define int4(v, x, y, z) \
int v, x, y, z; \
scanf("%d%d%d%d", &v, &x, &y, &z)
#define int5(v, w, x, y, z) \
int v, w, x, y, z; \
scanf("%d%d%d%d%d", &v, &w, &x, &y, &z)
#define scn(n, a) rep(i, n) cin >> a[i]
#define sc2n(n, a, b) rep(i, n) cin >> a[i] >> b[i]
#define pri(x) cout << x << "\n"
#define pri2(x, y) cout << x << " " << y << "\n"
#define pri3(x, y, z) cout << x << " " << y << " " << z << "\n"
#define pb push_back
#define mp make_pair
#define all(a) (a).begin(), (a).end()
#define endl "\n"
#define kabe puts("---------------------------")
#define kara puts("")
#define debug(x) cout << " --- " << x << "\n"
#define debug2(x, y) cout << " --- " << x << " " << y << "\n"
#define debug3(x, y, z) cout << " --- " << x << " " << y << " " << z << "\n"
#define X first
#define Y second
#define eps 0.0001
#define prid(x) printf("%.15lf\n", x)
signed main(void) {
int i, j, k;
for (int testcase = 0; testcase < 1234567; testcase++) {
string t, p;
cin >> t >> p;
if (t.size() < p.size())
break;
rep(i, t.size() - p.size() + 1) if (t.substr(i, p.size()) == p) pri(i);
/*/
//*/
break;
}
return 0;
}
|
insert
| 81 | 81 | 81 | 83 |
0
| |
p02247
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
struct RollingHash {
typedef long long int_type;
typedef pair<int_type, int_type> hash_type;
int_type base, mod[2];
vector<int_type> hashed[2], power[2];
RollingHash() { base = 9973LL, mod[0] = 999999937LL, mod[1] = 1000000007LL; }
void init(const string &s) {
int sz = s.size();
for (int i = 0; i < 2; i++) {
hashed[i].assign(sz + 1, 0);
power[i].assign(sz + 1, 0);
hashed[i][0] = 0;
power[i][0] = 1;
for (int j = 0; j < sz; j++) {
power[i][j + 1] = power[i][j] * base % mod[i];
hashed[i][j + 1] = (hashed[i][j] + s[j]) * base % mod[i];
}
}
}
hash_type get(int l, int r) {
int_type hash1 =
((hashed[0][r] - hashed[0][l] * power[0][r - l]) % mod[0] + mod[0]) %
mod[0];
int_type hash2 =
((hashed[1][r] - hashed[1][l] * power[1][r - l]) % mod[1] + mod[1]) %
mod[1];
return hash_type(hash1, hash2);
}
hash_type concat(hash_type hash1, hash_type hash2, int hash2_len) {
return hash_type((hash1.first * power[0][hash2_len] + hash2.first) % mod[0],
(hash1.second * power[1][hash2_len] + hash2.second) %
mod[1]);
}
};
int main() {
string T, P;
cin >> T >> P;
RollingHash rollhash[2];
rollhash[0].init(T);
rollhash[1].init(P);
for (int i = 0; i <= T.size() - P.size(); i++) {
if (rollhash[0].get(i, i + P.size()) == rollhash[1].get(0, P.size()))
cout << i << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct RollingHash {
typedef long long int_type;
typedef pair<int_type, int_type> hash_type;
int_type base, mod[2];
vector<int_type> hashed[2], power[2];
RollingHash() { base = 9973LL, mod[0] = 999999937LL, mod[1] = 1000000007LL; }
void init(const string &s) {
int sz = s.size();
for (int i = 0; i < 2; i++) {
hashed[i].assign(sz + 1, 0);
power[i].assign(sz + 1, 0);
hashed[i][0] = 0;
power[i][0] = 1;
for (int j = 0; j < sz; j++) {
power[i][j + 1] = power[i][j] * base % mod[i];
hashed[i][j + 1] = (hashed[i][j] + s[j]) * base % mod[i];
}
}
}
hash_type get(int l, int r) {
int_type hash1 =
((hashed[0][r] - hashed[0][l] * power[0][r - l]) % mod[0] + mod[0]) %
mod[0];
int_type hash2 =
((hashed[1][r] - hashed[1][l] * power[1][r - l]) % mod[1] + mod[1]) %
mod[1];
return hash_type(hash1, hash2);
}
hash_type concat(hash_type hash1, hash_type hash2, int hash2_len) {
return hash_type((hash1.first * power[0][hash2_len] + hash2.first) % mod[0],
(hash1.second * power[1][hash2_len] + hash2.second) %
mod[1]);
}
};
int main() {
string T, P;
cin >> T >> P;
RollingHash rollhash[2];
rollhash[0].init(T);
rollhash[1].init(P);
for (int i = 0; i <= (int)(T.size() - P.size()); i++) {
if (rollhash[0].get(i, i + P.size()) == rollhash[1].get(0, P.size()))
cout << i << endl;
}
return 0;
}
|
replace
| 55 | 56 | 55 | 56 |
0
| |
p02248
|
C++
|
Time Limit Exceeded
|
#include <iostream>
#include <string>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
string t, p;
cin >> t >> p;
int tl = t.length();
int pl = p.length();
int skip[256];
for (int i = 0; i < 256; i++)
skip[i] = pl;
for (int i = 0; i < pl - 1; i++)
skip[(unsigned)p[i]] = pl - 1 - i;
for (int pos = 0; pos <= tl - pl; pos += skip[(unsigned)t[pos + pl - 1]]) {
for (int i = pl - 1; i >= 0; i--) {
if (t[pos + i] != p[i])
break;
if (i == 0)
cout << pos << '\n';
}
}
return 0;
}
|
#include <iostream>
#include <string>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
string t, p;
cin >> t >> p;
for (int pos = 0; pos < t.length(); pos++) {
pos = t.find(p, pos);
if (pos == string::npos)
break;
cout << pos << '\n';
}
return 0;
}
|
replace
| 9 | 23 | 9 | 14 |
TLE
| |
p02248
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
typedef unsigned long long ull;
using namespace std;
void Rolling_Hash(const string &a, const string &b) {
const ull B = 100000007;
int al = a.length(), bl = b.length();
if (al > bl)
return;
ull t = 1;
for (int i = 0; i < al; i++)
t *= B;
ull ah = 0, bh = 0;
for (int i = 0; i < al; i++)
ah = ah * B + a[i];
for (int i = 0; i < al; i++)
bh = bh * B + b[i];
for (int i = 0; i + al <= bl; i++) {
if (ah == bh && a == b.substr(i, al))
cout << i << endl;
if (i + al < bl)
bh = bh * B + b[i + al] - b[i] * t;
}
}
int main() {
string T, P;
cin >> T >> P;
Rolling_Hash(P, T);
return 0;
}
|
#include <bits/stdc++.h>
typedef unsigned long long ull;
using namespace std;
void Rolling_Hash(const string &a, const string &b) {
const ull B = 100000007;
int al = a.length(), bl = b.length();
if (al > bl)
return;
ull t = 1;
for (int i = 0; i < al; i++)
t *= B;
ull ah = 0, bh = 0;
for (int i = 0; i < al; i++)
ah = ah * B + a[i];
for (int i = 0; i < al; i++)
bh = bh * B + b[i];
for (int i = 0; i + al <= bl; i++) {
if (ah == bh)
cout << i << endl;
if (i + al < bl)
bh = bh * B + b[i + al] - b[i] * t;
}
}
int main() {
string T, P;
cin >> T >> P;
Rolling_Hash(P, T);
return 0;
}
|
replace
| 21 | 22 | 21 | 22 |
TLE
| |
p02248
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
#define base 950527
using namespace std;
typedef unsigned long long ll;
map<ll, ll> map;
int main() {
string a, b;
cin >> a >> b;
ll hs = 0, n = 0, t = 1;
for (int i = 0; i < b.size(); i++) {
hs = hs * base + b[i];
n = n * base + a[i];
t *= base;
}
if (hs == n)
cout << 0 << endl;
for (int i = b.size(); i < a.size(); i++) {
n = n * base - t * a[i - b.size()];
n += a[i];
if (hs == n)
cout << i - b.size() + 1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#define base 950527
using namespace std;
typedef unsigned long long ll;
map<ll, ll> map;
int main() {
string a, b;
cin >> a >> b;
ll hs = 0, n = 0, t = 1;
for (int i = 0; i < b.size(); i++) {
hs = hs * base + b[i];
n = n * base + a[i];
t *= base;
}
if (hs == n)
cout << 0 << endl;
for (int i = b.size(); i < a.size(); i++) {
n = n * base - t * a[i - b.size()];
n += a[i];
if (hs == n)
printf("%d\n", i - (int)b.size() + 1);
}
return 0;
}
|
replace
| 23 | 24 | 23 | 24 |
TLE
| |
p02248
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cmath>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef unsigned long long lli;
typedef unsigned long long ull;
typedef vector<lli> vll;
typedef vector<bool> vbl;
typedef vector<vector<lli>> mat;
typedef vector<vector<bool>> matb;
typedef vector<string> vst;
typedef pair<lli, lli> pll;
typedef pair<double, double> pdd;
string t;
string p;
const ull b = 1000000007;
ull hsh = 0;
ull cmp = 0;
vll vb;
int main() {
cin >> t >> p;
vb = vll(p.size());
vb[0] = 1;
for (lli i = 1; i < p.size(); i++) {
vb[i] = vb[i - 1] * b;
}
for (lli i = 0; i < p.size(); i++) {
hsh += ((lli)p[i]) * vb[p.size() - i - 1];
cmp += ((lli)t[i]) * vb[p.size() - i - 1];
}
for (lli i = 0; i < t.size() - p.size(); i++) {
if (hsh == cmp)
cout << i << endl;
cmp -= vb.back() * t[i];
cmp *= b;
cmp += t[i + p.size()];
}
if (cmp == hsh)
cout << t.size() - p.size() << endl;
return 0;
}
|
#include <algorithm>
#include <cmath>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef unsigned long long lli;
typedef unsigned long long ull;
typedef vector<lli> vll;
typedef vector<bool> vbl;
typedef vector<vector<lli>> mat;
typedef vector<vector<bool>> matb;
typedef vector<string> vst;
typedef pair<lli, lli> pll;
typedef pair<double, double> pdd;
string t;
string p;
const ull b = 1000000007;
ull hsh = 0;
ull cmp = 0;
vll vb;
int main() {
cin >> t >> p;
if (t.size() < p.size())
return 0;
vb = vll(p.size());
vb[0] = 1;
for (lli i = 1; i < p.size(); i++) {
vb[i] = vb[i - 1] * b;
}
for (lli i = 0; i < p.size(); i++) {
hsh += ((lli)p[i]) * vb[p.size() - i - 1];
cmp += ((lli)t[i]) * vb[p.size() - i - 1];
}
for (lli i = 0; i < t.size() - p.size(); i++) {
if (hsh == cmp)
cout << i << endl;
cmp -= vb.back() * t[i];
cmp *= b;
cmp += t[i + p.size()];
}
if (cmp == hsh)
cout << t.size() - p.size() << endl;
return 0;
}
|
insert
| 32 | 32 | 32 | 34 |
0
| |
p02248
|
C++
|
Time Limit Exceeded
|
#include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#define rep(i, a) REP(i, 0, a)
#define REP(i, a, b) for (int i = a; i < b; ++i)
#define rrep(i, a) RREP(i, a, 0)
#define RREP(i, a, b) for (int i = a; i >= b; --i)
#define repll(i, a) REPLL(i, 0, a)
#define REPLL(i, a, b) for (ll i = a; i < b; ++i)
#define rrepll(i, a) RREPLL(i, a, 0)
#define RREPLL(i, a, b) for (ll i = a; i >= b; --i)
typedef long long ll;
typedef unsigned long long ull;
typedef std::pair<int, int> P;
typedef std::pair<int, P> PP;
const double PI = 3.14159265358979323846;
const double esp = 1e-9;
const int infi = (int)1e+9 + 10;
const ll infll = (ll)1e+18 + 10;
class RollingHash {
private:
static const ull B = (ull)1e+8 + 7;
std::string text;
int texSize;
std::vector<ull> pow, phash;
inline ull TextHash(int s, int e) { return phash[e] - phash[s] * pow[e - s]; }
public:
RollingHash(std::string tex)
: text(tex), texSize(text.size()), pow(texSize + 1), phash(texSize + 1) {
pow[0] = 1;
phash[0] = 0;
rep(i, texSize) {
phash[i + 1] = phash[i] * B + text[i];
pow[i + 1] = pow[i] * B;
}
}
void find(std::string pat) {
int patSize = pat.size();
if (patSize > texSize)
return;
ull patHash = 0;
rep(i, patSize) patHash = patHash * B + pat[i];
rep(i, texSize - patSize + 1) {
if (TextHash(i, i + patSize) == patHash) {
std::cout << i << std::endl;
}
}
}
};
int main() {
std::string a, b;
std::cin >> a >> b;
RollingHash rh(a);
rh.find(b);
return 0;
}
|
#include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#define rep(i, a) REP(i, 0, a)
#define REP(i, a, b) for (int i = a; i < b; ++i)
#define rrep(i, a) RREP(i, a, 0)
#define RREP(i, a, b) for (int i = a; i >= b; --i)
#define repll(i, a) REPLL(i, 0, a)
#define REPLL(i, a, b) for (ll i = a; i < b; ++i)
#define rrepll(i, a) RREPLL(i, a, 0)
#define RREPLL(i, a, b) for (ll i = a; i >= b; --i)
typedef long long ll;
typedef unsigned long long ull;
typedef std::pair<int, int> P;
typedef std::pair<int, P> PP;
const double PI = 3.14159265358979323846;
const double esp = 1e-9;
const int infi = (int)1e+9 + 10;
const ll infll = (ll)1e+18 + 10;
class RollingHash {
private:
static const ull B = (ull)1e+8 + 7;
std::string text;
int texSize;
std::vector<ull> pow, phash;
inline ull TextHash(int s, int e) { return phash[e] - phash[s] * pow[e - s]; }
public:
RollingHash(std::string tex)
: text(tex), texSize(text.size()), pow(texSize + 1), phash(texSize + 1) {
pow[0] = 1;
phash[0] = 0;
rep(i, texSize) {
phash[i + 1] = phash[i] * B + text[i];
pow[i + 1] = pow[i] * B;
}
}
void find(std::string pat) {
int patSize = pat.size();
if (patSize > texSize)
return;
ull patHash = 0;
rep(i, patSize) patHash = patHash * B + pat[i];
rep(i, texSize - patSize + 1) {
if (TextHash(i, i + patSize) == patHash) {
printf("%d\n", i);
}
}
}
};
int main() {
std::string a, b;
std::cin >> a >> b;
RollingHash rh(a);
rh.find(b);
return 0;
}
|
replace
| 66 | 67 | 66 | 67 |
TLE
| |
p02248
|
C++
|
Time Limit Exceeded
|
#include <iostream>
#include <string>
#include <vector>
#define CLEN 256
using namespace std;
template <typename T> std::vector<std::vector<T>> makeMatrix(int row, int col) {
std::vector<std::vector<T>> vv(row);
for (auto it = vv.begin(); it != vv.end(); it++) {
(*it).resize(col);
}
return vv;
}
vector<vector<int>> makeBadCTable(string pattern) {
int plen = pattern.size();
vector<vector<int>> table = makeMatrix<int>(plen, CLEN);
for (int i = 0; i < plen; i++) {
for (int j = 0; j < CLEN; j++) {
table[i][j] = -1;
}
}
for (int i = 0; i < plen; i++) {
char c = pattern[i];
for (int j = i + 1; j < plen; j++) {
table[j][c] = j - i;
}
}
return table;
}
void goodPre1(vector<int> &shift_table, vector<int> &memo_table,
string pattern) {
int len, i, j;
len = pattern.size();
i = len;
j = len + 1;
memo_table[i] = j;
while (i > 0) {
//?¬?????????????????????°????????????suffix??¨?????´????????¨????????????????????¨
while (j <= len && pattern[i - 1] != pattern[j - 1]) {
// shift_table[j]???0?????????????????????????¨????????????????????????????????????????
if (shift_table[j] == 0)
shift_table[j] = j - i;
// j???memo_table[j]????§????
//
j = memo_table[j];
}
i--;
j--;
memo_table[i] = j;
}
}
void goodPre2(vector<int> &shift_table, vector<int> &memo_table,
string pattern) {
int len, i, j;
len = pattern.size();
i = 0;
j = memo_table[0]; // prefix??¨suffix????????§?????´????????????index
while (i <= len) {
if (shift_table[i] == 0)
shift_table[i] = j;
// i==j??????????¬???????i>j????????£?????????????????????
// j???????¬??????????prefix??¨suffix????????´????????????index???
//????????????????????´???????????´???len???????¨?????????????
//???????????????memo_table[j]??????
//???j..len-1?????¨???????????????Pre1????????¨???????????¨?????????????????????
if (i == j)
j = memo_table[j];
i++;
}
}
vector<int> makeGoodSuffixTable(string pattern) {
vector<int> shift_table(pattern.size() + 1);
vector<int> memo_table(pattern.size() + 1);
goodPre1(shift_table, memo_table, pattern);
goodPre2(shift_table, memo_table, pattern);
return shift_table;
}
vector<int> bm(string text, string pattern) {
vector<int> matches;
vector<vector<int>> bad_table;
bad_table = makeBadCTable(pattern);
vector<int> good_table = makeGoodSuffixTable(pattern);
int ti, pi, tlen, plen;
tlen = text.size();
plen = pattern.size();
ti = 0;
pi = plen - 1;
int goal = 0;
while (ti + plen <= tlen) {
if (pattern[pi] == text[ti + pi]) {
if (pi == goal) {
matches.push_back(ti);
goal = 0;
ti++;
pi = plen - 1;
} else {
pi--;
}
} else {
char bad_c = text[ti + pi];
int bad_shift = bad_table[pi][bad_c];
if (bad_shift < 0)
bad_shift = pi + 1;
//??¬????????????
if (good_table[pi + 1] == pi + 1 && pi + 1 < plen) {
goal = plen - pi - 1;
} else {
goal = 0;
}
// printf("ti:%d,pi:%d,bad_shift:%d,good_shift:%d\n",ti,pi,bad_shift,good_table[pi+1]);
ti = ti + max(bad_shift, good_table[pi + 1]);
pi = plen - 1;
}
}
return matches;
}
int main() {
string T, P;
getline(cin, T);
getline(cin, P);
vector<int> matches = bm(T, P);
for (auto item : matches) {
printf("%d\n", item);
}
}
|
#include <iostream>
#include <string>
#include <vector>
#define CLEN 256
using namespace std;
template <typename T> std::vector<std::vector<T>> makeMatrix(int row, int col) {
std::vector<std::vector<T>> vv(row);
for (auto it = vv.begin(); it != vv.end(); it++) {
(*it).resize(col);
}
return vv;
}
vector<vector<int>> makeBadCTable(string pattern) {
int plen = pattern.size();
vector<vector<int>> table = makeMatrix<int>(plen, CLEN);
for (int i = 0; i < plen; i++) {
for (int j = 0; j < CLEN; j++) {
table[i][j] = -1;
}
}
for (int i = 0; i < plen; i++) {
char c = pattern[i];
for (int j = i + 1; j < plen; j++) {
table[j][c] = j - i;
}
}
return table;
}
void goodPre1(vector<int> &shift_table, vector<int> &memo_table,
string pattern) {
int len, i, j;
len = pattern.size();
i = len;
j = len + 1;
memo_table[i] = j;
while (i > 0) {
//?¬?????????????????????°????????????suffix??¨?????´????????¨????????????????????¨
while (j <= len && pattern[i - 1] != pattern[j - 1]) {
// shift_table[j]???0?????????????????????????¨????????????????????????????????????????
if (shift_table[j] == 0)
shift_table[j] = j - i;
// j???memo_table[j]????§????
//
j = memo_table[j];
}
i--;
j--;
memo_table[i] = j;
}
}
void goodPre2(vector<int> &shift_table, vector<int> &memo_table,
string pattern) {
int len, i, j;
len = pattern.size();
i = 0;
j = memo_table[0]; // prefix??¨suffix????????§?????´????????????index
while (i <= len) {
if (shift_table[i] == 0)
shift_table[i] = j;
// i==j??????????¬???????i>j????????£?????????????????????
// j???????¬??????????prefix??¨suffix????????´????????????index???
//????????????????????´???????????´???len???????¨?????????????
//???????????????memo_table[j]??????
//???j..len-1?????¨???????????????Pre1????????¨???????????¨?????????????????????
if (i == j)
j = memo_table[j];
i++;
}
}
vector<int> makeGoodSuffixTable(string pattern) {
vector<int> shift_table(pattern.size() + 1);
vector<int> memo_table(pattern.size() + 1);
goodPre1(shift_table, memo_table, pattern);
goodPre2(shift_table, memo_table, pattern);
return shift_table;
}
vector<int> bm(string text, string pattern) {
vector<int> matches;
vector<vector<int>> bad_table;
bad_table = makeBadCTable(pattern);
vector<int> good_table = makeGoodSuffixTable(pattern);
int ti, pi, tlen, plen;
tlen = text.size();
plen = pattern.size();
ti = 0;
pi = plen - 1;
int goal = 0;
while (ti + plen <= tlen) {
if (pattern[pi] == text[ti + pi]) {
if (pi == goal) {
matches.push_back(ti);
// goal=0;
// ti++;
ti = ti + good_table[0];
goal = plen - good_table[0];
pi = plen - 1;
} else {
pi--;
}
} else {
char bad_c = text[ti + pi];
int bad_shift = bad_table[pi][bad_c];
if (bad_shift < 0)
bad_shift = pi + 1;
//??¬????????????
if (good_table[pi + 1] == pi + 1 && pi + 1 < plen) {
goal = plen - pi - 1;
} else {
goal = 0;
}
// printf("ti:%d,pi:%d,bad_shift:%d,good_shift:%d\n",ti,pi,bad_shift,good_table[pi+1]);
ti = ti + max(bad_shift, good_table[pi + 1]);
pi = plen - 1;
}
}
return matches;
}
int main() {
string T, P;
getline(cin, T);
getline(cin, P);
vector<int> matches = bm(T, P);
for (auto item : matches) {
printf("%d\n", item);
}
}
|
replace
| 103 | 105 | 103 | 107 |
TLE
| |
p02248
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define rep(i, n) FOR(i, 0, n)
#define pb emplace_back
typedef unsigned long long ll;
typedef pair<int, int> pint;
const ll x = 1000000007;
string t, p;
int main() {
cin >> t >> p;
ll st = t.size(), sp = p.size();
ll q = 1;
rep(i, sp) q = q * x;
ll ht = 0, hp = 0;
rep(i, sp) {
ht = (ht * x + t[i]);
hp = (hp * x + p[i]);
}
rep(i, st - sp + 1) {
if (ht == hp)
cout << i << endl;
if (i < st - sp)
ht = ht * x + t[i + sp] - q * t[i];
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define rep(i, n) FOR(i, 0, n)
#define pb emplace_back
typedef unsigned long long ll;
typedef pair<int, int> pint;
const ll x = 1000000007;
string t, p;
int main() {
cin >> t >> p;
ll st = t.size(), sp = p.size();
if (st < sp)
return 0;
ll q = 1;
rep(i, sp) q = q * x;
ll ht = 0, hp = 0;
rep(i, sp) {
ht = (ht * x + t[i]);
hp = (hp * x + p[i]);
}
rep(i, st - sp + 1) {
if (ht == hp)
cout << i << endl;
if (i < st - sp)
ht = ht * x + t[i + sp] - q * t[i];
}
return 0;
}
|
insert
| 13 | 13 | 13 | 15 |
0
| |
p02248
|
C++
|
Time Limit Exceeded
|
#include <algorithm>
#include <array>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define REP(i, a, b) for (int i = a; i < (int)b; i++)
#define rep(i, n) REP(i, 0, n)
#define all(c) (c).begin(), (c).end()
#define zero(a) memset(a, 0, sizeof a)
#define minus(a) memset(a, -1, sizeof a)
template <class T1, class T2> inline bool minimize(T1 &a, T2 b) {
return b < a && (a = b, 1);
}
template <class T1, class T2> inline bool maximize(T1 &a, T2 b) {
return a < b && (a = b, 1);
}
typedef long long ll;
int const inf = 1 << 29;
constexpr long long to_int64(char x) { return (long long)x; }
template <class T> struct RollingHash { // not verified
const array<int, 3> mods = {{int(1e9 + 7), int(1e9 + 9), int(1234567891)}};
const array<int, 3> Ks = {{1007, 1009, 1013}};
vector<T> S;
vector<vector<long long>> hash;
vector<vector<long long>> pow_table;
void construct() {
hash.resize(mods.size());
int n = S.size();
rep(i, mods.size()) hash[i].resize(n + 1);
rep(i, mods.size()) {
for (int j = n - 1; j >= 0; j--) {
hash[i][j] = hash[i][j + 1] * Ks[i];
hash[i][j] += to_int64(S[j]);
hash[i][j] %= mods[i];
}
}
pow_table.resize(mods.size());
rep(i, mods.size()) pow_table[i].resize(n + 1);
rep(i, mods.size()) {
pow_table[i][0] = 1;
REP(j, 1, n + 1) {
pow_table[i][j] = (pow_table[i][j - 1] * Ks[i]) % mods[i];
}
}
}
RollingHash(vector<T> const &S) {
this->S = S;
construct();
}
RollingHash(string const &S) {
int n = S.size();
rep(i, n) { this->S.push_back(S[i]); }
construct();
}
long long get_hash(int t, int start, int end) const {
auto r = hash[t][start] - hash[t][end] * pow_table[t][end - start];
r %= mods[t];
if (r < 0) {
r += mods[t];
}
return r;
}
// ???????????\????????¨??????MOD??§?????´?????????????????????????????????
bool same(int a_start, int a_end, int b_start, int b_end) const {
int const len = a_end - a_start;
if (len != b_end - b_start) {
return false;
}
rep(i, mods.size()) {
if (get_hash(i, a_start, a_end) != get_hash(i, b_start, b_end)) {
return false;
}
}
return true;
}
// ????????????????????¨??????????????¨????????´???????????????
bool same(int a_start, int a_end, int b_start, int b_end,
shared_ptr<RollingHash<T>> const &rh) const {
if (rh == nullptr) {
return same(a_start, a_end, b_start, b_end);
}
int const len = a_end - a_start;
if (len != b_end - b_start) {
return false;
}
rep(i, mods.size()) {
if (get_hash(i, a_start, a_end) != rh->get_hash(i, b_start, b_end)) {
return false;
}
}
return true;
}
// ???????????§?°???????
bool compare(int a_start, int a_end, int b_start, int b_end,
shared_ptr<RollingHash<T>> const &rh = nullptr) const {
int a_len = a_end - a_start;
int b_len = b_end - b_start;
int len = min(a_len, b_len);
int max_len = len + 1;
int min_len = 0;
// ???????????§?????´????????????????????¢?´¢??§?????????
while (min_len + 1 < max_len) {
int next_len = (min_len + max_len) / 2;
if (same(a_start, a_start + next_len, b_start, b_start + next_len, rh)) {
min_len = next_len;
} else {
max_len = next_len;
}
}
if (a_start + min_len == a_end) {
if (b_start + min_len == b_end) {
return 0;
} else {
return -1;
}
} else {
if (b_start + min_len == b_end) {
return 1;
} else {
return S[a_start + min_len] == S[b_start + min_len];
}
}
}
};
int main() {
string a, b;
cin >> a >> b;
RollingHash<char> ra(a), rb(b);
int n = a.size(), m = b.size();
if (n < m) {
return 0;
}
auto rbptr = make_shared<RollingHash<char>>(rb);
rep(i, n - m + 1) {
if (ra.same(i, i + m, 0, m, rbptr)) {
cout << i << endl;
}
}
return 0;
}
|
#include <algorithm>
#include <array>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define REP(i, a, b) for (int i = a; i < (int)b; i++)
#define rep(i, n) REP(i, 0, n)
#define all(c) (c).begin(), (c).end()
#define zero(a) memset(a, 0, sizeof a)
#define minus(a) memset(a, -1, sizeof a)
template <class T1, class T2> inline bool minimize(T1 &a, T2 b) {
return b < a && (a = b, 1);
}
template <class T1, class T2> inline bool maximize(T1 &a, T2 b) {
return a < b && (a = b, 1);
}
typedef long long ll;
int const inf = 1 << 29;
constexpr long long to_int64(char x) { return (long long)x; }
template <class T> struct RollingHash { // not verified
// const array<int, 3> mods = {{int(1e9+7), int(1e9+9), int(1234567891)}}; //
// strong
const array<int, 1> mods = {{int(1e9 + 7)}}; // weak
const array<int, 3> Ks = {{1007, 1009, 1013}};
vector<T> S;
vector<vector<long long>> hash;
vector<vector<long long>> pow_table;
void construct() {
hash.resize(mods.size());
int n = S.size();
rep(i, mods.size()) hash[i].resize(n + 1);
rep(i, mods.size()) {
for (int j = n - 1; j >= 0; j--) {
hash[i][j] = hash[i][j + 1] * Ks[i];
hash[i][j] += to_int64(S[j]);
hash[i][j] %= mods[i];
}
}
pow_table.resize(mods.size());
rep(i, mods.size()) pow_table[i].resize(n + 1);
rep(i, mods.size()) {
pow_table[i][0] = 1;
REP(j, 1, n + 1) {
pow_table[i][j] = (pow_table[i][j - 1] * Ks[i]) % mods[i];
}
}
}
RollingHash(vector<T> const &S) {
this->S = S;
construct();
}
RollingHash(string const &S) {
int n = S.size();
rep(i, n) { this->S.push_back(S[i]); }
construct();
}
long long get_hash(int t, int start, int end) const {
auto r = hash[t][start] - hash[t][end] * pow_table[t][end - start];
r %= mods[t];
if (r < 0) {
r += mods[t];
}
return r;
}
// ???????????\????????¨??????MOD??§?????´?????????????????????????????????
bool same(int a_start, int a_end, int b_start, int b_end) const {
int const len = a_end - a_start;
if (len != b_end - b_start) {
return false;
}
rep(i, mods.size()) {
if (get_hash(i, a_start, a_end) != get_hash(i, b_start, b_end)) {
return false;
}
}
return true;
}
// ????????????????????¨??????????????¨????????´???????????????
bool same(int a_start, int a_end, int b_start, int b_end,
shared_ptr<RollingHash<T>> const &rh) const {
if (rh == nullptr) {
return same(a_start, a_end, b_start, b_end);
}
int const len = a_end - a_start;
if (len != b_end - b_start) {
return false;
}
rep(i, mods.size()) {
if (get_hash(i, a_start, a_end) != rh->get_hash(i, b_start, b_end)) {
return false;
}
}
return true;
}
// ???????????§?°???????
bool compare(int a_start, int a_end, int b_start, int b_end,
shared_ptr<RollingHash<T>> const &rh = nullptr) const {
int a_len = a_end - a_start;
int b_len = b_end - b_start;
int len = min(a_len, b_len);
int max_len = len + 1;
int min_len = 0;
// ???????????§?????´????????????????????¢?´¢??§?????????
while (min_len + 1 < max_len) {
int next_len = (min_len + max_len) / 2;
if (same(a_start, a_start + next_len, b_start, b_start + next_len, rh)) {
min_len = next_len;
} else {
max_len = next_len;
}
}
if (a_start + min_len == a_end) {
if (b_start + min_len == b_end) {
return 0;
} else {
return -1;
}
} else {
if (b_start + min_len == b_end) {
return 1;
} else {
return S[a_start + min_len] == S[b_start + min_len];
}
}
}
};
int main() {
string a, b;
cin >> a >> b;
RollingHash<char> ra(a), rb(b);
int n = a.size(), m = b.size();
if (n < m) {
return 0;
}
auto rbptr = make_shared<RollingHash<char>>(rb);
rep(i, n - m + 1) {
if (ra.same(i, i + m, 0, m, rbptr)) {
cout << i << endl;
}
}
return 0;
}
|
replace
| 43 | 44 | 43 | 46 |
TLE
| |
p02248
|
C++
|
Time Limit Exceeded
|
#include "bits/stdc++.h"
#include <unordered_map>
#include <unordered_set>
#pragma warning(disable : 4996)
using namespace std;
using ld = long double;
template <class T> using Table = vector<vector<T>>;
const ld eps = 1e-9;
//// < "D:\D_Download\Visual Studio
///2015\Projects\programing_contest_c++\Debug\a.txt" > "D:\D_Download\Visual
///Studio 2015\Projects\programing_contest_c++\Debug\b.txt"
#define REP(i, n) for (int i = 0; i < n; ++i)
string T, P;
struct SuffixArray {
struct SAComp {
const int h;
const vector<int> &g;
SAComp(const int h_, const vector<int> &g_) : h(h_), g(g_) { ; }
bool operator()(int a, int b) {
return a == b ? false : g[a] != g[b] ? g[a] < g[b] : g[a + h] < g[b + h];
}
};
static const int SIZE = 100000;
int n;
string str;
vector<int> sa;
vector<int> lcp;
SuffixArray() { ; }
SuffixArray(const string t) : str(t) { Init(); }
void Init() {
n = str.size();
buildSA();
buildLCP();
}
// O(mlogn)
////??????°????????????
// int find(const string p) {
// int m = p.size();
// int left = 0;
// int right = n-m;
// while (left < right) {
// int mid = (left + right) / 2;
// if (str.substr(sa[mid],m)<p.substr(0,m)) { left = mid + 1; }
// else { right = mid; }
// }
// return str.substr(sa[left], m)== p.substr(0, m)? sa[left] : -1;
// }
private:
// O(nlog^2n)
void buildSA() {
sa = vector<int>(n + 1);
vector<int> g(n + 1);
vector<int> b(n + 1);
REP(i, n + 1) {
sa[i] = i;
g[i] = str[i];
}
b[0] = 0;
b[n] = 0;
SAComp f(0, g);
sort(sa.begin(), sa.end(), SAComp(0, g));
for (int h = 1; b[n] != n; h *= 2) {
SAComp comp(h, g);
sort(sa.begin(), sa.end(), comp);
REP(i, n) b[i + 1] = b[i] + comp(sa[i], sa[i + 1]);
REP(i, n + 1) g[sa[i]] = b[i];
}
}
void buildLCP() {
lcp = vector<int>(n + 1);
int h = 0;
vector<int> b(n + 1);
REP(i, n + 1) { b[sa[i]] = i; }
REP(i, n + 1) {
if (b[i]) {
for (int j = sa[b[i] - 1];
j + h < n && i + h < n && str[j + h] == str[i + h]; h++) {
;
}
lcp[b[i]] = h;
} else {
lcp[b[i]] = -1;
}
if (h > 0) {
h--;
}
}
}
};
int main() {
cin >> T >> P;
vector<int> newsa;
{
SuffixArray asa(T);
vector<int> oldsa = asa.sa;
for (auto s : oldsa) {
newsa.push_back(s);
}
}
int r, l;
{
int amin = -1;
int amax = newsa.size();
while (amin + 1 != amax) {
int amid = (amin + amax) / 2;
string ast = T.substr(newsa[amid], P.size());
if (ast <= P)
amin = amid;
else
amax = amid;
}
r = amax;
}
{
int amin = -1;
int amax = newsa.size();
while (amin + 1 != amax) {
int amid = (amin + amax) / 2;
string ast = T.substr(newsa[amid], P.size());
if (ast < P)
amin = amid;
else
amax = amid;
}
l = amax;
}
vector<int> nums;
for (int i = l; i < r; ++i) {
nums.push_back(newsa[i]);
}
sort(nums.begin(), nums.end());
for (auto n : nums) {
cout << n << endl;
}
return 0;
}
|
#include "bits/stdc++.h"
#include <unordered_map>
#include <unordered_set>
#pragma warning(disable : 4996)
using namespace std;
using ld = long double;
template <class T> using Table = vector<vector<T>>;
const ld eps = 1e-9;
//// < "D:\D_Download\Visual Studio
///2015\Projects\programing_contest_c++\Debug\a.txt" > "D:\D_Download\Visual
///Studio 2015\Projects\programing_contest_c++\Debug\b.txt"
#define REP(i, n) for (int i = 0; i < n; ++i)
string T, P;
struct SuffixArray {
struct SAComp {
const int h;
const vector<int> &g;
SAComp(const int h_, const vector<int> &g_) : h(h_), g(g_) { ; }
bool operator()(int a, int b) {
return a == b ? false : g[a] != g[b] ? g[a] < g[b] : g[a + h] < g[b + h];
}
};
static const int SIZE = 100000;
int n;
string str;
vector<int> sa;
vector<int> lcp;
SuffixArray() { ; }
SuffixArray(const string t) : str(t) { Init(); }
void Init() {
n = str.size();
buildSA();
buildLCP();
}
// O(mlogn)
////??????°????????????
// int find(const string p) {
// int m = p.size();
// int left = 0;
// int right = n-m;
// while (left < right) {
// int mid = (left + right) / 2;
// if (str.substr(sa[mid],m)<p.substr(0,m)) { left = mid + 1; }
// else { right = mid; }
// }
// return str.substr(sa[left], m)== p.substr(0, m)? sa[left] : -1;
// }
private:
// O(nlog^2n)
void buildSA() {
sa = vector<int>(n + 1);
vector<int> g(n + 1);
vector<int> b(n + 1);
REP(i, n + 1) {
sa[i] = i;
g[i] = str[i];
}
b[0] = 0;
b[n] = 0;
SAComp f(0, g);
sort(sa.begin(), sa.end(), SAComp(0, g));
for (int h = 1; b[n] != n; h *= 2) {
SAComp comp(h, g);
sort(sa.begin(), sa.end(), comp);
REP(i, n) b[i + 1] = b[i] + comp(sa[i], sa[i + 1]);
REP(i, n + 1) g[sa[i]] = b[i];
}
}
void buildLCP() {
lcp = vector<int>(n + 1);
int h = 0;
vector<int> b(n + 1);
REP(i, n + 1) { b[sa[i]] = i; }
REP(i, n + 1) {
if (b[i]) {
for (int j = sa[b[i] - 1];
j + h < n && i + h < n && str[j + h] == str[i + h]; h++) {
;
}
lcp[b[i]] = h;
} else {
lcp[b[i]] = -1;
}
if (h > 0) {
h--;
}
}
}
};
int main() {
cin >> T >> P;
vector<int> newsa;
{
SuffixArray asa(T);
vector<int> oldsa = asa.sa;
for (auto s : oldsa) {
newsa.push_back(s);
}
}
int r, l;
{
int amin = -1;
int amax = newsa.size();
while (amin + 1 != amax) {
int amid = (amin + amax) / 2;
string ast = T.substr(newsa[amid], P.size());
if (ast <= P)
amin = amid;
else
amax = amid;
}
r = amax;
}
{
int amin = -1;
int amax = newsa.size();
while (amin + 1 != amax) {
int amid = (amin + amax) / 2;
string ast = T.substr(newsa[amid], P.size());
if (ast < P)
amin = amid;
else
amax = amid;
}
l = amax;
}
vector<int> nums;
for (int i = l; i < r; ++i) {
nums.push_back(newsa[i]);
}
sort(nums.begin(), nums.end());
for (auto n : nums) {
printf("%d\n", n);
}
return 0;
}
|
replace
| 141 | 142 | 141 | 142 |
TLE
| |
p02248
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
typedef unsigned long long ull;
ull B = 950527;
int n, m;
char str[1000005];
ull a[1000005];
int main() {
scanf("%s", str);
n = strlen(str);
for (int i = 0; i < n; i++) {
a[i] = str[i];
if (i)
a[i] += a[i - 1] * B;
}
scanf("%s", str);
m = strlen(str);
ull key = 0, num = 0, C = 1;
for (int i = 0; i < m; i++) {
key = key * B + str[i];
C *= B;
}
for (int i = 0; i < n; i++) {
num = a[i];
if (i - m >= 0)
num -= C * a[i - m];
if (key == num) {
cout << i - m + 1 << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef unsigned long long ull;
ull B = 950527;
int n, m;
char str[1000005];
ull a[1000005];
int main() {
scanf("%s", str);
n = strlen(str);
for (int i = 0; i < n; i++) {
a[i] = str[i];
if (i)
a[i] += a[i - 1] * B;
}
scanf("%s", str);
m = strlen(str);
ull key = 0, num = 0, C = 1;
for (int i = 0; i < m; i++) {
key = key * B + str[i];
C *= B;
}
for (int i = 0; i < n; i++) {
num = a[i];
if (i - m >= 0)
num -= C * a[i - m];
if (key == num) {
printf("%d\n", i - m + 1);
}
}
return 0;
}
|
replace
| 28 | 29 | 28 | 29 |
TLE
| |
p02248
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string T[2];
cin >> T[0] >> T[1];
typedef unsigned int int_type;
const int_type base = 9973;
vector<int_type> hashed[2], power[2];
for (int i = 0; i < 2; i++) {
int sz = T[i].size();
hashed[i].assign(sz + 1, 0);
power[i].assign(sz + 1, 0);
hashed[i][0] = 0;
power[i][0] = 1;
for (int j = 0; j < sz; j++) {
power[i][j + 1] = power[i][j] * base;
hashed[i][j + 1] = (hashed[i][j] + T[i][j]) * base;
}
}
for (int i = 0; i <= (int)(T[0].size() - T[1].size()); i++) {
if (hashed[0][i + T[1].size()] - hashed[0][i] * power[0][T[1].size()] ==
hashed[1][T[1].size()] - hashed[1][0] * power[0][T[1].size()]) {
cout << i << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string T[2];
cin >> T[0] >> T[1];
typedef unsigned int int_type;
const int_type base = 9973;
vector<int_type> hashed[2], power[2];
for (int i = 0; i < 2; i++) {
int sz = T[i].size();
hashed[i].assign(sz + 1, 0);
power[i].assign(sz + 1, 0);
hashed[i][0] = 0;
power[i][0] = 1;
for (int j = 0; j < sz; j++) {
power[i][j + 1] = power[i][j] * base;
hashed[i][j + 1] = (hashed[i][j] + T[i][j]) * base;
}
}
for (int i = 0; i <= (int)(T[0].size() - T[1].size()); i++) {
if (hashed[0][i + T[1].size()] - hashed[0][i] * power[0][T[1].size()] ==
hashed[1][T[1].size()] - hashed[1][0] * power[0][T[1].size()]) {
printf("%d\n", i);
}
}
return 0;
}
|
replace
| 29 | 30 | 29 | 30 |
TLE
| |
p02248
|
C++
|
Time Limit Exceeded
|
/*
* b.cc:
*/
#include <algorithm>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
/* constant */
const int MAX_N = 1000000;
const int MAX_M = 10000;
typedef long long ll;
const ll BS0 = 2549;
const ll BS1 = 4283;
const ll MOD0 = 1000000007;
const ll MOD1 = 1000000009;
/* typedef */
typedef vector<int> vi;
typedef queue<int> qi;
typedef pair<int, int> pii;
/* global variables */
/* subroutines */
ll rh(string &s, int m, ll bs, ll mod) {
ll h = 0;
for (int i = 0; i < m; i++)
h = (h * bs + s[i]) % mod;
return h;
}
ll powmod(ll a, int b, ll mod) {
ll pm = 1;
while (b > 0) {
if (b & 1)
pm = (pm * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return pm;
}
/* main */
int main() {
string s, p;
cin >> s >> p;
int n = s.size(), m = p.size();
ll ph0 = rh(p, m, BS0, MOD0);
ll ph1 = rh(p, m, BS1, MOD1);
// printf("%lld %lld\n", ph0, ph1);
ll e0 = powmod(BS0, m, MOD0);
ll e1 = powmod(BS1, m, MOD1);
ll sh0 = rh(s, m, BS0, MOD0);
ll sh1 = rh(s, m, BS1, MOD1);
for (int i = 0; i <= n - m; i++) {
if (sh0 == ph0 && sh1 == ph1) {
bool ok = true;
for (int j = 0; j < m; j++)
if (s[i + j] != p[j]) {
ok = false;
break;
}
if (ok)
printf("%d\n", i);
}
sh0 = (sh0 * BS0 % MOD0 + s[i + m] - s[i] * e0 % MOD0 + MOD0) % MOD0;
sh1 = (sh1 * BS1 % MOD1 + s[i + m] - s[i] * e1 % MOD1 + MOD1) % MOD1;
}
return 0;
}
|
/*
* b.cc:
*/
#include <algorithm>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
/* constant */
const int MAX_N = 1000000;
const int MAX_M = 10000;
typedef long long ll;
const ll BS0 = 2549;
const ll BS1 = 4283;
const ll MOD0 = 1000000007;
const ll MOD1 = 1000000009;
/* typedef */
typedef vector<int> vi;
typedef queue<int> qi;
typedef pair<int, int> pii;
/* global variables */
/* subroutines */
ll rh(string &s, int m, ll bs, ll mod) {
ll h = 0;
for (int i = 0; i < m; i++)
h = (h * bs + s[i]) % mod;
return h;
}
ll powmod(ll a, int b, ll mod) {
ll pm = 1;
while (b > 0) {
if (b & 1)
pm = (pm * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return pm;
}
/* main */
int main() {
string s, p;
cin >> s >> p;
int n = s.size(), m = p.size();
ll ph0 = rh(p, m, BS0, MOD0);
ll ph1 = rh(p, m, BS1, MOD1);
// printf("%lld %lld\n", ph0, ph1);
ll e0 = powmod(BS0, m, MOD0);
ll e1 = powmod(BS1, m, MOD1);
ll sh0 = rh(s, m, BS0, MOD0);
ll sh1 = rh(s, m, BS1, MOD1);
for (int i = 0; i <= n - m; i++) {
if (sh0 == ph0 && sh1 == ph1)
printf("%d\n", i);
sh0 = (sh0 * BS0 % MOD0 + s[i + m] - s[i] * e0 % MOD0 + MOD0) % MOD0;
sh1 = (sh1 * BS1 % MOD1 + s[i + m] - s[i] * e1 % MOD1 + MOD1) % MOD1;
}
return 0;
}
|
replace
| 84 | 94 | 84 | 86 |
TLE
| |
p02248
|
C++
|
Runtime Error
|
#include <cstdio>
#include <string>
#include <vector>
using namespace std;
const long long MOD = 1e9 + 7;
const long long BASE = 0x234567;
struct RollingHash {
string s;
long long mod, base;
vector<long long> hash, pow;
RollingHash() {}
RollingHash(string s, long long m, long long b) : s(s), mod(m), base(b) {
pow.resize(s.length() + 1);
pow[0] = 1;
for (size_t i = 0; i < s.length(); ++i)
(pow[i + 1] = pow[i] * base) %= mod;
hash.assign(s.length() + 1, 0);
for (size_t i = 0; i < s.length(); ++i)
(hash[i + 1] = hash[i] + pow[i] * s[i]) %= mod;
}
long long get_hash(size_t first, size_t last) {
return (hash[last] - hash[first] + mod) % mod;
}
long long make_hash(string t) {
long long h = 0;
for (size_t i = 0; i < t.length(); ++i)
(h += pow[i] * t[i]) %= mod;
return h;
}
long long diff(long long h, size_t pos, size_t len) {
return (h * pow[pos] - get_hash(pos, pos + len)) % mod;
}
bool is_equiv(long long h, size_t pos, size_t len) {
return !diff(h, pos, len);
}
};
int main() {
char buf[1 << 10];
scanf("%s", buf);
string T(buf);
RollingHash rhash(T, MOD, BASE);
scanf("%s", buf);
string P(buf);
long long h = rhash.make_hash(P);
for (size_t i = 0; i + P.length() <= T.length(); ++i)
if (rhash.is_equiv(h, i, P.length()))
printf("%zd\n", i);
return 0;
}
|
#include <cstdio>
#include <string>
#include <vector>
using namespace std;
const long long MOD = 1e9 + 7;
const long long BASE = 0x234567;
struct RollingHash {
string s;
long long mod, base;
vector<long long> hash, pow;
RollingHash() {}
RollingHash(string s, long long m, long long b) : s(s), mod(m), base(b) {
pow.resize(s.length() + 1);
pow[0] = 1;
for (size_t i = 0; i < s.length(); ++i)
(pow[i + 1] = pow[i] * base) %= mod;
hash.assign(s.length() + 1, 0);
for (size_t i = 0; i < s.length(); ++i)
(hash[i + 1] = hash[i] + pow[i] * s[i]) %= mod;
}
long long get_hash(size_t first, size_t last) {
return (hash[last] - hash[first] + mod) % mod;
}
long long make_hash(string t) {
long long h = 0;
for (size_t i = 0; i < t.length(); ++i)
(h += pow[i] * t[i]) %= mod;
return h;
}
long long diff(long long h, size_t pos, size_t len) {
return (h * pow[pos] - get_hash(pos, pos + len)) % mod;
}
bool is_equiv(long long h, size_t pos, size_t len) {
return !diff(h, pos, len);
}
};
int main() {
char buf[1 << 20];
scanf("%s", buf);
string T(buf);
RollingHash rhash(T, MOD, BASE);
scanf("%s", buf);
string P(buf);
long long h = rhash.make_hash(P);
for (size_t i = 0; i + P.length() <= T.length(); ++i)
if (rhash.is_equiv(h, i, P.length()))
printf("%zd\n", i);
return 0;
}
|
replace
| 43 | 44 | 43 | 44 |
0
| |
p02248
|
C++
|
Time Limit Exceeded
|
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define MOD 1000000007
#define INF 0x3f3f3f3f
#define INFL 0x3f3f3f3f3f3f3f3fLL
int main() {
string T, P;
cin >> T >> P;
for (int i = 0; i < T.size(); i++) {
for (int j = 0; j < P.size(); j++) {
if (T[i + j] != P[j])
break;
else if (j == P.size() - 1) {
cout << i << endl;
}
}
}
return 0;
}
|
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define MOD 1000000007
#define INF 0x3f3f3f3f
#define INFL 0x3f3f3f3f3f3f3f3fLL
int main() {
string T, P;
cin >> T >> P;
int t = T.size(), p = P.size();
for (int i = 0; i <= t - p; i++) {
if (T[i] == P[0]) {
if (T.substr(i, p) == P) {
printf("%d\n", i);
}
}
}
return 0;
}
|
replace
| 27 | 33 | 27 | 32 |
TLE
| |
p02249
|
C++
|
Runtime Error
|
#include <iostream>
using namespace std;
#include <stdio.h>
#include <string>
#define A 1355471101 // large prime number 1.
#define B 1466700101 // large prime number 2.
#define M 1522101101 // large prime number 3, larger than A and B.
int main() {
int i, j, H, W, R, C;
string *T;
scanf("%d %d", &H, &W);
T = new string[H];
for (i = 0; i < H; i++) {
cin >> T[i];
}
scanf("%d %d", &R, &C);
long long hash[100][100];
long long s;
char P[1000];
for (i = 0; i < R; i++) {
s = 0;
scanf("%s", P);
for (j = 0; j < C; j++) {
s = (s * B + P[j]) % M;
hash[i][j] = s;
}
}
for (j = 0; j < C; j++) {
s = 0;
for (i = 0; i < R; i++) {
s = (s * A + hash[i][j]) % M;
hash[i][j] = s;
}
}
long long last_has = hash[R - 1][C - 1];
for (i = 0; i < H; i++) {
s = 0;
for (j = 0; j < W; j++) {
s = (s * B + T[i][j]) % M;
hash[i][j] = s;
}
}
for (j = 0; j < W; j++) {
s = 0;
for (i = 0; i < H; i++) {
s = (s * A + hash[i][j]) % M;
hash[i][j] = s;
}
}
long long power_a, power_b, power_c, x, y, z;
x = A, y = R, z = 1;
for (; y; y >>= 1) {
if ((y & 1) != 0) {
z = (z * x) % M;
}
x = (x * x) % M;
}
power_a = z;
x = B, y = C, z = 1;
for (; y; y >>= 1) {
if ((y & 1) != 0) {
z = (z * x) % M;
}
x = (x * x) % M;
}
power_b = z;
power_c = (power_a * power_b) % M;
long long block1, block2, block3;
for (i = R - 1; i < H; i++) {
for (j = C - 1; j < W; j++) {
block1 = ((i >= R ? hash[i - R][j] : 0) * power_a) % M;
block2 = ((j >= C ? hash[i][j - C] : 0) * power_b) % M;
block3 =
M - ((((i >= R && j >= C) ? hash[i - R][j - C] : 0) * power_c) % M);
if (hash[i][j] == (block1 + block2 + block3 + last_has) % M) {
printf("%d %d\n", i - R + 1, j - C + 1);
}
}
}
delete[] T;
return 0;
}
|
#include <iostream>
using namespace std;
#include <stdio.h>
#include <string>
#define A 1355471101 // large prime number 1.
#define B 1466700101 // large prime number 2.
#define M 1522101101 // large prime number 3, larger than A and B.
int main() {
int i, j, H, W, R, C;
string *T;
scanf("%d %d", &H, &W);
T = new string[H];
for (i = 0; i < H; i++) {
cin >> T[i];
}
scanf("%d %d", &R, &C);
long long hash[1000][1000];
long long s;
char P[1000];
for (i = 0; i < R; i++) {
s = 0;
scanf("%s", P);
for (j = 0; j < C; j++) {
s = (s * B + P[j]) % M;
hash[i][j] = s;
}
}
for (j = 0; j < C; j++) {
s = 0;
for (i = 0; i < R; i++) {
s = (s * A + hash[i][j]) % M;
hash[i][j] = s;
}
}
long long last_has = hash[R - 1][C - 1];
for (i = 0; i < H; i++) {
s = 0;
for (j = 0; j < W; j++) {
s = (s * B + T[i][j]) % M;
hash[i][j] = s;
}
}
for (j = 0; j < W; j++) {
s = 0;
for (i = 0; i < H; i++) {
s = (s * A + hash[i][j]) % M;
hash[i][j] = s;
}
}
long long power_a, power_b, power_c, x, y, z;
x = A, y = R, z = 1;
for (; y; y >>= 1) {
if ((y & 1) != 0) {
z = (z * x) % M;
}
x = (x * x) % M;
}
power_a = z;
x = B, y = C, z = 1;
for (; y; y >>= 1) {
if ((y & 1) != 0) {
z = (z * x) % M;
}
x = (x * x) % M;
}
power_b = z;
power_c = (power_a * power_b) % M;
long long block1, block2, block3;
for (i = R - 1; i < H; i++) {
for (j = C - 1; j < W; j++) {
block1 = ((i >= R ? hash[i - R][j] : 0) * power_a) % M;
block2 = ((j >= C ? hash[i][j - C] : 0) * power_b) % M;
block3 =
M - ((((i >= R && j >= C) ? hash[i - R][j - C] : 0) * power_c) % M);
if (hash[i][j] == (block1 + block2 + block3 + last_has) % M) {
printf("%d %d\n", i - R + 1, j - C + 1);
}
}
}
delete[] T;
return 0;
}
|
replace
| 20 | 21 | 20 | 21 |
0
| |
p02249
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cassert>
#include <cctype>
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
struct AhoCorasick {
static const int ALPHABET_SIZE = 62, root = 0;
inline int index(char ch) {
if (isupper(ch))
return ch - 'A';
if (islower(ch))
return 26 + ch - 'a';
if (isdigit(ch))
return 52 + ch - '0';
assert(false);
return -1;
}
int N; // num of node
struct Node {
int parent, link;
int child[ALPHABET_SIZE], next[ALPHABET_SIZE];
char ch;
bool leaf;
Node() : parent(0), link(0), ch('\0'), leaf(false) {
link = -1;
fill(child, child + ALPHABET_SIZE, -1);
fill(next, next + ALPHABET_SIZE, -1);
}
};
vector<Node> nodes;
AhoCorasick(int maxNodes) : N(1), nodes(maxNodes) {
nodes[root].link = root;
nodes[root].parent = -1;
}
void add(string s) {
int cur = 0, sl = s.size();
for (int i = 0; i < sl; i++) {
char ch = s[i];
int c = index(ch);
if (nodes[cur].child[c] > -1) {
nodes[N].parent = cur;
nodes[N].ch = ch;
nodes[cur].child[c] = N++;
}
cur = nodes[cur].child[c];
}
nodes[cur].leaf = true;
}
int failure(int id) {
Node &node = nodes[id];
if (node.link == -1) {
if (!node.parent)
node.link = root;
else
node.link = go(failure(node.parent), node.ch);
}
return node.link;
}
int go(int id, char ch) {
int c = index(ch);
Node &node = nodes[id];
if (node.next[c] == -1) {
if (node.child[c] != -1)
node.next[c] = node.child[c];
else if (!id)
node.next[c] = root;
else
node.next[c] = go(failure(id), ch);
}
return node.next[c];
}
};
typedef pair<int, int> pii;
vector<pii> bakerBird(const vector<string> &T, const vector<string> &pattern) {
int pl = pattern.size(), tl = T.size(), pil = pattern[0].size();
AhoCorasick aho(500000);
for (int i = 0; i < pl; i++)
aho.add(pattern[i]);
vector<int> acc;
for (int i = 0; i < pl; i++) {
int node = 0;
for (int j = 0; j < pil; j++) {
node = aho.go(node, pattern[i][j]);
if (aho.nodes[node].leaf)
acc.push_back(node);
}
}
const int til = T[0].size();
int td[til][tl];
for (int i = 0; i < tl; i++) {
int node = 0;
for (int j = 0; j < til; j++) {
node = aho.go(node, T[i][j]);
td[til - j - 1][i] = node;
}
}
vector<pii> res;
int tl2 = acc.size(), sl = acc.size() + tl + 1;
vector<int> a(acc.size() + tl + 2, -1);
for (int i = 0; i < til; i++) {
vector<int> s = acc;
s.push_back(-1);
for (int j = 0; j < til; j++)
s.push_back(td[i][j]);
for (int k = 0, j = -1; k < sl; a[++k] = ++j)
while (j >= 0 && s[k] != s[j])
j = a[j];
for (int k = tl2 + 1; k <= sl; k++) {
if (a[k] == tl2)
res.push_back(pii(k - tl2 * 2 - 1, til - i - pil));
}
}
return res;
}
int main(void) {
int h, w, r, c;
cin >> h >> w;
vector<string> s(h);
for (int i = 0; i < h; i++) {
s[i].resize(w);
for (int j = 0; j < w; j++) {
scanf(" %c", &s[i][j]);
}
}
cin >> r >> c;
vector<string> t(r);
for (int i = 0; i < r; i++) {
t[i].resize(c);
for (int j = 0; j < c; j++) {
scanf(" %c", &t[i][j]);
}
}
vector<pii> res = bakerBird(s, t);
sort(res.begin(), res.end());
for (int i = 0; i < res.size(); i++)
cout << res[i].first << " " << res[i].second << "\n";
return 0;
}
|
#include <algorithm>
#include <cassert>
#include <cctype>
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
struct AhoCorasick {
static const int ALPHABET_SIZE = 62, root = 0;
inline int index(char ch) {
if (isupper(ch))
return ch - 'A';
if (islower(ch))
return 26 + ch - 'a';
if (isdigit(ch))
return 52 + ch - '0';
assert(false);
return -1;
}
int N; // num of node
struct Node {
int parent, link;
int child[ALPHABET_SIZE], next[ALPHABET_SIZE];
char ch;
bool leaf;
Node() : parent(0), link(0), ch('\0'), leaf(false) {
link = -1;
fill(child, child + ALPHABET_SIZE, -1);
fill(next, next + ALPHABET_SIZE, -1);
}
};
vector<Node> nodes;
AhoCorasick(int maxNodes) : N(1), nodes(maxNodes) {
nodes[root].link = root;
nodes[root].parent = -1;
}
void add(string s) {
int cur = 0, sl = s.size();
for (int i = 0; i < sl; i++) {
char ch = s[i];
int c = index(ch);
if (nodes[cur].child[c] == -1) {
nodes[N].parent = cur;
nodes[N].ch = ch;
nodes[cur].child[c] = N++;
}
cur = nodes[cur].child[c];
}
nodes[cur].leaf = true;
}
int failure(int id) {
Node &node = nodes[id];
if (node.link == -1) {
if (!node.parent)
node.link = root;
else
node.link = go(failure(node.parent), node.ch);
}
return node.link;
}
int go(int id, char ch) {
int c = index(ch);
Node &node = nodes[id];
if (node.next[c] == -1) {
if (node.child[c] != -1)
node.next[c] = node.child[c];
else if (!id)
node.next[c] = root;
else
node.next[c] = go(failure(id), ch);
}
return node.next[c];
}
};
typedef pair<int, int> pii;
vector<pii> bakerBird(const vector<string> &T, const vector<string> &pattern) {
int pl = pattern.size(), tl = T.size(), pil = pattern[0].size();
AhoCorasick aho(500000);
for (int i = 0; i < pl; i++)
aho.add(pattern[i]);
vector<int> acc;
for (int i = 0; i < pl; i++) {
int node = 0;
for (int j = 0; j < pil; j++) {
node = aho.go(node, pattern[i][j]);
if (aho.nodes[node].leaf)
acc.push_back(node);
}
}
const int til = T[0].size();
int td[til][tl];
for (int i = 0; i < tl; i++) {
int node = 0;
for (int j = 0; j < til; j++) {
node = aho.go(node, T[i][j]);
td[til - j - 1][i] = node;
}
}
vector<pii> res;
int tl2 = acc.size(), sl = acc.size() + tl + 1;
vector<int> a(acc.size() + tl + 2, -1);
for (int i = 0; i < til; i++) {
vector<int> s = acc;
s.push_back(-1);
for (int j = 0; j < til; j++)
s.push_back(td[i][j]);
for (int k = 0, j = -1; k < sl; a[++k] = ++j)
while (j >= 0 && s[k] != s[j])
j = a[j];
for (int k = tl2 + 1; k <= sl; k++) {
if (a[k] == tl2)
res.push_back(pii(k - tl2 * 2 - 1, til - i - pil));
}
}
return res;
}
int main(void) {
int h, w, r, c;
cin >> h >> w;
vector<string> s(h);
for (int i = 0; i < h; i++) {
s[i].resize(w);
for (int j = 0; j < w; j++) {
scanf(" %c", &s[i][j]);
}
}
cin >> r >> c;
vector<string> t(r);
for (int i = 0; i < r; i++) {
t[i].resize(c);
for (int j = 0; j < c; j++) {
scanf(" %c", &t[i][j]);
}
}
vector<pii> res = bakerBird(s, t);
sort(res.begin(), res.end());
for (int i = 0; i < res.size(); i++)
cout << res[i].first << " " << res[i].second << "\n";
return 0;
}
|
replace
| 52 | 53 | 52 | 53 |
-6
|
terminate called after throwing an instance of 'std::bad_alloc'
what(): std::bad_alloc
|
p02249
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cassert>
#include <cctype>
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
struct AhoCorasick {
static const int ALPHABET_SIZE = 62, root = 0;
inline int index(char ch) {
if (isupper(ch))
return ch - 'A';
if (islower(ch))
return 26 + ch - 'a';
if (isdigit(ch))
return 52 + ch - '0';
assert(false);
return -1;
}
int N; // num of node
struct Node {
int parent, link;
int child[ALPHABET_SIZE], next[ALPHABET_SIZE];
char ch;
bool leaf;
Node() : parent(0), link(0), ch('\0'), leaf(false) {
link = -1;
fill(child, child + ALPHABET_SIZE, -1);
fill(next, next + ALPHABET_SIZE, -1);
}
};
vector<Node> nodes;
AhoCorasick(int maxNodes) : N(1), nodes(maxNodes) {
nodes[root].link = root;
nodes[root].parent = -1;
}
void addString(string s) {
int cur = 0, sl = s.size();
for (int i = 0; i < sl; i++) {
char ch = s[i];
int c = index(ch);
if (!~nodes[cur].child[c]) {
nodes[N].parent = cur;
nodes[N].ch = ch;
nodes[cur].child[c] = N++;
}
cur = nodes[cur].child[c];
}
nodes[cur].leaf = true;
}
int link(int id) {
Node &node = nodes[id];
if (node.link == -1) {
if (!node.parent)
node.link = root;
else
node.link = trans(link(node.parent), node.ch);
}
return node.link;
}
int trans(int id, char ch) {
int c = index(ch);
Node &node = nodes[id];
if (node.next[c] >= 0) {
if (~node.child[c])
node.next[c] = node.child[c];
else if (!id)
node.next[c] = root;
else
node.next[c] = trans(link(id), ch);
}
return node.next[c];
}
};
typedef pair<int, int> pii;
vector<pii> bakerBird(const vector<string> &T, const vector<string> &pattern) {
int pl = pattern.size(), tl = T.size(), pil = pattern[0].size();
AhoCorasick aho(500000);
for (int i = 0; i < pl; i++)
aho.addString(pattern[i]);
vector<int> acc;
for (int i = 0; i < pl; i++) {
int node = 0;
for (int j = 0; j < pil; j++) {
node = aho.trans(node, pattern[i][j]);
if (aho.nodes[node].leaf)
acc.push_back(node);
}
}
const int til = T[0].size();
int td[til][tl];
for (int i = 0; i < tl; i++) {
int node = 0;
for (int j = 0; j < til; j++) {
node = aho.trans(node, T[i][j]);
td[til - j - 1][i] = node;
}
}
vector<pii> res;
int tl2 = acc.size(), sl = acc.size() + tl + 1;
vector<int> a(acc.size() + tl + 2, -1);
for (int i = 0; i < til; i++) {
vector<int> s = acc;
s.push_back(-1);
for (int j = 0; j < til; j++)
s.push_back(td[i][j]);
for (int k = 0, j = -1; k < sl; a[++k] = ++j)
while (j >= 0 && s[k] != s[j])
j = a[j];
for (int k = tl2 + 1; k <= sl; k++) {
if (a[k] == tl2)
res.push_back(pii(k - tl2 * 2 - 1, til - i - pil));
}
}
return res;
}
int main(void) {
int h, w, r, c;
cin >> h >> w;
vector<string> s(h);
for (int i = 0; i < h; i++) {
s[i].resize(w);
for (int j = 0; j < w; j++) {
scanf(" %c", &s[i][j]);
}
}
cin >> r >> c;
vector<string> t(r);
for (int i = 0; i < r; i++) {
t[i].resize(c);
for (int j = 0; j < c; j++) {
scanf(" %c", &t[i][j]);
}
}
vector<pii> res = bakerBird(s, t);
sort(res.begin(), res.end());
for (int i = 0; i < res.size(); i++)
cout << res[i].first << " " << res[i].second << "\n";
return 0;
}
|
#include <algorithm>
#include <cassert>
#include <cctype>
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
struct AhoCorasick {
static const int ALPHABET_SIZE = 62, root = 0;
inline int index(char ch) {
if (isupper(ch))
return ch - 'A';
if (islower(ch))
return 26 + ch - 'a';
if (isdigit(ch))
return 52 + ch - '0';
assert(false);
return -1;
}
int N; // num of node
struct Node {
int parent, link;
int child[ALPHABET_SIZE], next[ALPHABET_SIZE];
char ch;
bool leaf;
Node() : parent(0), link(0), ch('\0'), leaf(false) {
link = -1;
fill(child, child + ALPHABET_SIZE, -1);
fill(next, next + ALPHABET_SIZE, -1);
}
};
vector<Node> nodes;
AhoCorasick(int maxNodes) : N(1), nodes(maxNodes) {
nodes[root].link = root;
nodes[root].parent = -1;
}
void addString(string s) {
int cur = 0, sl = s.size();
for (int i = 0; i < sl; i++) {
char ch = s[i];
int c = index(ch);
if (!~nodes[cur].child[c]) {
nodes[N].parent = cur;
nodes[N].ch = ch;
nodes[cur].child[c] = N++;
}
cur = nodes[cur].child[c];
}
nodes[cur].leaf = true;
}
int link(int id) {
Node &node = nodes[id];
if (node.link == -1) {
if (!node.parent)
node.link = root;
else
node.link = trans(link(node.parent), node.ch);
}
return node.link;
}
int trans(int id, char ch) {
int c = index(ch);
Node &node = nodes[id];
if (node.next[c] == -1) {
if (~node.child[c])
node.next[c] = node.child[c];
else if (!id)
node.next[c] = root;
else
node.next[c] = trans(link(id), ch);
}
return node.next[c];
}
};
typedef pair<int, int> pii;
vector<pii> bakerBird(const vector<string> &T, const vector<string> &pattern) {
int pl = pattern.size(), tl = T.size(), pil = pattern[0].size();
AhoCorasick aho(500000);
for (int i = 0; i < pl; i++)
aho.addString(pattern[i]);
vector<int> acc;
for (int i = 0; i < pl; i++) {
int node = 0;
for (int j = 0; j < pil; j++) {
node = aho.trans(node, pattern[i][j]);
if (aho.nodes[node].leaf)
acc.push_back(node);
}
}
const int til = T[0].size();
int td[til][tl];
for (int i = 0; i < tl; i++) {
int node = 0;
for (int j = 0; j < til; j++) {
node = aho.trans(node, T[i][j]);
td[til - j - 1][i] = node;
}
}
vector<pii> res;
int tl2 = acc.size(), sl = acc.size() + tl + 1;
vector<int> a(acc.size() + tl + 2, -1);
for (int i = 0; i < til; i++) {
vector<int> s = acc;
s.push_back(-1);
for (int j = 0; j < til; j++)
s.push_back(td[i][j]);
for (int k = 0, j = -1; k < sl; a[++k] = ++j)
while (j >= 0 && s[k] != s[j])
j = a[j];
for (int k = tl2 + 1; k <= sl; k++) {
if (a[k] == tl2)
res.push_back(pii(k - tl2 * 2 - 1, til - i - pil));
}
}
return res;
}
int main(void) {
int h, w, r, c;
cin >> h >> w;
vector<string> s(h);
for (int i = 0; i < h; i++) {
s[i].resize(w);
for (int j = 0; j < w; j++) {
scanf(" %c", &s[i][j]);
}
}
cin >> r >> c;
vector<string> t(r);
for (int i = 0; i < r; i++) {
t[i].resize(c);
for (int j = 0; j < c; j++) {
scanf(" %c", &t[i][j]);
}
}
vector<pii> res = bakerBird(s, t);
sort(res.begin(), res.end());
for (int i = 0; i < res.size(); i++)
cout << res[i].first << " " << res[i].second << "\n";
return 0;
}
|
replace
| 76 | 77 | 76 | 77 |
-6
|
terminate called after throwing an instance of 'std::bad_alloc'
what(): std::bad_alloc
|
p02250
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
typedef long long ll;
typedef unsigned long long ull;
typedef unsigned __int128 HASH;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<ull, ull> pullull;
typedef pair<ll, int> plli;
typedef pair<double, int> pdbi;
typedef pair<int, pii> pipii;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vi> vvi;
typedef vector<vvi> vvvi;
typedef vector<pii> vpii;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep2(i, a, b) for (int i = (a); i < (b); i++)
#define rrep(i, n) for (int i = (n); i > 0; i--)
#define rrep2(i, a, b) for (int i = (a); i > b; i--)
#define pb push_back
#define fi first
#define se second
#define all(a) (a).begin(), (a).end()
const ll mod = 1000000000 + 7;
const ll hmod1 = 999999937;
const ll hmod2 = 1000000000 + 9;
const ll INF = 1 << 30;
const int dx4[4] = {1, 0, -1, 0};
const int dy4[4] = {0, 1, 0, -1};
const int dx8[8] = {1, 1, 1, 0, 0, -1, -1, -1};
const int dy8[8] = {0, 1, -1, 1, -1, 0, 1, -1};
const double pi = 3.141592653589793;
struct SuffixArray {
int n, k;
string text;
vector<int> sa;
vector<int> rank;
vector<int> lcp;
SuffixArray(const string &s)
: text(s), n(s.size()), sa(n + 1), rank(n + 1), lcp(n) {}
bool comp(int i, int j) {
if (rank[i] != rank[j])
return rank[i] < rank[j];
int ri = i + k <= n ? rank[i + k] : -1;
int rj = j + k <= n ? rank[j + k] : -1;
return ri < rj;
}
void construct_sa() {
for (int i = 0; i <= n; i++) {
sa[i] = i;
rank[i] = i < n ? text[i] : -1;
}
for (k = 1; k <= n; k *= 2) {
sort(sa.begin(), sa.end(),
[&](const int &i, const int &j) { return comp(i, j); });
vector<int> tmp(n + 1);
tmp[sa[0]] = 0;
for (int i = 1; i <= n; i++) {
tmp[sa[i]] = tmp[sa[i - 1]] + (comp(sa[i - 1], sa[i]) ? 1 : 0);
}
for (int i = 0; i <= n; i++) {
rank[i] = tmp[i];
}
}
}
void construct_lcp() {
int h = 0;
lcp[0] = 0;
for (int i = 0; i < n; i++) {
int j = sa[rank[i] - 1];
if (h > 0)
h--;
for (; j + h < n && i + h < n; h++) {
if (text[j + h] != text[i + h])
break;
}
lcp[rank[i] - 1] = h;
}
}
int low_bd(const string &pt) {
int l = 0, r = n + 1;
while (r - l > 1) {
int m = (r + l) / 2;
int val = text.compare(sa[m], pt.length(), pt);
if (val < 0)
l = m;
else
r = m;
}
return r;
}
int up_bd(const string &pt) {
int l = 1, r = n + 1;
while (r - l > 1) {
int m = (r + l) / 2;
int val = text.compare(sa[m], pt.length(), pt);
if (val <= 0)
l = m;
else
r = m;
}
return r;
}
bool match(const string &pt) {
int idx = low_bd(pt);
if (idx == sa.size())
return false;
return text.compare(sa[idx], pt.length(), pt) == 0 ? true : false;
}
int count(const string &pt) {
int l_idx = low_bd(pt);
if (l_idx == sa.size())
return 0;
if (text.compare(sa[l_idx], pt.length(), pt) != 0)
return 0;
int r_idx = up_bd(pt);
return r_idx - l_idx;
}
};
string t;
int q;
string p[1000];
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> t;
cin >> q;
rep(i, q) cin >> p[i];
SuffixArray suf(t);
suf.construct_sa();
rep(i, q) { cout << suf.match(p[i]) << endl; }
}
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
typedef long long ll;
typedef unsigned long long ull;
typedef unsigned __int128 HASH;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<ull, ull> pullull;
typedef pair<ll, int> plli;
typedef pair<double, int> pdbi;
typedef pair<int, pii> pipii;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vi> vvi;
typedef vector<vvi> vvvi;
typedef vector<pii> vpii;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep2(i, a, b) for (int i = (a); i < (b); i++)
#define rrep(i, n) for (int i = (n); i > 0; i--)
#define rrep2(i, a, b) for (int i = (a); i > b; i--)
#define pb push_back
#define fi first
#define se second
#define all(a) (a).begin(), (a).end()
const ll mod = 1000000000 + 7;
const ll hmod1 = 999999937;
const ll hmod2 = 1000000000 + 9;
const ll INF = 1 << 30;
const int dx4[4] = {1, 0, -1, 0};
const int dy4[4] = {0, 1, 0, -1};
const int dx8[8] = {1, 1, 1, 0, 0, -1, -1, -1};
const int dy8[8] = {0, 1, -1, 1, -1, 0, 1, -1};
const double pi = 3.141592653589793;
struct SuffixArray {
int n, k;
string text;
vector<int> sa;
vector<int> rank;
vector<int> lcp;
SuffixArray(const string &s)
: text(s), n(s.size()), sa(n + 1), rank(n + 1), lcp(n) {}
bool comp(int i, int j) {
if (rank[i] != rank[j])
return rank[i] < rank[j];
int ri = i + k <= n ? rank[i + k] : -1;
int rj = j + k <= n ? rank[j + k] : -1;
return ri < rj;
}
void construct_sa() {
for (int i = 0; i <= n; i++) {
sa[i] = i;
rank[i] = i < n ? text[i] : -1;
}
for (k = 1; k <= n; k *= 2) {
sort(sa.begin(), sa.end(),
[&](const int &i, const int &j) { return comp(i, j); });
vector<int> tmp(n + 1);
tmp[sa[0]] = 0;
for (int i = 1; i <= n; i++) {
tmp[sa[i]] = tmp[sa[i - 1]] + (comp(sa[i - 1], sa[i]) ? 1 : 0);
}
for (int i = 0; i <= n; i++) {
rank[i] = tmp[i];
}
}
}
void construct_lcp() {
int h = 0;
lcp[0] = 0;
for (int i = 0; i < n; i++) {
int j = sa[rank[i] - 1];
if (h > 0)
h--;
for (; j + h < n && i + h < n; h++) {
if (text[j + h] != text[i + h])
break;
}
lcp[rank[i] - 1] = h;
}
}
int low_bd(const string &pt) {
int l = 0, r = n + 1;
while (r - l > 1) {
int m = (r + l) / 2;
int val = text.compare(sa[m], pt.length(), pt);
if (val < 0)
l = m;
else
r = m;
}
return r;
}
int up_bd(const string &pt) {
int l = 1, r = n + 1;
while (r - l > 1) {
int m = (r + l) / 2;
int val = text.compare(sa[m], pt.length(), pt);
if (val <= 0)
l = m;
else
r = m;
}
return r;
}
bool match(const string &pt) {
int idx = low_bd(pt);
if (idx == sa.size())
return false;
return text.compare(sa[idx], pt.length(), pt) == 0 ? true : false;
}
int count(const string &pt) {
int l_idx = low_bd(pt);
if (l_idx == sa.size())
return 0;
if (text.compare(sa[l_idx], pt.length(), pt) != 0)
return 0;
int r_idx = up_bd(pt);
return r_idx - l_idx;
}
};
string t;
int q;
string p[10000];
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> t;
cin >> q;
rep(i, q) cin >> p[i];
SuffixArray suf(t);
suf.construct_sa();
rep(i, q) { cout << suf.match(p[i]) << endl; }
}
|
replace
| 139 | 140 | 139 | 140 |
0
| |
p02250
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
class suffix_array {
void create_begin_bucket(vector<int> &v, vector<int> &bucket) {
fill(bucket.begin(), bucket.end(), 0);
for (int i = 0; i < v.size(); i++)
bucket[v[i]]++;
int sum = 0;
for (int i = 0; i < bucket.size(); i++) {
bucket[i] += sum;
swap(sum, bucket[i]);
}
}
void create_end_bucket(vector<int> &v, vector<int> &bucket) {
fill(bucket.begin(), bucket.end(), 0);
for (int i = 0; i < v.size(); i++)
bucket[v[i]]++;
for (int i = 1; i < bucket.size(); i++)
bucket[i] += bucket[i - 1];
}
void induced_sort(vector<int> &v, vector<int> &sa, int mv,
vector<int> &bucket, vector<int> &is_l) {
create_begin_bucket(v, bucket);
for (int i = 0; i < v.size(); i++)
if (sa[i] > 0 && is_l[sa[i] - 1])
sa[bucket[v[sa[i] - 1]]++] = sa[i] - 1;
}
void invert_induced_sort(vector<int> &v, vector<int> &sa, int mv,
vector<int> &bucket, vector<int> &is_l) {
create_end_bucket(v, bucket);
for (int i = v.size() - 1; i >= 0; i--)
if (sa[i] > 0 && !is_l[sa[i] - 1])
sa[--bucket[v[sa[i] - 1]]] = sa[i] - 1;
}
vector<int> sa_is(vector<int> v, int mv) {
if (v.size() == 1)
return vector<int>(1, 0);
vector<int> is_l(v.size());
vector<int> bucket(mv + 1);
vector<int> sa(v.size(), -1);
auto is_lms = [&](int x) -> bool {
return x > 0 && is_l[x - 1] && !is_l[x];
};
is_l[v.size() - 1] = 0;
for (int i = v.size() - 2; i >= 0; i--)
is_l[i] = v[i] > v[i + 1] || (v[i] == v[i + 1] && is_l[i + 1]);
create_end_bucket(v, bucket);
for (int i = 0; i < v.size(); i++)
if (is_lms(i))
sa[--bucket[v[i]]] = i;
induced_sort(v, sa, mv, bucket, is_l);
invert_induced_sort(v, sa, mv, bucket, is_l);
int cur = 0;
vector<int> order(v.size());
for (int i = 0; i < v.size(); i++)
if (is_lms(i))
order[i] = cur++;
vector<int> next_v(cur);
cur = -1;
int prev = -1;
for (int i = 0; i < v.size(); i++) {
if (!is_lms(sa[i]))
continue;
bool diff = false;
for (int d = 0; d < v.size(); d++) {
if (prev == -1 || v[sa[i] + d] != v[prev + d] ||
is_l[sa[i] + d] != is_l[prev + d]) {
diff = true;
break;
} else if (d > 0 && is_lms(sa[i] + d))
break;
}
if (diff) {
cur++;
prev = sa[i];
}
next_v[order[sa[i]]] = cur;
}
vector<int> re_order(next_v.size());
for (int i = 0; i < v.size(); i++)
if (is_lms(i))
re_order[order[i]] = i;
vector<int> next_sa = sa_is(next_v, cur);
create_end_bucket(v, bucket);
for (int i = 0; i < sa.size(); i++)
sa[i] = -1;
for (int i = next_sa.size() - 1; i >= 0; i--)
sa[--bucket[v[re_order[next_sa[i]]]]] = re_order[next_sa[i]];
induced_sort(v, sa, mv, bucket, is_l);
invert_induced_sort(v, sa, mv, bucket, is_l);
return sa;
}
vector<int> sa_is(string &s) {
vector<int> v(s.size() + 1);
for (int i = 0; i < s.size(); i++)
v[i] = s[i];
sa = sa_is(v, *max_element(v.begin(), v.end()));
}
void construct_lcp() {
lcp.resize(s.size());
rank.resize(s.size() + 1);
int n = s.size();
for (int i = 0; i <= n; i++)
rank[sa[i]] = i;
int h = 0;
lcp[0] = 0;
for (int i = 0; i < n; i++) {
int j = sa[rank[i] - 1];
if (h > 0)
h--;
for (; j + h < n && i + h < n; h++) {
if (s[j + h] != s[i + h])
break;
}
lcp[rank[i] - 1] = h;
}
}
class sparse_table {
vector<vector<int>> st;
public:
void init(vector<int> &v) {
int b;
for (b = 0; (1 << b) <= v.size(); b++)
;
st.assign(b, vector<int>(1 << b));
return;
for (int i = 0; i < v.size(); i++)
st[0][i] = v[i];
for (int i = 1; i < b; i++) {
for (int j = 0; j + (1 << i) <= (1 << b); j++) {
st[i][j] = min(st[i - 1][j], st[i - 1][j + (1 << (i - 1))]);
}
}
}
int get_min(int l, int r) {
assert(l < r);
int b = 32 - __builtin_clz(r - l) - 1;
return min(st[b][l], st[b][r - (1 << b)]);
}
sparse_table() {}
sparse_table(vector<int> &v) { init(v); }
};
sparse_table st;
public:
string s;
vector<int> sa, lcp, rank;
void init(string &t) {
s = t;
sa_is(s);
construct_lcp();
st.init(lcp);
}
suffix_array(string &t) { init(t); }
suffix_array() {}
bool contain(string &t) {
int lb = 0, ub = s.size();
while (ub - lb > 1) {
int mid = (lb + ub) / 2;
if (s.compare(sa[mid], t.size(), t) < 0)
lb = mid;
else
ub = mid;
}
return s.compare(sa[ub], t.size(), t) == 0;
}
int get_lcp(int i, int j) {
if (rank[i] > rank[j])
swap(i, j);
return st.get_min(rank[i], rank[j]);
}
};
signed main() {
string s;
cin >> s;
suffix_array sa(s);
int q;
cin >> q;
while (q--) {
string t;
cin >> t;
cout << sa.contain(t) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class suffix_array {
void create_begin_bucket(vector<int> &v, vector<int> &bucket) {
fill(bucket.begin(), bucket.end(), 0);
for (int i = 0; i < v.size(); i++)
bucket[v[i]]++;
int sum = 0;
for (int i = 0; i < bucket.size(); i++) {
bucket[i] += sum;
swap(sum, bucket[i]);
}
}
void create_end_bucket(vector<int> &v, vector<int> &bucket) {
fill(bucket.begin(), bucket.end(), 0);
for (int i = 0; i < v.size(); i++)
bucket[v[i]]++;
for (int i = 1; i < bucket.size(); i++)
bucket[i] += bucket[i - 1];
}
void induced_sort(vector<int> &v, vector<int> &sa, int mv,
vector<int> &bucket, vector<int> &is_l) {
create_begin_bucket(v, bucket);
for (int i = 0; i < v.size(); i++)
if (sa[i] > 0 && is_l[sa[i] - 1])
sa[bucket[v[sa[i] - 1]]++] = sa[i] - 1;
}
void invert_induced_sort(vector<int> &v, vector<int> &sa, int mv,
vector<int> &bucket, vector<int> &is_l) {
create_end_bucket(v, bucket);
for (int i = v.size() - 1; i >= 0; i--)
if (sa[i] > 0 && !is_l[sa[i] - 1])
sa[--bucket[v[sa[i] - 1]]] = sa[i] - 1;
}
vector<int> sa_is(vector<int> v, int mv) {
if (v.size() == 1)
return vector<int>(1, 0);
vector<int> is_l(v.size());
vector<int> bucket(mv + 1);
vector<int> sa(v.size(), -1);
auto is_lms = [&](int x) -> bool {
return x > 0 && is_l[x - 1] && !is_l[x];
};
is_l[v.size() - 1] = 0;
for (int i = v.size() - 2; i >= 0; i--)
is_l[i] = v[i] > v[i + 1] || (v[i] == v[i + 1] && is_l[i + 1]);
create_end_bucket(v, bucket);
for (int i = 0; i < v.size(); i++)
if (is_lms(i))
sa[--bucket[v[i]]] = i;
induced_sort(v, sa, mv, bucket, is_l);
invert_induced_sort(v, sa, mv, bucket, is_l);
int cur = 0;
vector<int> order(v.size());
for (int i = 0; i < v.size(); i++)
if (is_lms(i))
order[i] = cur++;
vector<int> next_v(cur);
cur = -1;
int prev = -1;
for (int i = 0; i < v.size(); i++) {
if (!is_lms(sa[i]))
continue;
bool diff = false;
for (int d = 0; d < v.size(); d++) {
if (prev == -1 || v[sa[i] + d] != v[prev + d] ||
is_l[sa[i] + d] != is_l[prev + d]) {
diff = true;
break;
} else if (d > 0 && is_lms(sa[i] + d))
break;
}
if (diff) {
cur++;
prev = sa[i];
}
next_v[order[sa[i]]] = cur;
}
vector<int> re_order(next_v.size());
for (int i = 0; i < v.size(); i++)
if (is_lms(i))
re_order[order[i]] = i;
vector<int> next_sa = sa_is(next_v, cur);
create_end_bucket(v, bucket);
for (int i = 0; i < sa.size(); i++)
sa[i] = -1;
for (int i = next_sa.size() - 1; i >= 0; i--)
sa[--bucket[v[re_order[next_sa[i]]]]] = re_order[next_sa[i]];
induced_sort(v, sa, mv, bucket, is_l);
invert_induced_sort(v, sa, mv, bucket, is_l);
return sa;
}
vector<int> sa_is(string &s) {
vector<int> v(s.size() + 1);
for (int i = 0; i < s.size(); i++)
v[i] = s[i];
sa = sa_is(v, *max_element(v.begin(), v.end()));
}
void construct_lcp() {
lcp.resize(s.size());
rank.resize(s.size() + 1);
int n = s.size();
for (int i = 0; i <= n; i++)
rank[sa[i]] = i;
int h = 0;
lcp[0] = 0;
for (int i = 0; i < n; i++) {
int j = sa[rank[i] - 1];
if (h > 0)
h--;
for (; j + h < n && i + h < n; h++) {
if (s[j + h] != s[i + h])
break;
}
lcp[rank[i] - 1] = h;
}
}
class sparse_table {
vector<vector<int>> st;
public:
void init(vector<int> &v) {
int b;
for (b = 0; (1 << b) <= v.size(); b++)
;
st.resize(b);
for (int i = 0; i < b; i++)
st[i].resize(1 << b);
for (int i = 0; i < v.size(); i++)
st[0][i] = v[i];
for (int i = 1; i < b; i++) {
for (int j = 0; j + (1 << i) <= (1 << b); j++) {
st[i][j] = min(st[i - 1][j], st[i - 1][j + (1 << (i - 1))]);
}
}
}
int get_min(int l, int r) {
assert(l < r);
int b = 32 - __builtin_clz(r - l) - 1;
return min(st[b][l], st[b][r - (1 << b)]);
}
sparse_table() {}
sparse_table(vector<int> &v) { init(v); }
};
sparse_table st;
public:
string s;
vector<int> sa, lcp, rank;
void init(string &t) {
s = t;
sa_is(s);
construct_lcp();
st.init(lcp);
}
suffix_array(string &t) { init(t); }
suffix_array() {}
bool contain(string &t) {
int lb = 0, ub = s.size();
while (ub - lb > 1) {
int mid = (lb + ub) / 2;
if (s.compare(sa[mid], t.size(), t) < 0)
lb = mid;
else
ub = mid;
}
return s.compare(sa[ub], t.size(), t) == 0;
}
int get_lcp(int i, int j) {
if (rank[i] > rank[j])
swap(i, j);
return st.get_min(rank[i], rank[j]);
}
};
signed main() {
string s;
cin >> s;
suffix_array sa(s);
int q;
cin >> q;
while (q--) {
string t;
cin >> t;
cout << sa.contain(t) << endl;
}
return 0;
}
|
replace
| 138 | 140 | 138 | 141 |
-6
|
double free or corruption (out)
|
p02250
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
// BEGIN CUT HERE
struct SuffixArray {
int n, k;
string S;
vector<int> sa, lcp;
SuffixArray() {}
SuffixArray(string S) : S(S) { init(); }
void init() {
n = S.length();
sa.clear();
lcp.clear();
sa.resize(n + 1, 0);
lcp.resize(n + 1, 0);
build_sa();
build_lcp();
build_rmq();
}
void build_sa() {
S.push_back('$');
vector<int> c(n + 1, 0), ord(n + 1, 0);
for (int i = 0; i <= n; i++)
ord[i] = n - i;
sort(ord.begin(), ord.end(), [&](int a, int b) { return S[a] < S[b]; });
for (int i = 0; i <= n; i++) {
sa[i] = ord[i];
c[i] = S[i];
}
for (int len = 1; len <= n; len *= 2) {
vector<int> r = c;
for (int i = 0; i <= n; i++) {
c[sa[i]] = i > 0 && r[sa[i - 1]] == r[sa[i]] && sa[i - 1] + len <= n &&
r[sa[i - 1] + len / 2] == r[sa[i] + len / 2]
? c[sa[i - 1]]
: i;
}
vector<int> cnt(n + 1);
for (int i = 0; i <= n; i++)
cnt[i] = i;
vector<int> s = sa;
for (int i = 0; i <= n; i++) {
int s1 = s[i] - len;
if (s1 >= 0)
sa[cnt[c[s1]]++] = s1;
}
}
S.pop_back();
}
bool contains(string T) {
int a = 0, b = n + 1;
while (a + 1 < b) {
int c = (a + b) / 2;
if (S.compare(sa[c], T.length(), T) < 0)
a = c;
else
b = c;
}
if (b == n + 1)
b--;
return S.compare(sa[b], T.length(), T) == 0;
}
// O(|T|*log|S|)
int count(string T) {
int sl = S.length(), tl = T.length();
int a[2], b[2];
for (int i = 0; i < 2; i++) {
a[i] = 0;
b[i] = sl;
while (a[i] + 1 < b[i]) {
int c = (a[i] + b[i]) / 2;
if (S.compare(sa[c], tl, T) < 0 || (i && S.compare(sa[c], tl, T) == 0))
a[i] = c;
else
b[i] = c;
}
}
if (S.compare(sa[b[0]], tl, T) != 0)
return 0;
if (a[1] < sl && S.compare(sa[a[1] + 1], tl, T) == 0)
a[1]++;
if (b[0] > 0 && S.compare(sa[b[0] - 1], tl, T) == 0)
b[0]--;
return a[1] - b[0] + 1;
}
void build_lcp() {
vector<int> r2(n);
for (int i = 0; i < n; i++)
r2[sa[i]] = i;
int h = 0;
lcp[0] = 0;
for (int i = 0; i < n; i++) {
int j = sa[r2[i] - 1];
if (h > 0)
h--;
for (; j + h < n && i + h < n; h++) {
if (S[j + h] != S[i + h])
break;
}
lcp[r2[i] - 1] = h;
}
}
int getlcp(int p, string &T, int d) {
int i = 0;
int len = min((int)T.length() - d, (int)S.length() - p - d);
while (i < len && S[p + d + i] == T[d + i])
i++;
return i;
}
struct RMQ {
int n;
vector<int> dat;
const int def = INT_MAX;
RMQ() {}
RMQ(int n_) { init(n_); }
RMQ(int n_, vector<int> &a) {
init(n_);
build(n_, a);
}
void init(int n_) {
n = 1;
while (n < n_)
n *= 2;
dat.clear();
dat.resize(2 * n - 1, def);
}
void build(int n_, vector<int> &a) {
for (int i = 0; i < n_; i++)
dat[i + n - 1] = a[i];
for (int i = n - 2; i >= 0; i--)
dat[i] = min(dat[i * 2 + 1], dat[i * 2 + 2]);
}
void update(int k, int a) {
k += n - 1;
dat[k] = a;
while (k > 0) {
k = (k - 1) / 2;
dat[k] = min(dat[k * 2 + 1], dat[k * 2 + 2]);
}
}
int query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return def;
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 min(vl, vr);
}
}
int query(int a, int b) { return query(a, b, 0, 0, n); }
};
RMQ rmq;
void build_rmq() {
rmq.init(n);
rmq.build(n, lcp);
}
// O(|T|+log|S|)
int count2(string T) {
int a[2], b[2];
int sl = S.length(), tl = T.length();
for (int i = 0; i < 2; i++) {
int p, l, r;
p = tl;
a[i] = 0;
b[i] = sl;
l = getlcp(sa[a[i]], T, 0);
r = getlcp(sa[b[i]], T, 0);
while (a[i] + 1 < b[i]) {
int c = (a[i] + b[i]) / 2;
// cout<<a[i]<<" "<<b[i]<<" "<<c<<endl;
if (l >= r) {
int m = rmq.query(a[i], c);
if (m < l)
b[i] = c, r = m;
else {
int k = l + getlcp(sa[c], T, l);
if (i) {
if (k == p || S[sa[c] + k] < T[k])
a[i] = c, l = k;
else
b[i] = c, r = k;
} else {
if (k == p)
b[i] = c, r = k;
else if (S[sa[c] + k] < T[k])
a[i] = c, l = k;
else
b[i] = c, r = k;
}
}
} else {
int m = rmq.query(c, b[i]);
if (m < r)
a[i] = c, l = m;
else {
int k = r + getlcp(sa[c], T, r);
if (i) {
if (k == p || S[sa[c] + k] < T[k])
a[i] = c, l = k;
else
b[i] = c, r = k;
} else {
if (k == p)
b[i] = c, r = k;
else if (S[sa[c] + k] < T[k])
a[i] = c, l = k;
else
b[i] = c, r = k;
}
}
}
}
}
if (a[1] < sl && getlcp(sa[a[1] + 1], T, 0) == tl)
a[1]++;
if (b[0] > 0 && getlcp(sa[b[0] - 1], T, 0) == tl)
b[0]--;
if (getlcp(sa[b[0]], T, 0) != tl)
return 0;
return a[1] - b[0] + 1;
}
};
// END CUT HERE
char buf[1000001];
signed main() {
scanf("%s", buf);
string T(buf);
SuffixArray sa(T);
int q;
scanf("%lld", &q);
while (q--) {
scanf("%s", buf);
string P(buf);
printf("%lld\n", (int)sa.contains(P));
// assert(sa.count(P)==sa.count2(P));
}
return 0;
}
/*
verified on 2017/10/20
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=ALDS1_14_D
*/
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
// BEGIN CUT HERE
struct SuffixArray {
int n, k;
string S;
vector<int> sa, lcp;
SuffixArray() {}
SuffixArray(string S) : S(S) { init(); }
void init() {
n = S.length();
sa.clear();
lcp.clear();
sa.resize(n + 1, 0);
lcp.resize(n + 1, 0);
build_sa();
build_lcp();
build_rmq();
}
void build_sa() {
S.push_back('$');
vector<int> c(n + 1, 0), ord(n + 1, 0);
for (int i = 0; i <= n; i++)
ord[i] = n - i;
sort(ord.begin(), ord.end(), [&](int a, int b) { return S[a] < S[b]; });
for (int i = 0; i <= n; i++) {
sa[i] = ord[i];
c[i] = S[i];
}
for (int len = 1; len <= n; len *= 2) {
vector<int> r = c;
for (int i = 0; i <= n; i++) {
c[sa[i]] = i > 0 && r[sa[i - 1]] == r[sa[i]] && sa[i - 1] + len <= n &&
r[sa[i - 1] + len / 2] == r[sa[i] + len / 2]
? c[sa[i - 1]]
: i;
}
vector<int> cnt(n + 1);
for (int i = 0; i <= n; i++)
cnt[i] = i;
vector<int> s = sa;
for (int i = 0; i <= n; i++) {
int s1 = s[i] - len;
if (s1 >= 0)
sa[cnt[c[s1]]++] = s1;
}
}
S.pop_back();
}
bool contains(string T) {
int a = 0, b = n + 1;
while (a + 1 < b) {
int c = (a + b) / 2;
if (S.compare(sa[c], T.length(), T) < 0)
a = c;
else
b = c;
}
if (b == n + 1)
b--;
return S.compare(sa[b], T.length(), T) == 0;
}
// O(|T|*log|S|)
int count(string T) {
int sl = S.length(), tl = T.length();
int a[2], b[2];
for (int i = 0; i < 2; i++) {
a[i] = 0;
b[i] = sl;
while (a[i] + 1 < b[i]) {
int c = (a[i] + b[i]) / 2;
if (S.compare(sa[c], tl, T) < 0 || (i && S.compare(sa[c], tl, T) == 0))
a[i] = c;
else
b[i] = c;
}
}
if (S.compare(sa[b[0]], tl, T) != 0)
return 0;
if (a[1] < sl && S.compare(sa[a[1] + 1], tl, T) == 0)
a[1]++;
if (b[0] > 0 && S.compare(sa[b[0] - 1], tl, T) == 0)
b[0]--;
return a[1] - b[0] + 1;
}
void build_lcp() {
vector<int> r2(n + 1);
for (int i = 0; i <= n; i++)
r2[sa[i]] = i;
int h = 0;
lcp[0] = 0;
for (int i = 0; i < n; i++) {
int j = sa[r2[i] - 1];
if (h > 0)
h--;
for (; j + h < n && i + h < n; h++) {
if (S[j + h] != S[i + h])
break;
}
lcp[r2[i] - 1] = h;
}
}
int getlcp(int p, string &T, int d) {
int i = 0;
int len = min((int)T.length() - d, (int)S.length() - p - d);
while (i < len && S[p + d + i] == T[d + i])
i++;
return i;
}
struct RMQ {
int n;
vector<int> dat;
const int def = INT_MAX;
RMQ() {}
RMQ(int n_) { init(n_); }
RMQ(int n_, vector<int> &a) {
init(n_);
build(n_, a);
}
void init(int n_) {
n = 1;
while (n < n_)
n *= 2;
dat.clear();
dat.resize(2 * n - 1, def);
}
void build(int n_, vector<int> &a) {
for (int i = 0; i < n_; i++)
dat[i + n - 1] = a[i];
for (int i = n - 2; i >= 0; i--)
dat[i] = min(dat[i * 2 + 1], dat[i * 2 + 2]);
}
void update(int k, int a) {
k += n - 1;
dat[k] = a;
while (k > 0) {
k = (k - 1) / 2;
dat[k] = min(dat[k * 2 + 1], dat[k * 2 + 2]);
}
}
int query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return def;
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 min(vl, vr);
}
}
int query(int a, int b) { return query(a, b, 0, 0, n); }
};
RMQ rmq;
void build_rmq() {
rmq.init(n);
rmq.build(n, lcp);
}
// O(|T|+log|S|)
int count2(string T) {
int a[2], b[2];
int sl = S.length(), tl = T.length();
for (int i = 0; i < 2; i++) {
int p, l, r;
p = tl;
a[i] = 0;
b[i] = sl;
l = getlcp(sa[a[i]], T, 0);
r = getlcp(sa[b[i]], T, 0);
while (a[i] + 1 < b[i]) {
int c = (a[i] + b[i]) / 2;
// cout<<a[i]<<" "<<b[i]<<" "<<c<<endl;
if (l >= r) {
int m = rmq.query(a[i], c);
if (m < l)
b[i] = c, r = m;
else {
int k = l + getlcp(sa[c], T, l);
if (i) {
if (k == p || S[sa[c] + k] < T[k])
a[i] = c, l = k;
else
b[i] = c, r = k;
} else {
if (k == p)
b[i] = c, r = k;
else if (S[sa[c] + k] < T[k])
a[i] = c, l = k;
else
b[i] = c, r = k;
}
}
} else {
int m = rmq.query(c, b[i]);
if (m < r)
a[i] = c, l = m;
else {
int k = r + getlcp(sa[c], T, r);
if (i) {
if (k == p || S[sa[c] + k] < T[k])
a[i] = c, l = k;
else
b[i] = c, r = k;
} else {
if (k == p)
b[i] = c, r = k;
else if (S[sa[c] + k] < T[k])
a[i] = c, l = k;
else
b[i] = c, r = k;
}
}
}
}
}
if (a[1] < sl && getlcp(sa[a[1] + 1], T, 0) == tl)
a[1]++;
if (b[0] > 0 && getlcp(sa[b[0] - 1], T, 0) == tl)
b[0]--;
if (getlcp(sa[b[0]], T, 0) != tl)
return 0;
return a[1] - b[0] + 1;
}
};
// END CUT HERE
char buf[1000001];
signed main() {
scanf("%s", buf);
string T(buf);
SuffixArray sa(T);
int q;
scanf("%lld", &q);
while (q--) {
scanf("%s", buf);
string P(buf);
printf("%lld\n", (int)sa.contains(P));
// assert(sa.count(P)==sa.count2(P));
}
return 0;
}
/*
verified on 2017/10/20
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=ALDS1_14_D
*/
|
replace
| 89 | 91 | 89 | 91 |
-6
|
free(): invalid pointer
|
p02250
|
C++
|
Time Limit Exceeded
|
#include <algorithm>
#include <cassert>
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
#define REP(i, n) for (int i = 0; i < int(n); ++i)
#define ALL(A) (A).begin(), (A).end()
#define SZ(A) int(A.size())
using namespace std;
typedef unsigned long long ull;
struct RollingHash {
static const ull p = 100000007;
string s;
int n;
// vector<ull> pow, phash;
ull *pow, *phash;
RollingHash(const string &s) : s(s), n(SZ(s)) {
pow = new ull[n + 1];
phash = new ull[n + 1];
pow[0] = 1, phash[0] = 0;
REP(i, n) {
phash[i + 1] = s[i] + phash[i] * p;
pow[i + 1] = pow[i] * p;
}
}
~RollingHash() { free(pow), free(phash); }
inline bool operator()(const int &i, const int &j) const {
const int k = lcp(i, j);
return i + k >= n ? true : j + k >= n ? false : s[i + k] <= s[j + k];
}
/*
static ull hash(const string &t) {
ull h=0;
REP(i,SZ(t))h=t[i]+h*p;
return h;
}
*/
inline ull hash(const int &b, const int &e) const {
return phash[e] - phash[b] * pow[e - b];
}
/*
inline int find(string t) {
int w=t.size(),count=0;
if(w > SZ(s))return 0;
ull h=hash(t);
REP(i,n-w+1)count+=(hash(i,i+w)==h);
return count;
}
*/
inline int lcp(const int &i, const int &j) const {
int l = 0, r = n - max(i, j) + 1;
while (r - l > 1) {
const int m = (l + r) / 2;
(hash(i, i + m) == hash(j, j + m) ? l : r) = m;
}
return l;
}
};
/*
void mergesort(const int& n,int *a, const RollingHash& rh){
if(n>1){
int nb=n/2,nc=n-nb,b[nb],c[nc];
REP(i,nb)b[i]=a[i];
REP(i,nc)c[i]=a[nb+i];
//vector<int> b(a.begin(), a.begin()+n/2), c(a.begin()+n/2, a.end());
mergesort(nb,b,rh), mergesort(nc,c,rh);
for(int i=0,j=0,k=0;i<n;i++){
if(k>=nc)a[i]=b[j++];
else if(j>=nb)a[i]=c[k++];
else if(rh(b[j],c[k]))a[i]=b[j++];
else a[i]=c[k++];
}
}
}
*/
int L[1000000], R[1000000];
inline void merge(int *A, const int left, const int mid, const int right,
const RollingHash &rh) {
const int n1 = mid - left, n2 = right - mid;
REP(i, n1) L[i] = A[left + i];
REP(i, n2) R[i] = A[mid + i];
for (int k = left, i = 0, j = 0; k < right; k++) {
if (n2 <= j)
A[k] = L[i++];
else if (n1 <= i)
A[k] = R[j++];
else
A[k] = rh(L[i], R[j]) ? L[i++] : R[j++];
}
}
void mergeSort(int *A, const int left, const int right, const RollingHash &rh) {
if (left + 1 < right) {
const int mid = (left + right) >> 1;
mergeSort(A, left, mid, rh);
mergeSort(A, mid, right, rh);
merge(A, left, mid, right, rh);
}
}
// O(n (log n)^2)
vector<int> suffixArray(const RollingHash &rh) {
int n = rh.n + 1, sa[n];
REP(i, n) sa[i] = i;
// mergesort(n,sa,rh);
mergeSort(sa, 0, n, rh);
vector<int> res(n);
REP(i, n) res[i] = sa[i];
return res;
}
bool contain(const string &S, const vector<int> &sa, const string &T) {
int a = 0, b = SZ(S);
while (b - a > 1) {
const int c = (a + b) / 2;
(S.compare(sa[c], T.length(), T) < 0 ? a : b) = c;
}
return S.compare(sa[b], T.length(), T) == 0;
}
int main(void) {
char str[1000002];
string s, t;
scanf("%s", str);
s = str;
RollingHash rh = RollingHash(s);
vector<int> sa = suffixArray(rh);
int n;
cin >> n;
while (n--) {
scanf("%s", str);
t = str;
printf("%d\n", contain(s, sa, t));
}
return 0;
}
|
#include <algorithm>
#include <cassert>
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
#define REP(i, n) for (int i = 0; i < int(n); ++i)
#define ALL(A) (A).begin(), (A).end()
#define SZ(A) int(A.size())
using namespace std;
typedef unsigned long long ull;
struct RollingHash {
static const ull p = 100000007;
string s;
int n;
// vector<ull> pow, phash;
ull *pow, *phash;
RollingHash(const string &s) : s(s), n(SZ(s)) {
pow = new ull[n + 1];
phash = new ull[n + 1];
pow[0] = 1, phash[0] = 0;
REP(i, n) {
phash[i + 1] = s[i] + phash[i] * p;
pow[i + 1] = pow[i] * p;
}
}
~RollingHash() { free(pow), free(phash); }
inline bool operator()(const int &i, const int &j) const {
const int k = lcp(i, j);
return i + k >= n ? true : j + k >= n ? false : s[i + k] <= s[j + k];
}
/*
static ull hash(const string &t) {
ull h=0;
REP(i,SZ(t))h=t[i]+h*p;
return h;
}
*/
inline ull hash(const int &b, const int &e) const {
return phash[e] - phash[b] * pow[e - b];
}
/*
inline int find(string t) {
int w=t.size(),count=0;
if(w > SZ(s))return 0;
ull h=hash(t);
REP(i,n-w+1)count+=(hash(i,i+w)==h);
return count;
}
*/
inline int lcp(const int &i, const int &j) const {
int l = 0, r = n - max(i, j) + 1;
while (r - l > 1) {
const int m = (l + r) >> 1;
(hash(i, i + m) == hash(j, j + m) ? l : r) = m;
}
return l;
}
};
/*
void mergesort(const int& n,int *a, const RollingHash& rh){
if(n>1){
int nb=n/2,nc=n-nb,b[nb],c[nc];
REP(i,nb)b[i]=a[i];
REP(i,nc)c[i]=a[nb+i];
//vector<int> b(a.begin(), a.begin()+n/2), c(a.begin()+n/2, a.end());
mergesort(nb,b,rh), mergesort(nc,c,rh);
for(int i=0,j=0,k=0;i<n;i++){
if(k>=nc)a[i]=b[j++];
else if(j>=nb)a[i]=c[k++];
else if(rh(b[j],c[k]))a[i]=b[j++];
else a[i]=c[k++];
}
}
}
*/
int L[1000000], R[1000000];
inline void merge(int *A, const int left, const int mid, const int right,
const RollingHash &rh) {
const int n1 = mid - left, n2 = right - mid;
REP(i, n1) L[i] = A[left + i];
REP(i, n2) R[i] = A[mid + i];
for (int k = left, i = 0, j = 0; k < right; k++) {
if (n2 <= j)
A[k] = L[i++];
else if (n1 <= i)
A[k] = R[j++];
else
A[k] = rh(L[i], R[j]) ? L[i++] : R[j++];
}
}
void mergeSort(int *A, const int left, const int right, const RollingHash &rh) {
if (left + 1 < right) {
const int mid = (left + right) >> 1;
mergeSort(A, left, mid, rh);
mergeSort(A, mid, right, rh);
merge(A, left, mid, right, rh);
}
}
// O(n (log n)^2)
vector<int> suffixArray(const RollingHash &rh) {
int n = rh.n + 1, sa[n];
REP(i, n) sa[i] = i;
// mergesort(n,sa,rh);
mergeSort(sa, 0, n, rh);
vector<int> res(n);
REP(i, n) res[i] = sa[i];
return res;
}
bool contain(const string &S, const vector<int> &sa, const string &T) {
int a = 0, b = SZ(S);
while (b - a > 1) {
const int c = (a + b) / 2;
(S.compare(sa[c], T.length(), T) < 0 ? a : b) = c;
}
return S.compare(sa[b], T.length(), T) == 0;
}
int main(void) {
char str[1000002];
string s, t;
scanf("%s", str);
s = str;
RollingHash rh = RollingHash(s);
vector<int> sa = suffixArray(rh);
int n;
cin >> n;
while (n--) {
scanf("%s", str);
t = str;
printf("%d\n", contain(s, sa, t));
}
return 0;
}
|
replace
| 63 | 64 | 63 | 64 |
TLE
| |
p02250
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
// #define int long long
typedef pair<int, int> pint;
typedef vector<int> vint;
typedef vector<pint> vpint;
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define all(v) (v).begin(), (v).end()
#define rep(i, n) for (int i = 0; i < (n); i++)
#define reps(i, f, n) for (int i = (f); i < (n); i++)
#define each(it, v) \
for (__typeof((v).begin()) it = (v).begin(); it != (v).end(); it++)
template <class T, class U> void chmin(T &t, U f) {
if (t > f)
t = f;
}
template <class T, class U> void chmax(T &t, U f) {
if (t < f)
t = f;
}
namespace SA {
const int MAX = 1000000;
int N, K;
int tmp[MAX + 1], rank[MAX + 1];
bool compare_sa(int i, int j) {
if (rank[i] != rank[j])
return rank[i] < rank[j];
else {
int ri = (i + K <= N) ? rank[i + K] : -1;
int rj = (j + K <= N) ? rank[j + K] : -1;
return ri < rj;
}
}
vector<int> construct_sa(string S) {
N = S.size();
vector<int> sa(N + 1);
for (int i = 0; i <= N; i++)
sa[i] = i;
for (int i = 0; i <= N; i++) {
rank[i] = i == N ? -1 : S[i];
}
for (K = 1; K <= N; K *= 2) {
sort(sa.begin(), sa.end(), compare_sa);
tmp[sa[0]] = 0;
for (int i = 1; i <= N; i++) {
tmp[sa[i]] = tmp[sa[i - 1]] + (compare_sa(sa[i - 1], sa[i]) ? 1 : 0);
}
for (int i = 0; i <= N; i++)
rank[i] = tmp[i];
}
return sa;
}
} // namespace SA
bool exist(string &S, vint &sa, string &T) {
int a = 0, b = S.size();
while (b - a > 1) {
int c = (a + b) / 2;
if (S.substr(sa[c], S.size() - sa[c]) < T)
a = c;
else
b = c;
}
return S.substr(sa[b], min(S.size() - sa[b], T.size())) == T;
}
bool contain(string &S, vint &sa, string &T) {
int a = 0, b = S.size();
while (b - a > 1) {
int c = (a + b) / 2;
if (S.compare(sa[c], T.size(), T) < 0)
a = c;
else
b = c;
}
return S.compare(sa[b], T.size(), T) == 0;
}
signed main() {
string S;
vint sa;
int Q;
cin >> S;
sa = SA::construct_sa(S);
cin >> Q;
while (Q--) {
string T;
cin >> T;
if (exist(S, sa, T))
cout << 1 << endl;
else
cout << 0 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
// #define int long long
typedef pair<int, int> pint;
typedef vector<int> vint;
typedef vector<pint> vpint;
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define all(v) (v).begin(), (v).end()
#define rep(i, n) for (int i = 0; i < (n); i++)
#define reps(i, f, n) for (int i = (f); i < (n); i++)
#define each(it, v) \
for (__typeof((v).begin()) it = (v).begin(); it != (v).end(); it++)
template <class T, class U> void chmin(T &t, U f) {
if (t > f)
t = f;
}
template <class T, class U> void chmax(T &t, U f) {
if (t < f)
t = f;
}
namespace SA {
const int MAX = 1000000;
int N, K;
int tmp[MAX + 1], rank[MAX + 1];
bool compare_sa(int i, int j) {
if (rank[i] != rank[j])
return rank[i] < rank[j];
else {
int ri = (i + K <= N) ? rank[i + K] : -1;
int rj = (j + K <= N) ? rank[j + K] : -1;
return ri < rj;
}
}
vector<int> construct_sa(string S) {
N = S.size();
vector<int> sa(N + 1);
for (int i = 0; i <= N; i++)
sa[i] = i;
for (int i = 0; i <= N; i++) {
rank[i] = i == N ? -1 : S[i];
}
for (K = 1; K <= N; K *= 2) {
sort(sa.begin(), sa.end(), compare_sa);
tmp[sa[0]] = 0;
for (int i = 1; i <= N; i++) {
tmp[sa[i]] = tmp[sa[i - 1]] + (compare_sa(sa[i - 1], sa[i]) ? 1 : 0);
}
for (int i = 0; i <= N; i++)
rank[i] = tmp[i];
}
return sa;
}
} // namespace SA
bool exist(string &S, vint &sa, string &T) {
int a = 0, b = S.size();
while (b - a > 1) {
int c = (a + b) / 2;
if (S.substr(sa[c], S.size() - sa[c]) < T)
a = c;
else
b = c;
}
return S.substr(sa[b], min(S.size() - sa[b], T.size())) == T;
}
bool contain(string &S, vint &sa, string &T) {
int a = 0, b = S.size();
while (b - a > 1) {
int c = (a + b) / 2;
if (S.compare(sa[c], T.size(), T) < 0)
a = c;
else
b = c;
}
return S.compare(sa[b], T.size(), T) == 0;
}
signed main() {
string S;
vint sa;
int Q;
cin >> S;
sa = SA::construct_sa(S);
cin >> Q;
while (Q--) {
string T;
cin >> T;
if (contain(S, sa, T))
cout << 1 << endl;
else
cout << 0 << endl;
}
return 0;
}
|
replace
| 97 | 98 | 97 | 98 |
TLE
| |
p02250
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, x, y) for (int i = (x); i < (y); ++i)
#define debug(x) #x << "=" << (x)
#ifdef DEBUG
#define _GLIBCXX_DEBUG
#define print(x) std::cerr << debug(x) << " (L:" << __LINE__ << ")" << std::endl
#else
#define print(x)
#endif
const int inf = 1e9;
const int64_t inf64 = 1e18;
const double eps = 1e-9;
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "[";
for (const auto &v : vec) {
os << v << ",";
}
os << "]";
return os;
}
using i64 = int64_t;
vector<int> suffix_array(const string &s) {
const int n = s.size();
vector<int> rank(n + 1), sa(n + 1), tmp(n + 1);
for (int i = 0; i <= n; ++i) {
sa[i] = i;
rank[i] = i < n ? s[i] : -1;
}
for (int k = 1; k <= n; k *= 2) {
auto compare = [&](int i, int j) {
if (rank[i] != rank[j])
return rank[i] < rank[j];
else {
int ri = i + k <= n ? rank[i + k] : -1;
int rj = j + k <= n ? rank[j + k] : -1;
return ri < rj;
}
};
sort(sa.begin(), sa.end(), compare);
tmp[sa[0]] = 0;
for (int i = 1; i <= n; ++i) {
tmp[sa[i]] = tmp[sa[i - 1]] + (compare(sa[i - 1], sa[i]) ? 1 : 0);
}
for (int i = 0; i <= n; ++i) {
rank[i] = tmp[i];
}
}
return sa;
}
int lower_bound(const string &s, const vector<int> &sa, const string t) {
int lb = 0, ub = sa.size();
while (ub - lb > 1) {
int m = (lb + ub) / 2;
if (s.substr(sa[m], t.size()) >= t)
ub = m;
else
lb = m;
}
return ub;
}
int upper_bound(const string &s, const vector<int> &sa, const string t) {
int lb = 0, ub = sa.size();
while (ub - lb > 1) {
int m = (lb + ub) / 2;
if (s.substr(sa[m], t.size()) > t)
ub = m;
else
lb = m;
}
return ub;
}
void solve() {
string S;
int q;
cin >> S >> q;
auto sa = suffix_array(S);
cerr << sa << endl;
rep(i, 0, q) {
string T;
cin >> T;
if (upper_bound(S, sa, T) - lower_bound(S, sa, T) >= 1)
cout << 1 << endl;
else
cout << 0 << endl;
}
}
int main() {
std::cin.tie(0);
std::ios::sync_with_stdio(false);
cout.setf(ios::fixed);
cout.precision(10);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, x, y) for (int i = (x); i < (y); ++i)
#define debug(x) #x << "=" << (x)
#ifdef DEBUG
#define _GLIBCXX_DEBUG
#define print(x) std::cerr << debug(x) << " (L:" << __LINE__ << ")" << std::endl
#else
#define print(x)
#endif
const int inf = 1e9;
const int64_t inf64 = 1e18;
const double eps = 1e-9;
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "[";
for (const auto &v : vec) {
os << v << ",";
}
os << "]";
return os;
}
using i64 = int64_t;
vector<int> suffix_array(const string &s) {
const int n = s.size();
vector<int> rank(n + 1), sa(n + 1), tmp(n + 1);
for (int i = 0; i <= n; ++i) {
sa[i] = i;
rank[i] = i < n ? s[i] : -1;
}
for (int k = 1; k <= n; k *= 2) {
auto compare = [&](int i, int j) {
if (rank[i] != rank[j])
return rank[i] < rank[j];
else {
int ri = i + k <= n ? rank[i + k] : -1;
int rj = j + k <= n ? rank[j + k] : -1;
return ri < rj;
}
};
sort(sa.begin(), sa.end(), compare);
tmp[sa[0]] = 0;
for (int i = 1; i <= n; ++i) {
tmp[sa[i]] = tmp[sa[i - 1]] + (compare(sa[i - 1], sa[i]) ? 1 : 0);
}
for (int i = 0; i <= n; ++i) {
rank[i] = tmp[i];
}
}
return sa;
}
int lower_bound(const string &s, const vector<int> &sa, const string t) {
int lb = 0, ub = sa.size();
while (ub - lb > 1) {
int m = (lb + ub) / 2;
if (s.substr(sa[m], t.size()) >= t)
ub = m;
else
lb = m;
}
return ub;
}
int upper_bound(const string &s, const vector<int> &sa, const string t) {
int lb = 0, ub = sa.size();
while (ub - lb > 1) {
int m = (lb + ub) / 2;
if (s.substr(sa[m], t.size()) > t)
ub = m;
else
lb = m;
}
return ub;
}
void solve() {
string S;
int q;
cin >> S >> q;
auto sa = suffix_array(S);
rep(i, 0, q) {
string T;
cin >> T;
if (upper_bound(S, sa, T) - lower_bound(S, sa, T) >= 1)
cout << 1 << endl;
else
cout << 0 << endl;
}
}
int main() {
std::cin.tie(0);
std::ios::sync_with_stdio(false);
cout.setf(ios::fixed);
cout.precision(10);
solve();
return 0;
}
|
delete
| 86 | 87 | 86 | 86 |
0
|
[6,5,4,3,0,1,2,]
|
p02250
|
C++
|
Runtime Error
|
/*
* Multiple string matching (suffix array)
* O(T log T + \sum (P_i log T))
*
* Construction: reduce to sorting the cyclic shifts of A||'$'
*/
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
constexpr int kAlphabetSize = 37;
int ValueOf(char ch) {
if (ch == '$')
return 0;
if ('0' <= ch && ch <= '9')
return 1 + ch - '0';
if ('a' <= ch && ch <= 'z')
return 11 + ch - 'a';
cout << "Unexpected character!" << endl;
exit(1);
return -1;
}
vector<int> SortCyclicShifts(string &A) {
// Approach: sort cyclic substrings of length 1, 2, 4, ..., 2^(\ceil \lg n)
int n = A.size();
// After step k,
// p[i] stores the index (in A) of the ith-smallest (starting
// from 0) cyclic substring of A of length 2^k;
// c[i] stores the equivalence class (dense, starting from 0, in increasing
// sorted value order) of the length-2^k substring starting at A[i]
//
// psecond and cnext are temporary arrays used to populate p and c each step
// count is an auxiliary array used for bucket sort
vector<int> p(n), c(n), psecond(n), cnext(n), count(max(n, kAlphabetSize));
// Step 1: sort cyclic substrings of length 1
for (int i = 0; i < n; ++i)
++count[ValueOf(A[i])];
for (int i = 1; i < count.size(); ++i)
count[i] += count[i - 1];
for (int i = n - 1; i >= 0; --i)
p[--count[ValueOf(A[i])]] = i;
int num_classes = 1;
for (int i = 1; i < n; ++i) {
if (A[p[i]] != A[p[i - 1]]) {
c[p[i]] = num_classes;
++num_classes;
} else {
c[p[i]] = c[p[i - 1]];
}
}
// Step 2: for each k=1,...,ceil(log2(n)), use
// the result of sorting the cyclic substrings of length 2^{k-1} to
// sort the cyclic substrings of length 2^k
for (int h /* k-1 */ = 0; (1 << h) < n; ++h) {
// First, sort the cyclic substrings of length 2^k by their second halves;
// to do this, directly apply the fact that the second half of a length
// 2^k substring starting at index i is the length-2^{k-1} substring
// starting at index (i+2^{k-1})
for (int i = 0; i < n; ++i) {
psecond[i] = p[i] - (1 << h);
if (psecond[i] < 0)
psecond[i] += n;
}
// Second, complete the sort of cyclic substrings of
// length 2^k by performing an in-place sort keyed by their first halves
fill_n(begin(count), num_classes, 0);
// Count the number of occurrences of each equivalence class
// among cyclic substrings of length 2^{k-1}
for (int i = 0; i < n; ++i)
++count[c[i]];
for (int i = 1; i < num_classes; ++i)
count[i] += count[i - 1];
// Proceding in decreasing order sorted by second half,
// put each index of the array at the last available spot of the
// range, in sorted order, accorded to the equivalence class to which
// the index's _first_ half belongs
for (int i = n - 1; i >= 0; --i)
p[--count[c[psecond[i]]]] = psecond[i];
num_classes = 1;
cnext[p[0]] = 0;
for (int i = 1; i < n; ++i) {
if (c[p[i]] == c[p[i - 1]] &&
c[p[i] + (1 << h) % n] == c[p[i - 1] + (1 << h) % n]) {
cnext[p[i]] = cnext[p[i - 1]];
} else {
cnext[p[i]] = cnext[p[i - 1]] + 1;
++num_classes;
}
}
c.swap(cnext);
}
return p;
}
int main() {
string T;
cin >> T;
T.push_back('$');
auto suf = SortCyclicShifts(T);
int q;
cin >> q;
string P;
for (int i = 0; i < q; ++i) {
cin >> P;
auto res =
lower_bound(begin(suf), end(suf), P, [&T](int x, const string &P) {
string cmp = T.substr(x, P.size());
return cmp < P;
});
cout << (P == T.substr(*res, P.size())) << endl;
}
}
|
/*
* Multiple string matching (suffix array)
* O(T log T + \sum (P_i log T))
*
* Construction: reduce to sorting the cyclic shifts of A||'$'
*/
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
constexpr int kAlphabetSize = 37;
int ValueOf(char ch) {
if (ch == '$')
return 0;
if ('0' <= ch && ch <= '9')
return 1 + ch - '0';
if ('a' <= ch && ch <= 'z')
return 11 + ch - 'a';
cout << "Unexpected character!" << endl;
exit(1);
return -1;
}
vector<int> SortCyclicShifts(string &A) {
// Approach: sort cyclic substrings of length 1, 2, 4, ..., 2^(\ceil \lg n)
int n = A.size();
// After step k,
// p[i] stores the index (in A) of the ith-smallest (starting
// from 0) cyclic substring of A of length 2^k;
// c[i] stores the equivalence class (dense, starting from 0, in increasing
// sorted value order) of the length-2^k substring starting at A[i]
//
// psecond and cnext are temporary arrays used to populate p and c each step
// count is an auxiliary array used for bucket sort
vector<int> p(n), c(n), psecond(n), cnext(n), count(max(n, kAlphabetSize));
// Step 1: sort cyclic substrings of length 1
for (int i = 0; i < n; ++i)
++count[ValueOf(A[i])];
for (int i = 1; i < count.size(); ++i)
count[i] += count[i - 1];
for (int i = n - 1; i >= 0; --i)
p[--count[ValueOf(A[i])]] = i;
int num_classes = 1;
for (int i = 1; i < n; ++i) {
if (A[p[i]] != A[p[i - 1]]) {
c[p[i]] = num_classes;
++num_classes;
} else {
c[p[i]] = c[p[i - 1]];
}
}
// Step 2: for each k=1,...,ceil(log2(n)), use
// the result of sorting the cyclic substrings of length 2^{k-1} to
// sort the cyclic substrings of length 2^k
for (int h /* k-1 */ = 0; (1 << h) < n; ++h) {
// First, sort the cyclic substrings of length 2^k by their second halves;
// to do this, directly apply the fact that the second half of a length
// 2^k substring starting at index i is the length-2^{k-1} substring
// starting at index (i+2^{k-1})
for (int i = 0; i < n; ++i) {
psecond[i] = p[i] - (1 << h);
if (psecond[i] < 0)
psecond[i] += n;
}
// Second, complete the sort of cyclic substrings of
// length 2^k by performing an in-place sort keyed by their first halves
fill_n(begin(count), num_classes, 0);
// Count the number of occurrences of each equivalence class
// among cyclic substrings of length 2^{k-1}
for (int i = 0; i < n; ++i)
++count[c[i]];
for (int i = 1; i < num_classes; ++i)
count[i] += count[i - 1];
// Proceding in decreasing order sorted by second half,
// put each index of the array at the last available spot of the
// range, in sorted order, accorded to the equivalence class to which
// the index's _first_ half belongs
for (int i = n - 1; i >= 0; --i)
p[--count[c[psecond[i]]]] = psecond[i];
num_classes = 1;
cnext[p[0]] = 0;
for (int i = 1; i < n; ++i) {
if (c[p[i]] == c[p[i - 1]] &&
c[p[i] + (1 << h) % n] == c[p[i - 1] + (1 << h) % n]) {
cnext[p[i]] = cnext[p[i - 1]];
} else {
cnext[p[i]] = cnext[p[i - 1]] + 1;
++num_classes;
}
}
c.swap(cnext);
}
return p;
}
int main() {
string T;
cin >> T;
T.push_back('$');
auto suf = SortCyclicShifts(T);
int q;
cin >> q;
string P;
for (int i = 0; i < q; ++i) {
cin >> P;
auto res =
lower_bound(begin(suf), end(suf), P, [&T](int x, const string &P) {
string cmp = T.substr(x, P.size());
return cmp < P;
});
cout << (res != end(suf) && (P == T.substr(*res, P.size()))) << endl;
}
}
|
replace
| 126 | 127 | 126 | 127 |
0
| |
p02255
|
C++
|
Runtime Error
|
#include <stdio.h>
static const int N = 1000;
void print(int a[], int n) {
int k;
for (k = 0; k < n; k++) {
if (k > 0)
printf(" ");
printf("%d", a[k]);
}
printf("\n");
}
int main(void) {
int n, i, j, key;
int a[N + 1];
scanf("%d", &n);
// input
for (i = 0; i < n; i++) {
scanf("%d", a[i]);
}
print(a, n);
// insertion
for (i = 1; i < n; i++) {
key = a[i];
j = i - 1;
while (j >= 0 && a[j] > key) {
a[j + 1] = a[j];
j--;
}
a[j + 1] = key;
print(a, n);
}
return 0;
}
|
#include <stdio.h>
static const int N = 1000;
void print(int a[], int n) {
int k;
for (k = 0; k < n; k++) {
if (k > 0)
printf(" ");
printf("%d", a[k]);
}
printf("\n");
}
int main(void) {
int n, i, j, key;
int a[N + 1];
scanf("%d", &n);
// input
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
print(a, n);
// insertion
for (i = 1; i < n; i++) {
key = a[i];
j = i - 1;
while (j >= 0 && a[j] > key) {
a[j + 1] = a[j];
j--;
}
a[j + 1] = key;
print(a, n);
}
return 0;
}
|
replace
| 20 | 21 | 20 | 21 |
-11
| |
p02255
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <map>
#include <numeric>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
void show(vector<int> a) {
for (int i = 0; i < a.size() - 1; i++) {
cout << a[i] << " ";
}
cout << a[a.size() - 1] << endl;
}
vector<int> isort(vector<int> a, int n) {
int v = 0;
int j;
show(a);
for (int i = 1; i < n; i++) {
v = a[i];
j = i - 1;
while (j >= 0 && a[j] > v) {
a[j + 1] = a[j];
j--;
}
a[j + 1] = v;
show(a);
}
}
int main(void) {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++)
cin >> a[i];
isort(a, n);
return 0;
}
|
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <map>
#include <numeric>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
void show(vector<int> a) {
for (int i = 0; i < a.size() - 1; i++) {
cout << a[i] << " ";
}
cout << a[a.size() - 1] << endl;
}
vector<int> isort(vector<int> a, int n) {
int v = 0;
int j;
show(a);
for (int i = 1; i < n; i++) {
v = a[i];
j = i - 1;
while (j >= 0 && a[j] > v) {
a[j + 1] = a[j];
j--;
}
a[j + 1] = v;
show(a);
}
return a;
}
int main(void) {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++)
cin >> a[i];
isort(a, n);
return 0;
}
|
insert
| 33 | 33 | 33 | 34 |
-6
|
free(): invalid pointer
|
p02255
|
C++
|
Runtime Error
|
#include <iostream>
using namespace std;
int main() {
int n = 30;
int k[n];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> k[i];
}
for (int i = 0; i < n; i++) {
int v = k[i];
int j = i - 1;
while (j >= 0 && k[j] > v) {
k[j + 1] = k[j];
j--;
}
k[j + 1] = v;
for (int m = 0; m < n; m++) {
cout << k[m] << (m + 1 < n ? " " : "\n");
// printf("%d",k[m]);
// printf(" ");
}
}
return 0;
}
|
#include <iostream>
using namespace std;
int main() {
int n = 100;
int k[n];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> k[i];
}
for (int i = 0; i < n; i++) {
int v = k[i];
int j = i - 1;
while (j >= 0 && k[j] > v) {
k[j + 1] = k[j];
j--;
}
k[j + 1] = v;
for (int m = 0; m < n; m++) {
cout << k[m] << (m + 1 < n ? " " : "\n");
// printf("%d",k[m]);
// printf(" ");
}
}
return 0;
}
|
replace
| 4 | 5 | 4 | 5 |
0
| |
p02255
|
C++
|
Runtime Error
|
#include <iostream>
using namespace std;
int main() {
int numOfElement;
int elem[99] = {};
cin >> numOfElement;
for (int i = 0; i < numOfElement; i++) {
cin >> elem[i];
}
for (int i = 0; i < numOfElement; i++) {
for (int j = i; j > 0 && elem[j] < elem[j - 1]; j--) {
int buf = elem[j - 1];
elem[j - 1] = elem[j];
elem[j] = buf;
}
for (int j = 0; j < numOfElement; j++) {
if (j + 1 >= numOfElement) {
cout << elem[j];
break;
}
cout << elem[j] << " ";
}
cout << endl;
}
return 0;
}
|
#include <iostream>
using namespace std;
int main() {
int numOfElement;
int elem[100] = {};
cin >> numOfElement;
for (int i = 0; i < numOfElement; i++) {
cin >> elem[i];
}
for (int i = 0; i < numOfElement; i++) {
for (int j = i; j > 0 && elem[j] < elem[j - 1]; j--) {
int buf = elem[j - 1];
elem[j - 1] = elem[j];
elem[j] = buf;
}
for (int j = 0; j < numOfElement; j++) {
if (j + 1 >= numOfElement) {
cout << elem[j];
break;
}
cout << elem[j] << " ";
}
cout << endl;
}
return 0;
}
|
replace
| 5 | 6 | 5 | 6 |
0
| |
p02255
|
C++
|
Time Limit Exceeded
|
#include <iostream>
#include <vector>
using namespace std;
void insortionSort(vector<int> A) {
for (int i = 0; i < A.size(); i++) {
int v = A[i];
int j = i - 1;
while (j >= 0 && A[j] > v) {
A[j + 1] = A[j];
j--;
}
A[j + 1] = v;
for (int i : A) {
cout << i;
}
cout << endl;
}
}
int main() {
int N;
cin >> N;
vector<int> A(N);
for (int i = 0; i < N; i++) {
cin >> A[i];
}
insortionSort(A);
}
|
#include <iostream>
#include <vector>
using namespace std;
void insortionSort(vector<int> A) {
for (int i = 0; i < A.size(); i++) {
int v = A[i];
int j = i - 1;
while (j >= 0 && A[j] > v) {
A[j + 1] = A[j];
j--;
}
A[j + 1] = v;
for (int i = 0; i < A.size(); i++) {
cout << A[i];
if (i != A.size() - 1) {
cout << ' ';
}
}
cout << endl;
}
}
int main() {
int N;
cin >> N;
vector<int> A(N);
for (int i = 0; i < N; i++) {
cin >> A[i];
}
insortionSort(A);
}
|
replace
| 15 | 17 | 15 | 20 |
TLE
| |
p02255
|
C++
|
Runtime Error
|
#include <algorithm>
#include <climits>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef signed long long ll;
int main(void) {
int N = 0;
cin >> N;
vector<int> A(N, 0);
for (int i = 0; i < N; i++) {
cin >> A[i];
if (i > 0) {
cout << " ";
}
cout << A[i];
}
cout << endl;
for (int i = 1; i < N; i++) {
int value = A[i];
int j = i - 1;
while (j >= 0 && A[j] > value) {
A[j + 1] = A[j];
j--;
}
A[j] = value;
for (int k = 0; k < N; k++) {
if (k > 0) {
cout << " ";
}
cout << A[k];
}
cout << endl;
}
return 0;
}
|
#include <algorithm>
#include <climits>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef signed long long ll;
int main(void) {
int N = 0;
cin >> N;
vector<int> A(N, 0);
for (int i = 0; i < N; i++) {
cin >> A[i];
if (i > 0) {
cout << " ";
}
cout << A[i];
}
cout << endl;
for (int i = 1; i < N; i++) {
int value = A[i];
int j = i - 1;
while (j >= 0 && A[j] > value) {
A[j + 1] = A[j];
j--;
}
A[j + 1] = value;
for (int k = 0; k < N; k++) {
if (k > 0) {
cout << " ";
}
cout << A[k];
}
cout << endl;
}
return 0;
}
|
replace
| 34 | 35 | 34 | 35 |
-6
|
double free or corruption (out)
|
p02256
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int x, int y) {
cerr << x << " " << y << endl;
if (x < y)
swap(x, y);
if (x % y == 0)
return y;
return gcd(x % y, y);
}
int main(void) {
int x, y;
cin >> x >> y;
cout << gcd(x, y) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int x, int y) {
// cerr << x << " " << y << endl;
if (x < y)
swap(x, y);
if (x % y == 0)
return y;
return gcd(x % y, y);
}
int main(void) {
int x, y;
cin >> x >> y;
cout << gcd(x, y) << endl;
return 0;
}
|
replace
| 4 | 5 | 4 | 5 |
0
|
54 20
14 20
6 14
2 6
|
p02256
|
C++
|
Runtime Error
|
#include <cstdlib>
#include <iostream>
using namespace std;
// a > b
int gcd(int a, int b) {
if (a < b) {
cout << "Error : In using gcd function, must a > b.\n";
exit(1);
}
if (a % b == 0) {
return b;
} else {
gcd(b, a % b);
}
}
int main() {
int a, b;
cin >> a >> b;
cout << gcd(a, b) << endl;
return 0;
}
|
#include <cstdlib>
#include <iostream>
using namespace std;
// a > b
int gcd(int a, int b) {
int r;
while (1) {
r = a % b;
if (!r) {
return b;
} else {
a = b;
b = r;
}
}
}
int main() {
int a, b;
cin >> a >> b;
cout << gcd(a, b) << endl;
return 0;
}
|
replace
| 6 | 14 | 6 | 15 |
0
| |
p02256
|
C++
|
Runtime Error
|
#include <iostream>
using namespace std;
int main() {
int x, y, a;
cin >> x >> y;
while (x % y != 0) {
cout << a << endl;
x = y;
y = a;
}
cout << y << "\n";
}
|
#include <iostream>
using namespace std;
int main() {
int x, y, a;
cin >> x >> y;
while (x % y != 0) {
a = x % y;
x = y;
y = a;
}
cout << y << "\n";
}
|
replace
| 7 | 8 | 7 | 8 |
0
| |
p02256
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
if (max(a, b) % min(a, b) == 0) {
cout << min(a, b) << endl;
return 0;
}
for (int i = min(a, b) / 2; i >= 1; --i) {
if (a % i == 0 && b % i == 0) {
cout << i << endl;
return 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
if (max(a, b) % min(a, b) == 0) {
cout << min(a, b) << endl;
return 0;
}
for (int j = 2; j <= min(a, b); ++j) {
int i = min(a, b) / j;
if (a % i == 0 && b % i == 0) {
cout << i << endl;
return 0;
}
}
return 0;
}
|
replace
| 10 | 11 | 10 | 12 |
TLE
| |
p02256
|
C++
|
Runtime Error
|
#include <iostream>
using namespace std;
int gcd(int x, int y) {
int max;
if (y % (x % y) == 0) {
max = x % y;
return max;
} else {
gcd(y, x % y);
}
}
int main() {
int x, y;
cin >> x;
cin >> y;
if (x >= y)
cout << gcd(x, y) << endl;
if (y > x)
cout << gcd(y, x) << endl;
return 0;
}
|
#include <iostream>
using namespace std;
int gcd(int x, int y) {
int max;
if (x == y) {
return x;
} else if (y % (x % y) == 0) {
max = x % y;
return max;
} else {
gcd(y, x % y);
}
}
int main() {
int x, y;
cin >> x;
cin >> y;
if (x >= y)
cout << gcd(x, y) << endl;
if (y > x)
cout << gcd(y, x) << endl;
return 0;
}
|
replace
| 5 | 6 | 5 | 8 |
0
| |
p02256
|
C++
|
Time Limit Exceeded
|
#include <iostream>
#include <vector>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int a, b;
cin >> a;
cin >> b;
for (;;) {
if (a > b)
a = a % b;
else if (a < b)
b = b % a;
if (a * b == 0)
break;
}
cout << a + b << endl;
return 0;
}
|
#include <iostream>
#include <vector>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int a, b;
cin >> a;
cin >> b;
if (a - b == 0) {
cout << a << endl;
return 0;
}
for (;;) {
if (a > b)
a = a % b;
else if (a < b)
b = b % a;
if (a * b == 0)
break;
}
cout << a + b << endl;
return 0;
}
|
insert
| 9 | 9 | 9 | 13 |
TLE
| |
p02256
|
C++
|
Runtime Error
|
///
// File: alds1_1_b.cpp
// Author: ymiyamoto
//
// Created on Mon Nov 13 03:00:08 2017
//
#include <cstdint>
#include <iostream>
using namespace std;
uint64_t gcd(uint64_t a, uint64_t b) {
if (b > a)
gcd(a, b);
if (b == 0)
return a;
else
return gcd(b, a % b);
}
int32_t main() {
uint64_t a, b;
cin >> a >> b;
cout << gcd(a, b) << endl;
return 0;
}
|
///
// File: alds1_1_b.cpp
// Author: ymiyamoto
//
// Created on Mon Nov 13 03:00:08 2017
//
#include <cstdint>
#include <iostream>
using namespace std;
uint64_t gcd(uint64_t a, uint64_t b) {
if (b > a)
gcd(b, a);
if (b == 0)
return a;
else
return gcd(b, a % b);
}
int32_t main() {
uint64_t a, b;
cin >> a >> b;
cout << gcd(a, b) << endl;
return 0;
}
|
replace
| 14 | 15 | 14 | 15 |
0
| |
p02256
|
C++
|
Time Limit Exceeded
|
#include <iostream>
using namespace std;
int main() {
long long x, y;
cin >> x >> y;
if (x < y) {
long long t = y;
y = x;
x = t;
}
long long z = x % y;
long long a = 0;
for (long long i = 1; i < y + 1; i++) {
if (y % i == 0 && z % i == 0) {
a = i;
}
}
cout << a << endl;
}
|
#include <iostream>
using namespace std;
int main() {
long long x, y;
cin >> x >> y;
if (x < y) {
long long t = y;
y = x;
x = t;
}
while (1) {
long long z = x % y;
if (z == 0) {
break;
} else {
x = y;
y = z;
}
}
long long a;
for (int i = 1; i < y + 1; i++) {
if (x % i == 0 && y % i == 0) {
a = i;
}
}
cout << a << endl;
}
|
replace
| 10 | 14 | 10 | 22 |
TLE
| |
p02256
|
C++
|
Runtime Error
|
#include <iostream>
#define INPUT_FROM_FILE (1)
#if INPUT_FROM_FILE
#include <fstream>
#endif
int gcd(int a, int b) {
if (a % b == 0) {
return b;
}
return gcd(b, a % b);
}
int main(int argc, char **argv) {
#if INPUT_FROM_FILE
std::ifstream ifs("test.txt");
#endif
int a = 0;
int b = 0;
#if INPUT_FROM_FILE
ifs >> a >> b;
#else
std::cin >> a >> b;
#endif
if (a < b) {
std::swap(a, b);
}
std::cout << gcd(a, b) << std::endl;
return 0;
}
|
#include <iostream>
#define INPUT_FROM_FILE (0)
#if INPUT_FROM_FILE
#include <fstream>
#endif
int gcd(int a, int b) {
if (a % b == 0) {
return b;
}
return gcd(b, a % b);
}
int main(int argc, char **argv) {
#if INPUT_FROM_FILE
std::ifstream ifs("test.txt");
#endif
int a = 0;
int b = 0;
#if INPUT_FROM_FILE
ifs >> a >> b;
#else
std::cin >> a >> b;
#endif
if (a < b) {
std::swap(a, b);
}
std::cout << gcd(a, b) << std::endl;
return 0;
}
|
replace
| 1 | 2 | 1 | 2 |
-8
| |
p02256
|
C++
|
Runtime Error
|
#include <stdio.h>
#include <stdlib.h>
int main() {
int a, b, c, r, x, y, flag;
scanf("%d%d", &a, &b);
if (a == b) {
printf("%d\n", a);
exit(1);
} else if (a > b) {
flag = 0;
c = b;
} else {
c = a;
flag = 1;
}
if (flag == 0)
r = a % b;
if (flag == 1)
r = b % a;
while (1) {
x = c % r;
if (x == 0)
break;
c = r;
r = x;
// printf("%d %d %d\n",x,c,r);
}
printf("%d\n", r);
return 0;
}
|
#include <stdio.h>
#include <stdlib.h>
int main() {
int a, b, c, r, x, y, flag;
scanf("%d%d", &a, &b);
if (a == b) {
printf("%d\n", a);
return 0;
} else if (a > b) {
flag = 0;
c = b;
} else {
c = a;
flag = 1;
}
if (flag == 0)
r = a % b;
if (flag == 1)
r = b % a;
while (1) {
x = c % r;
if (x == 0)
break;
c = r;
r = x;
// printf("%d %d %d\n",x,c,r);
}
printf("%d\n", r);
return 0;
}
|
replace
| 11 | 12 | 11 | 12 |
0
| |
p02256
|
C++
|
Time Limit Exceeded
|
#include <iostream>
#include <math.h>
using namespace std;
long long int gcd(long long int x, long long int y) {
bool flag = true;
while (flag) {
if (x > y) {
if (x % y != 0) {
x = x % y;
}
if (x % y == 0) {
return y;
flag = false;
}
}
if (y > x) {
if (y % x != 0) {
y = y % x;
}
if (y % x == 0) {
return x;
flag = false;
}
}
}
}
int main() {
long long int x, y;
cin >> x >> y;
cout << gcd(x, y) << endl;
return 0;
}
|
#include <iostream>
#include <math.h>
using namespace std;
int gcd(int x, int y) {
if (x < y) {
return gcd(y, x);
} else if (x >= y && x % y != 0) {
return gcd(x % y, y);
} else {
return y;
}
}
int main() {
long long int x, y;
cin >> x >> y;
cout << gcd(x, y) << endl;
return 0;
}
|
replace
| 4 | 25 | 4 | 11 |
TLE
| |
p02256
|
C++
|
Time Limit Exceeded
|
#include <iostream>
using namespace std;
int main() {
long x, y;
cin >> x >> y;
while (x != 0 && y != 0) {
if (x > y) {
long tmp = 0;
tmp = y;
y = x % y;
x = tmp;
} else {
long tmp = 0;
tmp = x;
x = y;
y = tmp;
}
}
if (x == 0)
cout << y << endl;
else
cout << x << endl;
return 0;
}
|
#include <iostream>
using namespace std;
int main() {
long x, y;
cin >> x >> y;
while (x != 0 && y != 0) {
if (x >= y) {
long tmp = 0;
tmp = y;
y = x % y;
x = tmp;
} else {
long tmp = 0;
tmp = x;
x = y;
y = tmp;
}
}
if (x == 0)
cout << y << endl;
else
cout << x << endl;
return 0;
}
|
replace
| 7 | 8 | 7 | 8 |
TLE
| |
p02256
|
C++
|
Runtime Error
|
#include <cstdlib>
#include <iostream>
using namespace std;
int main() {
int x, y;
int ma, mi;
cin >> x >> y;
ma = max(x, y);
mi = min(x, y);
while (1) {
int t = ma % mi;
ma = max(t, mi);
mi = min(t, mi);
if (ma % mi == 0)
break;
}
cout << mi << endl;
return 0;
}
|
#include <cstdlib>
#include <iostream>
using namespace std;
int main() {
int x, y;
int ma, mi;
cin >> x >> y;
ma = max(x, y);
mi = min(x, y);
while (ma != mi) {
int t = ma % mi;
ma = max(t, mi);
mi = min(t, mi);
if (ma % mi == 0)
break;
}
cout << mi << endl;
return 0;
}
|
replace
| 13 | 14 | 13 | 14 |
0
| |
p02256
|
C++
|
Runtime Error
|
#include <iostream>
using namespace std;
int main() {
long long x, y, c;
cin >> x >> y;
if (x < y) {
c = y;
y = x;
x = c;
}
c = 0;
while (!x == 0 || y == 0) {
if (c % 2 == 0) {
x = x % y;
} else {
y = y % x;
}
++c;
}
cout << x + y << endl;
return 0;
}
|
#include <iostream>
using namespace std;
int main() {
long long x, y, c;
cin >> x >> y;
if (x < y) {
c = y;
y = x;
x = c;
}
c = 0;
while (x != 0 && y != 0) {
if (c % 2 == 0) {
x = x % y;
} else {
y = y % x;
}
++c;
}
cout << x + y << endl;
return 0;
}
|
replace
| 11 | 12 | 11 | 12 |
-8
| |
p02256
|
C++
|
Runtime Error
|
#include <iostream>
using namespace std;
int main() {
int a, b, c;
bool check = true;
cin >> a >> b;
while (check) {
if (a > b) {
c = a % b;
if (b % c == 0)
check = false;
a = c;
} else {
c = b % a;
if (a % c == 0)
check = false;
b = c;
}
}
cout << c << endl;
return 0;
}
|
#include <iostream>
using namespace std;
int main() {
int a, b, c;
bool check = true;
cin >> a >> b;
if (a == b) {
cout << a << endl;
return 0;
}
while (check) {
if (a > b) {
c = a % b;
if (b % c == 0)
check = false;
a = c;
} else {
c = b % a;
if (a % c == 0)
check = false;
b = c;
}
}
cout << c << endl;
return 0;
}
|
insert
| 7 | 7 | 7 | 11 |
0
| |
p02256
|
C++
|
Time Limit Exceeded
|
#include <iostream>
#include <vector>
using namespace std;
int main() {
int x, y;
cin >> x >> y;
int a, b;
if (x >= y) {
a = x;
b = y;
} else {
a = y;
b = x;
}
for (int i = b; i >= 1; i--) {
if (a % i == 0 && b % i == 0) {
cout << i << endl;
return 0;
}
}
}
|
#include <iostream>
#include <vector>
using namespace std;
int main() {
int x, y;
cin >> x >> y;
int a, b;
if (x >= y) {
a = x;
b = y;
} else {
a = y;
b = x;
}
int c;
while (true) {
c = a % b;
if (c == 0) {
cout << b << endl;
break;
} else {
a = b;
b = c;
}
}
}
|
replace
| 15 | 20 | 15 | 24 |
TLE
| |
p02256
|
C++
|
Runtime Error
|
#include <algorithm>
#include <iostream>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <utility>
using namespace std;
const double pi = acos(-1);
#define nyan cout << "(=^•ω•^=)" << endl;
#define int long long
#define rep(i, n) for (int i = 0; i < n; i++)
int gcd(int i, int j) {
if (i > j)
swap(i, j);
if (i == 1)
return 1;
if (i == j)
return i;
else
return gcd(i, j % i);
}
signed main() {
int x, y;
cin >> x >> y;
cout << gcd(x, y) << endl;
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <utility>
using namespace std;
const double pi = acos(-1);
#define nyan cout << "(=^•ω•^=)" << endl;
#define int long long
#define rep(i, n) for (int i = 0; i < n; i++)
int gcd(int i, int j) {
while (true) {
if (i < j)
swap(i, j);
if (!j)
break;
i %= j;
}
return i;
}
signed main() {
int x, y;
cin >> x >> y;
cout << gcd(x, y) << endl;
return 0;
}
|
replace
| 18 | 26 | 18 | 26 |
-8
| |
p02256
|
C++
|
Runtime Error
|
#include <cstdio>
#include <iostream>
#include <queue>
#include <sstream>
#include <stack>
#include <vector>
using namespace std;
const int N_MAX = 1000000;
int main() {
int x, y;
return -1;
}
|
#include <cstdio>
#include <iostream>
#include <queue>
#include <sstream>
#include <stack>
#include <vector>
using namespace std;
const int N_MAX = 1000000;
int main() {
int x, y;
cin >> x;
cin >> y;
int residue = -1;
int ans;
while (residue != 0) {
residue = max(x, y) % min(x, y);
ans = min(x, y);
if (x > y)
x = residue;
else
y = residue;
}
cout << ans << endl;
return 0;
}
|
replace
| 13 | 14 | 13 | 30 |
255
| |
p02256
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
void sorts(int *xx, int *yy);
int main() {
int x, y;
cin >> x >> y;
sorts(&x, &y);
x = x % y;
int ans = y;
for (int i = x; i >= 0; i--) {
if (y % i == 0 && x % i == 0) {
ans = i;
break;
}
}
cout << ans << endl;
}
void sorts(int *xx, int *yy) {
if (*xx < *yy) {
int temp = *xx;
*xx = *yy;
*yy = temp;
}
return;
}
|
#include <bits/stdc++.h>
using namespace std;
void sorts(int *xx, int *yy);
int main() {
int x, y;
cin >> x >> y;
sorts(&x, &y);
x = x % y;
if (!x) {
cout << y << endl;
return 0;
}
int ans = y;
for (int i = x; i >= 0; i--) {
if (y % i == 0 && x % i == 0) {
ans = i;
break;
}
}
cout << ans << endl;
}
void sorts(int *xx, int *yy) {
if (*xx < *yy) {
int temp = *xx;
*xx = *yy;
*yy = temp;
}
return;
}
|
insert
| 10 | 10 | 10 | 14 |
0
| |
p02256
|
C++
|
Runtime Error
|
#include <iostream>
using namespace std;
int gcd(int a, int b);
void swap(int *a, int *b);
int main() {
int a, b;
cin >> a >> b;
if (a < b)
swap(a, b);
cout << gcd(a, b) << endl;
}
void swap(int *a, int *b) {
int temp = *a;
*a = *b;
*b = temp;
}
int gcd(int a, int b) {
while (1) {
a = a % b;
if (b % a == 0)
return a;
b = b % a;
if (a % b == 0)
return b;
}
}
|
#include <iostream>
using namespace std;
int gcd(int a, int b);
void swap(int *a, int *b);
int main() {
int a, b;
cin >> a >> b;
if (a < b)
swap(a, b);
cout << gcd(a, b) << endl;
}
void swap(int *a, int *b) {
int temp = *a;
*a = *b;
*b = temp;
}
int gcd(int a, int b) {
if (a % b == 0)
return b;
while (1) {
a = a % b;
if (b % a == 0)
return a;
b = b % a;
if (a % b == 0)
return b;
}
}
|
insert
| 24 | 24 | 24 | 26 |
0
| |
p02256
|
C++
|
Time Limit Exceeded
|
//
// Write a program which finds the greatest common divisor of two natural
// numbers a and b
//
#include <iostream>
using namespace std;
void read(int &x, int &y);
int calcGcd(const int x, const int y);
void write(const int gcd);
int main() {
int x = 0, y = 0;
int ret = 0;
read(x, y);
ret = x > y ? calcGcd(x, y) : calcGcd(y, x);
write(ret);
}
void read(int &x, int &y) { cin >> x >> y; }
int calcGcd(const int x, const int y) {
int r = 0;
r = x - y;
if (y == r)
return r;
y > r ? calcGcd(y, r) : calcGcd(r, y);
}
void write(const int gcd) { cout << gcd << endl; }
|
//
// Write a program which finds the greatest common divisor of two natural
// numbers a and b
//
#include <iostream>
using namespace std;
void read(int &x, int &y);
int calcGcd(const int x, const int y);
void write(const int gcd);
int main() {
int x = 0, y = 0;
int ret = 0;
read(x, y);
ret = x > y ? calcGcd(x, y) : calcGcd(y, x);
write(ret);
}
void read(int &x, int &y) { cin >> x >> y; }
int calcGcd(const int x, const int y) {
int r = 0;
if (x == y)
return x;
r = x - y;
if (y == r)
return r;
y > r ? calcGcd(y, r) : calcGcd(r, y);
}
void write(const int gcd) { cout << gcd << endl; }
|
insert
| 25 | 25 | 25 | 28 |
TLE
| |
p02256
|
C++
|
Runtime Error
|
#include <algorithm>
#include <stdio.h>
int gcd(int, int);
int main() {
int x, y, z;
scanf("%d %d\n", x, y);
z = gcd(x, y);
printf("%d\n", z);
return 0;
}
int gcd(int x, int y) {
int r;
while (y > 0) {
r = x % y;
x = y;
y = r;
}
return x;
}
|
#include <algorithm>
#include <stdio.h>
int gcd(int, int);
int main() {
int x, y, z;
scanf("%d %d", &x, &y);
z = gcd(x, y);
printf("%d\n", z);
return 0;
}
int gcd(int x, int y) {
int r;
while (y > 0) {
r = x % y;
x = y;
y = r;
}
return x;
}
|
replace
| 7 | 8 | 7 | 8 |
-11
| |
p02256
|
C++
|
Runtime Error
|
#include <iostream>
using namespace std;
long int gcd(int a, int b) {
if (a < b)
return gcd(b, a);
if (b == 1)
return a;
return gcd(b, a % b);
}
int main() {
long int x, y;
cin >> x >> y;
cout << gcd(x, y) << endl;
return 0;
}
|
#include <iostream>
using namespace std;
long int gcd(int a, int b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
int main() {
long int x, y;
cin >> x >> y;
cout << gcd(x, y) << endl;
return 0;
}
|
replace
| 4 | 7 | 4 | 5 |
-8
| |
p02256
|
C++
|
Runtime Error
|
#include <stdio.h>
int main(void) {
int x;
int y;
int r;
int tmp;
scanf("%d %d", &x, &y);
if (y >= x) {
x = tmp;
x = y;
y = tmp;
}
while (1) {
r = x % y;
if (r == 0) {
printf("%d\n", y);
break;
}
x = y;
y = r;
}
return 0;
}
|
#include <stdio.h>
int main(void) {
int x;
int y;
int r;
int tmp;
scanf("%d %d", &x, &y);
if (y >= x) {
tmp = x;
x = y;
y = tmp;
}
while (1) {
r = x % y;
if (r == 0) {
printf("%d\n", y);
break;
}
x = y;
y = r;
}
return 0;
}
|
replace
| 10 | 11 | 10 | 11 |
0
| |
p02256
|
C++
|
Time Limit Exceeded
|
#include <stdio.h>
int main() {
int a, b, c;
scanf("%d %d", &a, &b);
c = a > b ? b : a;
while (c > 0 && (a % c || b % c))
c--;
printf("%d\n", c);
return 0;
}
|
#include <stdio.h>
int main() {
int a, b, c;
scanf("%d %d", &a, &b);
if (a < b) {
c = a;
a = b;
b = c;
}
while (b) {
c = b;
b = a % b;
a = c;
}
printf("%d\n", a);
return 0;
}
|
replace
| 5 | 9 | 5 | 16 |
TLE
| |
p02256
|
C++
|
Runtime Error
|
#include <stdio.h>
int gcd(int x, int y) { return (x % y > 0 || x > y) ? gcd(y, x % y) : y; }
int main() {
int x, y;
int w;
scanf("%d %d", &x, &y);
w = gcd(x, y);
printf("%d\n", w);
}
|
#include <stdio.h>
int gcd(int x, int y) { return (x % y > 0) ? gcd(y, x % y) : y; }
int main() {
int x, y;
int w;
scanf("%d %d", &x, &y);
w = gcd(x, y);
printf("%d\n", w);
}
|
replace
| 1 | 2 | 1 | 2 |
-8
| |
p02256
|
C++
|
Runtime Error
|
#include <stdio.h>
int gcd(int x, int y) {
int ans;
if (x == 1 || y == 1) {
return x * y;
} else if (x > y) {
ans = gcd(y, x % y);
} else {
ans = gcd(x, y % x);
}
return ans;
}
int main(void) {
int x, y;
scanf("%d %d", &x, &y);
printf("%d\n", gcd(x, y));
return 0;
}
|
#include <stdio.h>
int gcd(int x, int y) {
int ans;
if (x == 0) {
return y;
} else if (y == 0) {
return x;
} else if (x > y) {
ans = gcd(y, x % y);
} else {
ans = gcd(x, y % x);
}
return ans;
}
int main(void) {
int x, y;
scanf("%d %d", &x, &y);
printf("%d\n", gcd(x, y));
return 0;
}
|
replace
| 4 | 6 | 4 | 8 |
-8
| |
p02256
|
C++
|
Runtime Error
|
#include <cmath>
#include <ctype.h>
#include <iomanip>
#include <iostream>
#include <stdio.h>
#include <string.h>
using namespace std;
int main(void) {
int x, y, d, a, b;
cin >> x >> y;
if (y > x) {
b = y;
y = x;
x = b;
}
a = x % y;
for (d = a;; d--) {
if (y % d == 0 && a % d == 0) {
cout << d << endl;
break;
}
}
return 0;
}
|
#include <cmath>
#include <ctype.h>
#include <iomanip>
#include <iostream>
#include <stdio.h>
#include <string.h>
using namespace std;
int main(void) {
int x, y, d, a, b;
cin >> x >> y;
if (y > x) {
b = y;
y = x;
x = b;
}
if (x == y) {
cout << x << endl;
return 0;
}
a = x % y;
for (d = a;; d--) {
if (y % d == 0 && a % d == 0) {
cout << d << endl;
break;
}
}
return 0;
}
|
insert
| 17 | 17 | 17 | 21 |
0
| |
p02257
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
#include <math.h>
using namespace std;
int main() {
int x, y, n, b = 0, o;
cin >> n;
for (o = 0; o < n; o++) {
cin >> x;
for (y = 2; y < x; y++) {
if (x % y == 0) {
goto loop;
}
}
b++;
loop:;
}
cout << b << endl;
}
|
#include <bits/stdc++.h>
#include <math.h>
using namespace std;
int main() {
int x, y, n, b = 0, o;
cin >> n;
for (o = 0; o < n; o++) {
cin >> x;
for (y = 2; y * y <= x; y++) {
if (x % y == 0) {
goto loop;
}
}
b++;
loop:;
}
cout << b << endl;
}
|
replace
| 8 | 9 | 8 | 9 |
TLE
| |
p02257
|
C++
|
Time Limit Exceeded
|
#include <cmath>
#include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
int A[n], count = 0;
for (int i = 0; i < n; i++) {
cin >> A[i];
}
for (int i = 0; i < n; i++) {
int L = A[i];
int M = sqrt(L);
for (int x = 2; x < L; x++) {
if (L % x == 0) {
count--;
break;
}
}
count++;
}
cout << count << endl;
return 0;
}
|
#include <cmath>
#include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
int A[n], count = 0;
for (int i = 0; i < n; i++) {
cin >> A[i];
}
for (int i = 0; i < n; i++) {
int L = A[i];
int M = sqrt(L);
for (int x = 2; x <= M; x++) {
if (L % x == 0) {
count--;
break;
}
}
count++;
}
cout << count << endl;
return 0;
}
|
replace
| 14 | 15 | 14 | 15 |
TLE
| |
p02257
|
C++
|
Time Limit Exceeded
|
#include <iostream>
using namespace std;
bool is_prime[50000000];
int main() {
for (int i = 0; i < 50000000; i++) {
is_prime[i] = true;
}
is_prime[0] = false;
for (int i = 1; i < 50000000; i++) {
if (is_prime[i]) {
for (int j = i * 3 + 1; j < 50000000; j += 2 * i + 1) {
is_prime[j] = false;
}
}
}
int n, tag;
cin >> n;
int cnt = 0;
for (int i = 0; i < n; i++) {
cin >> tag;
if (tag % 2 == 0) {
if (tag == 2) {
cnt++;
}
} else {
if (is_prime[tag / 2]) {
cnt++;
}
}
}
cout << cnt << endl;
int xxx;
cin >> xxx;
return 0;
}
|
#include <iostream>
using namespace std;
bool is_prime[50000000];
int main() {
for (int i = 0; i < 50000000; i++) {
is_prime[i] = true;
}
is_prime[0] = false;
for (int i = 1; i * i + i < 25000000; i++) {
if (is_prime[i]) {
for (int j = i * 3 + 1; j < 50000000; j += 2 * i + 1) {
is_prime[j] = false;
}
}
}
int n, tag;
cin >> n;
int cnt = 0;
for (int i = 0; i < n; i++) {
cin >> tag;
if (tag % 2 == 0) {
if (tag == 2) {
cnt++;
}
} else {
if (is_prime[tag / 2]) {
cnt++;
}
}
}
cout << cnt << endl;
int xxx;
cin >> xxx;
return 0;
}
|
replace
| 11 | 12 | 11 | 12 |
TLE
| |
p02257
|
Python
|
Time Limit Exceeded
|
prime = set([2])
for i in range(3, 100000000, 2):
for j in prime:
if i % j == 0:
break
else:
prime.add(i)
n = int(input())
cnt = 0
for i in (int(input()) for _ in range(n)):
if i in prime:
cnt += 1
print(cnt)
|
import sys
from math import *
readline = sys.stdin.readline
def isPrime(x):
if x == 2 or x == 3:
return True
elif x % 2 == 0 or x % 3 == 0:
return False
s = ceil(sqrt(x))
for i in range(5, s + 1, 2):
if x % i == 0:
return False
return True
print(sum(isPrime(int(readline())) for _ in range(int(input()))))
|
replace
| 0 | 13 | 0 | 19 |
TLE
| |
p02257
|
C++
|
Time Limit Exceeded
|
#include <iostream>
using namespace std;
using ll = long long;
#define debug(x) cerr << #x << ": " << x << endl;
#define line() cerr << "---------------" << endl;
bool isPrime(int x) {
if (x == 1)
return false;
for (int i = 2; i < x; i++) {
if (x % i == 0) {
return false;
}
}
return true;
}
int main() {
int n;
cin >> n;
int cnt = 0;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
if (isPrime(x)) {
cnt++;
}
}
cout << cnt << endl;
return 0;
}
|
#include <iostream>
using namespace std;
using ll = long long;
#define debug(x) cerr << #x << ": " << x << endl;
#define line() cerr << "---------------" << endl;
bool isPrime(int x) {
if (x == 1)
return false;
for (int i = 2; i * i <= x; i++) {
if (x % i == 0) {
return false;
}
}
return true;
}
int main() {
int n;
cin >> n;
int cnt = 0;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
if (isPrime(x)) {
cnt++;
}
}
cout << cnt << endl;
return 0;
}
|
replace
| 10 | 11 | 10 | 11 |
TLE
| |
p02257
|
C++
|
Runtime Error
|
#include <iostream>
using namespace std;
#define CALC_PRIME_MAX 10000 // _/10 ^ 8
#define PRIME_ELEMENT_MAX 1229 // prime( _/10 ^ 8 )
int prime_number[PRIME_ELEMENT_MAX];
bool isPrime(int element) {
for (int i = 0; prime_number[i] * prime_number[i] <= element; i++) {
if (element % prime_number[i] == 0)
return false;
}
return true;
}
void calcPrime() {
// add 2, 3 (prime)
int prime_index = 2;
prime_number[0] = 2;
prime_number[1] = 3;
// next prime is 5
for (int element = 5; element <= CALC_PRIME_MAX; element += 2) {
bool is_prime = true;
// judge prime
for (int i = 1; prime_number[i] * prime_number[i] <= element; i++) {
if (element % prime_number[i] == 0) {
is_prime = false;
break;
}
}
// add prime
if (is_prime)
prime_number[prime_index++] = element;
}
// cout << "prime_element_num = " << prime_index << endl;
return;
}
int main() {
int n, element, count = 0;
calcPrime();
cin >> n;
for (int i = 0; i < n; i++) {
cin >> element;
if (isPrime(element))
count++;
}
cout << count << endl;
return 0;
}
|
#include <iostream>
using namespace std;
#define CALC_PRIME_MAX 10007 // _/10 ^ 8 + next prime
#define PRIME_ELEMENT_MAX 1230 // prime( _/10 ^ 8 ) + 1(10007)
int prime_number[PRIME_ELEMENT_MAX];
bool isPrime(int element) {
for (int i = 0; prime_number[i] * prime_number[i] <= element; i++) {
if (element % prime_number[i] == 0)
return false;
}
return true;
}
void calcPrime() {
// add 2, 3 (prime)
int prime_index = 2;
prime_number[0] = 2;
prime_number[1] = 3;
// next prime is 5
for (int element = 5; element <= CALC_PRIME_MAX; element += 2) {
bool is_prime = true;
// judge prime
for (int i = 1; prime_number[i] * prime_number[i] <= element; i++) {
if (element % prime_number[i] == 0) {
is_prime = false;
break;
}
}
// add prime
if (is_prime)
prime_number[prime_index++] = element;
}
// cout << "prime_element_num = " << prime_index << endl;
return;
}
int main() {
int n, element, count = 0;
calcPrime();
cin >> n;
for (int i = 0; i < n; i++) {
cin >> element;
if (isPrime(element))
count++;
}
cout << count << endl;
return 0;
}
|
replace
| 4 | 6 | 4 | 6 |
0
| |
p02257
|
C++
|
Time Limit Exceeded
|
#include <iostream>
#include <vector>
using namespace std;
bool isPrime(int val);
int countPrime(vector<int> &array);
int main() {
int size;
vector<int> array;
cin >> size;
for (int i = 0; i < size; i++) {
int tmp;
cin >> tmp;
array.push_back(tmp);
}
cout << countPrime(array) << endl;
return 0;
}
int countPrime(vector<int> &array) {
int num = 0;
for (int i = 0; i < array.size(); i++) {
if (isPrime(array[i])) {
num++;
}
}
return num;
}
bool isPrime(int val) {
if (val <= 1) {
return false;
}
for (int i = 2; i <= val / 2; i++) {
if (val % i == 0) {
return false;
}
}
return true;
}
|
#include <iostream>
#include <vector>
using namespace std;
bool isPrime(int val);
int countPrime(vector<int> &array);
int main() {
int size;
vector<int> array;
cin >> size;
for (int i = 0; i < size; i++) {
int tmp;
cin >> tmp;
array.push_back(tmp);
}
cout << countPrime(array) << endl;
return 0;
}
int countPrime(vector<int> &array) {
int num = 0;
for (int i = 0; i < array.size(); i++) {
if (isPrime(array[i])) {
num++;
}
}
return num;
}
bool isPrime(int val) {
if (val <= 1) {
return false;
}
for (int i = 2; i * i <= val; i++) {
if (val % i == 0) {
return false;
}
}
return true;
}
|
replace
| 34 | 35 | 34 | 35 |
TLE
| |
p02257
|
C++
|
Time Limit Exceeded
|
#include <iostream>
int main(void) {
std::ios::sync_with_stdio(false);
int n, COUNT = 0;
std::cin >> n;
int x;
for (int i = 0; i < n; ++i) {
std::cin >> x;
if (x == 2) {
++COUNT;
} else if (x % 2 != 0) {
bool FLUG = false;
int Max = static_cast<int>(x / 2) + 1;
for (int i = 3; i < Max; i += 2) {
if (x % i == 0) {
FLUG = true;
break;
}
}
if (FLUG == false) {
++COUNT;
}
}
}
std::cout << COUNT << std::endl;
// system("pause");
return 0;
}
|
#include <iostream>
int main(void) {
std::ios::sync_with_stdio(false);
int n, COUNT = 0;
std::cin >> n;
int x;
for (int i = 0; i < n; ++i) {
std::cin >> x;
if (x == 2) {
++COUNT;
} else if (x % 2 != 0) {
bool FLUG = false;
for (int i = 3; i * i <= x; i += 2) {
if (x % i == 0) {
FLUG = true;
break;
}
}
if (FLUG == false) {
++COUNT;
}
}
}
std::cout << COUNT << std::endl;
// system("pause");
return 0;
}
|
replace
| 12 | 14 | 12 | 13 |
TLE
| |
p02257
|
C++
|
Time Limit Exceeded
|
#include <cmath>
#include <iostream>
using namespace std;
void PrimeNumSum(int &sum, unsigned int &num) {
unsigned int divisor = num / 2 + 1;
if (divisor == 2) {
sum++;
return;
}
while (divisor >= 2) {
if (num % divisor == 0) {
return;
}
divisor--;
}
sum++;
}
int main() {
int count;
cin >> count;
unsigned int *list = new unsigned int[count];
for (int i = 0; i < count; i++) {
cin >> list[i];
}
int sum = 0;
for (int i = 0; i < count; i++) {
PrimeNumSum(sum, list[i]);
}
cout << sum << endl;
delete[] list;
return 0;
}
|
#include <cmath>
#include <iostream>
using namespace std;
void PrimeNumSum(int &sum, unsigned int &num) {
unsigned int divisor = sqrt(num) + 1;
if (divisor == 2) {
sum++;
return;
}
while (divisor >= 2) {
if (num % divisor == 0) {
return;
}
divisor--;
}
sum++;
}
int main() {
int count;
cin >> count;
unsigned int *list = new unsigned int[count];
for (int i = 0; i < count; i++) {
cin >> list[i];
}
int sum = 0;
for (int i = 0; i < count; i++) {
PrimeNumSum(sum, list[i]);
}
cout << sum << endl;
delete[] list;
return 0;
}
|
replace
| 6 | 7 | 6 | 7 |
TLE
| |
p02257
|
C++
|
Runtime Error
|
#include <cmath>
#include <iostream>
#include <vector>
bool is_prime(int a);
int main() {
int n;
int cnt = 0;
std::cin >> n;
std::vector<int> a(n);
for (int i = 0; i < n; i++) {
std::cin >> a[i];
}
for (int i = 0; i < n; i++) {
bool flag = is_prime(a[i]);
if (flag)
cnt++;
}
std::cout << cnt << '\n';
return 0;
}
bool is_prime(int a) {
for (int i = 0; i < std::sqrt(a); i++) {
if (a % i == 0)
return false;
}
return true;
}
|
#include <cmath>
#include <iostream>
#include <vector>
bool is_prime(int a);
int main() {
int n;
int cnt = 0;
std::cin >> n;
std::vector<int> a(n);
for (int i = 0; i < n; i++) {
std::cin >> a[i];
}
for (int i = 0; i < n; i++) {
bool flag = is_prime(a[i]);
if (flag)
cnt++;
}
std::cout << cnt << '\n';
return 0;
}
bool is_prime(int a) {
if (a == 2) {
return true;
} else if (a == 0 || a == 1) {
return false;
}
for (int i = 2; i <= std::sqrt(a); i++) {
if (a % i == 0)
return false;
}
return true;
}
|
replace
| 24 | 25 | 24 | 30 |
-8
| |
p02257
|
C++
|
Runtime Error
|
#include <cmath>
#include <iostream>
#include <vector>
using namespace std;
void Makepn(vector<int> &v, int n) {
int count = 1;
int i, j;
vector<bool> pn(n + 1, true);
pn[0] = false;
pn[1] = false;
for (i = 2; i < sqrt(n); i++) {
if (pn[i]) {
for (j = 0; i * (j + 2) < n; j++) {
pn[i * (j + 2)] = false;
}
}
}
for (i = 2; i < n; i++) {
if (pn[i]) {
count++;
}
}
v.resize(count);
v[0] = 2;
j = 1;
for (i = 3; i <= n; i += 2) {
if (pn[i]) {
v[j++] = i;
}
}
return;
}
int main() {
ios::sync_with_stdio(false);
vector<int> pn;
Makepn(pn, 10000);
int n, num, ans;
cin >> n;
ans = n;
for (int i = 0; i < n; i++) {
cin >> num;
for (int j = 0; j < pn.size(); j++) {
if (pn[j] * pn[j] > num)
break;
if (num % pn[j] == 0) {
ans--;
break;
}
}
}
cout << ans << endl;
return 0;
}
|
#include <cmath>
#include <iostream>
#include <vector>
using namespace std;
void Makepn(vector<int> &v, int n) {
int count = 0;
int i, j;
vector<bool> pn(n + 1, true);
pn[0] = false;
pn[1] = false;
for (i = 2; i < sqrt(n); i++) {
if (pn[i]) {
for (j = 0; i * (j + 2) < n; j++) {
pn[i * (j + 2)] = false;
}
}
}
for (i = 2; i < n; i++) {
if (pn[i]) {
count++;
}
}
v.resize(count);
v[0] = 2;
j = 1;
for (i = 3; i <= n; i += 2) {
if (pn[i]) {
v[j++] = i;
}
}
return;
}
int main() {
ios::sync_with_stdio(false);
vector<int> pn;
Makepn(pn, 10000);
int n, num, ans;
cin >> n;
ans = n;
for (int i = 0; i < n; i++) {
cin >> num;
for (int j = 0; j < pn.size(); j++) {
if (pn[j] * pn[j] > num)
break;
if (num % pn[j] == 0) {
ans--;
break;
}
}
}
cout << ans << endl;
return 0;
}
|
replace
| 6 | 7 | 6 | 7 |
0
| |
p02257
|
C++
|
Time Limit Exceeded
|
#include <cstdio>
using namespace std;
bool Prime(int x) {
for (int i = 2; i < (x / 2 + 1); i++) {
if (x % i == 0) {
return false;
}
}
return true;
}
int main() {
int n;
scanf("%d", &n);
int N[n];
for (int i = 0; i < n; i++) {
scanf(" %d", &N[i]);
}
int cnt;
for (int i = 0; i < n; i++) {
if (Prime(N[i]) == true) {
cnt++;
}
}
printf("%d\n", cnt);
return 0;
}
|
#include <cstdio>
using namespace std;
bool Prime(int x) {
for (int i = 2; i * i <= x; i++) {
if (x % i == 0) {
return false;
}
}
return true;
}
int main() {
int n;
scanf("%d", &n);
int N[n];
for (int i = 0; i < n; i++) {
scanf(" %d", &N[i]);
}
int cnt;
for (int i = 0; i < n; i++) {
if (Prime(N[i]) == true) {
cnt++;
}
}
printf("%d\n", cnt);
return 0;
}
|
replace
| 3 | 4 | 3 | 4 |
TLE
| |
p02257
|
C++
|
Time Limit Exceeded
|
#include <iostream>
#include <math.h>
#include <stdio.h>
#include <string.h>
using namespace std;
#define MAX 256
int f(int x) {
if (x == 2)
return 1;
if (x % 2 == 0)
return 0;
for (int i = 3; i <= x / 2; i += 2) {
if (x % i == 0)
return 0;
}
return 1;
}
int main(void) {
int a;
scanf("%d", &a);
int count = 0, b;
for (int i = 0; i < a; i++) {
scanf("%d", &b);
count += f(b);
}
printf("%d\n", count);
return 0;
}
|
#include <iostream>
#include <math.h>
#include <stdio.h>
#include <string.h>
using namespace std;
#define MAX 256
int f(int x) {
if (x == 2)
return 1;
if (x % 2 == 0)
return 0;
for (int i = 3; i <= (int)sqrt(x); i += 2) {
if (x % i == 0)
return 0;
}
return 1;
}
int main(void) {
int a;
scanf("%d", &a);
int count = 0, b;
for (int i = 0; i < a; i++) {
scanf("%d", &b);
count += f(b);
}
printf("%d\n", count);
return 0;
}
|
replace
| 13 | 14 | 13 | 14 |
TLE
| |
p02257
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define reps(i, f, n) for (int i = (f); i <= (n); ++i)
#define outl(x) cout << (x) << '\n'
#define FAST() cin.tie(0), ios::sync_with_stdio(false)
template <class A, class B> inline bool chmax(A &a, B b) {
return b > a ? a = b, 1 : 0;
}
template <class A, class B> inline bool chmin(A &a, B b) {
return b < a ? a = b, 1 : 0;
}
inline int updiv(int a, int b) { return ((a + b - 1) / b); }
bool prime(int n) {
if ((n & 1) == 0)
return (n == 2);
for (int i = 3; i < n; i += 2) {
if (n % i == 0)
return (false);
}
return (true);
}
int main() {
FAST();
int n, a, cnt = 0;
cin >> n;
while (n--) {
cin >> a;
cnt += prime(a);
}
outl(cnt);
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define reps(i, f, n) for (int i = (f); i <= (n); ++i)
#define outl(x) cout << (x) << '\n'
#define FAST() cin.tie(0), ios::sync_with_stdio(false)
template <class A, class B> inline bool chmax(A &a, B b) {
return b > a ? a = b, 1 : 0;
}
template <class A, class B> inline bool chmin(A &a, B b) {
return b < a ? a = b, 1 : 0;
}
inline int updiv(int a, int b) { return ((a + b - 1) / b); }
bool prime(int n) {
if ((n & 1) == 0)
return (n == 2);
for (int i = 3; i * i <= n; i += 2) {
if (n % i == 0)
return (false);
}
return (true);
}
int main() {
FAST();
int n, a, cnt = 0;
cin >> n;
while (n--) {
cin >> a;
cnt += prime(a);
}
outl(cnt);
}
|
replace
| 17 | 18 | 17 | 18 |
TLE
| |
p02257
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int cnt = 0;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
for (int j = 2; j < a; j++) {
if (a % j == 0) {
cnt++;
break;
}
}
}
cout << n - cnt << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int cnt = 0;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
int t = sqrt(a);
for (int j = 2; j <= t; j++) {
if (a % j == 0) {
cnt++;
break;
}
}
}
cout << n - cnt << endl;
return 0;
}
|
replace
| 12 | 13 | 12 | 14 |
TLE
| |
p02257
|
C++
|
Runtime Error
|
#include <cmath>
#include <iostream>
using namespace std;
int prs[5000];
int pri = 1;
int isPrime(int a) {
int flg;
if (sqrt(a) > prs[pri]) {
for (int i = prs[pri] + 2; i <= sqrt(a); i += 2) {
flg = 1;
for (int j = 0; j <= pri; j++) {
if (sqrt(i) < prs[i])
break;
if (i % prs[j] == 0) {
flg = 0;
break;
}
}
if (flg)
prs[++pri] = i;
}
// for (int i=0;i<=pri;i++)cout << prs[i] << " ";
}
for (int i = 0; i <= pri; i++) {
if (sqrt(a) < prs[i])
break;
if (a % prs[i] == 0)
return 0;
}
return 1;
}
int main() {
prs[0] = 2;
prs[1] = 3;
int n, a, cnt = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a;
cnt += isPrime(a);
}
cout << cnt << endl;
return 0;
}
|
#include <cmath>
#include <iostream>
using namespace std;
int prs[10000];
int pri = 1;
int isPrime(int a) {
int flg;
if (sqrt(a) > prs[pri]) {
for (int i = prs[pri] + 2; i <= sqrt(a); i += 2) {
flg = 1;
for (int j = 0; j <= pri; j++) {
if (sqrt(i) < prs[i])
break;
if (i % prs[j] == 0) {
flg = 0;
break;
}
}
if (flg)
prs[++pri] = i;
}
// for (int i=0;i<=pri;i++)cout << prs[i] << " ";
}
for (int i = 0; i <= pri; i++) {
if (sqrt(a) < prs[i])
break;
if (a % prs[i] == 0)
return 0;
}
return 1;
}
int main() {
prs[0] = 2;
prs[1] = 3;
int n, a, cnt = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a;
cnt += isPrime(a);
}
cout << cnt << endl;
return 0;
}
|
replace
| 4 | 5 | 4 | 5 |
0
| |
p02257
|
C++
|
Time Limit Exceeded
|
#include <iostream>
typedef long long ll;
bool isPrime(ll a);
int main() {
using namespace std;
ll A[10001];
int n, prime = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> A[i];
if (isPrime(A[i])) {
prime++;
}
}
cout << prime << endl;
return 0;
}
bool isPrime(ll a) {
for (ll i = 2; i < a; i++) {
if (a % i == 0) {
return false;
}
}
return true;
}
|
#include <iostream>
typedef long long ll;
bool isPrime(ll a);
int main() {
using namespace std;
ll A[10001];
int n, prime = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> A[i];
if (isPrime(A[i])) {
prime++;
}
}
cout << prime << endl;
return 0;
}
bool isPrime(ll a) {
for (ll i = 2; i * i <= a; i++) {
if (a % i == 0) {
return false;
}
}
return true;
}
|
replace
| 20 | 21 | 20 | 21 |
TLE
| |
p02257
|
C++
|
Time Limit Exceeded
|
#include <cmath>
#include <iostream>
using namespace std;
int main() {
int n, m, i, count;
cin >> n;
count = 0;
for (int j = 0; j < n; ++j) {
cin >> m;
if (m == 2)
++count;
else if (m < 2 || m % 2 == 0) {
continue;
} else {
i = 3;
while (i <= sqrt(m)) {
if (m % i == 0)
continue;
i = i + 2;
}
if (i > sqrt(m)) {
++count;
}
}
}
cout << count << endl;
return 0;
}
|
#include <cmath>
#include <iostream>
using namespace std;
int main() {
int n, m, i, count;
cin >> n;
count = 0;
for (int j = 0; j < n; ++j) {
cin >> m;
if (m == 2)
++count;
else if (m < 2 || m % 2 == 0) {
continue;
} else {
i = 3;
while (i <= sqrt(m)) {
if (m % i == 0)
break;
i = i + 2;
}
if (i > sqrt(m)) {
++count;
}
}
}
cout << count << endl;
return 0;
}
|
replace
| 19 | 20 | 19 | 20 |
TLE
| |
p02257
|
C++
|
Time Limit Exceeded
|
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cfloat>
#include <climits>
#include <cmath>
#include <cstdio>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#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 < (int)n; ++i)
bool isPrime(int num) {
// if(num < 2) return false;
if (num == 2)
return true;
if (num % 2 == 0)
return false;
for (int i = 3; i < num; i += 2) {
if (num % i == 0)
return false;
}
return true;
}
int main() {
int N;
int count = 0;
int num;
cin >> N;
REP(i, N) {
cin >> num;
if (isPrime(num))
++count;
}
cout << count << endl;
return 0;
}
|
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cfloat>
#include <climits>
#include <cmath>
#include <cstdio>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#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 < (int)n; ++i)
bool isPrime(int num) {
// if(num < 2) return false;
if (num == 2)
return true;
if (num % 2 == 0)
return false;
// +1 重要
for (int i = 3; i < sqrt(num) + 1; i += 2) {
if (num % i == 0)
return false;
}
return true;
}
int main() {
int N;
int count = 0;
int num;
cin >> N;
REP(i, N) {
cin >> num;
if (isPrime(num))
++count;
}
cout << count << endl;
return 0;
}
|
replace
| 32 | 33 | 32 | 34 |
TLE
| |
p02257
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 50001;
int prime[maxn], cnt, res;
bool isprime[maxn];
void maketable() {
int base = (int)sqrt((double)maxn);
isprime[0] = isprime[1] = 1;
for (int i = 2; i < base; i++) {
if (!isprime[i]) {
prime[cnt++] = i;
for (int j = i + i; j < maxn; j += i) {
isprime[j] = 1;
}
}
}
}
void solve(int n) {
int k = (int)sqrt((double)n);
for (int i = 0; prime[i] <= k; i++) {
if (n % prime[i] == 0) {
return;
}
}
res++;
}
int main() {
maketable();
int n, s;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &s);
solve(s);
}
printf("%d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 50001;
int prime[maxn], cnt, res;
bool isprime[maxn];
void maketable() {
int base = (int)sqrt((double)maxn);
isprime[0] = isprime[1] = 1;
for (int i = 2; i < maxn; i++) { // 此处i<maxn与以前的不同
if (!isprime[i]) {
prime[cnt++] = i;
for (int j = i + i; j < maxn; j += i) {
isprime[j] = 1;
}
}
}
}
void solve(int n) {
int k = (int)sqrt((double)n);
for (int i = 0; prime[i] <= k; i++) {
if (n % prime[i] == 0) {
return;
}
}
res++;
}
int main() {
maketable();
int n, s;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &s);
solve(s);
}
printf("%d\n", res);
return 0;
}
|
replace
| 13 | 14 | 13 | 14 |
0
| |
p02257
|
C++
|
Time Limit Exceeded
|
#include <iostream>
using namespace std;
bool primenum(int x);
int main() {
int n;
int i;
int num[10000];
int ans = 0;
cin >> n;
for (i = 0; i < n; i++) {
cin >> num[i];
}
for (i = 0; i < n; i++) {
if (primenum(num[i]) == true)
ans++;
}
cout << ans << "\n";
}
bool primenum(int x) {
int j = 3;
if (x == 2)
return (true);
if (x % 2 == 0 || x < 2)
return (false);
while (j * j <= x) {
if (x % j == 0) {
return (false);
}
}
return (true);
}
|
#include <iostream>
using namespace std;
bool primenum(int x);
int main() {
int n;
int i;
int num[10000];
int ans = 0;
cin >> n;
for (i = 0; i < n; i++) {
cin >> num[i];
}
for (i = 0; i < n; i++) {
if (primenum(num[i]) == true)
ans++;
}
cout << ans << "\n";
}
bool primenum(int x) {
int j = 3;
if (x == 2)
return (true);
if (x % 2 == 0 || x < 2)
return (false);
while (j * j <= x) {
if (x % j == 0) {
return (false);
}
j += 2;
}
return (true);
}
|
insert
| 38 | 38 | 38 | 39 |
TLE
| |
p02257
|
C++
|
Time Limit Exceeded
|
#include <iostream>
using namespace std;
int main() {
int n, a[11000], cnt = 0;
cin >> n;
for (int i = 0; i < n; ++i)
cin >> a[i];
for (int i = 0; i < n; ++i) {
bool sosu = true;
for (int j = 2; j < a[i]; ++j) {
if (a[i] % j == 0) {
sosu = false;
break;
}
}
if (sosu)
++cnt;
}
cout << cnt << endl;
return 0;
}
|
#include <iostream>
using namespace std;
int main() {
int n, a[11000], cnt = 0;
cin >> n;
for (int i = 0; i < n; ++i)
cin >> a[i];
for (int i = 0; i < n; ++i) {
bool sosu = true;
for (int j = 2; j * j <= a[i]; ++j) {
if (a[i] % j == 0) {
sosu = false;
break;
}
}
if (sosu)
++cnt;
}
cout << cnt << endl;
return 0;
}
|
replace
| 11 | 12 | 11 | 12 |
TLE
| |
p02257
|
C++
|
Time Limit Exceeded
|
#include <iostream>
using namespace std;
int main() {
int N;
int x;
int count = 0;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> x;
for (int j = 2; j < x / 2 + 1; j++) {
if (x != 2) {
if (x % j == 0) {
count++;
break;
}
}
}
}
cout << N - count << endl;
return 0;
}
|
#include <iostream>
using namespace std;
int main() {
int N;
int x;
int count = 0;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> x;
for (int j = 2; j * j <= x; j++) {
if (x % j == 0) {
count++;
break;
}
}
}
cout << N - count << endl;
return 0;
}
|
replace
| 10 | 16 | 10 | 14 |
TLE
| |
p02257
|
C++
|
Runtime Error
|
#include <iostream>
#include <vector>
using namespace std;
#define MAX_N 1e6
int main(void) {
vector<bool> eratos(MAX_N, true);
eratos[0] = eratos[1] = false;
for (int i = 2; i * i < MAX_N; i++) {
if (eratos[i]) {
for (int j = 2; i * j < MAX_N; j++) {
eratos[i * j] = false;
}
}
}
int n, input, ans = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> input;
if (eratos[input]) {
++ans;
}
}
cout << ans << endl;
return 0;
}
|
#include <iostream>
#include <vector>
using namespace std;
#define MAX_N (1e8) + 1
int main(void) {
vector<bool> eratos(MAX_N, true);
eratos[0] = eratos[1] = false;
for (int i = 2; i * i < MAX_N; i++) {
if (eratos[i]) {
for (int j = 2; i * j < MAX_N; j++) {
eratos[i * j] = false;
}
}
}
int n, input, ans = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> input;
if (eratos[input]) {
++ans;
}
}
cout << ans << endl;
return 0;
}
|
replace
| 4 | 5 | 4 | 5 |
0
| |
p02257
|
C++
|
Time Limit Exceeded
|
#include <algorithm>
#include <bitset>
#include <cctype>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
const int MAX_NUM = 100000000;
vector<bool> ps(MAX_NUM + 1, true);
int main() {
ps[0] = ps[1] = false;
for (int i = 2; i <= MAX_NUM; i++) {
if (!ps[i]) {
continue;
}
for (int j = i + i; j <= MAX_NUM; j += i) {
ps[j] = false;
}
}
int n;
cin >> n;
int ans = 0;
for (int i = 0; i < n; i++) {
int k;
cin >> k;
if (ps[k]) {
ans++;
}
}
cout << ans << endl;
}
|
#include <algorithm>
#include <bitset>
#include <cctype>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
const int MAX_NUM = 100000000;
vector<bool> ps(MAX_NUM + 1, true);
int main() {
ps[0] = ps[1] = false;
for (int i = 4; i <= MAX_NUM; i += 2) {
ps[i] = false;
}
for (int i = 3; i <= MAX_NUM; i += 2) {
if (!ps[i]) {
continue;
}
for (int j = i + i; j <= MAX_NUM; j += i) {
ps[j] = false;
}
}
int n;
cin >> n;
int ans = 0;
for (int i = 0; i < n; i++) {
int k;
cin >> k;
if (ps[k]) {
ans++;
}
}
cout << ans << endl;
}
|
replace
| 30 | 31 | 30 | 34 |
TLE
| |
p02257
|
C++
|
Memory Limit Exceeded
|
#include <iostream>
#include <vector>
using namespace std;
#define MAX_N (1e9) + 1
int main(void) {
//?????????????????????
vector<bool> eratos(MAX_N, true);
eratos[0] = eratos[1] = false;
for (int i = 2; i * i < MAX_N; i++)
if (eratos[i])
for (int j = 2; i * j < MAX_N; j++)
eratos[i * j] = false;
//?????¨?????????
int n, input, ans = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> input;
if (eratos[input])
++ans;
}
//??????
cout << ans << endl;
return 0;
}
|
#include <iostream>
#include <vector>
using namespace std;
#define MAX_N (1e8) + 1
int main(void) {
//?????????????????????
vector<bool> eratos(MAX_N, true);
eratos[0] = eratos[1] = false;
for (int i = 2; i * i < MAX_N; i++)
if (eratos[i])
for (int j = 2; i * j < MAX_N; j++)
eratos[i * j] = false;
//?????¨?????????
int n, input, ans = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> input;
if (eratos[input])
++ans;
}
//??????
cout << ans << endl;
return 0;
}
|
replace
| 4 | 5 | 4 | 5 |
MLE
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.