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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
p03096 | C++ | Runtime Error | #include <algorithm>
#include <array>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iostream>
#include <list>
#include <map>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int main() {
uint32_t n;
cin >> n;
vector<uint32_t> cs(n);
for (uint32_t i = 0; i < n; i++) {
cin >> cs[i];
}
vector<uint64_t> vals(n);
vector<uint32_t> marks(n + 1, -1); // 1 origin, idx: c, elem : idx
vals[0] = 1;
marks[cs[0]] = 0;
for (uint32_t i = 1; i < n; i++) {
// cout << i << " " << vals[i - 1] << endl;
uint32_t c = cs[i];
if (c == cs[i - 1]) {
vals[i] = vals[i - 1];
continue;
}
uint32_t &cur_mark = marks[c];
if (cur_mark != -1) {
vals[i] = vals[i - 1] + vals[cur_mark];
vals[i] %= 1000000007;
} else {
vals[i] = vals[i - 1];
}
// cout << i << " " << c << " " << vals[i] << endl;
cur_mark = i;
}
cout << vals[n - 1] << endl;
return 0;
}
| #include <algorithm>
#include <array>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iostream>
#include <list>
#include <map>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int main() {
uint32_t n;
cin >> n;
vector<uint32_t> cs(n);
for (uint32_t i = 0; i < n; i++) {
cin >> cs[i];
}
vector<uint64_t> vals(n);
vector<uint32_t> marks(200001, -1); // 1 origin, idx: c, elem : idx
vals[0] = 1;
marks[cs[0]] = 0;
for (uint32_t i = 1; i < n; i++) {
// cout << i << " " << vals[i - 1] << endl;
uint32_t c = cs[i];
if (c == cs[i - 1]) {
vals[i] = vals[i - 1];
continue;
}
uint32_t &cur_mark = marks[c];
if (cur_mark != -1) {
vals[i] = vals[i - 1] + vals[cur_mark];
vals[i] %= 1000000007;
} else {
vals[i] = vals[i - 1];
}
// cout << i << " " << c << " " << vals[i] << endl;
cur_mark = i;
}
cout << vals[n - 1] << endl;
return 0;
}
| replace | 30 | 31 | 30 | 31 | 0 | |
p03096 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep2(i, x, n) for (int i = x; i < n; i++)
#define rep3(i, n) for (int i = n - 1; i >= 0; i--)
#define rep4(i, x, n) for (int i = x; i > n; i--)
#define elif else if
typedef long long ll;
typedef pair<ll, ll> P;
const ll MOD = 1e9 + 7;
const ll MOD2 = 998244353;
const ll INF = 1e15;
int main() {
int N;
cin >> N;
int C[N];
rep(i, N) cin >> C[i];
ll dp[N];
map<int, int> mp;
vector<int> vec[N];
dp[0] = 1;
mp[C[0]] = 0;
vec[0].push_back(0);
rep2(i, 1, N) {
if (C[i] == C[i - 1])
dp[i] = dp[i - 1];
elif (!mp.count(C[i])) {
dp[i] = dp[i - 1];
mp[C[i]] = i;
vec[i].push_back(i);
}
else {
dp[i] = dp[i - 1];
int j = mp[C[i]];
rep(k, vec[j].size()) {
int l = vec[j][k];
if (l >= 1)
dp[i] += dp[l - 1];
else
dp[i] += 1;
dp[i] %= MOD;
}
vec[j].push_back(i);
}
}
cout << dp[N - 1] << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep2(i, x, n) for (int i = x; i < n; i++)
#define rep3(i, n) for (int i = n - 1; i >= 0; i--)
#define rep4(i, x, n) for (int i = x; i > n; i--)
#define elif else if
typedef long long ll;
typedef pair<ll, ll> P;
const ll MOD = 1e9 + 7;
const ll MOD2 = 998244353;
const ll INF = 1e15;
int main() {
int N;
cin >> N;
int C[N];
rep(i, N) cin >> C[i];
ll dp[N];
map<int, int> mp;
vector<int> vec[N];
dp[0] = 1;
mp[C[0]] = 0;
vec[0].push_back(0);
rep2(i, 1, N) {
if (C[i] == C[i - 1])
dp[i] = dp[i - 1];
elif (!mp.count(C[i])) {
dp[i] = dp[i - 1];
mp[C[i]] = i;
vec[i].push_back(i);
}
else {
dp[i] = dp[i - 1];
int j = mp[C[i]];
int k = vec[j].size() - 1;
dp[i] += dp[vec[j][k]];
dp[i] %= MOD;
vec[j].push_back(i);
}
}
cout << dp[N - 1] << endl;
} | replace | 35 | 43 | 35 | 38 | TLE | |
p03096 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <forward_list>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <tuple>
#include <utility>
#include <vector>
#define rep(i, s, g) for ((i) = (s); (i) < (g); ++(i))
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
const ll MOD = 1e9 + 7;
const ll INF = (1ll << 60);
int main(void) {
int n;
cin >> n;
vector<ll> c(n), dp(n + 1, 1);
vector<vector<ll>> s(n + 1, vector<ll>());
for (int i = 0; i < n; i++) {
cin >> c[i];
c[i];
s[c[i]].push_back(i);
}
for (int i = 0; i < n; i++) {
int x = lower_bound(s[c[i]].begin(), s[c[i]].end(), i) - s[c[i]].begin();
if (x > 0) {
if (s[c[i]][x] - s[c[i]][x - 1] > 1) {
dp[i + 1] = dp[i] + dp[s[c[i]][x - 1] + 1];
dp[i + 1] %= MOD;
} else {
dp[i + 1] = dp[i];
dp[i + 1] %= MOD;
}
} else {
dp[i + 1] = dp[i];
dp[i + 1] %= MOD;
}
}
cout << dp[n] << endl;
}
| #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <forward_list>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <tuple>
#include <utility>
#include <vector>
#define rep(i, s, g) for ((i) = (s); (i) < (g); ++(i))
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
const ll MOD = 1e9 + 7;
const ll INF = (1ll << 60);
int main(void) {
int n;
cin >> n;
vector<ll> c(n), dp(n + 1, 1);
vector<vector<ll>> s(200010, vector<ll>());
for (int i = 0; i < n; i++) {
cin >> c[i];
c[i];
s[c[i]].push_back(i);
}
for (int i = 0; i < n; i++) {
int x = lower_bound(s[c[i]].begin(), s[c[i]].end(), i) - s[c[i]].begin();
if (x > 0) {
if (s[c[i]][x] - s[c[i]][x - 1] > 1) {
dp[i + 1] = dp[i] + dp[s[c[i]][x - 1] + 1];
dp[i + 1] %= MOD;
} else {
dp[i + 1] = dp[i];
dp[i + 1] %= MOD;
}
} else {
dp[i + 1] = dp[i];
dp[i + 1] %= MOD;
}
}
cout << dp[n] << endl;
}
| replace | 29 | 30 | 29 | 30 | 0 | |
p03096 | C++ | Runtime Error | /*やったぜ。 投稿者：変態糞土方 (8月16日（水）07時14分22秒)
昨日の8月15日にいつもの浮浪者のおっさん（60歳）と先日メールくれた汚れ好きの土方のにいちゃん
（45歳）とわし（53歳）の3人で県北にある川の土手の下で盛りあったぜ。
今日は明日が休みなんでコンビニで酒とつまみを買ってから滅多に人が来ない所なんで、
そこでしこたま酒を飲んでからやりはじめたんや。
3人でちんぽ舐めあいながら地下足袋だけになり持って来たいちぢく浣腸を3本ずつ入れあった。
しばらくしたら、けつの穴がひくひくして来るし、糞が出口を求めて腹の中でぐるぐるしている。
浮浪者のおっさんにけつの穴をなめさせながら、兄ちゃんのけつの穴を舐めてたら、
先に兄ちゃんがわしの口に糞をドバーっと出して来た。
それと同時におっさんもわしも糞を出したんや。もう顔中、糞まみれや、
3人で出した糞を手で掬いながらお互いの体にぬりあったり、
糞まみれのちんぽを舐めあって小便で浣腸したりした。ああ～～たまらねえぜ。
しばらくやりまくってから又浣腸をしあうともう気が狂う程気持ちええんじゃ。
浮浪者のおっさんのけつの穴にわしのちんぽを突うずるっ込んでやると
けつの穴が糞と小便でずるずるして気持ちが良い。
にいちゃんもおっさんの口にちんぽ突っ込んで腰をつかって居る。
糞まみれのおっさんのちんぽを掻きながら、思い切り射精したんや。
それからは、もうめちゃくちゃにおっさんと兄ちゃんの糞ちんぽを舐めあい、
糞を塗りあい、二回も男汁を出した。もう一度やりたいぜ。
やはり大勢で糞まみれになると最高やで。こんな、変態親父と糞あそびしないか。
ああ～～早く糞まみれになろうぜ。
岡山の県北であえる奴なら最高や。わしは163*90*53,おっさんは165*75*60、や
糞まみれでやりたいやつ、至急、メールくれや。
土方姿のまま浣腸して、糞だらけでやろうや。*/
#include "bits/stdc++.h"
#include <numeric>
#define rep(i, n) for (int i = 0; i < n; i++)
typedef long long ll;
typedef unsigned long long ull;
using namespace std;
#define llMAX numeric_limits<long long>::max()
#define intMAX numeric_limits<int>::max()
#define llMIN numeric_limits<long long>::min()
#define intMIN numeric_limits<int>::min()
#define d_5 100000
#define d9_7 1000000007
#define vll vector<vector<long long>>
#define vl vector<long long>
#define vi vector<int>
#define vii vector<vector<int>>
#define pb push_back
#define pf push_front
#define ld long double
int main(void) {
int n;
cin >> n;
vi c(n + 1);
rep(i, n) { cin >> c[i + 1]; }
c[0] = 100005;
vl dp(1 + n, 0);
vl colors(100010, 0);
dp[0] = 1;
rep(i, n) {
if (c[i + 1] != c[i]) {
dp[i + 1] = dp[i] + colors[c[i + 1]];
dp[i + 1] %= d9_7;
colors[c[i + 1]] += dp[i];
} else {
dp[i + 1] = dp[i];
}
}
cout << dp[n] << endl;
return 0;
}
| /*やったぜ。 投稿者：変態糞土方 (8月16日（水）07時14分22秒)
昨日の8月15日にいつもの浮浪者のおっさん（60歳）と先日メールくれた汚れ好きの土方のにいちゃん
（45歳）とわし（53歳）の3人で県北にある川の土手の下で盛りあったぜ。
今日は明日が休みなんでコンビニで酒とつまみを買ってから滅多に人が来ない所なんで、
そこでしこたま酒を飲んでからやりはじめたんや。
3人でちんぽ舐めあいながら地下足袋だけになり持って来たいちぢく浣腸を3本ずつ入れあった。
しばらくしたら、けつの穴がひくひくして来るし、糞が出口を求めて腹の中でぐるぐるしている。
浮浪者のおっさんにけつの穴をなめさせながら、兄ちゃんのけつの穴を舐めてたら、
先に兄ちゃんがわしの口に糞をドバーっと出して来た。
それと同時におっさんもわしも糞を出したんや。もう顔中、糞まみれや、
3人で出した糞を手で掬いながらお互いの体にぬりあったり、
糞まみれのちんぽを舐めあって小便で浣腸したりした。ああ～～たまらねえぜ。
しばらくやりまくってから又浣腸をしあうともう気が狂う程気持ちええんじゃ。
浮浪者のおっさんのけつの穴にわしのちんぽを突うずるっ込んでやると
けつの穴が糞と小便でずるずるして気持ちが良い。
にいちゃんもおっさんの口にちんぽ突っ込んで腰をつかって居る。
糞まみれのおっさんのちんぽを掻きながら、思い切り射精したんや。
それからは、もうめちゃくちゃにおっさんと兄ちゃんの糞ちんぽを舐めあい、
糞を塗りあい、二回も男汁を出した。もう一度やりたいぜ。
やはり大勢で糞まみれになると最高やで。こんな、変態親父と糞あそびしないか。
ああ～～早く糞まみれになろうぜ。
岡山の県北であえる奴なら最高や。わしは163*90*53,おっさんは165*75*60、や
糞まみれでやりたいやつ、至急、メールくれや。
土方姿のまま浣腸して、糞だらけでやろうや。*/
#include "bits/stdc++.h"
#include <numeric>
#define rep(i, n) for (int i = 0; i < n; i++)
typedef long long ll;
typedef unsigned long long ull;
using namespace std;
#define llMAX numeric_limits<long long>::max()
#define intMAX numeric_limits<int>::max()
#define llMIN numeric_limits<long long>::min()
#define intMIN numeric_limits<int>::min()
#define d_5 100000
#define d9_7 1000000007
#define vll vector<vector<long long>>
#define vl vector<long long>
#define vi vector<int>
#define vii vector<vector<int>>
#define pb push_back
#define pf push_front
#define ld long double
int main(void) {
int n;
cin >> n;
vi c(n + 1);
rep(i, n) { cin >> c[i + 1]; }
c[0] = 100005;
vl dp(1 + n, 0);
vl colors(300010, 0);
dp[0] = 1;
rep(i, n) {
if (c[i + 1] != c[i]) {
dp[i + 1] = dp[i] + colors[c[i + 1]];
dp[i + 1] %= d9_7;
colors[c[i + 1]] += dp[i];
} else {
dp[i + 1] = dp[i];
}
}
cout << dp[n] << endl;
return 0;
}
| replace | 74 | 75 | 74 | 75 | 0 | |
p03096 | C++ | Runtime Error | /*----------------by syr----------------*/
/*
iii ii
rBQBBBBBBE BBR iBBBBQBBL XBBBBBBQBBBBB
iBBQJ 7BBB BBsSBBr BBQ i cBBB
rBBU iBBw BBBQi HBBi KBBi
BBH BB5 iBBB isL wBB5
GBB iBBi 6BB iBBB
BBQ BQB BBD QBBi
BBB BQB iQBi 1BBv
sBBg wBBB QBB iBBB
7BBBBBBBBBi BBR wBBBBBBBBBBBBB
irvi ii ii i i iii
i5U
BBB
BB7
1BB
iPBBBBBKBBR JBR1 rQBO BR UBQP iBBQi
7BBBGs7sXBBBi QBBr gBBE rBB BB2BB7HBZQBB
QBBi sBQ BBB iBBB SQBBR BBBB cBQ
gBQ BBg BBB KBBi MBBH BBB BBs
iBBv iBBi QBBBL BBR pBB iBB
pBB BBB iBBBB iBB BBL KBB
MBB BBBR BBB JBBi DBR iBQ BBL
GBB 7BBBB2 PBBH BBBi BQr DBB iBB
BQBXwgBBP BB7 1BBB BBQ7 1BB BBc BBB
2BBBBw BB EBBS QBBi HBa iBB BB7
*/
#include <bits/stdc++.h>
using namespace std;
#define PH push
#define MP make_pair
#define PB push_back
#define fst first
#define snd second
#define FOR(i, x, y) for (int i = (x); i < (y); ++i)
#define REP(i, x, y) for (int i = (x); i <= (y); ++i)
#define x0 x0123456789
#define y0 y0123456789
#define x1 x1234567890
#define y1 y1234567890
#define x2 x2345678901
#define y2 y2345678901
typedef double db;
typedef long long ll;
typedef long double ldb;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int INF = 1e9 + 7;
const int maxn = 1e5 + 5;
void add(int &a, int b) { a = (a + b >= INF) ? (a + b - INF) : (a + b); }
int n, m, ans = 0;
int a[maxn], f[maxn], g[maxn], sum[maxn];
int main() {
scanf("%d", &m);
REP(i, 1, m) {
int x;
scanf("%d", &x);
if (x == a[n])
continue;
a[++n] = x;
}
f[0] = sum[0] = 1;
REP(i, 1, n) {
f[i] = g[a[i]];
sum[i] = (f[i] + sum[i - 1]) % INF;
if (i - 2 >= 0)
add(g[a[i - 1]], sum[i - 2]);
}
// REP(i,0,n) printf("%d ",f[i]);
// puts("");
REP(i, 0, n) add(ans, f[i]);
printf("%d\n", ans);
return 0;
}
| /*----------------by syr----------------*/
/*
iii ii
rBQBBBBBBE BBR iBBBBQBBL XBBBBBBQBBBBB
iBBQJ 7BBB BBsSBBr BBQ i cBBB
rBBU iBBw BBBQi HBBi KBBi
BBH BB5 iBBB isL wBB5
GBB iBBi 6BB iBBB
BBQ BQB BBD QBBi
BBB BQB iQBi 1BBv
sBBg wBBB QBB iBBB
7BBBBBBBBBi BBR wBBBBBBBBBBBBB
irvi ii ii i i iii
i5U
BBB
BB7
1BB
iPBBBBBKBBR JBR1 rQBO BR UBQP iBBQi
7BBBGs7sXBBBi QBBr gBBE rBB BB2BB7HBZQBB
QBBi sBQ BBB iBBB SQBBR BBBB cBQ
gBQ BBg BBB KBBi MBBH BBB BBs
iBBv iBBi QBBBL BBR pBB iBB
pBB BBB iBBBB iBB BBL KBB
MBB BBBR BBB JBBi DBR iBQ BBL
GBB 7BBBB2 PBBH BBBi BQr DBB iBB
BQBXwgBBP BB7 1BBB BBQ7 1BB BBc BBB
2BBBBw BB EBBS QBBi HBa iBB BB7
*/
#include <bits/stdc++.h>
using namespace std;
#define PH push
#define MP make_pair
#define PB push_back
#define fst first
#define snd second
#define FOR(i, x, y) for (int i = (x); i < (y); ++i)
#define REP(i, x, y) for (int i = (x); i <= (y); ++i)
#define x0 x0123456789
#define y0 y0123456789
#define x1 x1234567890
#define y1 y1234567890
#define x2 x2345678901
#define y2 y2345678901
typedef double db;
typedef long long ll;
typedef long double ldb;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int INF = 1e9 + 7;
const int maxn = 2e5 + 5;
void add(int &a, int b) { a = (a + b >= INF) ? (a + b - INF) : (a + b); }
int n, m, ans = 0;
int a[maxn], f[maxn], g[maxn], sum[maxn];
int main() {
scanf("%d", &m);
REP(i, 1, m) {
int x;
scanf("%d", &x);
if (x == a[n])
continue;
a[++n] = x;
}
f[0] = sum[0] = 1;
REP(i, 1, n) {
f[i] = g[a[i]];
sum[i] = (f[i] + sum[i - 1]) % INF;
if (i - 2 >= 0)
add(g[a[i - 1]], sum[i - 2]);
}
// REP(i,0,n) printf("%d ",f[i]);
// puts("");
REP(i, 0, n) add(ans, f[i]);
printf("%d\n", ans);
return 0;
}
| replace | 54 | 55 | 54 | 55 | 0 | |
p03096 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define P pair<ll, ll>
#define FOR(I, A, B) for (ll I = int(A); I < int(B); ++I)
#define FORR(I, A, B) for (ll I = int((B)-1); I >= int(A); --I)
#define TO(x, t, f) ((x) ? (t) : (f))
#define SORT(x) (sort(x.begin(), x.end())) // 0 2 2 3 4 5 8 9
#define POSL(x, v) \
(lower_bound(x.begin(), x.end(), v) - x.begin()) // xi>=v x is sorted
#define POSU(x, v) \
(upper_bound(x.begin(), x.end(), v) - x.begin()) // xi>v x is sorted
#define NUM(x, v) (POSU(x, v) - POSL(x, v)) // x is sorted
#define REV(x) (reverse(x.begin(), x.end())) // reverse
ll gcd(ll a, ll b) {
if (a < b)
swap(a, b);
if (a % b == 0)
return b;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) {
ll c = gcd(a, b);
return ((a / c) * (b / c) * c);
} // saisyo kobaisu
#define NEXTP(x) next_permutation(x.begin(), x.end())
const ll INF = 1e18 + 7;
const ll MOD = 1e9 + 7;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll N, n = 2;
cin >> N;
vector<ll> C, dp(N + 3, 0), sum(N + 3, 0);
C.push_back(0);
FOR(i, 0, N) {
ll k;
cin >> k;
if (C.size() == 1) {
C.push_back(k);
} else if (k != C[n - 1]) {
C.push_back(k);
n++;
}
}
N = n;
dp[1] = 1;
sum[C[1]] = 1;
FOR(i, 2, N + 1) {
dp[i] = (dp[i - 1] + sum[C[i]]) % MOD;
sum[C[i]] = dp[i];
}
cout << dp[N] << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define P pair<ll, ll>
#define FOR(I, A, B) for (ll I = int(A); I < int(B); ++I)
#define FORR(I, A, B) for (ll I = int((B)-1); I >= int(A); --I)
#define TO(x, t, f) ((x) ? (t) : (f))
#define SORT(x) (sort(x.begin(), x.end())) // 0 2 2 3 4 5 8 9
#define POSL(x, v) \
(lower_bound(x.begin(), x.end(), v) - x.begin()) // xi>=v x is sorted
#define POSU(x, v) \
(upper_bound(x.begin(), x.end(), v) - x.begin()) // xi>v x is sorted
#define NUM(x, v) (POSU(x, v) - POSL(x, v)) // x is sorted
#define REV(x) (reverse(x.begin(), x.end())) // reverse
ll gcd(ll a, ll b) {
if (a < b)
swap(a, b);
if (a % b == 0)
return b;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) {
ll c = gcd(a, b);
return ((a / c) * (b / c) * c);
} // saisyo kobaisu
#define NEXTP(x) next_permutation(x.begin(), x.end())
const ll INF = 1e18 + 7;
const ll MOD = 1e9 + 7;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll N, n = 2;
cin >> N;
if (N == 1 || N == 2) {
cout << 1 << endl;
return 0;
}
vector<ll> C, dp(N + 3, 0), sum(N + 3, 0);
C.push_back(0);
FOR(i, 0, N) {
ll k;
cin >> k;
if (C.size() == 1) {
C.push_back(k);
} else if (k != C[n - 1]) {
C.push_back(k);
n++;
}
}
N = n;
dp[1] = 1;
sum[C[1]] = 1;
FOR(i, 2, N + 1) {
dp[i] = (dp[i - 1] + sum[C[i]]) % MOD;
sum[C[i]] = dp[i];
}
cout << dp[N] << endl;
} | insert | 35 | 35 | 35 | 39 | 0 | |
p03096 | C++ | Runtime Error | #include <iostream>
#include <vector>
using namespace std;
const int MOD = 1000000007;
int dp[100010];
vector<int> before(100010, -1); // ある色の直前の位置
int main() {
int n;
cin >> n;
vector<int> lc(n);
for (int i = 0; i < n; ++i) {
cin >> lc[i];
}
dp[0] = 1;
for (int i = 0; i < n; ++i) {
int c = lc[i];
int bi = before[c];
// cout << i << " " << lc[i] << " " << bi << endl;
dp[i + 1] = dp[i]; // 反転させない場合の数
before[c] = i;
if (bi == -1 || bi == i - 1)
continue;
dp[i + 1] += dp[bi + 1]; // 反転させる場合の数
dp[i + 1] %= MOD;
}
cout << dp[n] << endl;
}
| #include <iostream>
#include <vector>
using namespace std;
const int MOD = 1000000007;
int dp[200010];
vector<int> before(200010, -1); // ある色の直前の位置
int main() {
int n;
cin >> n;
vector<int> lc(n);
for (int i = 0; i < n; ++i) {
cin >> lc[i];
}
dp[0] = 1;
for (int i = 0; i < n; ++i) {
int c = lc[i];
int bi = before[c];
// cout << i << " " << lc[i] << " " << bi << endl;
dp[i + 1] = dp[i]; // 反転させない場合の数
before[c] = i;
if (bi == -1 || bi == i - 1)
continue;
dp[i + 1] += dp[bi + 1]; // 反転させる場合の数
dp[i + 1] %= MOD;
}
cout << dp[n] << endl;
}
| replace | 5 | 7 | 5 | 7 | 0 | |
p03096 | C++ | Runtime Error | #include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
const ll MOD = 1000000007;
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
vector<int> a;
for (int i = 0; i < n; ++i) {
int c;
cin >> c;
--c;
if (a.size() == 0)
a.push_back(c);
else if (a.back() != c)
a.push_back(c);
}
n = a.size();
vector<ll> dp(n);
vector<ll> przed(100000, 0);
for (int i = 0; i < n; ++i) {
if (przed[a[i]] == 0) {
if (i != 0)
dp[i] = dp[i - 1];
else
dp[i] = 1;
} else
dp[i] = (przed[a[i]] + dp[i - 1]) % MOD;
if (i != 0)
przed[a[i]] = (przed[a[i]] + dp[i - 1]) % MOD;
else
przed[a[i]] = 1;
}
cout << dp[n - 1];
return 0;
}
| #include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
const ll MOD = 1000000007;
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
vector<int> a;
for (int i = 0; i < n; ++i) {
int c;
cin >> c;
--c;
if (a.size() == 0)
a.push_back(c);
else if (a.back() != c)
a.push_back(c);
}
n = a.size();
vector<ll> dp(n);
vector<ll> przed(200000, 0);
for (int i = 0; i < n; ++i) {
if (przed[a[i]] == 0) {
if (i != 0)
dp[i] = dp[i - 1];
else
dp[i] = 1;
} else
dp[i] = (przed[a[i]] + dp[i - 1]) % MOD;
if (i != 0)
przed[a[i]] = (przed[a[i]] + dp[i - 1]) % MOD;
else
przed[a[i]] = 1;
}
cout << dp[n - 1];
return 0;
}
| replace | 25 | 26 | 25 | 26 | 0 | |
p03096 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define FOR(i, m, n) for (int(i) = (m); (i) < (n); (i)++)
#define All(v) (v).begin(), (v).end()
#define pb push_back
#define MP(a, b) make_pair((a), (b))
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
const int INF = 1 << 30;
const ll LINF = 1LL << 60;
const int MOD = 1e9 + 7;
template <uint_fast64_t MOD> class ModInt {
using u64 = uint_fast64_t;
public:
u64 a;
ModInt(const u64 x = 0) : a(x % MOD) {}
constexpr u64 &value() { return a; }
constexpr ModInt operator-() { return a ? MOD - a : 0; }
constexpr ModInt operator+(const ModInt rhs) { return ModInt(*this) += rhs; }
constexpr ModInt operator-(const ModInt rhs) { return ModInt(*this) -= rhs; }
constexpr ModInt operator*(const ModInt rhs) { return ModInt(*this) *= rhs; }
constexpr ModInt operator/(const ModInt rhs) { return ModInt(*this) /= rhs; }
constexpr ModInt &operator+=(const ModInt rhs) {
a += rhs.a;
if (a >= MOD) {
a -= MOD;
}
return *this;
}
constexpr ModInt &operator-=(const ModInt rhs) {
if (a < rhs.a) {
a += MOD;
}
a -= rhs.a;
return *this;
}
constexpr ModInt &operator*=(const ModInt rhs) {
a = a * rhs.a % MOD;
return *this;
}
constexpr ModInt &operator/=(const ModInt rhs) {
*this *= rhs.inv();
return *this;
}
constexpr bool operator==(const ModInt rhs) { return this->a == rhs.a; }
constexpr bool operator!=(const ModInt rhs) { return this->a != rhs.a; }
friend constexpr ostream &operator<<(ostream &os, const ModInt<MOD> &x) {
return os << x.a;
}
friend constexpr istream &operator>>(istream &is, ModInt<MOD> &x) {
return is >> x.a;
}
constexpr ModInt inv() {
u64 x = a, y = MOD, u = 1, v = 0, t = 0;
while (y > 0) {
t = x / y;
a -= t * y;
swap(x, y);
u -= t * v;
swap(u, v);
}
return ModInt(u);
}
constexpr ModInt pow(int e) {
u64 x = 1, p = a;
while (e > 0) {
if (e % 2 == 0) {
p = (p * p) % MOD;
e /= 2;
} else {
x = (x * p) % MOD;
e--;
}
}
return ModInt(x);
}
};
int main() {
using mint = ModInt<MOD>;
int N;
cin >> N;
vector<int> C(N);
rep(i, N) cin >> C[i];
vector<int> last(N + 1, -1);
vector<mint> dp(N + 1);
dp[0] = 1;
// dp[i]:=i個めまで使った時の通り数
for (int i = 0; i < N; i++) {
if (last[C[i]] != -1) {
if (last[C[i]] != i - 1)
dp[i + 1] = dp[i] + dp[last[C[i]] + 1];
else
dp[i + 1] = dp[i];
} else {
dp[i + 1] = dp[i];
}
last[C[i]] = i;
}
cout << dp[N] << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define FOR(i, m, n) for (int(i) = (m); (i) < (n); (i)++)
#define All(v) (v).begin(), (v).end()
#define pb push_back
#define MP(a, b) make_pair((a), (b))
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
const int INF = 1 << 30;
const ll LINF = 1LL << 60;
const int MOD = 1e9 + 7;
template <uint_fast64_t MOD> class ModInt {
using u64 = uint_fast64_t;
public:
u64 a;
ModInt(const u64 x = 0) : a(x % MOD) {}
constexpr u64 &value() { return a; }
constexpr ModInt operator-() { return a ? MOD - a : 0; }
constexpr ModInt operator+(const ModInt rhs) { return ModInt(*this) += rhs; }
constexpr ModInt operator-(const ModInt rhs) { return ModInt(*this) -= rhs; }
constexpr ModInt operator*(const ModInt rhs) { return ModInt(*this) *= rhs; }
constexpr ModInt operator/(const ModInt rhs) { return ModInt(*this) /= rhs; }
constexpr ModInt &operator+=(const ModInt rhs) {
a += rhs.a;
if (a >= MOD) {
a -= MOD;
}
return *this;
}
constexpr ModInt &operator-=(const ModInt rhs) {
if (a < rhs.a) {
a += MOD;
}
a -= rhs.a;
return *this;
}
constexpr ModInt &operator*=(const ModInt rhs) {
a = a * rhs.a % MOD;
return *this;
}
constexpr ModInt &operator/=(const ModInt rhs) {
*this *= rhs.inv();
return *this;
}
constexpr bool operator==(const ModInt rhs) { return this->a == rhs.a; }
constexpr bool operator!=(const ModInt rhs) { return this->a != rhs.a; }
friend constexpr ostream &operator<<(ostream &os, const ModInt<MOD> &x) {
return os << x.a;
}
friend constexpr istream &operator>>(istream &is, ModInt<MOD> &x) {
return is >> x.a;
}
constexpr ModInt inv() {
u64 x = a, y = MOD, u = 1, v = 0, t = 0;
while (y > 0) {
t = x / y;
a -= t * y;
swap(x, y);
u -= t * v;
swap(u, v);
}
return ModInt(u);
}
constexpr ModInt pow(int e) {
u64 x = 1, p = a;
while (e > 0) {
if (e % 2 == 0) {
p = (p * p) % MOD;
e /= 2;
} else {
x = (x * p) % MOD;
e--;
}
}
return ModInt(x);
}
};
int main() {
using mint = ModInt<MOD>;
int N;
cin >> N;
vector<int> C(N);
rep(i, N) cin >> C[i];
vector<int> last(200010, -1);
vector<mint> dp(N + 1);
dp[0] = 1;
// dp[i]:=i個めまで使った時の通り数
for (int i = 0; i < N; i++) {
if (last[C[i]] != -1) {
if (last[C[i]] != i - 1)
dp[i + 1] = dp[i] + dp[last[C[i]] + 1];
else
dp[i + 1] = dp[i];
} else {
dp[i + 1] = dp[i];
}
last[C[i]] = i;
}
cout << dp[N] << endl;
return 0;
} | replace | 103 | 104 | 103 | 104 | 0 | |
p03096 | C++ | Runtime Error | #include <cstdio>
#include <iostream>
using namespace std;
const int mod = 1e9 + 7;
int n, c[100010], lst[100010], f[100010];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i)
scanf("%d", &c[i]);
f[0] = 1;
for (int i = 1; i <= n; ++i) {
f[i] = f[i - 1];
if (lst[c[i]] && lst[c[i]] != i - 1)
(f[i] += f[lst[c[i]]]) %= mod;
lst[c[i]] = i;
}
printf("%d\n", f[n]);
return 0;
} | #include <cstdio>
#include <iostream>
using namespace std;
const int mod = 1e9 + 7;
int n, c[200010], lst[200010], f[200010];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i)
scanf("%d", &c[i]);
f[0] = 1;
for (int i = 1; i <= n; ++i) {
f[i] = f[i - 1];
if (lst[c[i]] && lst[c[i]] != i - 1)
(f[i] += f[lst[c[i]]]) %= mod;
lst[c[i]] = i;
}
printf("%d\n", f[n]);
return 0;
} | replace | 7 | 8 | 7 | 8 | 0 | |
p03096 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
const int md = 1e9 + 7;
inline void add(int &a, int b) {
a += b;
if (a >= md)
a -= md;
}
int main() {
int n;
cin >> n;
vector<int> c(n + 1);
c[0] = -1;
for (int i = 1; i <= n; i++) {
cin >> c[i];
c[i]--;
}
vector<int> dp(n + 1, 0), ep(n, 0);
dp[0] = 1;
for (int i = 1; i <= n; i++) {
int prv = c[i - 1];
int crr = c[i];
if (prv != crr)
add(ep[crr], dp[i - 1]);
dp[i] = ep[crr];
}
cout << dp[n] << '\n';
return 0;
} | #include <bits/stdc++.h>
using namespace std;
const int md = 1e9 + 7;
inline void add(int &a, int b) {
a += b;
if (a >= md)
a -= md;
}
int main() {
int n;
cin >> n;
vector<int> c(n + 1);
c[0] = -1;
for (int i = 1; i <= n; i++) {
cin >> c[i];
c[i]--;
}
vector<int> dp(n + 1, 0), ep(2e5, 0);
dp[0] = 1;
for (int i = 1; i <= n; i++) {
int prv = c[i - 1];
int crr = c[i];
if (prv != crr)
add(ep[crr], dp[i - 1]);
dp[i] = ep[crr];
}
cout << dp[n] << '\n';
return 0;
} | replace | 17 | 18 | 17 | 18 | 0 | |
p03096 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pll = pair<ll, ll>;
using pld = pair<ld, ld>;
const int INF = 1e9 + 7;
const ll LINF = 1LL << 60;
const ll MOD = 1e9 + 7;
const ld PI = acos(-1);
const ld EPS = 1e-9; // 微調整用（EPSより小さいと0と判定など）
#define gcd __gcd // llは受け取ってくれない
int lcm(int a, int b) { return a / gcd(a, b) * b; }
#define ALL(a) a.begin(), a.end() // sort(ALL(vec));
#define REP(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define rep(i, n) REP(i, 0, n)
#define MP(a, b) make_pair(a, b)
#define SORT_UNIQUE(c) \
(sort(c.begin(), c.end()), \
c.resize(distance(c.begin(), unique(c.begin(), c.end()))))
#define GET_POS(c, x) (lower_bound(c.begin(), c.end(), x) - c.begin())
#define PB push_back
#define SZ(x) ((int)(x).size) // size()がunsignedなのでエラー避けに
// 最大値、最小値を更新する。aよりbのが大きい（小さい）か等しければaを更新してtrueを返す。そうでなければ何もせずfalseを返す
// chmax(nowmax,x);
template <typename T> bool chmax(T &a, T b) { return (a = max(a, b)) == b; }
template <typename T> bool chmin(T &a, T b) { return (a = min(a, b)) == b; }
// ----- template end ---- //
// ------- library ------- //
// ----- library end ----- //
int main() {
int N;
cin >> N;
if (N <= 2) {
cout << 1 << endl;
return 0;
}
vector<ll> DP(N + 1, 1); // DP[0]を入れる必要があるので0-indexed
// color(0-indexed)が直前に登場した時の位置
//(色番号(.at())は0-indexedで、格納する位置は1-indexed)
vector<int> prev(N, -1);
int nowcolor;
REP(i, 1, N + 1) {
// iは1-indexed !!
cin >> nowcolor;
nowcolor -= 1;
if (prev.at(nowcolor) == -1) {
// 未登場なら前のDPを引き継ぐだけ
DP.at(i) = DP.at(i - 1);
} else if (prev.at(nowcolor) == i - 1) {
// 直前に出たばかりなら、やはり前のDPを引き継ぐだけ
DP.at(i) = DP.at(i - 1);
} else {
// 1つ以上前に出ていた場合、その時のDPも引き継ぐ
DP.at(i) = (DP.at(i - 1) + DP.at(prev.at(nowcolor))) % MOD;
}
prev.at(nowcolor) = i;
}
cout << DP.at(N) << endl;
// -- main() end -- //
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pll = pair<ll, ll>;
using pld = pair<ld, ld>;
const int INF = 1e9 + 7;
const ll LINF = 1LL << 60;
const ll MOD = 1e9 + 7;
const ld PI = acos(-1);
const ld EPS = 1e-9; // 微調整用（EPSより小さいと0と判定など）
#define gcd __gcd // llは受け取ってくれない
int lcm(int a, int b) { return a / gcd(a, b) * b; }
#define ALL(a) a.begin(), a.end() // sort(ALL(vec));
#define REP(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define rep(i, n) REP(i, 0, n)
#define MP(a, b) make_pair(a, b)
#define SORT_UNIQUE(c) \
(sort(c.begin(), c.end()), \
c.resize(distance(c.begin(), unique(c.begin(), c.end()))))
#define GET_POS(c, x) (lower_bound(c.begin(), c.end(), x) - c.begin())
#define PB push_back
#define SZ(x) ((int)(x).size) // size()がunsignedなのでエラー避けに
// 最大値、最小値を更新する。aよりbのが大きい（小さい）か等しければaを更新してtrueを返す。そうでなければ何もせずfalseを返す
// chmax(nowmax,x);
template <typename T> bool chmax(T &a, T b) { return (a = max(a, b)) == b; }
template <typename T> bool chmin(T &a, T b) { return (a = min(a, b)) == b; }
// ----- template end ---- //
// ------- library ------- //
// ----- library end ----- //
int main() {
int N;
cin >> N;
if (N <= 2) {
cout << 1 << endl;
return 0;
}
vector<ll> DP(N + 1, 1); // DP[0]を入れる必要があるので0-indexed
// color(0-indexed)が直前に登場した時の位置
//(色番号(.at())は0-indexedで、格納する位置は1-indexed)
vector<int> prev(200000, -1);
int nowcolor;
REP(i, 1, N + 1) {
// iは1-indexed !!
cin >> nowcolor;
nowcolor -= 1;
if (prev.at(nowcolor) == -1) {
// 未登場なら前のDPを引き継ぐだけ
DP.at(i) = DP.at(i - 1);
} else if (prev.at(nowcolor) == i - 1) {
// 直前に出たばかりなら、やはり前のDPを引き継ぐだけ
DP.at(i) = DP.at(i - 1);
} else {
// 1つ以上前に出ていた場合、その時のDPも引き継ぐ
DP.at(i) = (DP.at(i - 1) + DP.at(prev.at(nowcolor))) % MOD;
}
prev.at(nowcolor) = i;
}
cout << DP.at(N) << endl;
// -- main() end -- //
}
| replace | 50 | 51 | 50 | 51 | 0 | |
p03096 | C++ | Runtime Error | /* -*- coding: utf-8 -*-
*
* b.cc: B: Reversi
*/
#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 = 100000;
const int MAX_C = 100000;
const int MOD = 1000000007;
/* typedef */
/* global variables */
int cs[MAX_N], nxts[MAX_N], ps[MAX_C], dp[MAX_N + 1];
/* subroutines */
inline void addmod(int &a, int b) { a = (a + b) % MOD; }
/* main */
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++)
scanf("%d", cs + i), cs[i]--;
memset(nxts, -1, sizeof(nxts));
memset(ps, -1, sizeof(ps));
for (int i = n - 1; i >= 0; i--) {
int &pci = ps[cs[i]];
if (pci >= 0)
nxts[i] = pci;
pci = i;
}
dp[0] = 1;
for (int i = 0; i < n; i++) {
addmod(dp[i + 1], dp[i]);
if (nxts[i] > i + 1)
addmod(dp[nxts[i]], dp[i]);
}
printf("%d\n", dp[n]);
return 0;
}
| /* -*- coding: utf-8 -*-
*
* b.cc: B: Reversi
*/
#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 = 200000;
const int MAX_C = 200000;
const int MOD = 1000000007;
/* typedef */
/* global variables */
int cs[MAX_N], nxts[MAX_N], ps[MAX_C], dp[MAX_N + 1];
/* subroutines */
inline void addmod(int &a, int b) { a = (a + b) % MOD; }
/* main */
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++)
scanf("%d", cs + i), cs[i]--;
memset(nxts, -1, sizeof(nxts));
memset(ps, -1, sizeof(ps));
for (int i = n - 1; i >= 0; i--) {
int &pci = ps[cs[i]];
if (pci >= 0)
nxts[i] = pci;
pci = i;
}
dp[0] = 1;
for (int i = 0; i < n; i++) {
addmod(dp[i + 1], dp[i]);
if (nxts[i] > i + 1)
addmod(dp[nxts[i]], dp[i]);
}
printf("%d\n", dp[n]);
return 0;
}
| replace | 28 | 30 | 28 | 30 | 0 | |
p03096 | C++ | Runtime Error | #include "bits/stdc++.h"
using namespace std;
/////////////////// TYPES & MACROS ///////////////////////////////
#define mp make_pair
#define eb emplace_back
#define pb push_back
#define all(x) x.begin(), x.end()
#define ff first
#define ss second
#define vv vector
#define exist(s, e) (s.find(e) != s.end())
#define sz(x) ((int)(x).size())
#define int ll
#define el '\n'
typedef long long ll;
typedef long double ld;
typedef double dd;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const ll INFLL = 0x7f7f7f7f7f7f7f7f, MOD = 1e9 + 7;
const int INF = 0x7f7f7f7f;
/// if(///////////////// DEBUG /////////////////////////////////////////
#define D(x) cerr << #x << " is:\t" << x << '\n';
#define DD(x, y) \
cerr << '(' << #x << ',' << #y << ") are:\t" << x << ' ' << y << '\n';
#define DDD(x, y, z) \
cerr << '(' << #x << ',' << #y << ',' << #z << ") are:\t" << x << ' ' << y \
<< ' ' << z << '\n';
/////////////////// VARIABLES & FUNCTIONS//////////////////////////
vv<vv<int>> adj;
vi vis, color;
int dx8[] = {0, 1, 1, 1, 0, -1, -1, -1}, dy8[] = {1, 1, 0, -1, -1, -1, 0, 1},
dx4[] = {0, 1, 0, -1}, dy4[] = {1, 0, -1, 0};
inline ll mexp(ll x, ll n, ll m = MOD) {
ll res = 1;
x %= m;
while (n) {
if (n & 1)
res = (res * x) % m;
n >>= 1;
x = (x * x) % m;
}
return res;
}
inline ll gcd(ll a, ll b) {
while (a > 0 && b > 0) {
if (a > b)
a %= b;
else
b %= a;
}
return a + b;
}
///////////////////// MAIN STARTS //////////////////////////////////
int32_t main(void) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout << fixed;
cerr << fixed;
cout << setprecision(10);
cerr << setprecision(3);
mt19937 genr(chrono::high_resolution_clock::now().time_since_epoch().count());
const int NN = 1e5 + 10;
int n;
cin >> n;
vv<ll> c(NN, -1), dp(n + 1, 0);
dp[0] = 1;
for (int i = 1; i <= n; ++i) {
int t;
cin >> t;
if (c[t] != -1 && c[t] != i - 1) {
dp[i] = dp[c[t]];
}
c[t] = i;
dp[i] = (dp[i] + dp[i - 1]) % MOD;
}
cout << dp[n] << el;
return 0;
}
| #include "bits/stdc++.h"
using namespace std;
/////////////////// TYPES & MACROS ///////////////////////////////
#define mp make_pair
#define eb emplace_back
#define pb push_back
#define all(x) x.begin(), x.end()
#define ff first
#define ss second
#define vv vector
#define exist(s, e) (s.find(e) != s.end())
#define sz(x) ((int)(x).size())
#define int ll
#define el '\n'
typedef long long ll;
typedef long double ld;
typedef double dd;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const ll INFLL = 0x7f7f7f7f7f7f7f7f, MOD = 1e9 + 7;
const int INF = 0x7f7f7f7f;
/// if(///////////////// DEBUG /////////////////////////////////////////
#define D(x) cerr << #x << " is:\t" << x << '\n';
#define DD(x, y) \
cerr << '(' << #x << ',' << #y << ") are:\t" << x << ' ' << y << '\n';
#define DDD(x, y, z) \
cerr << '(' << #x << ',' << #y << ',' << #z << ") are:\t" << x << ' ' << y \
<< ' ' << z << '\n';
/////////////////// VARIABLES & FUNCTIONS//////////////////////////
vv<vv<int>> adj;
vi vis, color;
int dx8[] = {0, 1, 1, 1, 0, -1, -1, -1}, dy8[] = {1, 1, 0, -1, -1, -1, 0, 1},
dx4[] = {0, 1, 0, -1}, dy4[] = {1, 0, -1, 0};
inline ll mexp(ll x, ll n, ll m = MOD) {
ll res = 1;
x %= m;
while (n) {
if (n & 1)
res = (res * x) % m;
n >>= 1;
x = (x * x) % m;
}
return res;
}
inline ll gcd(ll a, ll b) {
while (a > 0 && b > 0) {
if (a > b)
a %= b;
else
b %= a;
}
return a + b;
}
///////////////////// MAIN STARTS //////////////////////////////////
int32_t main(void) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout << fixed;
cerr << fixed;
cout << setprecision(10);
cerr << setprecision(3);
mt19937 genr(chrono::high_resolution_clock::now().time_since_epoch().count());
const int NN = 3e5 + 10;
int n;
cin >> n;
vv<ll> c(NN, -1), dp(n + 1, 0);
dp[0] = 1;
for (int i = 1; i <= n; ++i) {
int t;
cin >> t;
if (c[t] != -1 && c[t] != i - 1) {
dp[i] = dp[c[t]];
}
c[t] = i;
dp[i] = (dp[i] + dp[i - 1]) % MOD;
}
cout << dp[n] << el;
return 0;
}
| replace | 66 | 67 | 66 | 67 | 0 | |
p03096 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007LL;
int main(int argc, char const *argv[]) {
int n;
cin >> n;
int c[n];
for (int i = 0; i < n; ++i) {
cin >> c[i];
}
long long ans[n], memo[100005] = {};
ans[0] = 1LL;
memo[c[0]] = 1LL;
for (int i = 1; i < n; ++i) {
ans[i] = ans[i - 1];
if (c[i] != c[i - 1]) {
ans[i] += memo[c[i]];
}
ans[i] %= mod;
memo[c[i]] = ans[i];
}
cout << ans[n - 1] << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007LL;
int main(int argc, char const *argv[]) {
int n;
cin >> n;
int c[n];
for (int i = 0; i < n; ++i) {
cin >> c[i];
}
long long ans[n + 5], memo[200005] = {};
ans[0] = 1LL;
memo[c[0]] = 1LL;
for (int i = 1; i < n; ++i) {
ans[i] = ans[i - 1];
if (c[i] != c[i - 1]) {
ans[i] += memo[c[i]];
}
ans[i] %= mod;
memo[c[i]] = ans[i];
}
cout << ans[n - 1] << endl;
return 0;
} | replace | 12 | 13 | 12 | 13 | 0 | |
p03096 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
typedef long long ll;
int main() {
ll N;
cin >> N;
vector<ll> C;
for (int i = 0; i < N; i++) {
int c;
cin >> c;
if (i == 0) {
C.emplace_back(c);
} else if (C.back() != c) {
C.emplace_back(c);
}
}
vector<ll> dp(200010, 0LL);
dp[0] = 1LL;
vector<ll> num(N + 1, 0);
for (int i = 0; i < C.size(); i++) {
dp[i] += num[C[i]];
dp[i] %= mod;
if (i == 0) {
num[C[i]] = 1LL;
} else {
num[C[i]] += dp[i - 1];
}
if (i > 0)
dp[i] += dp[i - 1];
dp[i] %= mod;
}
cout << dp[C.size() - 1] << endl;
} | #include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
typedef long long ll;
int main() {
ll N;
cin >> N;
vector<ll> C;
for (int i = 0; i < N; i++) {
int c;
cin >> c;
if (i == 0) {
C.emplace_back(c);
} else if (C.back() != c) {
C.emplace_back(c);
}
}
vector<ll> dp(200010, 0LL);
dp[0] = 1LL;
vector<ll> num(200010, 0);
for (int i = 0; i < C.size(); i++) {
dp[i] += num[C[i]];
dp[i] %= mod;
if (i == 0) {
num[C[i]] = 1LL;
} else {
num[C[i]] += dp[i - 1];
}
if (i > 0)
dp[i] += dp[i - 1];
dp[i] %= mod;
}
cout << dp[C.size() - 1] << endl;
} | replace | 19 | 20 | 19 | 20 | 0 | |
p03096 | C++ | Runtime Error | #include "bits/stdc++.h"
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long int ll;
typedef pair<ll, ll> P;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const int mod = 1000000007;
struct mint {
ll x;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return (*this) *= a.inv(); }
mint operator/(const mint a) const {
mint res(*this);
return res /= a;
}
bool operator==(const mint a) { return x == a.x; }
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<int> a(n);
rep(i, n) {
cin >> a[i];
--a[i];
}
vector<mint> ans(n + 1, 0);
ans[a[0]] = 1;
rep(i, n - 1) {
if (a[i] != a[i + 1])
ans[a[i + 1]] += ans[a[i]];
}
cout << ans[a[n - 1]].x << endl;
return 0;
}
| #include "bits/stdc++.h"
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long int ll;
typedef pair<ll, ll> P;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const int mod = 1000000007;
struct mint {
ll x;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return (*this) *= a.inv(); }
mint operator/(const mint a) const {
mint res(*this);
return res /= a;
}
bool operator==(const mint a) { return x == a.x; }
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<int> a(n);
rep(i, n) {
cin >> a[i];
--a[i];
}
vector<mint> ans(200005, 0);
ans[a[0]] = 1;
rep(i, n - 1) {
if (a[i] != a[i + 1])
ans[a[i + 1]] += ans[a[i]];
}
cout << ans[a[n - 1]].x << endl;
return 0;
}
| replace | 79 | 80 | 79 | 80 | 0 | |
p03096 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std::literals::string_literals;
using i64 = long long;
using std::cin;
using std::cout;
using std::endl;
int main() {
int n;
scanf("%d", &n);
std::vector<int> c(n);
for (int i = 0; i < n; i++) {
scanf("%d", &c[i]);
c[i]--;
}
const int M = 2e5 + 10;
std::vector<int> latte(n, -1);
std::vector<int> vec(M, -1);
for (int i = 0; i < n; i++) {
if (latte[c[i]] != -1 and latte[c[i]] + 1 != i) {
vec[latte[c[i]]] = i;
}
latte[c[i]] = i;
}
const int MOD = 1e9 + 7;
std::vector<int> dp(n + 1, 0);
dp[0] = 1;
for (int i = 0; i < n; i++) {
(dp[i + 1] += dp[i]) %= MOD;
if (vec[i] != -1)
(dp[vec[i]] += dp[i]) %= MOD;
}
printf("%d\n", dp[n]);
return 0;
}
| #include <bits/stdc++.h>
using namespace std::literals::string_literals;
using i64 = long long;
using std::cin;
using std::cout;
using std::endl;
int main() {
int n;
scanf("%d", &n);
std::vector<int> c(n);
for (int i = 0; i < n; i++) {
scanf("%d", &c[i]);
c[i]--;
}
const int M = 2e5 + 10;
std::vector<int> latte(M, -1);
std::vector<int> vec(n, -1);
for (int i = 0; i < n; i++) {
if (latte[c[i]] != -1 and latte[c[i]] + 1 != i) {
vec[latte[c[i]]] = i;
}
latte[c[i]] = i;
}
const int MOD = 1e9 + 7;
std::vector<int> dp(n + 1, 0);
dp[0] = 1;
for (int i = 0; i < n; i++) {
(dp[i + 1] += dp[i]) %= MOD;
if (vec[i] != -1)
(dp[vec[i]] += dp[i]) %= MOD;
}
printf("%d\n", dp[n]);
return 0;
}
| replace | 18 | 20 | 18 | 20 | 0 | |
p03096 | C++ | Runtime Error | #include <iostream>
#include <vector>
using namespace std;
int N;
int mod = 1e9 + 7;
int main() {
cin >> N;
vector<long long> dp(N + 1, 1);
vector<int> p(N + 1, -1); // p[i]: 最後の色iの位置
int c;
cin >> c;
p[c] = 1;
dp[0] = 1;
for (int i = 1; i < N; i++) {
cin >> c;
dp[i] = dp[i - 1];
if (p[c] > 0 && p[c] != i) {
dp[i] += dp[p[c] - 1];
dp[i] %= mod;
}
p[c] = i + 1;
}
cout << dp[N - 1] << endl;
}
| #include <iostream>
#include <vector>
using namespace std;
int N;
int mod = 1e9 + 7;
int main() {
cin >> N;
vector<long long> dp(N + 1, 1);
vector<int> p(2e5 + 1, -1); // p[i]: 最後の色iの位置
int c;
cin >> c;
p[c] = 1;
dp[0] = 1;
for (int i = 1; i < N; i++) {
cin >> c;
dp[i] = dp[i - 1];
if (p[c] > 0 && p[c] != i) {
dp[i] += dp[p[c] - 1];
dp[i] %= mod;
}
p[c] = i + 1;
}
cout << dp[N - 1] << endl;
}
| replace | 10 | 11 | 10 | 11 | 0 | |
p03096 | C++ | Runtime Error | #include <bits/stdc++.h>
#include <stdio.h>
#define FOR(i, n) for (lli i = 0; i < (lli)(n); ++i)
#define FORU(i, j, k) for (lli i = (j); i <= (lli)(k); ++i)
#define FORD(i, j, k) for (lli i = (j); i >= (lli)(k); --i)
#define SQ(x) ((x) * (x))
#define all(x) begin(x), end(x)
#define rall(x) rbegin(x), rend(x)
#define mp make_pair
#define mt make_tuple
#define pb push_back
#define eb emplace_back
using namespace std;
template <typename... As> struct tpl : public std::tuple<As...> {
using std::tuple<As...>::tuple;
tpl() {}
tpl(std::tuple<As...> const &b) { std::tuple<As...>::operator=(b); }
template <typename T = tuple<As...>>
typename tuple_element<0, T>::type const &x() const {
return get<0>(*this);
}
template <typename T = tuple<As...>> typename tuple_element<0, T>::type &x() {
return get<0>(*this);
}
template <typename T = tuple<As...>>
typename tuple_element<1, T>::type const &y() const {
return get<1>(*this);
}
template <typename T = tuple<As...>> typename tuple_element<1, T>::type &y() {
return get<1>(*this);
}
template <typename T = tuple<As...>>
typename tuple_element<2, T>::type const &z() const {
return get<2>(*this);
}
template <typename T = tuple<As...>> typename tuple_element<2, T>::type &z() {
return get<2>(*this);
}
template <typename T = tuple<As...>>
typename tuple_element<3, T>::type const &w() const {
return get<3>(*this);
}
template <typename T = tuple<As...>> typename tuple_element<3, T>::type &w() {
return get<3>(*this);
}
};
using lli = long long int;
using llu = long long unsigned;
using pii = tpl<lli, lli>;
using piii = tpl<lli, lli, lli>;
using piiii = tpl<lli, lli, lli, lli>;
using vi = vector<lli>;
using vii = vector<pii>;
using viii = vector<piii>;
using vvi = vector<vi>;
using vvii = vector<vii>;
using vviii = vector<viii>;
template <class T> using min_queue = priority_queue<T, vector<T>, greater<T>>;
template <class T> using max_queue = priority_queue<T>;
template <size_t... I> struct my_index_sequence {
using type = my_index_sequence;
static constexpr array<size_t, sizeof...(I)> value = {{I...}};
};
namespace my_index_sequence_detail {
template <typename I, typename J> struct concat;
template <size_t... I, size_t... J>
struct concat<my_index_sequence<I...>, my_index_sequence<J...>>
: my_index_sequence<I..., (sizeof...(I) + J)...> {};
template <size_t N>
struct make_index_sequence
: concat<typename make_index_sequence<N / 2>::type,
typename make_index_sequence<N - N / 2>::type>::type {};
template <> struct make_index_sequence<0> : my_index_sequence<> {};
template <> struct make_index_sequence<1> : my_index_sequence<0> {};
} // namespace my_index_sequence_detail
template <class... A>
using my_index_sequence_for =
typename my_index_sequence_detail::make_index_sequence<sizeof...(A)>::type;
template <class T, size_t... I>
void print_tuple(ostream &s, T const &a, my_index_sequence<I...>) {
using swallow = int[];
(void)swallow{0, (void(s << (I == 0 ? "" : ", ") << get<I>(a)), 0)...};
}
template <class T> ostream &print_collection(ostream &s, T const &a);
template <class... A> ostream &operator<<(ostream &s, tpl<A...> const &a);
template <class... A> ostream &operator<<(ostream &s, tuple<A...> const &a);
template <class A, class B>
ostream &operator<<(ostream &s, pair<A, B> const &a);
template <class T, size_t I>
ostream &operator<<(ostream &s, array<T, I> const &a) {
return print_collection(s, a);
}
template <class T> ostream &operator<<(ostream &s, vector<T> const &a) {
return print_collection(s, a);
}
template <class T, class U>
ostream &operator<<(ostream &s, multimap<T, U> const &a) {
return print_collection(s, a);
}
template <class T> ostream &operator<<(ostream &s, multiset<T> const &a) {
return print_collection(s, a);
}
template <class T, class U>
ostream &operator<<(ostream &s, map<T, U> const &a) {
return print_collection(s, a);
}
template <class T> ostream &operator<<(ostream &s, set<T> const &a) {
return print_collection(s, a);
}
template <class T> ostream &print_collection(ostream &s, T const &a) {
s << '[';
for (auto it = begin(a); it != end(a); ++it) {
s << *it;
if (it != prev(end(a)))
s << " ";
}
return s << ']';
}
template <class... A> ostream &operator<<(ostream &s, tpl<A...> const &a) {
s << '(';
print_tuple(s, a, my_index_sequence_for<A...>{});
return s << ')';
}
template <class... A> ostream &operator<<(ostream &s, tuple<A...> const &a) {
s << '(';
print_tuple(s, a, my_index_sequence_for<A...>{});
return s << ')';
}
template <class A, class B>
ostream &operator<<(ostream &s, pair<A, B> const &a) {
return s << "(" << get<0>(a) << ", " << get<1>(a) << ")";
}
//------------------------------------------------------------------------------
// --- BEGIN SNIPPET MODULAR ---
const lli MOD = 1e9 + 7;
inline lli fexp(lli a, lli b, lli m = MOD) {
lli r = 1;
while (b) {
if (b & 1)
r = (r * a) % m;
a = (a * a) % m;
b /= 2;
}
return r;
}
inline lli invmod(lli a, lli m = MOD) { return fexp(a, m - 2, m); }
lli nmod(lli x) { return (x % MOD + MOD) % MOD; }
struct Zn {
lli x;
Zn(lli x_) : x(x_) {
x %= MOD;
if (x < 0)
x = (x + MOD) % MOD;
}
Zn operator+(Zn const &o) const { return Zn(x + o.x); }
Zn operator-(Zn const &o) const { return Zn(x - o.x); }
Zn operator*(Zn const &o) const { return Zn(x * o.x); }
Zn &operator+=(Zn const &o) { return *this = *this + o; }
Zn &operator-=(Zn const &o) { return *this = *this - o; }
Zn &operator*=(Zn const &o) { return *this = *this * o; }
};
pii egcd(lli a, lli b) {
if (a % b == 0) {
return mt(0, 1);
} else {
pii p = egcd(b, a % b);
int u = p.x(), v = p.y();
return mt(v, u - (a / b) * v);
}
}
// solve x*a = b [mod m]
int solveInv(lli a, lli b, lli m) {
if (b == 0)
return 0;
pii p = egcd(a, m);
lli g = __gcd(m, a);
return (((b / g) * p.x()) % m + m) % m;
}
// --- END SNIPPET MODULAR ---
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vi C(n);
FOR(i, n) cin >> C[i];
vi A(n, 0);
vi last(n + 16, -1);
vi right(n + 16, -1);
FORD(i, n - 1, 0) {
if (last[C[i]] != -1) {
right[i] = last[C[i]];
}
last[C[i]] = i;
}
lli cur = 1;
FOR(i, n) {
(cur += A[i]) %= MOD;
if (right[i] != -1 && right[i] != i + 1)
(A[right[i]] += cur) %= MOD;
}
cout << cur << endl;
return 0;
}
| #include <bits/stdc++.h>
#include <stdio.h>
#define FOR(i, n) for (lli i = 0; i < (lli)(n); ++i)
#define FORU(i, j, k) for (lli i = (j); i <= (lli)(k); ++i)
#define FORD(i, j, k) for (lli i = (j); i >= (lli)(k); --i)
#define SQ(x) ((x) * (x))
#define all(x) begin(x), end(x)
#define rall(x) rbegin(x), rend(x)
#define mp make_pair
#define mt make_tuple
#define pb push_back
#define eb emplace_back
using namespace std;
template <typename... As> struct tpl : public std::tuple<As...> {
using std::tuple<As...>::tuple;
tpl() {}
tpl(std::tuple<As...> const &b) { std::tuple<As...>::operator=(b); }
template <typename T = tuple<As...>>
typename tuple_element<0, T>::type const &x() const {
return get<0>(*this);
}
template <typename T = tuple<As...>> typename tuple_element<0, T>::type &x() {
return get<0>(*this);
}
template <typename T = tuple<As...>>
typename tuple_element<1, T>::type const &y() const {
return get<1>(*this);
}
template <typename T = tuple<As...>> typename tuple_element<1, T>::type &y() {
return get<1>(*this);
}
template <typename T = tuple<As...>>
typename tuple_element<2, T>::type const &z() const {
return get<2>(*this);
}
template <typename T = tuple<As...>> typename tuple_element<2, T>::type &z() {
return get<2>(*this);
}
template <typename T = tuple<As...>>
typename tuple_element<3, T>::type const &w() const {
return get<3>(*this);
}
template <typename T = tuple<As...>> typename tuple_element<3, T>::type &w() {
return get<3>(*this);
}
};
using lli = long long int;
using llu = long long unsigned;
using pii = tpl<lli, lli>;
using piii = tpl<lli, lli, lli>;
using piiii = tpl<lli, lli, lli, lli>;
using vi = vector<lli>;
using vii = vector<pii>;
using viii = vector<piii>;
using vvi = vector<vi>;
using vvii = vector<vii>;
using vviii = vector<viii>;
template <class T> using min_queue = priority_queue<T, vector<T>, greater<T>>;
template <class T> using max_queue = priority_queue<T>;
template <size_t... I> struct my_index_sequence {
using type = my_index_sequence;
static constexpr array<size_t, sizeof...(I)> value = {{I...}};
};
namespace my_index_sequence_detail {
template <typename I, typename J> struct concat;
template <size_t... I, size_t... J>
struct concat<my_index_sequence<I...>, my_index_sequence<J...>>
: my_index_sequence<I..., (sizeof...(I) + J)...> {};
template <size_t N>
struct make_index_sequence
: concat<typename make_index_sequence<N / 2>::type,
typename make_index_sequence<N - N / 2>::type>::type {};
template <> struct make_index_sequence<0> : my_index_sequence<> {};
template <> struct make_index_sequence<1> : my_index_sequence<0> {};
} // namespace my_index_sequence_detail
template <class... A>
using my_index_sequence_for =
typename my_index_sequence_detail::make_index_sequence<sizeof...(A)>::type;
template <class T, size_t... I>
void print_tuple(ostream &s, T const &a, my_index_sequence<I...>) {
using swallow = int[];
(void)swallow{0, (void(s << (I == 0 ? "" : ", ") << get<I>(a)), 0)...};
}
template <class T> ostream &print_collection(ostream &s, T const &a);
template <class... A> ostream &operator<<(ostream &s, tpl<A...> const &a);
template <class... A> ostream &operator<<(ostream &s, tuple<A...> const &a);
template <class A, class B>
ostream &operator<<(ostream &s, pair<A, B> const &a);
template <class T, size_t I>
ostream &operator<<(ostream &s, array<T, I> const &a) {
return print_collection(s, a);
}
template <class T> ostream &operator<<(ostream &s, vector<T> const &a) {
return print_collection(s, a);
}
template <class T, class U>
ostream &operator<<(ostream &s, multimap<T, U> const &a) {
return print_collection(s, a);
}
template <class T> ostream &operator<<(ostream &s, multiset<T> const &a) {
return print_collection(s, a);
}
template <class T, class U>
ostream &operator<<(ostream &s, map<T, U> const &a) {
return print_collection(s, a);
}
template <class T> ostream &operator<<(ostream &s, set<T> const &a) {
return print_collection(s, a);
}
template <class T> ostream &print_collection(ostream &s, T const &a) {
s << '[';
for (auto it = begin(a); it != end(a); ++it) {
s << *it;
if (it != prev(end(a)))
s << " ";
}
return s << ']';
}
template <class... A> ostream &operator<<(ostream &s, tpl<A...> const &a) {
s << '(';
print_tuple(s, a, my_index_sequence_for<A...>{});
return s << ')';
}
template <class... A> ostream &operator<<(ostream &s, tuple<A...> const &a) {
s << '(';
print_tuple(s, a, my_index_sequence_for<A...>{});
return s << ')';
}
template <class A, class B>
ostream &operator<<(ostream &s, pair<A, B> const &a) {
return s << "(" << get<0>(a) << ", " << get<1>(a) << ")";
}
//------------------------------------------------------------------------------
// --- BEGIN SNIPPET MODULAR ---
const lli MOD = 1e9 + 7;
inline lli fexp(lli a, lli b, lli m = MOD) {
lli r = 1;
while (b) {
if (b & 1)
r = (r * a) % m;
a = (a * a) % m;
b /= 2;
}
return r;
}
inline lli invmod(lli a, lli m = MOD) { return fexp(a, m - 2, m); }
lli nmod(lli x) { return (x % MOD + MOD) % MOD; }
struct Zn {
lli x;
Zn(lli x_) : x(x_) {
x %= MOD;
if (x < 0)
x = (x + MOD) % MOD;
}
Zn operator+(Zn const &o) const { return Zn(x + o.x); }
Zn operator-(Zn const &o) const { return Zn(x - o.x); }
Zn operator*(Zn const &o) const { return Zn(x * o.x); }
Zn &operator+=(Zn const &o) { return *this = *this + o; }
Zn &operator-=(Zn const &o) { return *this = *this - o; }
Zn &operator*=(Zn const &o) { return *this = *this * o; }
};
pii egcd(lli a, lli b) {
if (a % b == 0) {
return mt(0, 1);
} else {
pii p = egcd(b, a % b);
int u = p.x(), v = p.y();
return mt(v, u - (a / b) * v);
}
}
// solve x*a = b [mod m]
int solveInv(lli a, lli b, lli m) {
if (b == 0)
return 0;
pii p = egcd(a, m);
lli g = __gcd(m, a);
return (((b / g) * p.x()) % m + m) % m;
}
// --- END SNIPPET MODULAR ---
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vi C(n);
FOR(i, n) cin >> C[i];
vi A(n, 0);
vi last(3e5, -1);
vi right(3e5, -1);
FORD(i, n - 1, 0) {
if (last[C[i]] != -1) {
right[i] = last[C[i]];
}
last[C[i]] = i;
}
lli cur = 1;
FOR(i, n) {
(cur += A[i]) %= MOD;
if (right[i] != -1 && right[i] != i + 1)
(A[right[i]] += cur) %= MOD;
}
cout << cur << endl;
return 0;
}
| replace | 222 | 224 | 222 | 224 | 0 | |
p03096 | C++ | Runtime Error | #include <bits/stdc++.h>
#define M 100005
using namespace std;
const int mod = 1e9 + 7;
int n, c[M];
int dp[M], val[M];
void Add(int &x, int y) {
x += y;
if (x >= mod)
x -= mod;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d", &c[i]);
dp[0] = 1;
c[0] = -1;
for (int i = 1; i <= n; i++) {
if (c[i] != c[i - 1])
Add(val[c[i]], dp[i - 1]);
Add(dp[i], val[c[i]]);
}
printf("%d\n", dp[n]);
return 0;
} | #include <bits/stdc++.h>
#define M 200005
using namespace std;
const int mod = 1e9 + 7;
int n, c[M];
int dp[M], val[M];
void Add(int &x, int y) {
x += y;
if (x >= mod)
x -= mod;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d", &c[i]);
dp[0] = 1;
c[0] = -1;
for (int i = 1; i <= n; i++) {
if (c[i] != c[i - 1])
Add(val[c[i]], dp[i - 1]);
Add(dp[i], val[c[i]]);
}
printf("%d\n", dp[n]);
return 0;
} | replace | 1 | 2 | 1 | 2 | 0 | |
p03096 | C++ | Runtime Error | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#define x first
#define y second
#define bug(x) cerr << #x << '=' << x << ' '
#define debug(x) cerr << #x << '=' << x << '\n'
#define FOR(a, b, c) for (int a = (b), a##_end = (c); a <= a##_end; ++a)
#define ROF(a, b, c) for (int a = (b), a##_end = (c); a >= a##_end; --a)
using namespace std;
typedef long long ll;
typedef pair<int, int> PII;
const int INF = 0x3f3f3f3f, N = 1e5 + 10, P = 1e9 + 7;
template <class T> inline bool chkmin(T &A, const T &B) {
return B < A ? A = B, 1 : 0;
}
template <class T> inline bool chkmax(T &A, const T &B) {
return A < B ? A = B, 1 : 0;
}
int dp[N], nxt[N], n;
int now[N], A[N];
int main() {
scanf("%d", &n);
FOR(i, 1, n) scanf("%d", &A[i]);
ROF(i, n, 1) {
nxt[i] = now[A[i]];
now[A[i]] = i;
}
dp[1] = 1;
FOR(i, 1, n - 1) {
if (nxt[i] != i + 1)
dp[nxt[i]] = (dp[nxt[i]] + dp[i]) % P;
dp[i + 1] = (dp[i + 1] + dp[i]) % P;
}
printf("%d\n", dp[n]);
return 0;
} | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#define x first
#define y second
#define bug(x) cerr << #x << '=' << x << ' '
#define debug(x) cerr << #x << '=' << x << '\n'
#define FOR(a, b, c) for (int a = (b), a##_end = (c); a <= a##_end; ++a)
#define ROF(a, b, c) for (int a = (b), a##_end = (c); a >= a##_end; --a)
using namespace std;
typedef long long ll;
typedef pair<int, int> PII;
const int INF = 0x3f3f3f3f, N = 2e5 + 10, P = 1e9 + 7;
template <class T> inline bool chkmin(T &A, const T &B) {
return B < A ? A = B, 1 : 0;
}
template <class T> inline bool chkmax(T &A, const T &B) {
return A < B ? A = B, 1 : 0;
}
int dp[N], nxt[N], n;
int now[N], A[N];
int main() {
scanf("%d", &n);
FOR(i, 1, n) scanf("%d", &A[i]);
ROF(i, n, 1) {
nxt[i] = now[A[i]];
now[A[i]] = i;
}
dp[1] = 1;
FOR(i, 1, n - 1) {
if (nxt[i] != i + 1)
dp[nxt[i]] = (dp[nxt[i]] + dp[i]) % P;
dp[i + 1] = (dp[i + 1] + dp[i]) % P;
}
printf("%d\n", dp[n]);
return 0;
} | replace | 13 | 14 | 13 | 14 | 0 | |
p03096 | C++ | Runtime Error | // 高知能系Vtuberの高井茅乃です。
// Twitter: https://twitter.com/takaichino
// YouTube: https://www.youtube.com/channel/UCTOxnI3eOI_o1HRgzq-LEZw
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define INTINF 1999999999
#define REP(i, n) for (int i = 0; i < n; i++)
#define REP1(i, n) for (int i = 1; i <= n; i++)
#define MODA 1000000007
// つねに10億7などの剰余をとる構造体
// 参考: https://www.youtube.com/watch?v=L8grWxBlIZ4&t=9858
// 参考:
// https://qiita.com/drken/items/3b4fdf0a78e7a138cd9a#4-%E7%B4%AF%E4%B9%97-an
int mod = MODA;
struct modint {
ll x;
modint(ll x) : x(x % mod) {}
modint &operator+=(const modint a) {
(x += a.x) %= mod;
return *this;
}
modint &operator-=(const modint a) {
(x -= a.x) %= mod;
if (x < 0)
x += mod;
return *this;
}
modint &operator*=(const modint a) {
(x *= a.x) %= mod;
return *this;
}
modint &operator/=(modint a) {
ll exp = mod - 2;
while (exp > 0) {
if (exp & 1)
*this *= a.x;
a *= a.x;
exp >>= 1;
}
return *this;
}
modint operator+(const modint a) const {
modint res(*this);
return res += a;
}
modint operator-(const modint a) const {
modint res(*this);
return res -= a;
}
modint operator*(const modint a) const {
modint res(*this);
return res *= a;
}
modint operator/(const modint a) const {
modint res(*this);
return res /= a;
}
};
modint modpow(modint x, ll n) {
modint res = 1;
while (n > 0) {
if (n & 1)
res = res * x.x;
x = x * x;
n >>= 1;
}
return res;
}
int main() {
modint ans = 1;
int tmp;
int n;
cin >> n;
vector<pair<int, ll>> lo(n + 1);
REP(i, n + 1) lo[i] = make_pair(-1, (ll)0);
int prec = 0, c;
REP(i, n) {
cin >> c;
if (lo[c].first != i - 1 && lo[c].first != -1)
ans += lo[c].second;
lo[c] = make_pair(i, ans.x);
}
cout << ans.x << endl;
} | // 高知能系Vtuberの高井茅乃です。
// Twitter: https://twitter.com/takaichino
// YouTube: https://www.youtube.com/channel/UCTOxnI3eOI_o1HRgzq-LEZw
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define INTINF 1999999999
#define REP(i, n) for (int i = 0; i < n; i++)
#define REP1(i, n) for (int i = 1; i <= n; i++)
#define MODA 1000000007
// つねに10億7などの剰余をとる構造体
// 参考: https://www.youtube.com/watch?v=L8grWxBlIZ4&t=9858
// 参考:
// https://qiita.com/drken/items/3b4fdf0a78e7a138cd9a#4-%E7%B4%AF%E4%B9%97-an
int mod = MODA;
struct modint {
ll x;
modint(ll x) : x(x % mod) {}
modint &operator+=(const modint a) {
(x += a.x) %= mod;
return *this;
}
modint &operator-=(const modint a) {
(x -= a.x) %= mod;
if (x < 0)
x += mod;
return *this;
}
modint &operator*=(const modint a) {
(x *= a.x) %= mod;
return *this;
}
modint &operator/=(modint a) {
ll exp = mod - 2;
while (exp > 0) {
if (exp & 1)
*this *= a.x;
a *= a.x;
exp >>= 1;
}
return *this;
}
modint operator+(const modint a) const {
modint res(*this);
return res += a;
}
modint operator-(const modint a) const {
modint res(*this);
return res -= a;
}
modint operator*(const modint a) const {
modint res(*this);
return res *= a;
}
modint operator/(const modint a) const {
modint res(*this);
return res /= a;
}
};
modint modpow(modint x, ll n) {
modint res = 1;
while (n > 0) {
if (n & 1)
res = res * x.x;
x = x * x;
n >>= 1;
}
return res;
}
int main() {
modint ans = 1;
int tmp;
int n;
cin >> n;
vector<pair<int, ll>> lo(200001);
REP(i, 200001) lo[i] = make_pair(-1, (ll)0);
int prec = 0, c;
REP(i, n) {
cin >> c;
if (lo[c].first != i - 1 && lo[c].first != -1)
ans += lo[c].second;
lo[c] = make_pair(i, ans.x);
}
cout << ans.x << endl;
} | replace | 78 | 80 | 78 | 80 | 0 | |
p03096 | C++ | Time Limit Exceeded | #include "bits/stdc++.h"
using namespace std;
using ll = int64_t;
constexpr ll MOD = 1e9 + 7;
vector<ll> pos[200001];
ll N;
vector<ll> C;
vector<ll> memo;
ll solve(ll left) {
if (left >= N) {
return 1;
}
if (memo[left] != -1) {
return memo[left];
}
ll next = *upper_bound(pos[C[left]].begin(), pos[C[left]].end(), left);
ll ans;
if (next == left + 1) {
ans = solve(next);
} else if (next >= N) {
ans = solve(left + 1);
} else {
ans = (solve(next) + solve(left + 1)) % MOD;
}
return ans;
}
int main() {
cin >> N;
C.resize(N);
memo.resize(N, -1);
for (ll i = 0; i < N; i++) {
cin >> C[i];
pos[C[i]].push_back(i);
}
for (ll i = 1; i <= 200000; i++) {
pos[i].push_back(N);
}
cout << solve(0) << endl;
} | #include "bits/stdc++.h"
using namespace std;
using ll = int64_t;
constexpr ll MOD = 1e9 + 7;
vector<ll> pos[200001];
ll N;
vector<ll> C;
vector<ll> memo;
ll solve(ll left) {
if (left >= N) {
return 1;
}
if (memo[left] != -1) {
return memo[left];
}
ll next = *upper_bound(pos[C[left]].begin(), pos[C[left]].end(), left);
ll ans;
if (next == left + 1) {
ans = solve(next);
} else if (next >= N) {
ans = solve(left + 1);
} else {
ans = (solve(next) + solve(left + 1)) % MOD;
}
return memo[left] = ans;
}
int main() {
cin >> N;
C.resize(N);
memo.resize(N, -1);
for (ll i = 0; i < N; i++) {
cin >> C[i];
pos[C[i]].push_back(i);
}
for (ll i = 1; i <= 200000; i++) {
pos[i].push_back(N);
}
cout << solve(0) << endl;
} | replace | 31 | 32 | 31 | 32 | TLE | |
p03096 | C++ | Runtime Error | #include <bits/stdc++.h>
#define int long long
#define endl '\n'
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define bug1(x) \
{ cerr << (#x) << "=" << x << endl; }
#define bug2(x, y) \
{ cerr << (#x) << "=" << (x) << " " << (#y) << "=" << (y) << endl; }
#define bug3(x, y, z) \
{ \
cerr << (#x) << "=" << (x) << " " << (#y) << "=" << (y) << " " \
<< (#z) << "=" << (z) << endl; \
}
#define bug4(x, y, z, w) \
{ \
cerr << (#x) << "=" << (x) << " " << (#y) << "=" << (y) << " " \
<< (#z) << "=" << (z) << " " << (#w) << "=" << w << endl; \
}
#define bug5(x, y, z, w, p) \
{ \
cerr << (#x) << "=" << (x) << " " << (#y) << "=" << (y) << " " \
<< (#z) << "=" << (z) << " " << (#w) << "=" << w << " " << (#p) \
<< "=" << p << endl; \
}
#define bug6(x, y, z, w, p, q) \
{ \
cerr << (#x) << "=" << (x) << " " << (#y) << "=" << (y) << " " \
<< (#z) << "=" << (z) << " " << (#w) << "=" << w << " " << (#p) \
<< "=" << p << " " << (#q) << "=" << q << endl; \
}
#define bugn(x, n) \
{ \
cerr << (#x) << ":"; \
for (int i = 0; i < n; i++) \
cerr << x[i] << " "; \
cerr << endl; \
}
#define bugnm(x, n, m) \
{ \
cerr << (#x) << endl; \
for (int i = 0; i < n; i++) { \
cerr << "Row #" << i << ":"; \
for (int j = 0; j < m; j++) \
cerr << x[i][j] << " "; \
cerr << endl; \
} \
}
typedef long long ll;
typedef long double ld;
using namespace std;
#define next _
const int maxn = 1e5 + 10, mod = 1e9 + 7;
vector<int> a(maxn), dp(maxn), next(maxn), mp(maxn);
int n;
int32_t main() {
IOS cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = n; i >= 1; i--) {
if (mp[a[i]]) {
next[i] = mp[a[i]];
}
mp[a[i]] = i;
}
dp[n] = 1;
for (int i = n - 1; i >= 1; i--) {
dp[i] += dp[i + 1];
if (next[i] && next[i] != i + 1) {
dp[i] += dp[next[i]];
}
dp[i] %= mod;
}
cout << dp[1];
}
/*
* long long or int?
* index out of bound?
* Tested on own test case?corner?
* Make more general solution.
* Read Read Read Read ....
*/
| #include <bits/stdc++.h>
#define int long long
#define endl '\n'
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define bug1(x) \
{ cerr << (#x) << "=" << x << endl; }
#define bug2(x, y) \
{ cerr << (#x) << "=" << (x) << " " << (#y) << "=" << (y) << endl; }
#define bug3(x, y, z) \
{ \
cerr << (#x) << "=" << (x) << " " << (#y) << "=" << (y) << " " \
<< (#z) << "=" << (z) << endl; \
}
#define bug4(x, y, z, w) \
{ \
cerr << (#x) << "=" << (x) << " " << (#y) << "=" << (y) << " " \
<< (#z) << "=" << (z) << " " << (#w) << "=" << w << endl; \
}
#define bug5(x, y, z, w, p) \
{ \
cerr << (#x) << "=" << (x) << " " << (#y) << "=" << (y) << " " \
<< (#z) << "=" << (z) << " " << (#w) << "=" << w << " " << (#p) \
<< "=" << p << endl; \
}
#define bug6(x, y, z, w, p, q) \
{ \
cerr << (#x) << "=" << (x) << " " << (#y) << "=" << (y) << " " \
<< (#z) << "=" << (z) << " " << (#w) << "=" << w << " " << (#p) \
<< "=" << p << " " << (#q) << "=" << q << endl; \
}
#define bugn(x, n) \
{ \
cerr << (#x) << ":"; \
for (int i = 0; i < n; i++) \
cerr << x[i] << " "; \
cerr << endl; \
}
#define bugnm(x, n, m) \
{ \
cerr << (#x) << endl; \
for (int i = 0; i < n; i++) { \
cerr << "Row #" << i << ":"; \
for (int j = 0; j < m; j++) \
cerr << x[i][j] << " "; \
cerr << endl; \
} \
}
typedef long long ll;
typedef long double ld;
using namespace std;
#define next _
const int maxn = 2e5 + 10, mod = 1e9 + 7;
vector<int> a(maxn), dp(maxn), next(maxn), mp(maxn);
int n;
int32_t main() {
IOS cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = n; i >= 1; i--) {
if (mp[a[i]]) {
next[i] = mp[a[i]];
}
mp[a[i]] = i;
}
dp[n] = 1;
for (int i = n - 1; i >= 1; i--) {
dp[i] += dp[i + 1];
if (next[i] && next[i] != i + 1) {
dp[i] += dp[next[i]];
}
dp[i] %= mod;
}
cout << dp[1];
}
/*
* long long or int?
* index out of bound?
* Tested on own test case?corner?
* Make more general solution.
* Read Read Read Read ....
*/
| replace | 55 | 56 | 55 | 56 | 0 | |
p03096 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
using namespace std;
typedef long long int LL;
typedef pair<int, int> P;
typedef pair<int, pair<int, int>> PP;
typedef pair<LL, int> LP;
const int INF = 1 << 30;
const LL MAX = 1e9 + 7;
void array_show(int *a, int n) {
for (int i = 0; i < n; i++)
printf("%d%c", a[i], (i != n - 1 ? ' ' : '\n'));
}
void array_show(LL *a, int n) {
for (int i = 0; i < n; i++)
printf("%lld%c", a[i], (i != n - 1 ? ' ' : '\n'));
}
vector<int> v1;
LL num[100005];
int main() {
int n;
int i, j, k;
LL a, b, c;
cin >> n;
for (i = 0, a = -1; i < n; i++) {
cin >> b;
if (a != b)
v1.push_back(b);
a = b;
}
for (i = 0, a = 1; i < v1.size(); i++, b = a) {
if (num[v1[i]] == 0) {
num[v1[i]] = a;
continue;
}
a += num[v1[i]];
num[v1[i]] += b;
if (a >= MAX)
a %= MAX;
if (num[v1[i]] >= MAX)
num[v1[i]] %= MAX;
}
cout << a << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
using namespace std;
typedef long long int LL;
typedef pair<int, int> P;
typedef pair<int, pair<int, int>> PP;
typedef pair<LL, int> LP;
const int INF = 1 << 30;
const LL MAX = 1e9 + 7;
void array_show(int *a, int n) {
for (int i = 0; i < n; i++)
printf("%d%c", a[i], (i != n - 1 ? ' ' : '\n'));
}
void array_show(LL *a, int n) {
for (int i = 0; i < n; i++)
printf("%lld%c", a[i], (i != n - 1 ? ' ' : '\n'));
}
vector<int> v1;
LL num[200005];
int main() {
int n;
int i, j, k;
LL a, b, c;
cin >> n;
for (i = 0, a = -1; i < n; i++) {
cin >> b;
if (a != b)
v1.push_back(b);
a = b;
}
for (i = 0, a = 1; i < v1.size(); i++, b = a) {
if (num[v1[i]] == 0) {
num[v1[i]] = a;
continue;
}
a += num[v1[i]];
num[v1[i]] += b;
if (a >= MAX)
a %= MAX;
if (num[v1[i]] >= MAX)
num[v1[i]] %= MAX;
}
cout << a << endl;
return 0;
}
| replace | 28 | 29 | 28 | 29 | 0 | |
p03096 | C++ | Runtime Error | #include <iostream>
#include <vector>
#define MOD 1000000007LL
using namespace std;
typedef long long ll;
int main() {
int n;
cin >> n;
vector<int> arr;
int pre = 0;
for (int i = 0; i < n; i++) {
int c;
cin >> c;
if (pre != c) {
arr.push_back(c);
pre = c;
}
}
n = arr.size();
vector<int> next(n, 0);
vector<int> last(n + 1, -1);
for (int i = 0; i < n; i++) {
if (last[arr[i]] != -1) {
next[last[arr[i]]] = i;
}
last[arr[i]] = i;
}
vector<ll> dp(n);
dp[0] = 1;
for (int i = 0; i < n - 1; i++) {
dp[i + 1] = (dp[i + 1] + dp[i]) % MOD;
if (next[i] > 0)
dp[next[i]] = (dp[next[i]] + dp[i]) % MOD;
}
cout << dp[n - 1] << endl;
}
| #include <iostream>
#include <vector>
#define MOD 1000000007LL
using namespace std;
typedef long long ll;
int main() {
int n;
cin >> n;
vector<int> arr;
int pre = 0;
for (int i = 0; i < n; i++) {
int c;
cin >> c;
if (pre != c) {
arr.push_back(c);
pre = c;
}
}
n = arr.size();
vector<int> next(n, 0);
vector<int> last(200001, -1);
for (int i = 0; i < n; i++) {
if (last[arr[i]] != -1) {
next[last[arr[i]]] = i;
}
last[arr[i]] = i;
}
vector<ll> dp(n);
dp[0] = 1;
for (int i = 0; i < n - 1; i++) {
dp[i + 1] = (dp[i + 1] + dp[i]) % MOD;
if (next[i] > 0)
dp[next[i]] = (dp[next[i]] + dp[i]) % MOD;
}
cout << dp[n - 1] << endl;
}
| replace | 21 | 22 | 21 | 22 | 0 | |
p03096 | C++ | Runtime Error | #include <iostream>
#include <stdio.h>
// #include <bits/stdc++.h>
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstring>
#include <float.h>
#include <iomanip>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#define INF 1e18
#define rep(i, n) for (int i = 0; (i) < (int)(n); i++)
#define REP(i, a, b) for (int i = (int)(a); (i) <= (int)(b); i++)
#define VEC(type, c, n) \
std::vector<type> c(n); \
for (auto &i : c) \
std::cin >> i;
#define vec(type, n) vector<type>(n)
#define vvec(m, n) vector<vector<int>>(int(m), vector<int>(n))
#define ALL(a) (a).begin(), (a).end()
using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
using P = pair<ll, ll>;
const int MOD = 1e9 + 7;
ll dp[200010];
int main() {
int n;
cin >> n;
vector<int> a(n);
rep(i, n) cin >> a[i];
vector<int> tab(n + 1, -1);
dp[0] = 1;
rep(i, n) {
if (tab[a[i]] == -1 || tab[a[i]] == i) {
dp[i + 1] = dp[i] % MOD;
} else {
dp[i + 1] = (dp[i] + dp[tab[a[i]]]) % MOD;
}
tab[a[i]] = i + 1;
}
cout << dp[n] << endl;
}
| #include <iostream>
#include <stdio.h>
// #include <bits/stdc++.h>
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstring>
#include <float.h>
#include <iomanip>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#define INF 1e18
#define rep(i, n) for (int i = 0; (i) < (int)(n); i++)
#define REP(i, a, b) for (int i = (int)(a); (i) <= (int)(b); i++)
#define VEC(type, c, n) \
std::vector<type> c(n); \
for (auto &i : c) \
std::cin >> i;
#define vec(type, n) vector<type>(n)
#define vvec(m, n) vector<vector<int>>(int(m), vector<int>(n))
#define ALL(a) (a).begin(), (a).end()
using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
using P = pair<ll, ll>;
const int MOD = 1e9 + 7;
ll dp[200010];
int main() {
int n;
cin >> n;
vector<int> a(n);
rep(i, n) cin >> a[i];
vector<int> tab(200010, -1);
dp[0] = 1;
rep(i, n) {
if (tab[a[i]] == -1 || tab[a[i]] == i) {
dp[i + 1] = dp[i] % MOD;
} else {
dp[i + 1] = (dp[i] + dp[tab[a[i]]]) % MOD;
}
tab[a[i]] = i + 1;
}
cout << dp[n] << endl;
}
| replace | 42 | 43 | 42 | 43 | 0 | |
p03096 | C++ | Runtime Error | #pragma region
#define _USE_MATH_DEFINES
#include <algorithm>
#include <cmath>
#include <cstdint>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
// #define rep(i, s, e) for (int(i) = (s); (i) < (e); ++(i))
#define rep(i, e) for (int(i) = 0; (i) < (e); ++(i))
#define rrep(i, s) for (int(i) = (s)-1; (i) >= 0; --(i))
#define all(x) x.begin(), x.end()
#pragma endregion
int main() {
int n;
cin >> n;
vector<vector<int>> pos(n + 1);
vector<ll> dp(n + 1);
dp[0] = 1;
int pre = 0;
rep(i, n) {
int a;
cin >> a;
dp[i + 1] = dp[i];
if (pre != a && pos[a].size() != 0) {
dp[i + 1] += dp[pos[a].back() + 1];
}
dp[i + 1] %= (ll)1e9 + 7;
pos[a].push_back(i);
pre = a;
}
cout << dp[n] << endl;
} | #pragma region
#define _USE_MATH_DEFINES
#include <algorithm>
#include <cmath>
#include <cstdint>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
// #define rep(i, s, e) for (int(i) = (s); (i) < (e); ++(i))
#define rep(i, e) for (int(i) = 0; (i) < (e); ++(i))
#define rrep(i, s) for (int(i) = (s)-1; (i) >= 0; --(i))
#define all(x) x.begin(), x.end()
#pragma endregion
int main() {
int n;
cin >> n;
vector<vector<int>> pos(200005);
vector<ll> dp(n + 1);
dp[0] = 1;
int pre = 0;
rep(i, n) {
int a;
cin >> a;
dp[i + 1] = dp[i];
if (pre != a && pos[a].size() != 0) {
dp[i + 1] += dp[pos[a].back() + 1];
}
dp[i + 1] %= (ll)1e9 + 7;
pos[a].push_back(i);
pre = a;
}
cout << dp[n] << endl;
} | replace | 27 | 28 | 27 | 28 | 0 | |
p03096 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
long long md = 1e9 + 7;
int N;
cin >> N;
int bef = -1;
vector<int> C;
for (int i = 0; i < N; i++) {
int c;
cin >> c;
if (c != bef)
C.push_back(c);
bef = c;
}
int Clen = C.size();
vector<long long> dp(Clen, 0);
dp[0]++;
vector<int> check(N + 1, -1);
for (int i = 0; i < Clen; i++) {
if (i > 0)
dp[i] += dp[i - 1];
if (check[C[i]] >= 0) {
dp[i] += dp[check[C[i]]];
}
dp[i] %= md;
check[C[i]] = i;
}
cout << dp[Clen - 1] << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
long long md = 1e9 + 7;
int N;
cin >> N;
int bef = -1;
vector<int> C;
for (int i = 0; i < N; i++) {
int c;
cin >> c;
if (c != bef)
C.push_back(c);
bef = c;
}
int Clen = C.size();
vector<long long> dp(Clen, 0);
dp[0]++;
vector<int> check(2 * 100000 + 1, -1);
for (int i = 0; i < Clen; i++) {
if (i > 0)
dp[i] += dp[i - 1];
if (check[C[i]] >= 0) {
dp[i] += dp[check[C[i]]];
}
dp[i] %= md;
check[C[i]] = i;
}
cout << dp[Clen - 1] << endl;
}
| replace | 19 | 20 | 19 | 20 | 0 | |
p03096 | C++ | Runtime Error | #include <bits/stdc++.h>
#include <math.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
const ll mod = 1000000007;
const ll INF = 1001001001;
const ll LINF = 1001001001001001001;
ll n;
vector<ll> c(0);
vector<ll> mem;
vector<vector<ll>> place(200000, vector<ll>(0));
void prvec(vector<ll> vec) { // for debug
ll n = vec.size();
cout << "------------------------------------\n";
rep(i, n) cout << i << " " << vec.at(i) << "\n";
cout << "------------------------------------\n";
}
void pr2d(vector<vector<ll>> vec) { // for debug
ll h = vec.size();
ll w = vec.at(0).size();
cout << "------------------------------------\n";
rep(i, h) {
rep(j, w) { cout << vec.at(i).at(j) << " "; }
cout << "\n";
}
cout << "------------------------------------\n";
}
ll f(ll x) {
if (x == n - 1)
return 1;
if (mem.at(x) != -1)
return mem.at(x);
ll ret = f(x + 1);
ll y = c.at(x);
ll add = 0;
auto it = upper_bound(place.at(y).begin(), place.at(y).end(), x);
if (it != place.at(y).end())
add = f(*it);
ret = (ret + add) % mod;
mem.at(x) = ret;
return ret;
}
// main starts here
int main() {
cin >> n;
ll prev = INF;
rep(i, n) {
ll a;
cin >> a;
if (a != prev)
c.emplace_back(a);
prev = a;
}
n = c.size();
rep(i, n) place.at(c.at(i)).emplace_back(i);
mem.resize(n, -1);
cout << f(0) << endl;
}
| #include <bits/stdc++.h>
#include <math.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
const ll mod = 1000000007;
const ll INF = 1001001001;
const ll LINF = 1001001001001001001;
ll n;
vector<ll> c(0);
vector<ll> mem;
vector<vector<ll>> place(200001, vector<ll>(0));
void prvec(vector<ll> vec) { // for debug
ll n = vec.size();
cout << "------------------------------------\n";
rep(i, n) cout << i << " " << vec.at(i) << "\n";
cout << "------------------------------------\n";
}
void pr2d(vector<vector<ll>> vec) { // for debug
ll h = vec.size();
ll w = vec.at(0).size();
cout << "------------------------------------\n";
rep(i, h) {
rep(j, w) { cout << vec.at(i).at(j) << " "; }
cout << "\n";
}
cout << "------------------------------------\n";
}
ll f(ll x) {
if (x == n - 1)
return 1;
if (mem.at(x) != -1)
return mem.at(x);
ll ret = f(x + 1);
ll y = c.at(x);
ll add = 0;
auto it = upper_bound(place.at(y).begin(), place.at(y).end(), x);
if (it != place.at(y).end())
add = f(*it);
ret = (ret + add) % mod;
mem.at(x) = ret;
return ret;
}
// main starts here
int main() {
cin >> n;
ll prev = INF;
rep(i, n) {
ll a;
cin >> a;
if (a != prev)
c.emplace_back(a);
prev = a;
}
n = c.size();
rep(i, n) place.at(c.at(i)).emplace_back(i);
mem.resize(n, -1);
cout << f(0) << endl;
}
| replace | 12 | 13 | 12 | 13 | 0 | |
p03096 | C++ | Runtime Error | #include <bits/stdc++.h>
#define ll long long
using namespace std;
const ll mod = 1e9 + 7;
const int maxn = 5e5 + 7;
int sum[maxn];
stack<int> sta;
std::vector<int> v;
int a[maxn];
int pre[maxn], pos[maxn];
ll dp[maxn];
int main() {
int n;
cin >> n;
for (int i = 0; i < n * 10; i++)
pre[i] = 0;
for (int i = 1; i <= n; i++)
cin >> a[i];
stack<int> sta;
for (int i = 1; i <= n; i++) {
if (sta.empty())
sta.push(a[i]);
else if (sta.top() != a[i])
sta.push(a[i]);
}
int sz = sta.size();
for (int i = sz; i >= 1; i--)
a[i] = sta.top(), sta.pop();
for (int i = 1; i <= sz; i++)
pre[i] = pos[a[i]], pos[a[i]] = i;
dp[0] = 1;
for (int i = 1; i <= sz; i++) {
dp[i] = dp[i - 1];
if (pre[i] != 0)
dp[i] = (dp[i] + dp[pre[i]]) % mod;
}
cout << dp[sz] << endl;
return 0;
}
| #include <bits/stdc++.h>
#define ll long long
using namespace std;
const ll mod = 1e9 + 7;
const int maxn = 5e5 + 7;
int sum[maxn];
stack<int> sta;
std::vector<int> v;
int a[maxn];
int pre[maxn], pos[maxn];
ll dp[maxn];
int main() {
int n;
cin >> n;
for (int i = 0; i < n * 2; i++)
pre[i] = 0;
for (int i = 1; i <= n; i++)
cin >> a[i];
stack<int> sta;
for (int i = 1; i <= n; i++) {
if (sta.empty())
sta.push(a[i]);
else if (sta.top() != a[i])
sta.push(a[i]);
}
int sz = sta.size();
for (int i = sz; i >= 1; i--)
a[i] = sta.top(), sta.pop();
for (int i = 1; i <= sz; i++)
pre[i] = pos[a[i]], pos[a[i]] = i;
dp[0] = 1;
for (int i = 1; i <= sz; i++) {
dp[i] = dp[i - 1];
if (pre[i] != 0)
dp[i] = (dp[i] + dp[pre[i]]) % mod;
}
cout << dp[sz] << endl;
return 0;
}
| replace | 19 | 20 | 19 | 20 | 0 | |
p03096 | C++ | Runtime Error | #include <iostream>
#include <map>
#include <stdio.h>
#include <string.h>
#include <string>
#include <vector>
#define MOD 1000000007
#define N_MAX 100005
using namespace std;
typedef long long ll;
int main() {
int N;
int C[N_MAX];
ll dp[N_MAX];
int m[N_MAX];
C[0] = 200005;
cin >> N;
for (int i = 1; i <= N; i++) {
cin >> C[i];
m[C[i]] = 0;
}
bool update = false;
dp[0] = 1;
for (int i = 1; i <= N; i++) {
dp[i] = dp[i - 1];
if (C[i - 1] != C[i]) {
dp[i] += m[C[i]];
dp[i] = dp[i] % MOD;
}
m[C[i]] = dp[i];
}
cout << dp[N] << endl;
} | #include <iostream>
#include <map>
#include <stdio.h>
#include <string.h>
#include <string>
#include <vector>
#define MOD 1000000007
#define N_MAX 200006
using namespace std;
typedef long long ll;
int main() {
int N;
int C[N_MAX];
ll dp[N_MAX];
int m[N_MAX];
C[0] = 200005;
cin >> N;
for (int i = 1; i <= N; i++) {
cin >> C[i];
m[C[i]] = 0;
}
bool update = false;
dp[0] = 1;
for (int i = 1; i <= N; i++) {
dp[i] = dp[i - 1];
if (C[i - 1] != C[i]) {
dp[i] += m[C[i]];
dp[i] = dp[i] % MOD;
}
m[C[i]] = dp[i];
}
cout << dp[N] << endl;
} | replace | 7 | 8 | 7 | 8 | 0 | |
p03096 | C++ | Runtime Error | #include "bits/stdc++.h"
using namespace std;
using ll = long long;
using vll = vector<ll>;
using pl4 = pair<ll, ll>;
using str = string;
using vpl4 = vector<pair<ll, ll>>;
#define sz size()
#define be begin()
#define en end()
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define llin(x) \
ll(x); \
cin >> (x);
#define stin(x) \
str(x); \
cin >> (x);
#define vllin(x, n) \
vll(x)(n); \
FOR(i, 0, n - 1) { cin >> (x)[i]; }
#define vllin2(a, b, n) \
vll(a)(n); \
vll(b)(n); \
FOR(i, 0, n - 1) { cin >> (a)[i] >> b[i]; }
#define vpl4in(x, n) \
vpl4(x)((n), mp(0, 0)); \
FOR(i, 0, n - 1) { cin >> x[i].fi >> x[i].se; }
#define FOR(i, a, b) for (ll i = a; i <= b; i++)
#define rFOR(i, b, a) for (ll i = a; i >= b; i--)
#define SORT(x) sort(x.be, x.en)
#define rSORT(x) sort(x.rbegin(), x.rend())
#define say(x) cout << (x);
#define sal(x) cout << (x) << endl;
#define sas cout << (' ');
#define sayR(x) cout << fixed << setprecision(10) << (x);
#define salR(x) cout << fixed << setprecision(10) << (x) << endl;
#define yn(a) cout << ((a) ? "yes" : "no") << endl;
#define Yn(a) cout << ((a) ? "Yes" : "No") << endl;
#define YN(a) cout << ((a) ? "YES" : "NO") << endl;
#define Imp(a) cout << ((a) ? "Possible" : "Impossible") << endl;
#define IMP(a) cout << ((a) ? "POSSIBLE" : "IMPOSSIBLE") << endl;
#define pow(a, b) ll(pow(a, b))
ll MOD = 1000000007;
signed main() {
llin(n);
vllin(c, n);
vll m(n, -1);
vll l(n, -1);
m[0] = 1;
l[c[0]] = 0;
FOR(d, 1, n - 1) {
if (c[d] == c[d - 1]) {
m[d] = m[d - 1];
} else {
if (l[c[d]] == -1) {
m[d] = m[d - 1];
} else {
m[d] = (m[d - 1] + m[l[c[d]]]) % MOD;
}
}
l[c[d]] = d;
}
sal(m[n - 1]);
} | #include "bits/stdc++.h"
using namespace std;
using ll = long long;
using vll = vector<ll>;
using pl4 = pair<ll, ll>;
using str = string;
using vpl4 = vector<pair<ll, ll>>;
#define sz size()
#define be begin()
#define en end()
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define llin(x) \
ll(x); \
cin >> (x);
#define stin(x) \
str(x); \
cin >> (x);
#define vllin(x, n) \
vll(x)(n); \
FOR(i, 0, n - 1) { cin >> (x)[i]; }
#define vllin2(a, b, n) \
vll(a)(n); \
vll(b)(n); \
FOR(i, 0, n - 1) { cin >> (a)[i] >> b[i]; }
#define vpl4in(x, n) \
vpl4(x)((n), mp(0, 0)); \
FOR(i, 0, n - 1) { cin >> x[i].fi >> x[i].se; }
#define FOR(i, a, b) for (ll i = a; i <= b; i++)
#define rFOR(i, b, a) for (ll i = a; i >= b; i--)
#define SORT(x) sort(x.be, x.en)
#define rSORT(x) sort(x.rbegin(), x.rend())
#define say(x) cout << (x);
#define sal(x) cout << (x) << endl;
#define sas cout << (' ');
#define sayR(x) cout << fixed << setprecision(10) << (x);
#define salR(x) cout << fixed << setprecision(10) << (x) << endl;
#define yn(a) cout << ((a) ? "yes" : "no") << endl;
#define Yn(a) cout << ((a) ? "Yes" : "No") << endl;
#define YN(a) cout << ((a) ? "YES" : "NO") << endl;
#define Imp(a) cout << ((a) ? "Possible" : "Impossible") << endl;
#define IMP(a) cout << ((a) ? "POSSIBLE" : "IMPOSSIBLE") << endl;
#define pow(a, b) ll(pow(a, b))
ll MOD = 1000000007;
signed main() {
llin(n);
vllin(c, n);
vll m(n, -1);
vll l(200005, -1);
m[0] = 1;
l[c[0]] = 0;
FOR(d, 1, n - 1) {
if (c[d] == c[d - 1]) {
m[d] = m[d - 1];
} else {
if (l[c[d]] == -1) {
m[d] = m[d - 1];
} else {
m[d] = (m[d - 1] + m[l[c[d]]]) % MOD;
}
}
l[c[d]] = d;
}
sal(m[n - 1]);
} | replace | 56 | 57 | 56 | 57 | 0 | |
p03096 | C++ | Runtime Error | #include <algorithm>
#include <cstdio>
using namespace std;
const int N = 1e5 + 10;
typedef long long ll;
const ll mod = 1e9 + 7;
ll coldp[N];
ll dp[N];
int c[N];
int n;
int main() {
dp[0] = 1;
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d", &c[i]);
for (int i = 1; i <= n; i++) {
dp[i] = dp[i - 1];
if ((i - 1) && c[i - 1] != c[i])
(dp[i] += coldp[c[i]]) %= mod;
coldp[c[i]] = dp[i];
// printf("%lld ",dp[i]);
}
printf("%lld", dp[n]);
return 0;
} | #include <algorithm>
#include <cstdio>
using namespace std;
const int N = 2 * 1e5 + 10;
typedef long long ll;
const ll mod = 1e9 + 7;
ll coldp[N];
ll dp[N];
int c[N];
int n;
int main() {
dp[0] = 1;
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d", &c[i]);
for (int i = 1; i <= n; i++) {
dp[i] = dp[i - 1];
if ((i - 1) && c[i - 1] != c[i])
(dp[i] += coldp[c[i]]) %= mod;
coldp[c[i]] = dp[i];
// printf("%lld ",dp[i]);
}
printf("%lld", dp[n]);
return 0;
} | replace | 3 | 4 | 3 | 4 | 0 | |
p03096 | C++ | Runtime Error | #include <iostream>
#include <vector>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> C(N + 1);
vector<int> latest(N + 1, -1);
vector<int> DP(N + 1, 0);
for (int i = 1; i <= N; i++) {
cin >> C[i];
}
DP[0] = 1;
for (int i = 1; i <= N; i++) {
if (latest[C[i]] >= 0 && latest[C[i]] + 1 != i) {
DP[i] = DP[i - 1] + DP[latest[C[i]]];
} else {
DP[i] = DP[i - 1];
}
DP[i] %= (int)(1e9 + 7);
latest[C[i]] = i;
}
cout << DP[N] << endl;
return 0;
} | #include <iostream>
#include <vector>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> C(N + 1);
vector<int> latest(200002, -1);
vector<unsigned int> DP(N + 1, 0);
for (int i = 1; i <= N; i++) {
cin >> C[i];
}
DP[0] = 1;
for (int i = 1; i <= N; i++) {
if (latest[C[i]] >= 0 && latest[C[i]] + 1 != i) {
DP[i] = DP[i - 1] + DP[latest[C[i]]];
} else {
DP[i] = DP[i - 1];
}
DP[i] %= (int)(1e9 + 7);
latest[C[i]] = i;
}
cout << DP[N] << endl;
return 0;
} | replace | 10 | 12 | 10 | 12 | 0 | |
p03096 | C++ | Time Limit Exceeded | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
const int mo = 1e9 + 7;
const int maxn = 200002;
int n, c[maxn];
vector<int> pos[maxn];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
vector<int> idx(n, -1);
for (int i = 0; i < n; ++i) {
cin >> c[i];
if (i == 0 || c[i] != c[i - 1]) {
idx[i] = pos[c[i]].size();
pos[c[i]].push_back(i);
}
}
vector<long long> f(n);
f[0] = 1;
for (int i = 1; i < n; ++i) {
f[i] = f[i - 1];
if (idx[i] != -1) {
int cur = c[i];
for (int j = idx[i] - 1; j >= 0; --j) {
int t = pos[cur][j];
// printf("%d %d\n", t, i);
if (t == 0)
++f[i];
else
f[i] += f[t - 1];
}
f[i] %= mo;
}
}
cout << f[n - 1] << endl;
return 0;
} | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
const int mo = 1e9 + 7;
const int maxn = 200002;
int n, c[maxn];
vector<int> pos[maxn];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
vector<int> idx(n, -1);
for (int i = 0; i < n; ++i) {
cin >> c[i];
if (i == 0 || c[i] != c[i - 1]) {
idx[i] = pos[c[i]].size();
pos[c[i]].push_back(i);
}
}
vector<long long> f(n);
f[0] = 1;
for (int i = 1; i < n; ++i) {
f[i] = f[i - 1];
if (idx[i] > 0) {
int t = pos[c[i]][idx[i] - 1];
f[i] += f[t];
f[i] %= mo;
}
}
cout << f[n - 1] << endl;
return 0;
} | replace | 42 | 52 | 42 | 46 | TLE | |
p03096 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#define FOR(i, x, y) for (int i = (x), i##END = (y); i <= i##END; ++i)
#define DOR(i, x, y) for (int i = (x), i##END = (y); i >= i##END; --i)
template <typename T, typename _T> inline bool chk_min(T &x, const _T y) {
return y < x ? x = y, 1 : 0;
}
template <typename T, typename _T> inline bool chk_max(T &x, const _T y) {
return x < y ? x = y, 1 : 0;
}
typedef long long ll;
const int N = 1e5 + 5;
const int P = 1e9 + 7;
int dp[N], Sum[N];
int a[N];
int n;
int main() {
scanf("%d", &n);
FOR(i, 1, n) scanf("%d", &a[i]);
int m = n;
n = 1;
FOR(i, 2, m) if (a[i] != a[n]) a[++n] = a[i];
dp[0] = 1;
FOR(i, 1, n) {
dp[i] = (dp[i - 1] + Sum[a[i]]) % P;
(Sum[a[i]] += dp[i - 1]) %= P;
}
printf("%d\n", dp[n]);
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#define FOR(i, x, y) for (int i = (x), i##END = (y); i <= i##END; ++i)
#define DOR(i, x, y) for (int i = (x), i##END = (y); i >= i##END; --i)
template <typename T, typename _T> inline bool chk_min(T &x, const _T y) {
return y < x ? x = y, 1 : 0;
}
template <typename T, typename _T> inline bool chk_max(T &x, const _T y) {
return x < y ? x = y, 1 : 0;
}
typedef long long ll;
const int N = 2e5 + 5;
const int P = 1e9 + 7;
int dp[N], Sum[N];
int a[N];
int n;
int main() {
scanf("%d", &n);
FOR(i, 1, n) scanf("%d", &a[i]);
int m = n;
n = 1;
FOR(i, 2, m) if (a[i] != a[n]) a[++n] = a[i];
dp[0] = 1;
FOR(i, 1, n) {
dp[i] = (dp[i - 1] + Sum[a[i]]) % P;
(Sum[a[i]] += dp[i - 1]) %= P;
}
printf("%d\n", dp[n]);
return 0;
} | replace | 15 | 16 | 15 | 16 | 0 | |
p03096 | C++ | Runtime Error | #include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <vector>
#define N 100005
#define mod 1000000007ll
using namespace std;
typedef long long ll;
inline int rd() {
int x = 0;
char c = getchar();
while (!isdigit(c))
c = getchar();
while (isdigit(c)) {
x = x * 10 + (c ^ 48);
c = getchar();
}
return x;
}
int n, c[N], f[N], pos[N], lst[N];
int main() {
n = rd();
f[0] = 1;
for (int i = 1; i <= n; ++i) {
c[i] = rd();
if (lst[c[i]] < i - 1)
pos[i] = lst[c[i]];
lst[c[i]] = i;
f[i] = (f[i - 1] + (pos[i] ? f[pos[i]] : 0)) % mod;
}
printf("%d\n", f[n]);
return 0;
}
| #include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <vector>
#define N 200005
#define mod 1000000007ll
using namespace std;
typedef long long ll;
inline int rd() {
int x = 0;
char c = getchar();
while (!isdigit(c))
c = getchar();
while (isdigit(c)) {
x = x * 10 + (c ^ 48);
c = getchar();
}
return x;
}
int n, c[N], f[N], pos[N], lst[N];
int main() {
n = rd();
f[0] = 1;
for (int i = 1; i <= n; ++i) {
c[i] = rd();
if (lst[c[i]] < i - 1)
pos[i] = lst[c[i]];
lst[c[i]] = i;
f[i] = (f[i - 1] + (pos[i] ? f[pos[i]] : 0)) % mod;
}
printf("%d\n", f[n]);
return 0;
}
| replace | 8 | 9 | 8 | 9 | 0 | |
p03096 | C++ | Runtime Error | #include <bits/stdc++.h>
#define fo(i, a, b) for (int i = a; i <= b; ++i)
#define fod(i, a, b) for (int i = a; i >= b; --i)
#define N 100005
#define LL long long
#define mo 1000000007
using namespace std;
LL f[N];
int lst[N], a[N], n;
int main() {
cin >> n;
fo(i, 1, n) scanf("%d", &a[i]);
f[0] = 1;
fo(i, 1, n) {
f[i] = f[i - 1];
if (lst[a[i]] != i - 1 && lst[a[i]] != 0)
f[i] = (f[i] + f[lst[a[i]]]) % mo;
lst[a[i]] = i;
}
printf("%lld\n", f[n]);
} | #include <bits/stdc++.h>
#define fo(i, a, b) for (int i = a; i <= b; ++i)
#define fod(i, a, b) for (int i = a; i >= b; --i)
#define N 300005
#define LL long long
#define mo 1000000007
using namespace std;
LL f[N];
int lst[N], a[N], n;
int main() {
cin >> n;
fo(i, 1, n) scanf("%d", &a[i]);
f[0] = 1;
fo(i, 1, n) {
f[i] = f[i - 1];
if (lst[a[i]] != i - 1 && lst[a[i]] != 0)
f[i] = (f[i] + f[lst[a[i]]]) % mo;
lst[a[i]] = i;
}
printf("%lld\n", f[n]);
} | replace | 3 | 4 | 3 | 4 | 0 | |
p03096 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define REP(i, st, ed) for (register int i = st, i##end = ed; i <= i##end; ++i)
#define DREP(i, st, ed) for (register int i = st, i##end = ed; i >= i##end; --i)
template <typename T> inline bool chkmin(T &x, T y) {
return (y < x) ? (x = y, 1) : 0;
}
template <typename T> inline bool chkmax(T &x, T y) {
return (y > x) ? (x = y, 1) : 0;
}
typedef long long ll;
inline int read() {
int x;
char c;
int f = 1;
while ((c = getchar()) != '-' && (c > '9' || c < '0'))
;
if (c == '-')
f = -1, c = getchar();
x = c ^ '0';
while ((c = getchar()) >= '0' && c <= '9')
x = (x << 1) + (x << 3) + (c ^ '0');
return x * f;
}
inline ll readll() {
ll x;
char c;
int f = 1;
while ((c = getchar()) != '-' && (c > '9' || c < '0'))
;
if (c == '-')
f = -1, c = getchar();
x = c ^ '0';
while ((c = getchar()) >= '0' && c <= '9')
x = (x << 1ll) + (x << 3ll) + (c ^ '0');
return x * f;
}
const int maxn = 1e5 + 10, mod = 1e9 + 7;
inline void add(int &x, int y) {
x += y;
x = (x >= mod ? x - mod : x);
}
int dp[maxn];
int main() {
int n = read();
dp[0] = 1;
int lst = 0;
REP(i, 1, n) {
int x = read();
if (x == lst)
continue;
int u = dp[0], v = dp[x];
add(dp[0], v), add(dp[x], u);
lst = x;
}
printf("%d\n", dp[0]);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define REP(i, st, ed) for (register int i = st, i##end = ed; i <= i##end; ++i)
#define DREP(i, st, ed) for (register int i = st, i##end = ed; i >= i##end; --i)
template <typename T> inline bool chkmin(T &x, T y) {
return (y < x) ? (x = y, 1) : 0;
}
template <typename T> inline bool chkmax(T &x, T y) {
return (y > x) ? (x = y, 1) : 0;
}
typedef long long ll;
inline int read() {
int x;
char c;
int f = 1;
while ((c = getchar()) != '-' && (c > '9' || c < '0'))
;
if (c == '-')
f = -1, c = getchar();
x = c ^ '0';
while ((c = getchar()) >= '0' && c <= '9')
x = (x << 1) + (x << 3) + (c ^ '0');
return x * f;
}
inline ll readll() {
ll x;
char c;
int f = 1;
while ((c = getchar()) != '-' && (c > '9' || c < '0'))
;
if (c == '-')
f = -1, c = getchar();
x = c ^ '0';
while ((c = getchar()) >= '0' && c <= '9')
x = (x << 1ll) + (x << 3ll) + (c ^ '0');
return x * f;
}
const int maxn = 2e5 + 10, mod = 1e9 + 7;
inline void add(int &x, int y) {
x += y;
x = (x >= mod ? x - mod : x);
}
int dp[maxn];
int main() {
int n = read();
dp[0] = 1;
int lst = 0;
REP(i, 1, n) {
int x = read();
if (x == lst)
continue;
int u = dp[0], v = dp[x];
add(dp[0], v), add(dp[x], u);
lst = x;
}
printf("%d\n", dp[0]);
return 0;
} | replace | 37 | 38 | 37 | 38 | 0 | |
p03096 | C++ | Runtime Error | #include <bits/stdc++.h>
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define sz(x) int(x.size())
#define ALL(c) (c).begin(), (c).end()
#define SUM(x) std::accumulate(ALL(x), 0LL)
#define MIN(v) *std::min_element(v.begin(), v.end())
#define MAX(v) *std::max_element(v.begin(), v.end())
#define EXIST(v, x) (std::find(v.begin(), v.end(), x) != v.end())
#define FORV(i, v) for (auto i = v.begin(); i != v.end(); i++)
using namespace std;
typedef int64_t ll;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
const int INF = 1001001001;
const ll INFL = (1LL << 60);
const double eps = (1e-9);
const ll mod = 1e9 + 7;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<ll> c(n);
rep(i, n) cin >> c[i];
vector<ll> sum(n, 0);
vector<ll> dp(n + 1, 0);
dp[0] = 1;
rep(i, n) {
ll x = c[i];
if (i != 0 && c[i] == c[i - 1]) {
dp[i + 1] = dp[i];
continue; // 同じ値の間には区切りを入れない
}
sum[x] = (sum[x] + dp[i]) % mod;
dp[i + 1] = sum[x];
}
cout << dp[n] << endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define sz(x) int(x.size())
#define ALL(c) (c).begin(), (c).end()
#define SUM(x) std::accumulate(ALL(x), 0LL)
#define MIN(v) *std::min_element(v.begin(), v.end())
#define MAX(v) *std::max_element(v.begin(), v.end())
#define EXIST(v, x) (std::find(v.begin(), v.end(), x) != v.end())
#define FORV(i, v) for (auto i = v.begin(); i != v.end(); i++)
using namespace std;
typedef int64_t ll;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
const int INF = 1001001001;
const ll INFL = (1LL << 60);
const double eps = (1e-9);
const ll mod = 1e9 + 7;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<ll> c(n);
rep(i, n) cin >> c[i];
vector<ll> sum(2e5 + 5, 0);
vector<ll> dp(n + 1, 0);
dp[0] = 1;
rep(i, n) {
ll x = c[i];
if (i != 0 && c[i] == c[i - 1]) {
dp[i + 1] = dp[i];
continue; // 同じ値の間には区切りを入れない
}
sum[x] = (sum[x] + dp[i]) % mod;
dp[i + 1] = sum[x];
}
cout << dp[n] << endl;
return 0;
}
| replace | 42 | 43 | 42 | 43 | 0 | |
p03096 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define PI 3.141592653589793
#define rep(i, n) for (int i = 0; i < (n); i++)
#define REP(i, a, n) for (int i = a; i < (n); i++)
#define rrep(i, n, k) \
for (int i = (n); i >= (k); i--) \
;
#define all(x) (x).begin(), (x).end()
#define vi vector<int>
template <class T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &elemnt : v)
is >> elemnt;
return is;
}
template <class T, class U> istream &operator>>(istream &is, pair<T, U> &p) {
is >> p.first >> p.second;
return is;
}
template <class T> vector<T> make_vector(size_t a) { return vector<T>(a); }
template <class T, class... Ts> auto make_vector(size_t a, Ts... ts) {
return vector<decltype(make_vector<T>(ts...))>(a, make_vector<T>(ts...));
}
const int MOD = 1e9 + 7;
const int INF = 2e18;
template <int mod> struct ModInt {
int x;
ModInt() : x(0) {}
ModInt(int64_t y) : x(y >= 0 ? y % mod : (mod - (-y) % mod) % mod) {}
ModInt &operator+=(const ModInt &p) {
if ((x += p.x) >= mod)
x -= mod;
return *this;
}
ModInt &operator-=(const ModInt &p) {
if ((x += mod - p.x) >= mod)
x -= mod;
return *this;
}
ModInt &operator*=(const ModInt &p) {
x = (int)(1LL * x * p.x % mod);
return *this;
}
ModInt &operator/=(const ModInt &p) {
*this *= p.inverse();
return *this;
}
ModInt operator-() const { return ModInt(-x); }
ModInt operator+(const ModInt &p) const { return ModInt(*this) += p; }
ModInt operator-(const ModInt &p) const { return ModInt(*this) -= p; }
ModInt operator*(const ModInt &p) const { return ModInt(*this) *= p; }
ModInt operator/(const ModInt &p) const { return ModInt(*this) /= p; }
bool operator==(const ModInt &p) const { return x == p.x; }
bool operator!=(const ModInt &p) const { return x != p.x; }
ModInt inverse() const {
int a = x, b = mod, u = 1, v = 0, t;
while (b > 0) {
t = a / b;
swap(a -= t * b, b);
swap(u -= t * v, v);
}
return ModInt(u);
}
ModInt pow(int64_t n) const {
ModInt ret(1), mul(x);
while (n > 0) {
if (n & 1)
ret *= mul;
mul *= mul;
n >>= 1;
}
return ret;
}
friend ostream &operator<<(ostream &os, const ModInt &p) { return os << p.x; }
friend istream &operator>>(istream &is, ModInt &a) {
int64_t t;
is >> t;
a = ModInt<mod>(t);
return (is);
}
static int get_mod() { return mod; }
};
using modint = ModInt<MOD>;
signed main() {
int N;
cin >> N;
vector<int> C(1);
cin >> C;
vector<set<int>> idx(100100);
for (int i = 1; i < N; i++) {
int temp;
cin >> temp;
if (*C.rbegin() != temp)
C.push_back(temp);
idx[temp].insert(C.size() - 1);
}
vector<modint> ans(C.size(), 1);
for (int i = C.size() - 2; i >= 0; i--) {
auto itr = idx[C[i]].upper_bound(i);
if (itr == idx[C[i]].end())
ans[i] = ans[i + 1];
else
ans[i] = ans[i + 1] + ans[*itr];
}
cout << ans[0] << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
#define PI 3.141592653589793
#define rep(i, n) for (int i = 0; i < (n); i++)
#define REP(i, a, n) for (int i = a; i < (n); i++)
#define rrep(i, n, k) \
for (int i = (n); i >= (k); i--) \
;
#define all(x) (x).begin(), (x).end()
#define vi vector<int>
template <class T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &elemnt : v)
is >> elemnt;
return is;
}
template <class T, class U> istream &operator>>(istream &is, pair<T, U> &p) {
is >> p.first >> p.second;
return is;
}
template <class T> vector<T> make_vector(size_t a) { return vector<T>(a); }
template <class T, class... Ts> auto make_vector(size_t a, Ts... ts) {
return vector<decltype(make_vector<T>(ts...))>(a, make_vector<T>(ts...));
}
const int MOD = 1e9 + 7;
const int INF = 2e18;
template <int mod> struct ModInt {
int x;
ModInt() : x(0) {}
ModInt(int64_t y) : x(y >= 0 ? y % mod : (mod - (-y) % mod) % mod) {}
ModInt &operator+=(const ModInt &p) {
if ((x += p.x) >= mod)
x -= mod;
return *this;
}
ModInt &operator-=(const ModInt &p) {
if ((x += mod - p.x) >= mod)
x -= mod;
return *this;
}
ModInt &operator*=(const ModInt &p) {
x = (int)(1LL * x * p.x % mod);
return *this;
}
ModInt &operator/=(const ModInt &p) {
*this *= p.inverse();
return *this;
}
ModInt operator-() const { return ModInt(-x); }
ModInt operator+(const ModInt &p) const { return ModInt(*this) += p; }
ModInt operator-(const ModInt &p) const { return ModInt(*this) -= p; }
ModInt operator*(const ModInt &p) const { return ModInt(*this) *= p; }
ModInt operator/(const ModInt &p) const { return ModInt(*this) /= p; }
bool operator==(const ModInt &p) const { return x == p.x; }
bool operator!=(const ModInt &p) const { return x != p.x; }
ModInt inverse() const {
int a = x, b = mod, u = 1, v = 0, t;
while (b > 0) {
t = a / b;
swap(a -= t * b, b);
swap(u -= t * v, v);
}
return ModInt(u);
}
ModInt pow(int64_t n) const {
ModInt ret(1), mul(x);
while (n > 0) {
if (n & 1)
ret *= mul;
mul *= mul;
n >>= 1;
}
return ret;
}
friend ostream &operator<<(ostream &os, const ModInt &p) { return os << p.x; }
friend istream &operator>>(istream &is, ModInt &a) {
int64_t t;
is >> t;
a = ModInt<mod>(t);
return (is);
}
static int get_mod() { return mod; }
};
using modint = ModInt<MOD>;
signed main() {
int N;
cin >> N;
vector<int> C(1);
cin >> C;
vector<set<int>> idx(200100);
for (int i = 1; i < N; i++) {
int temp;
cin >> temp;
if (*C.rbegin() != temp)
C.push_back(temp);
idx[temp].insert(C.size() - 1);
}
vector<modint> ans(C.size(), 1);
for (int i = C.size() - 2; i >= 0; i--) {
auto itr = idx[C[i]].upper_bound(i);
if (itr == idx[C[i]].end())
ans[i] = ans[i + 1];
else
ans[i] = ans[i + 1] + ans[*itr];
}
cout << ans[0] << endl;
}
| replace | 110 | 111 | 110 | 111 | 0 | |
p03096 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using i64 = int64_t;
const i64 MOD = 1e9 + 7;
const i64 INF = 1e18 + 7;
// pythonのrangeのような範囲for文用のclass for(const auto& i : Range<>(10))
// のように書く
template <typename T = i64> struct Range {
struct iterator {
T value;
const T step, last;
const T &operator*() { return value; }
iterator(T value, T step, T last) : value(value), step(step), last(last) {}
iterator operator++() {
value = step < static_cast<T>(0) ? max(value + step, last)
: min(value + step, last);
return *this;
}
bool operator!=(const iterator &x) { return value != x.value; }
};
const T start, last, step;
Range(const T start, const T last, const T step = static_cast<T>(1))
: start(start), last(last), step(step) {}
Range(const T last) : start(0), last(last), step(1) {}
iterator begin() { return iterator(start, step, last); }
iterator end() { return iterator(last, step, last); }
};
// lambda式を用いた再帰
template <typename F> struct FixPoint {
const F _f;
FixPoint(F &&f) : _f(forward<F>(f)) {}
template <typename... Types>
decltype(auto) operator()(Types &&...args) const {
return _f(*this, forward<Types>(args)...);
}
};
template <typename F> static decltype(auto) makeRec(F &&f) {
return FixPoint<F>(forward<F>(f));
}
// 多次元vectorの一斉初期化 makeVector<i64, 0>(a, b, ...)のように書く
template <typename T, T Value = T()> vector<T> makeVector(size_t x) {
return vector<T>(x, T(Value));
}
template <typename T, T Value = T(), typename... Types>
auto makeVector(size_t x, Types... args) {
return vector<decltype(makeVector<T, Value>(args...))>(
x, makeVector<T, Value>(args...));
}
// 最大値を更新し、更新できた時にはtrueを返す
template <typename T = i64> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
// 同様に最小値を更新する
template <typename T = i64> bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
// 行数と変数名、値をclogに表示するデバッグ用print
#define dump(x) \
fprintf(stderr, "line =%4d, name =%7s , ", __LINE__, #x); \
clog << "value = " << x << endl;
// 同様の配列向けデバッグ用print
#define vecdump(x) \
fprintf(stderr, "line =%4d, name =%7s\n", __LINE__, #x); \
_dump_macro(x);
void _dump(int, string &x) { clog << x << endl; }
template <typename T> void _dump(bool, T &x) { clog << x << " "; }
template <typename T, typename U = typename T::iterator> void _dump(int, T &x) {
for (auto &elm : x)
_dump(0, elm);
clog << endl;
}
template <typename T> void _dump_macro(T &x) { _dump(0, x); }
// input用の関数群
void _input(int, string &x) { cin >> x; }
template <typename T> void _input(bool, T &x) { cin >> x; }
template <typename T, typename U = typename T::iterator>
void _input(int, T &x) {
for (auto &elm : x)
_input(0, elm);
}
template <typename T> void input_single(T &x) { _input(0, x); }
auto input() {}
template <typename T, typename... Types> void input(T &value, Types &&...args) {
input_single(value);
input(forward<Types>(args)...);
};
void _pararell_input(size_t) {}
template <typename T, typename... Types>
void _pararell_input(size_t index, T &value, Types &&...args) {
input(value[index]);
_pararell_input(index, forward<Types>(args)...);
}
template <typename... Types>
void pararell_input(size_t count, Types &&...args) {
for (const auto &i : Range<>(count))
_pararell_input(i, forward<Types>(args)...);
}
template <typename T> struct Segtree {
int n;
T op;
vector<T> elm;
function<T(T, T)> f;
Segtree(int n, T init, function<T(T, T)> f, T op = T())
: n(n), op(op), elm(2 * n, init), f(f) {}
void set(int x, T val) {
x += n;
elm[x] = val;
while (x >>= 1)
elm[x] = f(elm[2 * x], elm[2 * x + 1]);
}
void update(int x, T val) {
x += n;
elm[x] = f(val, elm[x]);
while (x >>= 1)
elm[x] = f(elm[2 * x], elm[2 * x + 1]);
}
T get(int x, int y) const {
T val = op;
for (x += n, y += n - 1; x <= y; x >>= 1, y >>= 1) {
if (x & 1)
val = f(val, elm[x++]);
if (!(y & 1))
val = f(val, elm[y--]);
}
return val;
}
};
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
int n;
input(n);
vector<int> a(n);
input(a);
vector<int> tt(1, a[0] - 1);
for (const auto &i : Range<>(1, n)) {
if (tt.back() != a[i] - 1)
tt.emplace_back(a[i] - 1);
}
Segtree<i64> seg(
n + 3, 0, [](i64 x, i64 y) { return (x + y) % MOD; }, 0);
vector<i64> sum(n + 3, 0);
n = tt.size();
seg.set(0, 1);
for (const auto &i : Range<>(n)) {
i64 tmp = sum[tt[i]];
sum[tt[i]] = (sum[tt[i]] + seg.get(0, i + 1)) % MOD;
seg.set(i + 1, tmp % MOD);
}
cout << seg.get(0, n + 1) % MOD << endl;
}
| #include <bits/stdc++.h>
using namespace std;
using i64 = int64_t;
const i64 MOD = 1e9 + 7;
const i64 INF = 1e18 + 7;
// pythonのrangeのような範囲for文用のclass for(const auto& i : Range<>(10))
// のように書く
template <typename T = i64> struct Range {
struct iterator {
T value;
const T step, last;
const T &operator*() { return value; }
iterator(T value, T step, T last) : value(value), step(step), last(last) {}
iterator operator++() {
value = step < static_cast<T>(0) ? max(value + step, last)
: min(value + step, last);
return *this;
}
bool operator!=(const iterator &x) { return value != x.value; }
};
const T start, last, step;
Range(const T start, const T last, const T step = static_cast<T>(1))
: start(start), last(last), step(step) {}
Range(const T last) : start(0), last(last), step(1) {}
iterator begin() { return iterator(start, step, last); }
iterator end() { return iterator(last, step, last); }
};
// lambda式を用いた再帰
template <typename F> struct FixPoint {
const F _f;
FixPoint(F &&f) : _f(forward<F>(f)) {}
template <typename... Types>
decltype(auto) operator()(Types &&...args) const {
return _f(*this, forward<Types>(args)...);
}
};
template <typename F> static decltype(auto) makeRec(F &&f) {
return FixPoint<F>(forward<F>(f));
}
// 多次元vectorの一斉初期化 makeVector<i64, 0>(a, b, ...)のように書く
template <typename T, T Value = T()> vector<T> makeVector(size_t x) {
return vector<T>(x, T(Value));
}
template <typename T, T Value = T(), typename... Types>
auto makeVector(size_t x, Types... args) {
return vector<decltype(makeVector<T, Value>(args...))>(
x, makeVector<T, Value>(args...));
}
// 最大値を更新し、更新できた時にはtrueを返す
template <typename T = i64> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
// 同様に最小値を更新する
template <typename T = i64> bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
// 行数と変数名、値をclogに表示するデバッグ用print
#define dump(x) \
fprintf(stderr, "line =%4d, name =%7s , ", __LINE__, #x); \
clog << "value = " << x << endl;
// 同様の配列向けデバッグ用print
#define vecdump(x) \
fprintf(stderr, "line =%4d, name =%7s\n", __LINE__, #x); \
_dump_macro(x);
void _dump(int, string &x) { clog << x << endl; }
template <typename T> void _dump(bool, T &x) { clog << x << " "; }
template <typename T, typename U = typename T::iterator> void _dump(int, T &x) {
for (auto &elm : x)
_dump(0, elm);
clog << endl;
}
template <typename T> void _dump_macro(T &x) { _dump(0, x); }
// input用の関数群
void _input(int, string &x) { cin >> x; }
template <typename T> void _input(bool, T &x) { cin >> x; }
template <typename T, typename U = typename T::iterator>
void _input(int, T &x) {
for (auto &elm : x)
_input(0, elm);
}
template <typename T> void input_single(T &x) { _input(0, x); }
auto input() {}
template <typename T, typename... Types> void input(T &value, Types &&...args) {
input_single(value);
input(forward<Types>(args)...);
};
void _pararell_input(size_t) {}
template <typename T, typename... Types>
void _pararell_input(size_t index, T &value, Types &&...args) {
input(value[index]);
_pararell_input(index, forward<Types>(args)...);
}
template <typename... Types>
void pararell_input(size_t count, Types &&...args) {
for (const auto &i : Range<>(count))
_pararell_input(i, forward<Types>(args)...);
}
template <typename T> struct Segtree {
int n;
T op;
vector<T> elm;
function<T(T, T)> f;
Segtree(int n, T init, function<T(T, T)> f, T op = T())
: n(n), op(op), elm(2 * n, init), f(f) {}
void set(int x, T val) {
x += n;
elm[x] = val;
while (x >>= 1)
elm[x] = f(elm[2 * x], elm[2 * x + 1]);
}
void update(int x, T val) {
x += n;
elm[x] = f(val, elm[x]);
while (x >>= 1)
elm[x] = f(elm[2 * x], elm[2 * x + 1]);
}
T get(int x, int y) const {
T val = op;
for (x += n, y += n - 1; x <= y; x >>= 1, y >>= 1) {
if (x & 1)
val = f(val, elm[x++]);
if (!(y & 1))
val = f(val, elm[y--]);
}
return val;
}
};
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
int n;
input(n);
vector<int> a(n);
input(a);
vector<int> tt(1, a[0] - 1);
for (const auto &i : Range<>(1, n)) {
if (tt.back() != a[i] - 1)
tt.emplace_back(a[i] - 1);
}
Segtree<i64> seg(
n + 3, 0, [](i64 x, i64 y) { return (x + y) % MOD; }, 0);
vector<i64> sum(200005, 0);
n = tt.size();
seg.set(0, 1);
for (const auto &i : Range<>(n)) {
i64 tmp = sum[tt[i]];
sum[tt[i]] = (sum[tt[i]] + seg.get(0, i + 1)) % MOD;
seg.set(i + 1, tmp % MOD);
}
cout << seg.get(0, n + 1) % MOD << endl;
}
| replace | 191 | 192 | 191 | 192 | 0 | |
p03096 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define LL long long
#define clr(x, y) memset(x, y, sizeof(x))
#define FOR(x, l, r) for (int x = l, x##_ = r; x <= x##_; x++)
#define FR(x, l, r) for (int x = l, x##_ = r; x < x##_; x++)
#define DOR(x, r, l) for (int x = r, x##_ = l; x >= x##_; x--)
using namespace std;
const int N = 200005;
const LL P = 1e9 + 7;
LL dp[N];
int n, A[N], tot, R[N], L[N], top[N];
LL dfs(int x) {
// printf("%d\n",x);
if (x == tot)
return 1;
// if(dp[x])return dp[x];
LL cnt = dfs(x + 1);
int to = R[x];
// while(to){
// printf("R:%d %d\n",to,tot);
if (to)
(cnt += dfs(to)) %= P;
// to=R[to];
// }
return dp[x] = cnt;
}
void Add(int x, int id) {
if (top[x])
R[top[x]] = id, L[id] = top[x];
top[x] = id;
}
int main() {
scanf("%d", &n);
FOR(i, 1, n) {
int x;
scanf("%d", &x);
if (x != A[tot]) {
A[++tot] = x;
Add(x, tot);
}
}
dp[tot] = 1;
printf("%lld\n", dfs(1));
// FOR(i,1,n)printf("%lld ",dp[i]);puts("");
return 0;
} | #include <bits/stdc++.h>
#define LL long long
#define clr(x, y) memset(x, y, sizeof(x))
#define FOR(x, l, r) for (int x = l, x##_ = r; x <= x##_; x++)
#define FR(x, l, r) for (int x = l, x##_ = r; x < x##_; x++)
#define DOR(x, r, l) for (int x = r, x##_ = l; x >= x##_; x--)
using namespace std;
const int N = 200005;
const LL P = 1e9 + 7;
LL dp[N];
int n, A[N], tot, R[N], L[N], top[N];
LL dfs(int x) {
// printf("%d\n",x);
if (x == tot)
return 1;
if (dp[x])
return dp[x];
LL cnt = dfs(x + 1);
int to = R[x];
// while(to){
// printf("R:%d %d\n",to,tot);
if (to)
(cnt += dfs(to)) %= P;
// to=R[to];
// }
return dp[x] = cnt;
}
void Add(int x, int id) {
if (top[x])
R[top[x]] = id, L[id] = top[x];
top[x] = id;
}
int main() {
scanf("%d", &n);
FOR(i, 1, n) {
int x;
scanf("%d", &x);
if (x != A[tot]) {
A[++tot] = x;
Add(x, tot);
}
}
dp[tot] = 1;
printf("%lld\n", dfs(1));
// FOR(i,1,n)printf("%lld ",dp[i]);puts("");
return 0;
} | replace | 15 | 16 | 15 | 17 | TLE | |
p03096 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int mod = 1e9 + 7;
int main() {
ll n;
cin >> n;
vector<ll> c(1);
cin >> c[0];
for (ll i = 1; i < n; ++i) {
ll ci;
cin >> ci;
if (c.back() != ci)
c.push_back(ci);
}
map<ll, ll> m;
m.insert({c[0], 1});
vector<ll> dp(n, 0);
dp[0] = 1;
for (ll i = 1; i < n; ++i) {
dp[i] = (dp[i - 1] + m[c[i]]) % mod;
m[c[i]] = dp[i];
}
cout << dp.back() << endl;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int mod = 1e9 + 7;
int main() {
ll n;
cin >> n;
vector<ll> c(1);
cin >> c[0];
for (ll i = 1; i < n; ++i) {
ll ci;
cin >> ci;
if (c.back() != ci)
c.push_back(ci);
}
n = c.size();
map<ll, ll> m;
m.insert({c[0], 1});
vector<ll> dp(n, 0);
dp[0] = 1;
for (ll i = 1; i < n; ++i) {
dp[i] = (dp[i - 1] + m[c[i]]) % mod;
m[c[i]] = dp[i];
}
cout << dp.back() << endl;
} | insert | 17 | 17 | 17 | 18 | 0 | |
p03096 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
const int mod = 1000000007;
int n, patterns = 1, prev = 0;
cin >> n;
vector<int> p(n + 1);
for (int i = 0; i < n; i++) {
int c, w;
cin >> c;
if (c == prev)
continue;
w = (patterns + p.at(c)) % mod;
patterns = w;
p.at(c) = w;
prev = c;
}
cout << patterns << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
const int mod = 1000000007;
int n, patterns = 1, prev = 0;
cin >> n;
vector<int> p(200001);
for (int i = 0; i < n; i++) {
int c, w;
cin >> c;
if (c == prev)
continue;
w = (patterns + p.at(c)) % mod;
patterns = w;
p.at(c) = w;
prev = c;
}
cout << patterns << endl;
}
| replace | 7 | 8 | 7 | 8 | 0 | |
p03096 | C++ | Runtime Error | #include <bits/stdc++.h>
#include <cassert>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
/*
struct Edge
{
int to;
int weight;
Edge(int t, int w) : to(t), weight(w) {}
};
using Graph = vector<vector<Edge>>;
*/
using Graph = vector<vector<int>>;
const long long INF = 1LL << 60;
const int INT_INF = 1000000000;
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
// int dx[8] = {-1, -1, -1, 0, 0, 1, 1, 1}, dy[8] = {-1, 0, 1, 1, -1, 1, 0, -1};
const int mod = 1000000007;
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const { return mint(*this) += a; }
mint operator-(const mint a) const { return mint(*this) -= a; }
mint operator*(const mint a) const { return mint(*this) *= a; }
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return *this *= a.inv(); }
mint operator/(const mint a) const { return mint(*this) /= a; }
};
istream &operator>>(istream &is, const mint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }
struct combination {
vector<mint> fact, ifact;
combination(int n) : fact(n + 1), ifact(n + 1) {
assert(n < mod);
fact[0] = 1;
for (int i = 1; i <= n; ++i)
fact[i] = fact[i - 1] * i;
ifact[n] = fact[n].inv();
for (int i = n; i >= 1; --i)
ifact[i - 1] = ifact[i] * i;
}
mint operator()(int n, int k) {
if (k < 0 || k > n)
return 0;
return fact[n] * ifact[k] * ifact[n - k];
}
mint p(int n, int k) { return fact[n] * ifact[n - k]; }
} c(1000005);
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int N;
cin >> N;
vector<int> C(N);
for (auto &it : C) {
cin >> it;
it--;
}
vector<int> left(N + 2, -1);
vector<mint> dp(N + 2, 0);
dp[0] = 1;
for (int i = 0; i < N; i++) {
dp[i + 1] += dp[i];
int c = C[i];
if (left[c] >= 0 && left[c] < i - 1)
dp[i + 1] += dp[left[c] + 1];
left[c] = i;
}
cout << dp[N] << endl;
return 0;
} | #include <bits/stdc++.h>
#include <cassert>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
/*
struct Edge
{
int to;
int weight;
Edge(int t, int w) : to(t), weight(w) {}
};
using Graph = vector<vector<Edge>>;
*/
using Graph = vector<vector<int>>;
const long long INF = 1LL << 60;
const int INT_INF = 1000000000;
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
// int dx[8] = {-1, -1, -1, 0, 0, 1, 1, 1}, dy[8] = {-1, 0, 1, 1, -1, 1, 0, -1};
const int mod = 1000000007;
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const { return mint(*this) += a; }
mint operator-(const mint a) const { return mint(*this) -= a; }
mint operator*(const mint a) const { return mint(*this) *= a; }
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return *this *= a.inv(); }
mint operator/(const mint a) const { return mint(*this) /= a; }
};
istream &operator>>(istream &is, const mint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }
struct combination {
vector<mint> fact, ifact;
combination(int n) : fact(n + 1), ifact(n + 1) {
assert(n < mod);
fact[0] = 1;
for (int i = 1; i <= n; ++i)
fact[i] = fact[i - 1] * i;
ifact[n] = fact[n].inv();
for (int i = n; i >= 1; --i)
ifact[i - 1] = ifact[i] * i;
}
mint operator()(int n, int k) {
if (k < 0 || k > n)
return 0;
return fact[n] * ifact[k] * ifact[n - k];
}
mint p(int n, int k) { return fact[n] * ifact[n - k]; }
} c(1000005);
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int N;
cin >> N;
vector<int> C(N);
for (auto &it : C) {
cin >> it;
it--;
}
vector<int> left(200001, -1);
vector<mint> dp(200001, 0);
dp[0] = 1;
for (int i = 0; i < N; i++) {
dp[i + 1] += dp[i];
int c = C[i];
if (left[c] >= 0 && left[c] < i - 1)
dp[i + 1] += dp[left[c] + 1];
left[c] = i;
}
cout << dp[N] << endl;
return 0;
} | replace | 93 | 95 | 93 | 95 | 0 | |
p03096 | C++ | Runtime Error | #include <algorithm>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
long long MOD = 1000000007;
int main() {
int N;
cin >> N;
vector<int> C(N, 0);
for (int i = 0; i < N; i++) {
cin >> C[i];
}
vector<long long> pattern(N, 0);
pattern[0] = 1;
vector<int> prev(N + 1, -1);
for (int i = 0; i < N; i++) {
int c = C[i];
if (prev[c] != -1 && prev[c] != i - 1) {
pattern[i] = (pattern[prev[c]] + pattern[i - 1]) % MOD;
} else if (i > 0) {
pattern[i] = pattern[i - 1];
}
prev[c] = i;
}
cout << pattern[N - 1] << endl;
} | #include <algorithm>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
long long MOD = 1000000007;
int main() {
int N;
cin >> N;
vector<int> C(N, 0);
for (int i = 0; i < N; i++) {
cin >> C[i];
}
vector<long long> pattern(N, 0);
pattern[0] = 1;
vector<int> prev(200000 + 1, -1);
for (int i = 0; i < N; i++) {
int c = C[i];
if (prev[c] != -1 && prev[c] != i - 1) {
pattern[i] = (pattern[prev[c]] + pattern[i - 1]) % MOD;
} else if (i > 0) {
pattern[i] = pattern[i - 1];
}
prev[c] = i;
}
cout << pattern[N - 1] << endl;
} | replace | 26 | 27 | 26 | 27 | 0 | |
p03096 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define REP(i, N) for (int i = 0; i < (int)N; i++)
#define FOR(i, a, b) for (int i = a; i < (int)b; i++)
#define ALL(x) (x).begin(), (x).end()
#define INF (1 << 30)
#define LLINF (1LL << 62)
#define DEBUG(...) debug(__LINE__, ":" __VA_ARGS__)
constexpr int MOD = 1000000007;
using ll = long long;
using Pii = pair<int, int>;
using Pll = pair<ll, ll>;
template <class T> string to_string(T s);
template <class S, class T> string to_string(pair<S, T> p);
string to_string(string s);
template <class T> string to_string(T v) {
if (v.empty())
return "{}";
string ret = "{";
auto itr = v.begin(), next = ++v.begin();
for (; next != v.end(); ++itr, ++next)
ret += to_string(*itr) + ",";
ret += to_string(*itr) + "}";
return ret;
}
template <class S, class T> string to_string(pair<S, T> p) {
return "{" + to_string(p.first) + "," + to_string(p.second) + "}";
}
string to_string(string s) { return s; }
void debug() { cerr << endl; }
template <class Head, class... Tail> void debug(Head head, Tail... tail) {
cerr << to_string(head) << " ";
debug(tail...);
}
struct IO {
#ifdef _WIN32
inline char getchar_unlocked() { return getchar(); }
inline void putchar_unlocked(char c) { putchar(c); }
#endif
string separator = " ";
template <class T> inline void read(T &x) {
char c;
do {
c = getchar_unlocked();
} while (c != '-' && (c < '0' || '9' < c));
bool minus = 0;
if (c == '-') {
minus = 1;
c = getchar_unlocked();
}
x = 0;
while ('0' <= c && c <= '9') {
x *= 10;
x += c - '0';
c = getchar_unlocked();
}
if (minus)
x = -x;
}
inline void read(string &x) {
char c;
do {
c = getchar_unlocked();
} while (c == ' ' || c == '\n');
x.clear();
do {
x += c;
c = getchar_unlocked();
} while (c != ' ' && c != '\n' && c != EOF);
}
template <class T> inline void read(vector<T> &v) {
for (auto &x : v)
read(x);
}
template <class Head, class... Tail>
inline void read(Head &head, Tail &...tail) {
read(head);
read(tail...);
}
template <class T> inline void write(T x) {
char buf[32];
int p = 0;
if (x < 0) {
x = -x;
putchar_unlocked('-');
}
if (x == 0)
putchar_unlocked('0');
while (x > 0) {
buf[p++] = (x % 10) + '0';
x /= 10;
}
while (p) {
putchar_unlocked(buf[--p]);
}
}
inline void write(string x) {
for (char c : x)
putchar_unlocked(c);
}
inline void write(const char s[]) {
for (int i = 0; s[i] != 0; ++i)
putchar_unlocked(s[i]);
}
template <class T> inline void write(vector<T> v) {
for (auto itr = v.begin(); itr + 1 != v.end(); ++itr) {
write(*itr);
write(separator);
}
write(v.back());
}
template <class Head, class... Tail>
inline void write(Head head, Tail... tail) {
write(head);
write(separator);
write(tail...);
}
void set_separator(string s) { separator = s; }
} io;
int main() {
int N;
io.read(N);
vector<int> C(N);
io.read(C);
vector<ll> dp(N + 1);
vector<int> last(100000, -1);
dp[0] = 1;
REP(i, N) {
dp[i + 1] = dp[i];
if (last[C[i] - 1] != -1 && last[C[i] - 1] != i - 1)
dp[i + 1] += dp[last[C[i] - 1] + 1];
dp[i + 1] %= MOD;
last[C[i] - 1] = i;
}
io.write(dp[N]);
io.write("\n");
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define REP(i, N) for (int i = 0; i < (int)N; i++)
#define FOR(i, a, b) for (int i = a; i < (int)b; i++)
#define ALL(x) (x).begin(), (x).end()
#define INF (1 << 30)
#define LLINF (1LL << 62)
#define DEBUG(...) debug(__LINE__, ":" __VA_ARGS__)
constexpr int MOD = 1000000007;
using ll = long long;
using Pii = pair<int, int>;
using Pll = pair<ll, ll>;
template <class T> string to_string(T s);
template <class S, class T> string to_string(pair<S, T> p);
string to_string(string s);
template <class T> string to_string(T v) {
if (v.empty())
return "{}";
string ret = "{";
auto itr = v.begin(), next = ++v.begin();
for (; next != v.end(); ++itr, ++next)
ret += to_string(*itr) + ",";
ret += to_string(*itr) + "}";
return ret;
}
template <class S, class T> string to_string(pair<S, T> p) {
return "{" + to_string(p.first) + "," + to_string(p.second) + "}";
}
string to_string(string s) { return s; }
void debug() { cerr << endl; }
template <class Head, class... Tail> void debug(Head head, Tail... tail) {
cerr << to_string(head) << " ";
debug(tail...);
}
struct IO {
#ifdef _WIN32
inline char getchar_unlocked() { return getchar(); }
inline void putchar_unlocked(char c) { putchar(c); }
#endif
string separator = " ";
template <class T> inline void read(T &x) {
char c;
do {
c = getchar_unlocked();
} while (c != '-' && (c < '0' || '9' < c));
bool minus = 0;
if (c == '-') {
minus = 1;
c = getchar_unlocked();
}
x = 0;
while ('0' <= c && c <= '9') {
x *= 10;
x += c - '0';
c = getchar_unlocked();
}
if (minus)
x = -x;
}
inline void read(string &x) {
char c;
do {
c = getchar_unlocked();
} while (c == ' ' || c == '\n');
x.clear();
do {
x += c;
c = getchar_unlocked();
} while (c != ' ' && c != '\n' && c != EOF);
}
template <class T> inline void read(vector<T> &v) {
for (auto &x : v)
read(x);
}
template <class Head, class... Tail>
inline void read(Head &head, Tail &...tail) {
read(head);
read(tail...);
}
template <class T> inline void write(T x) {
char buf[32];
int p = 0;
if (x < 0) {
x = -x;
putchar_unlocked('-');
}
if (x == 0)
putchar_unlocked('0');
while (x > 0) {
buf[p++] = (x % 10) + '0';
x /= 10;
}
while (p) {
putchar_unlocked(buf[--p]);
}
}
inline void write(string x) {
for (char c : x)
putchar_unlocked(c);
}
inline void write(const char s[]) {
for (int i = 0; s[i] != 0; ++i)
putchar_unlocked(s[i]);
}
template <class T> inline void write(vector<T> v) {
for (auto itr = v.begin(); itr + 1 != v.end(); ++itr) {
write(*itr);
write(separator);
}
write(v.back());
}
template <class Head, class... Tail>
inline void write(Head head, Tail... tail) {
write(head);
write(separator);
write(tail...);
}
void set_separator(string s) { separator = s; }
} io;
int main() {
int N;
io.read(N);
vector<int> C(N);
io.read(C);
vector<ll> dp(N + 1);
vector<int> last(200000, -1);
dp[0] = 1;
REP(i, N) {
dp[i + 1] = dp[i];
if (last[C[i] - 1] != -1 && last[C[i] - 1] != i - 1)
dp[i + 1] += dp[last[C[i] - 1] + 1];
dp[i + 1] %= MOD;
last[C[i] - 1] = i;
}
io.write(dp[N]);
io.write("\n");
return 0;
}
| replace | 133 | 134 | 133 | 134 | 0 | |
p03096 | C++ | Runtime Error | #include <stdint.h>
#include <stdlib.h>
#include <algorithm>
#include <iostream>
#include <numeric>
#include <vector>
using namespace std;
using default_counter_t = int64_t;
// macro
#define let auto const &
#define overload4(a, b, c, d, name, ...) name
#define rep1(n) \
for (default_counter_t i = 0, end_i = default_counter_t(n); i < end_i; ++i)
#define rep2(i, n) \
for (default_counter_t i = 0, end_##i = default_counter_t(n); i < end_##i; \
++i)
#define rep3(i, a, b) \
for (default_counter_t i = default_counter_t(a), \
end_##i = default_counter_t(b); \
i < end_##i; ++i)
#define rep4(i, a, b, c) \
for (default_counter_t i = default_counter_t(a), \
end_##i = default_counter_t(b); \
i < end_##i; i += default_counter_t(c))
#define rep(...) overload4(__VA_ARGS__, rep4, rep3, rep2, rep1)(__VA_ARGS__)
#define rrep1(n) \
for (default_counter_t i = default_counter_t(n) - 1; i >= 0; --i)
#define rrep2(i, n) \
for (default_counter_t i = default_counter_t(n) - 1; i >= 0; --i)
#define rrep3(i, a, b) \
for (default_counter_t i = default_counter_t(b) - 1, \
begin_##i = default_counter_t(a); \
i >= begin_##i; --i)
#define rrep4(i, a, b, c) \
for (default_counter_t \
i = (default_counter_t(b) - default_counter_t(a) - 1) / \
default_counter_t(c) * default_counter_t(c) + \
default_counter_t(a), \
begin_##i = default_counter_t(a); \
i >= begin_##i; i -= default_counter_t(c))
#define rrep(...) \
overload4(__VA_ARGS__, rrep4, rrep3, rrep2, rrep1)(__VA_ARGS__)
#define ALL(f, c, ...) \
(([&](decltype((c)) cccc) { \
return (f)(std::begin(cccc), std::end(cccc), ##__VA_ARGS__); \
})(c))
// function
template <class C> constexpr C &Sort(C &a) {
std::sort(std::begin(a), std::end(a));
return a;
}
template <class C> constexpr auto &Min(C const &a) {
return *std::min_element(std::begin(a), std::end(a));
}
template <class C> constexpr auto &Max(C const &a) {
return *std::max_element(std::begin(a), std::end(a));
}
template <class C> constexpr auto Total(C const &c) {
return std::accumulate(std::begin(c), std::end(c), C(0));
}
template <typename T> auto CumSum(std::vector<T> const &v) {
std::vector<T> a(v.size() + 1, T(0));
for (std::size_t i = 0; i < a.size() - size_t(1); ++i)
a[i + 1] = a[i] + v[i];
return a;
}
template <typename T> constexpr bool ChMax(T &a, T const &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T> constexpr bool ChMin(T &a, T const &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
void In(void) { return; }
template <typename First, typename... Rest>
void In(First &first, Rest &...rest) {
cin >> first;
In(rest...);
return;
}
template <class T, typename I> void VectorIn(vector<T> &v, const I n) {
v.resize(size_t(n));
rep(i, v.size()) cin >> v[i];
}
void Out(void) {
cout << "\n";
return;
}
template <typename First, typename... Rest>
void Out(First first, Rest... rest) {
cout << first << " ";
Out(rest...);
return;
}
constexpr auto yes(const bool c) { return c ? "yes" : "no"; }
constexpr auto Yes(const bool c) { return c ? "Yes" : "No"; }
constexpr auto YES(const bool c) { return c ? "YES" : "NO"; }
#ifdef USE_STACK_TRACE_LOGGER
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Weverything"
#include <glog/logging.h>
#pragma clang diagnostic pop
#endif //__clang__
#endif // USE_STACK_TRACE_LOGGER
signed main(int argc, char *argv[]) {
(void)argc;
#ifdef USE_STACK_TRACE_LOGGER
google::InitGoogleLogging(argv[0]);
google::InstallFailureSignalHandler();
#else
(void)argv;
#endif // USE_STACK_TRACE_LOGGER
int64_t N;
In(N);
vector<int64_t> C(N);
rep(i, N) {
In(C[i]);
C[i]--;
}
vector<int64_t> last(N, -1);
vector<int64_t> dp(N, 0);
dp[0] = 1;
last[C[0]] = 0;
rep(i, 1, N) {
int64_t tmp = 0;
if (last[C[i]] >= 0 && last[C[i]] < i - 1) {
tmp = dp[last[C[i]]];
}
last[C[i]] = i;
dp[i] = dp[i - 1] + tmp;
dp[i] %= 1000000007;
}
cout << dp[N - 1] << endl;
return EXIT_SUCCESS;
}
| #include <stdint.h>
#include <stdlib.h>
#include <algorithm>
#include <iostream>
#include <numeric>
#include <vector>
using namespace std;
using default_counter_t = int64_t;
// macro
#define let auto const &
#define overload4(a, b, c, d, name, ...) name
#define rep1(n) \
for (default_counter_t i = 0, end_i = default_counter_t(n); i < end_i; ++i)
#define rep2(i, n) \
for (default_counter_t i = 0, end_##i = default_counter_t(n); i < end_##i; \
++i)
#define rep3(i, a, b) \
for (default_counter_t i = default_counter_t(a), \
end_##i = default_counter_t(b); \
i < end_##i; ++i)
#define rep4(i, a, b, c) \
for (default_counter_t i = default_counter_t(a), \
end_##i = default_counter_t(b); \
i < end_##i; i += default_counter_t(c))
#define rep(...) overload4(__VA_ARGS__, rep4, rep3, rep2, rep1)(__VA_ARGS__)
#define rrep1(n) \
for (default_counter_t i = default_counter_t(n) - 1; i >= 0; --i)
#define rrep2(i, n) \
for (default_counter_t i = default_counter_t(n) - 1; i >= 0; --i)
#define rrep3(i, a, b) \
for (default_counter_t i = default_counter_t(b) - 1, \
begin_##i = default_counter_t(a); \
i >= begin_##i; --i)
#define rrep4(i, a, b, c) \
for (default_counter_t \
i = (default_counter_t(b) - default_counter_t(a) - 1) / \
default_counter_t(c) * default_counter_t(c) + \
default_counter_t(a), \
begin_##i = default_counter_t(a); \
i >= begin_##i; i -= default_counter_t(c))
#define rrep(...) \
overload4(__VA_ARGS__, rrep4, rrep3, rrep2, rrep1)(__VA_ARGS__)
#define ALL(f, c, ...) \
(([&](decltype((c)) cccc) { \
return (f)(std::begin(cccc), std::end(cccc), ##__VA_ARGS__); \
})(c))
// function
template <class C> constexpr C &Sort(C &a) {
std::sort(std::begin(a), std::end(a));
return a;
}
template <class C> constexpr auto &Min(C const &a) {
return *std::min_element(std::begin(a), std::end(a));
}
template <class C> constexpr auto &Max(C const &a) {
return *std::max_element(std::begin(a), std::end(a));
}
template <class C> constexpr auto Total(C const &c) {
return std::accumulate(std::begin(c), std::end(c), C(0));
}
template <typename T> auto CumSum(std::vector<T> const &v) {
std::vector<T> a(v.size() + 1, T(0));
for (std::size_t i = 0; i < a.size() - size_t(1); ++i)
a[i + 1] = a[i] + v[i];
return a;
}
template <typename T> constexpr bool ChMax(T &a, T const &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T> constexpr bool ChMin(T &a, T const &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
void In(void) { return; }
template <typename First, typename... Rest>
void In(First &first, Rest &...rest) {
cin >> first;
In(rest...);
return;
}
template <class T, typename I> void VectorIn(vector<T> &v, const I n) {
v.resize(size_t(n));
rep(i, v.size()) cin >> v[i];
}
void Out(void) {
cout << "\n";
return;
}
template <typename First, typename... Rest>
void Out(First first, Rest... rest) {
cout << first << " ";
Out(rest...);
return;
}
constexpr auto yes(const bool c) { return c ? "yes" : "no"; }
constexpr auto Yes(const bool c) { return c ? "Yes" : "No"; }
constexpr auto YES(const bool c) { return c ? "YES" : "NO"; }
#ifdef USE_STACK_TRACE_LOGGER
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Weverything"
#include <glog/logging.h>
#pragma clang diagnostic pop
#endif //__clang__
#endif // USE_STACK_TRACE_LOGGER
signed main(int argc, char *argv[]) {
(void)argc;
#ifdef USE_STACK_TRACE_LOGGER
google::InitGoogleLogging(argv[0]);
google::InstallFailureSignalHandler();
#else
(void)argv;
#endif // USE_STACK_TRACE_LOGGER
int64_t N;
In(N);
vector<int64_t> C(N);
rep(i, N) {
In(C[i]);
C[i]--;
}
vector<int64_t> last(300000, -1);
vector<int64_t> dp(N, 0);
dp[0] = 1;
last[C[0]] = 0;
rep(i, 1, N) {
int64_t tmp = 0;
if (last[C[i]] >= 0 && last[C[i]] < i - 1) {
tmp = dp[last[C[i]]];
}
last[C[i]] = i;
dp[i] = dp[i - 1] + tmp;
dp[i] %= 1000000007;
}
cout << dp[N - 1] << endl;
return EXIT_SUCCESS;
}
| replace | 141 | 142 | 141 | 142 | 0 | |
p03096 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> C(N);
for (int i = 0; i < N; ++i)
cin >> C[i];
C.erase(unique(begin(C), end(C)), end(C));
const long long MOD = 1000000007;
vector<long long> sum(N + 1);
sum[C[0]] = 1;
for (int i = 1; i < C.size(); ++i) {
sum[C[i]] = (sum[C[i]] + sum[C[i - 1]]) % MOD;
}
cout << sum[*rbegin(C)] << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> C(N);
for (int i = 0; i < N; ++i)
cin >> C[i];
C.erase(unique(begin(C), end(C)), end(C));
const long long MOD = 1000000007;
long long sum[200001] = {};
sum[C[0]] = 1;
for (int i = 1; i < C.size(); ++i) {
sum[C[i]] = (sum[C[i]] + sum[C[i - 1]]) % MOD;
}
cout << sum[*rbegin(C)] << endl;
} | replace | 12 | 13 | 12 | 13 | 0 | |
p03096 | C++ | Runtime Error | #include <cstdio>
#include <cstring>
using namespace std;
using ll = long long;
const static int MOD = 1000000007;
int main() {
int N;
scanf("%d", &N);
int C[N];
scanf("%d", C);
int id = 0;
for (int i = 0; i < N - 1; ++i) {
int tmp;
scanf("%d", &tmp);
if (tmp != C[id])
C[++id] = tmp;
}
int last[N + 1];
memset(last, -1, sizeof last);
ll dp[N];
dp[0] = 1;
last[C[0]] = 0;
for (int i = 0; i < id; ++i) {
dp[i + 1] = dp[i];
if (last[C[i + 1]] >= 0) {
(dp[i + 1] += dp[last[C[i + 1]]]) %= MOD;
}
last[C[i + 1]] = i + 1;
}
printf("%lld\n", dp[id]);
return 0;
} | #include <cstdio>
#include <cstring>
using namespace std;
using ll = long long;
const static int MOD = 1000000007;
int main() {
int N;
scanf("%d", &N);
int C[N];
scanf("%d", C);
int id = 0;
for (int i = 0; i < N - 1; ++i) {
int tmp;
scanf("%d", &tmp);
if (tmp != C[id])
C[++id] = tmp;
}
int last[200001];
memset(last, -1, sizeof last);
ll dp[N];
dp[0] = 1;
last[C[0]] = 0;
for (int i = 0; i < id; ++i) {
dp[i + 1] = dp[i];
if (last[C[i + 1]] >= 0) {
(dp[i + 1] += dp[last[C[i + 1]]]) %= MOD;
}
last[C[i + 1]] = i + 1;
}
printf("%lld\n", dp[id]);
return 0;
} | replace | 18 | 19 | 18 | 19 | 0 | |
p03096 | 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 All(a) (a).begin(), (a).end()
#define sp " "
#define INF 1e18
#define INT_INF 1e9
typedef long long ll;
const ll MOD = 1000000007;
const ll MOD_9 = 998244353;
int N;
int main() {
cin >> N;
vector<int> C(N);
vector<int> F(200010, 0);
long long DP[N + 1];
DP[0] = 1;
Rep(i, N) cin >> C[i + 1];
Rep(i, N) {
if (F[C[i + 1]] == 0)
DP[i + 1] = DP[i];
else if (F[C[i + 1]] == i)
DP[i + 1] = DP[i];
else
DP[i + 1] = DP[i] + DP[F[C[i + 1]]];
F[C[i + 1]] = i + 1;
DP[i + 1] %= MOD;
// cout << DP[i+1] << endl;
}
cout << DP[N] << endl;
// cin >> N;
} | #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 All(a) (a).begin(), (a).end()
#define sp " "
#define INF 1e18
#define INT_INF 1e9
typedef long long ll;
const ll MOD = 1000000007;
const ll MOD_9 = 998244353;
int N;
int main() {
cin >> N;
vector<int> C(N + 1);
vector<int> F(200010, 0);
long long DP[N + 1];
DP[0] = 1;
Rep(i, N) cin >> C[i + 1];
Rep(i, N) {
if (F[C[i + 1]] == 0)
DP[i + 1] = DP[i];
else if (F[C[i + 1]] == i)
DP[i + 1] = DP[i];
else
DP[i + 1] = DP[i] + DP[F[C[i + 1]]];
F[C[i + 1]] = i + 1;
DP[i + 1] %= MOD;
// cout << DP[i+1] << endl;
}
cout << DP[N] << endl;
// cin >> N;
} | replace | 18 | 19 | 18 | 19 | 0 | |
p03096 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define all(s) s.begin(), s.end()
#define vi vector<int>
#define pb push_back
#define ii pair<int, int>
#define x first
#define y second
const int N = 200005;
const int MOD = 1000000007;
int dp[N], c[N];
vi v[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
dp[0] = 1;
for (int i = 1; i <= n; i++) {
cin >> c[i];
v[c[i]].pb(i);
for (int j = 0; j < (int)v[c[i]].size(); j++) {
if (j > 0 && v[c[i]][j] == v[c[i]][j - 1] + 1)
continue;
int u = v[c[i]][j];
dp[i] = (dp[i] + dp[u - 1]) % MOD;
}
}
cout << dp[n];
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define all(s) s.begin(), s.end()
#define vi vector<int>
#define pb push_back
#define ii pair<int, int>
#define x first
#define y second
const int N = 200005;
const int MOD = 1000000007;
int dp[N], c[N];
vi v[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
dp[0] = 1;
for (int i = 1; i <= n; i++) {
cin >> c[i];
v[c[i]].pb(i);
if (v[c[i]].size() == 1) {
dp[i] = dp[i - 1];
continue;
}
int u = v[c[i]][v[c[i]].size() - 2];
if (u == i - 1) {
dp[i] = dp[u];
} else {
dp[i] = (dp[i - 1] + dp[u]) % MOD;
}
}
cout << dp[n];
return 0;
} | replace | 26 | 31 | 26 | 35 | TLE | |
p03096 | C++ | Runtime Error | #include <algorithm>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <functional>
#include <iostream>
#include <iterator>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
using ll = long long;
using ld = double;
using P = pair<ll, ll>;
using T = tuple<ll, ll, ll, ll>; //(x, y, dx, dy)
const ll INF = 1e17;
const ld eps = 1e-10;
const ll MOD = 1e9 + 7;
const double pi = acos(-1.0);
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll N;
cin >> N;
vector<ll> c(N);
for (int i = 0; i < N; i++) {
cin >> c[i];
c[i]--;
}
vector<ll> sum(N);
vector<ll> dp(N + 1);
dp[0] = 1;
for (int i = 0; i < N; i++) {
dp[i + 1] = (dp[i + 1] + dp[i]) % MOD;
if (i == 0 || c[i] != c[i - 1]) {
dp[i + 1] = (dp[i + 1] + sum[c[i]]) % MOD;
sum[c[i]] = (sum[c[i]] + dp[i]) % MOD;
}
}
cout << dp[N] << endl;
return 0;
}
| #include <algorithm>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <functional>
#include <iostream>
#include <iterator>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
using ll = long long;
using ld = double;
using P = pair<ll, ll>;
using T = tuple<ll, ll, ll, ll>; //(x, y, dx, dy)
const ll INF = 1e17;
const ld eps = 1e-10;
const ll MOD = 1e9 + 7;
const double pi = acos(-1.0);
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll N;
cin >> N;
vector<ll> c(N);
for (int i = 0; i < N; i++) {
cin >> c[i];
c[i]--;
}
vector<ll> sum(2e5 + 10);
vector<ll> dp(N + 1);
dp[0] = 1;
for (int i = 0; i < N; i++) {
dp[i + 1] = (dp[i + 1] + dp[i]) % MOD;
if (i == 0 || c[i] != c[i - 1]) {
dp[i + 1] = (dp[i + 1] + sum[c[i]]) % MOD;
sum[c[i]] = (sum[c[i]] + dp[i]) % MOD;
}
}
cout << dp[N] << endl;
return 0;
}
| replace | 40 | 41 | 40 | 41 | 0 | |
p03096 | C++ | Runtime Error | #include <bits/stdc++.h>
#define P 1000000007
using namespace std;
int f[120000], sum[120000];
int a[120000];
int n;
int main() {
scanf("%d", &n);
f[0] = 1;
for (int i = 1; i <= n; i++)
scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) {
f[i] = f[i - 1];
if (a[i] != a[i - 1])
(f[i] += sum[a[i]]) %= P;
if (a[i] != a[i - 1])
(sum[a[i]] = f[i]) %= P;
}
printf("%d\n", f[n]);
} | #include <bits/stdc++.h>
#define P 1000000007
using namespace std;
int f[220000], sum[220000];
int a[220000];
int n;
int main() {
scanf("%d", &n);
f[0] = 1;
for (int i = 1; i <= n; i++)
scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) {
f[i] = f[i - 1];
if (a[i] != a[i - 1])
(f[i] += sum[a[i]]) %= P;
if (a[i] != a[i - 1])
(sum[a[i]] = f[i]) %= P;
}
printf("%d\n", f[n]);
} | replace | 3 | 5 | 3 | 5 | 0 | |
p03096 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define double long double
#define fo(a, b) for (int a = 0; a < b; a++)
#define Sort(a) sort(a.begin(), a.end())
#define rev(a) reverse(a.begin(), a.end())
#define fi first
#define se second
#define sz size()
#define bgn begin()
#define en end()
#define pb push_back
#define pp() pop_back()
#define V vector
#define P pair
#define yuko(a) setprecision(a)
#define uni(a) a.erase(unique(a.begin(), a.end()), a.end())
#define Q queue
#define pri priority_queue
#define Pri priority_queue<int, vector<int>, greater<int>>
#define PriP \
priority_queue<P<int, int>, vector<P<int, int>>, greater<P<int, int>>>
#define ff first.first
#define fs first.second
#define sf second.first
#define ss second.second
#define all(a) (a).begin(), (a).end()
#define elif else if
int low(V<int> &a, int b) {
auto c = lower_bound(a.begin(), a.end(), b);
int d = c - a.bgn;
return d;
}
int upp(V<int> &a, int b) {
auto c = upper_bound(a.begin(), a.end(), b);
int d = c - a.bgn;
return d;
}
template <class T> void cou(vector<vector<T>> a) {
int b = a.size();
int c = a[0].size();
fo(i, b) {
fo(j, c) {
cout << a[i][j];
if (j == c - 1)
cout << endl;
else
cout << ' ';
}
}
}
int wari(int a, int b) {
if (a % b == 0)
return a / b;
else
return a / b + 1;
}
int keta(int a) {
double b = a;
b = log10(b);
int c = b;
return c + 1;
}
int souwa(int a) { return a * (a + 1) / 2; }
int gcm(int a, int b) {
if (a % b == 0)
return b;
return gcm(b, a % b);
}
bool prime(int a) {
if (a < 2)
return false;
else if (a == 2)
return true;
else if (a % 2 == 0)
return false;
for (int i = 3; i <= sqrt(a) + 1; i += 2) {
if (a % i == 0)
return false;
}
return true;
}
struct Union {
vector<int> par;
Union(int a) { par = vector<int>(a, -1); }
int find(int a) {
if (par[a] < 0)
return a;
else
return par[a] = find(par[a]);
}
bool same(int a, int b) { return find(a) == find(b); }
int Size(int a) { return -par[find(a)]; }
void unite(int a, int b) {
a = find(a);
b = find(b);
if (a == b)
return;
if (Size(b) > Size(a))
swap<int>(a, b);
par[a] += par[b];
par[b] = a;
}
};
int ketas(int a) {
string b = to_string(a);
int c = 0;
fo(i, keta(a)) { c += b[i] - '0'; }
return c;
}
bool fe(int a, int b) {
a %= 10;
b %= 10;
if (a == 0)
a = 10;
if (b == 0)
b = 10;
if (a > b)
return true;
else
return false;
}
int INF = 1000000007;
struct edge {
int s, t, d;
};
V<int> mojisyu(string a) {
V<int> b(26, 0);
fo(i, a.sz) { b[a[i] - 'a']++; }
return b;
}
int wa2(int a) {
if (a % 2 == 1)
return a / 2;
return a / 2 - 1;
}
/*signed main(){
int a,b,c;
cin>>a>>b>>c;
V<V<edge>> d(a);
fo(i,b){
edge e;
cin>>e.s>>e.t>>e.d;
d[e.s].pb(e);
}
V<int> e(a,INF);
e[c]=0;
priority_queue<P<int,int>,V<P<int,int>>,greater<P<int,int>>> f;
f.push({0,c});
int h=INF;
while(!f.empty()){
P<int,int> g;
g=f.top();
f.pop();
int v = g.second, i = g.first;
for(edge l : d[v]){
if(e[l.t] > i + l.d){
e[l.t] = i + l.d;
f.push({i+l.d , l.t});
}
}
}
fo(i,a){
if(e[i]==INF)
cout<<"INF"<<endl;
else
cout<<e[i]<<endl;
}
}
?*/
int nCr(int n, int r) {
int a = 1;
r = min(r, n - r);
for (int i = n; i > n - r; i--) {
a *= i;
a /= n - i + 1;
}
return a;
}
/*void sea(int x,int y){
if(x<0||a<=x||y<0||b<=y||c[x][y]=='#')
return;
if(d[x][y])
return;
d[x][y]++;
sea(x+1,y);
sea(x-1,y);
sea(x,y+1);
sea(x,y-1);
}*/
int kaijou(int a) {
int b = 1;
fo(i, a) b *= i + 1;
return b;
}
int nPr(int a, int b) {
if (a < b)
return 0;
if (b == 0)
return 1;
int c = 1;
for (int i = a; i > a - b; i--) {
c *= i;
c %= INF;
}
return c;
}
int modinv(int a, int m) {
int b = m, u = 1, v = 0;
while (b) {
int t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
int lcm(int a, int b) {
int c = modinv(gcm(a, b), INF);
return ((a * c) % INF) * (b % INF) % INF;
}
int MOD = INF;
int fac[1000010], finv[1000010], inv[1000010];
// テーブルを作る前処理
// 先にCOMinit()で前処理をする
// ABC145D
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < 1000010; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
int COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
bool naka(int a, int b, V<V<char>> c) {
return (a >= 0 && b >= 0 && a < c.sz && b < c[0].sz);
}
V<P<int, int>> mawari8 = {{0, -1}, {0, 1}, {1, 0}, {-1, 0},
{-1, -1}, {1, 1}, {1, -1}, {-1, -1}};
int inf = 1000000000000000007;
/*
signed main(){
int a,b,c;
cin>>a>>b>>c;
V<V<edge>> d(a);
fo(i,b){
edge e;
cin>>e.s>>e.t>>e.d;
d[e.s].pb(e);
}
V<int> e(a,INF);
e[c]=0;
priority_queue<P<int,int>,V<P<int,int>>,greater<P<int,int>>> f;
f.push({0,c});
int h=INF;
while(!f.empty()){
P<int,int> g;
g=f.top();
f.pop();
int v = g.second, i = g.first;
for(edge l : d[v]){
if(e[l.t] > i + l.d){
e[l.t] = i + l.d;
f.push({i+l.d , l.t});
}
}
}
fo(i,a){
if(e[i]==INF)
cout<<"INF"<<endl;
else
cout<<e[i]<<endl;
}
}*/
V<P<int, int>> mawari4 = {{0, -1}, {0, 1}, {1, 0}, {-1, 0}};
// 最短経路の表 a(全部INFで初期化)
// 縦横 x,y
// 迷路 f
// スタートsx,sy
// ゴールgx,gy
// 文字はgから使おうね
/*int bfs_haba(){
Q<P<int,int>> b;
a[sx][sy]=0;
b.push({sx,sy});
while(!b.empty()){
P<int,int> c=b.front();
b.pop();
if(c.fi==gx&&c.se==gy){
break;
}
fo(i,4){
int d=c.fi+mawari4[i].fi;
int e=c.se+mawari4[i].se;
if(0<=d&&0<=e&&d<x&&e<y&&f[d][e]!='#'&&a[d][e]==INF){
b.push({d,e});
a[d][e]=1+a[c.fi][c.se];
}
}
}
return a[gx][gy];
}*/
V<int> onajibubun(string a) {
V<int> b(a.sz);
for (int i = 1, j = 0; i < a.sz; i++) {
if (i + b[i - j] < j + b[j])
b[i] = b[i - j];
else {
int c = max<int>(0, j + b[j] - i);
while (i + c < a.sz && a[c] == a[i + c])
c++;
b[i] = c;
j = i;
}
}
b[0] = a.sz;
return b;
}
// 各頂点ごとにどこに辺が出てるかの表がc
// 各頂点ごとの色を表すV<int>(頂点数max)のcolorを用意する
// aはどこ塗るか、bは何で塗るかなので、(0,1,c)でよぶとおけ
V<int> color(205);
bool nibu_hantei(int a, int b, V<V<int>> c) {
color[a] = b;
fo(i, c[a].sz) {
if (b == color[c[a][i]])
return false;
if (color[c[a][i]] == 0 && !nibu_hantei(c[a][i], -b, c))
return false;
}
return true;
}
// aは頂点数
// nibu_hanteiの上にcolorを用意する
// 各頂点ごとにどこに辺が出てるかの表がc
bool renketujanai_nibu_hantei(int a, V<V<int>> c) {
fo(i, a) {
if (color[i] == 0) {
if (!nibu_hantei(i, 1, c))
return false;
}
}
return true;
}
signed main() {
int a;
cin >> a;
V<int> b(a);
fo(i, a) cin >> b[i];
V<V<int>> c(a + 100);
fo(i, a) { c[b[i]].pb(i); }
V<int> dp(a + 100);
dp[0] = 1;
for (int i = 1; i <= a; i++) {
dp[i] += dp[i - 1];
dp[i] %= INF;
int e = low(c[b[i - 1]], i - 1);
if (e > 0) {
int f = c[b[i - 1]][e - 1];
if (i - 1 - f > 1) {
dp[i] += dp[f + 1];
dp[i] %= INF;
}
}
}
cout << dp[a] << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define double long double
#define fo(a, b) for (int a = 0; a < b; a++)
#define Sort(a) sort(a.begin(), a.end())
#define rev(a) reverse(a.begin(), a.end())
#define fi first
#define se second
#define sz size()
#define bgn begin()
#define en end()
#define pb push_back
#define pp() pop_back()
#define V vector
#define P pair
#define yuko(a) setprecision(a)
#define uni(a) a.erase(unique(a.begin(), a.end()), a.end())
#define Q queue
#define pri priority_queue
#define Pri priority_queue<int, vector<int>, greater<int>>
#define PriP \
priority_queue<P<int, int>, vector<P<int, int>>, greater<P<int, int>>>
#define ff first.first
#define fs first.second
#define sf second.first
#define ss second.second
#define all(a) (a).begin(), (a).end()
#define elif else if
int low(V<int> &a, int b) {
auto c = lower_bound(a.begin(), a.end(), b);
int d = c - a.bgn;
return d;
}
int upp(V<int> &a, int b) {
auto c = upper_bound(a.begin(), a.end(), b);
int d = c - a.bgn;
return d;
}
template <class T> void cou(vector<vector<T>> a) {
int b = a.size();
int c = a[0].size();
fo(i, b) {
fo(j, c) {
cout << a[i][j];
if (j == c - 1)
cout << endl;
else
cout << ' ';
}
}
}
int wari(int a, int b) {
if (a % b == 0)
return a / b;
else
return a / b + 1;
}
int keta(int a) {
double b = a;
b = log10(b);
int c = b;
return c + 1;
}
int souwa(int a) { return a * (a + 1) / 2; }
int gcm(int a, int b) {
if (a % b == 0)
return b;
return gcm(b, a % b);
}
bool prime(int a) {
if (a < 2)
return false;
else if (a == 2)
return true;
else if (a % 2 == 0)
return false;
for (int i = 3; i <= sqrt(a) + 1; i += 2) {
if (a % i == 0)
return false;
}
return true;
}
struct Union {
vector<int> par;
Union(int a) { par = vector<int>(a, -1); }
int find(int a) {
if (par[a] < 0)
return a;
else
return par[a] = find(par[a]);
}
bool same(int a, int b) { return find(a) == find(b); }
int Size(int a) { return -par[find(a)]; }
void unite(int a, int b) {
a = find(a);
b = find(b);
if (a == b)
return;
if (Size(b) > Size(a))
swap<int>(a, b);
par[a] += par[b];
par[b] = a;
}
};
int ketas(int a) {
string b = to_string(a);
int c = 0;
fo(i, keta(a)) { c += b[i] - '0'; }
return c;
}
bool fe(int a, int b) {
a %= 10;
b %= 10;
if (a == 0)
a = 10;
if (b == 0)
b = 10;
if (a > b)
return true;
else
return false;
}
int INF = 1000000007;
struct edge {
int s, t, d;
};
V<int> mojisyu(string a) {
V<int> b(26, 0);
fo(i, a.sz) { b[a[i] - 'a']++; }
return b;
}
int wa2(int a) {
if (a % 2 == 1)
return a / 2;
return a / 2 - 1;
}
/*signed main(){
int a,b,c;
cin>>a>>b>>c;
V<V<edge>> d(a);
fo(i,b){
edge e;
cin>>e.s>>e.t>>e.d;
d[e.s].pb(e);
}
V<int> e(a,INF);
e[c]=0;
priority_queue<P<int,int>,V<P<int,int>>,greater<P<int,int>>> f;
f.push({0,c});
int h=INF;
while(!f.empty()){
P<int,int> g;
g=f.top();
f.pop();
int v = g.second, i = g.first;
for(edge l : d[v]){
if(e[l.t] > i + l.d){
e[l.t] = i + l.d;
f.push({i+l.d , l.t});
}
}
}
fo(i,a){
if(e[i]==INF)
cout<<"INF"<<endl;
else
cout<<e[i]<<endl;
}
}
?*/
int nCr(int n, int r) {
int a = 1;
r = min(r, n - r);
for (int i = n; i > n - r; i--) {
a *= i;
a /= n - i + 1;
}
return a;
}
/*void sea(int x,int y){
if(x<0||a<=x||y<0||b<=y||c[x][y]=='#')
return;
if(d[x][y])
return;
d[x][y]++;
sea(x+1,y);
sea(x-1,y);
sea(x,y+1);
sea(x,y-1);
}*/
int kaijou(int a) {
int b = 1;
fo(i, a) b *= i + 1;
return b;
}
int nPr(int a, int b) {
if (a < b)
return 0;
if (b == 0)
return 1;
int c = 1;
for (int i = a; i > a - b; i--) {
c *= i;
c %= INF;
}
return c;
}
int modinv(int a, int m) {
int b = m, u = 1, v = 0;
while (b) {
int t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
int lcm(int a, int b) {
int c = modinv(gcm(a, b), INF);
return ((a * c) % INF) * (b % INF) % INF;
}
int MOD = INF;
int fac[1000010], finv[1000010], inv[1000010];
// テーブルを作る前処理
// 先にCOMinit()で前処理をする
// ABC145D
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < 1000010; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
int COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
bool naka(int a, int b, V<V<char>> c) {
return (a >= 0 && b >= 0 && a < c.sz && b < c[0].sz);
}
V<P<int, int>> mawari8 = {{0, -1}, {0, 1}, {1, 0}, {-1, 0},
{-1, -1}, {1, 1}, {1, -1}, {-1, -1}};
int inf = 1000000000000000007;
/*
signed main(){
int a,b,c;
cin>>a>>b>>c;
V<V<edge>> d(a);
fo(i,b){
edge e;
cin>>e.s>>e.t>>e.d;
d[e.s].pb(e);
}
V<int> e(a,INF);
e[c]=0;
priority_queue<P<int,int>,V<P<int,int>>,greater<P<int,int>>> f;
f.push({0,c});
int h=INF;
while(!f.empty()){
P<int,int> g;
g=f.top();
f.pop();
int v = g.second, i = g.first;
for(edge l : d[v]){
if(e[l.t] > i + l.d){
e[l.t] = i + l.d;
f.push({i+l.d , l.t});
}
}
}
fo(i,a){
if(e[i]==INF)
cout<<"INF"<<endl;
else
cout<<e[i]<<endl;
}
}*/
V<P<int, int>> mawari4 = {{0, -1}, {0, 1}, {1, 0}, {-1, 0}};
// 最短経路の表 a(全部INFで初期化)
// 縦横 x,y
// 迷路 f
// スタートsx,sy
// ゴールgx,gy
// 文字はgから使おうね
/*int bfs_haba(){
Q<P<int,int>> b;
a[sx][sy]=0;
b.push({sx,sy});
while(!b.empty()){
P<int,int> c=b.front();
b.pop();
if(c.fi==gx&&c.se==gy){
break;
}
fo(i,4){
int d=c.fi+mawari4[i].fi;
int e=c.se+mawari4[i].se;
if(0<=d&&0<=e&&d<x&&e<y&&f[d][e]!='#'&&a[d][e]==INF){
b.push({d,e});
a[d][e]=1+a[c.fi][c.se];
}
}
}
return a[gx][gy];
}*/
V<int> onajibubun(string a) {
V<int> b(a.sz);
for (int i = 1, j = 0; i < a.sz; i++) {
if (i + b[i - j] < j + b[j])
b[i] = b[i - j];
else {
int c = max<int>(0, j + b[j] - i);
while (i + c < a.sz && a[c] == a[i + c])
c++;
b[i] = c;
j = i;
}
}
b[0] = a.sz;
return b;
}
// 各頂点ごとにどこに辺が出てるかの表がc
// 各頂点ごとの色を表すV<int>(頂点数max)のcolorを用意する
// aはどこ塗るか、bは何で塗るかなので、(0,1,c)でよぶとおけ
V<int> color(205);
bool nibu_hantei(int a, int b, V<V<int>> c) {
color[a] = b;
fo(i, c[a].sz) {
if (b == color[c[a][i]])
return false;
if (color[c[a][i]] == 0 && !nibu_hantei(c[a][i], -b, c))
return false;
}
return true;
}
// aは頂点数
// nibu_hanteiの上にcolorを用意する
// 各頂点ごとにどこに辺が出てるかの表がc
bool renketujanai_nibu_hantei(int a, V<V<int>> c) {
fo(i, a) {
if (color[i] == 0) {
if (!nibu_hantei(i, 1, c))
return false;
}
}
return true;
}
signed main() {
int a;
cin >> a;
V<int> b(a);
fo(i, a) cin >> b[i];
V<V<int>> c(200009);
fo(i, a) { c[b[i]].pb(i); }
V<int> dp(a + 100);
dp[0] = 1;
for (int i = 1; i <= a; i++) {
dp[i] += dp[i - 1];
dp[i] %= INF;
int e = low(c[b[i - 1]], i - 1);
if (e > 0) {
int f = c[b[i - 1]][e - 1];
if (i - 1 - f > 1) {
dp[i] += dp[f + 1];
dp[i] %= INF;
}
}
}
cout << dp[a] << endl;
} | replace | 365 | 366 | 365 | 366 | 0 | |
p03096 | C++ | Runtime Error | #include <array>
#include <bits/stdc++.h>
using namespace std;
using ULL = unsigned long long;
using UL = unsigned;
using LL = long long;
#define rep(i, n) for (UL i = 0; i < (n); i++)
struct Problem {
void Solve() {
UL N;
cin >> N;
vector<UL> C(N);
rep(i, N) {
cin >> C[i];
C[i]--;
}
vector<ULL> dp(N + 1);
dp[0] = 1;
vector<UL> P(N);
vector<UL> CP;
CP.assign(N, (UL)-1);
rep(i, N) {
P[i] = CP[C[i]];
CP[C[i]] = i;
}
// rep(i, N) cout << P[i] << " "; cout << endl;
rep(i, N) {
dp[i + 1] = dp[i];
if (P[i] != -1)
if (P[i] != i - 1)
dp[i + 1] += dp[P[i] + 1];
dp[i + 1] %= 1000000007;
}
// rep(i, N) cout << dp[i] << " ";
cout << dp[N] << endl;
}
Problem();
};
int main() {
unique_ptr<Problem> p(new Problem());
p->Solve();
return 0;
}
Problem::Problem() { cout << fixed << setprecision(10); } | #include <array>
#include <bits/stdc++.h>
using namespace std;
using ULL = unsigned long long;
using UL = unsigned;
using LL = long long;
#define rep(i, n) for (UL i = 0; i < (n); i++)
struct Problem {
void Solve() {
UL N;
cin >> N;
vector<UL> C(N);
rep(i, N) {
cin >> C[i];
C[i]--;
}
vector<ULL> dp(N + 1);
dp[0] = 1;
vector<UL> P(N);
vector<UL> CP;
CP.assign(200000, (UL)-1);
rep(i, N) {
P[i] = CP[C[i]];
CP[C[i]] = i;
}
// rep(i, N) cout << P[i] << " "; cout << endl;
rep(i, N) {
dp[i + 1] = dp[i];
if (P[i] != -1)
if (P[i] != i - 1)
dp[i + 1] += dp[P[i] + 1];
dp[i + 1] %= 1000000007;
}
// rep(i, N) cout << dp[i] << " ";
cout << dp[N] << endl;
}
Problem();
};
int main() {
unique_ptr<Problem> p(new Problem());
p->Solve();
return 0;
}
Problem::Problem() { cout << fixed << setprecision(10); } | replace | 22 | 23 | 22 | 23 | 0 | |
p03096 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll MOD = 1e9 + 7;
int N;
cin >> N;
vector<int> C(N, 0);
for (int i = 0; i < N; i++) {
int c;
cin >> c;
c--;
C[i] = c;
}
vector<ll> ans(N, 0);
vector<ll> pos(N, -1);
for (int i = 0; i < N; i++) {
int c = C[i];
if (pos[c] != -1 && C[i] != C[i - 1]) {
int p = pos[c];
ans[i] = (ans[i - 1] + ans[p] + 1) % MOD;
} else if (i > 0) {
ans[i] = ans[i - 1];
}
pos[c] = i;
}
cout << (ans[N - 1] + 1) % MOD << '\n';
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll MOD = 1e9 + 7;
int N;
cin >> N;
vector<int> C(N, 0);
for (int i = 0; i < N; i++) {
int c;
cin >> c;
c--;
C[i] = c;
}
vector<ll> ans(N, 0);
vector<ll> pos(2e5 + 10, -1);
for (int i = 0; i < N; i++) {
int c = C[i];
if (pos[c] != -1 && C[i] != C[i - 1]) {
int p = pos[c];
ans[i] = (ans[i - 1] + ans[p] + 1) % MOD;
} else if (i > 0) {
ans[i] = ans[i - 1];
}
pos[c] = i;
}
cout << (ans[N - 1] + 1) % MOD << '\n';
return 0;
} | replace | 20 | 21 | 20 | 21 | 0 | |
p03096 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define fi first
#define se second
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define srep(i, s, t) for (int i = s; i < t; ++i)
#define rng(a) a.begin(), a.end()
#define sz(x) (int)(x).size()
#define uni(x) x.erase(unique(rng(x)), x.end())
#define show(x) cout << #x << " = " << x << endl;
#define PQ(T) priority_queue<T, v(T), greater<T>>
#define newline puts("")
#define v(T) vector<T>
#define vv(T) v(v(T))
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
typedef set<int> S;
typedef queue<int> Q;
typedef queue<P> QP;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<P> vp;
const ll LINF = 1001002003004005006ll;
const int INF = 1001001001;
const int MOD = 1000000007;
int main() {
int N;
cin >> N;
vi A(N);
rep(i, N) { cin >> A[i]; }
vvi cnt(200010);
rep(i, N) { cnt[A[i]].push_back(i); }
vi dp(N + 1, 0);
dp[0] = 1;
rep(i, N) {
vi c = cnt[A[i]];
int p = lower_bound(rng(c), i) - c.begin();
if (p + 1 < sz(c)) {
int r = c[p + 1];
if (r != i + 1) {
dp[r] += dp[i];
dp[r] %= MOD;
}
}
dp[i + 1] += dp[i];
dp[i + 1] %= MOD;
}
cout << dp[N] << endl;
return 0;
} | #include <bits/stdc++.h>
#define fi first
#define se second
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define srep(i, s, t) for (int i = s; i < t; ++i)
#define rng(a) a.begin(), a.end()
#define sz(x) (int)(x).size()
#define uni(x) x.erase(unique(rng(x)), x.end())
#define show(x) cout << #x << " = " << x << endl;
#define PQ(T) priority_queue<T, v(T), greater<T>>
#define newline puts("")
#define v(T) vector<T>
#define vv(T) v(v(T))
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
typedef set<int> S;
typedef queue<int> Q;
typedef queue<P> QP;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<P> vp;
const ll LINF = 1001002003004005006ll;
const int INF = 1001001001;
const int MOD = 1000000007;
int main() {
int N;
cin >> N;
vi A(N);
rep(i, N) { cin >> A[i]; }
vvi cnt(200010);
rep(i, N) { cnt[A[i]].push_back(i); }
vi dp(N + 1, 0);
dp[0] = 1;
rep(i, N) {
int p = lower_bound(rng(cnt[A[i]]), i) - cnt[A[i]].begin();
if (p + 1 < sz(cnt[A[i]])) {
int r = cnt[A[i]][p + 1];
if (r != i + 1) {
dp[r] += dp[i];
dp[r] %= MOD;
}
}
dp[i + 1] += dp[i];
dp[i + 1] %= MOD;
}
cout << dp[N] << endl;
return 0;
} | replace | 38 | 42 | 38 | 41 | TLE | |
p03096 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL_DEBUG
#include "LOCAL_DEBUG.hpp"
#endif
#define int long long
const int MOD = 1e9 + 7;
signed main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
vector<int> dp(n + 1, 0), pos(n + 1, -1);
for (int i = 0; i < n; i++) {
if (i > 0 && a[i - 1] == a[i]) {
dp[i + 1] = dp[i];
continue;
}
if (pos[a[i]] == -1) {
dp[i + 1] = max(1LL, dp[i]);
pos[a[i]] = i + 1;
} else {
dp[i + 1] = (dp[i] + dp[pos[a[i]]]) % MOD;
pos[a[i]] = i + 1;
}
}
cout << dp[n] << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL_DEBUG
#include "LOCAL_DEBUG.hpp"
#endif
#define int long long
const int MOD = 1e9 + 7;
signed main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
vector<int> dp(n + 1, 0), pos(n + 1 + 2e5, -1);
for (int i = 0; i < n; i++) {
if (i > 0 && a[i - 1] == a[i]) {
dp[i + 1] = dp[i];
continue;
}
if (pos[a[i]] == -1) {
dp[i + 1] = max(1LL, dp[i]);
pos[a[i]] = i + 1;
} else {
dp[i + 1] = (dp[i] + dp[pos[a[i]]]) % MOD;
pos[a[i]] = i + 1;
}
}
cout << dp[n] << endl;
return 0;
}
| replace | 17 | 18 | 17 | 18 | 0 | |
p03096 | C++ | Time Limit Exceeded | #include "bits/stdc++.h"
using namespace std;
const long mod = 1e9 + 7;
void solve() {
int N;
cin >> N;
vector<int> as(N), nx[200020];
for (int i = 0; i < N; i++) {
cin >> as[i];
nx[as[i]].push_back(i);
}
for (int i = 0; i < 200020; i++) {
nx[i].push_back(N + 1);
}
vector<long> dp(N + 1);
dp[0] = 1;
for (int i = 0; i < N; i++) {
int a = as[i];
auto v = nx[a];
int j = *lower_bound(v.begin(), v.end(), i + 1);
if (j != N + 1 && j != i + 1) {
dp[j] += dp[i];
dp[j] %= mod;
}
dp[i + 1] += dp[i];
dp[i + 1] %= mod;
// cout <<i << ' ' << j << ' ' << dp[i] << endl;
}
cout << dp[N] << endl;
}
int main(void) {
solve();
// cout << "yui(*-v・)yui" << endl;
return 0;
}
| #include "bits/stdc++.h"
using namespace std;
const long mod = 1e9 + 7;
void solve() {
int N;
cin >> N;
vector<int> as(N), nx[200020];
for (int i = 0; i < N; i++) {
cin >> as[i];
nx[as[i]].push_back(i);
}
for (int i = 0; i < 200020; i++) {
nx[i].push_back(N + 1);
}
vector<long> dp(N + 1);
dp[0] = 1;
for (int i = 0; i < N; i++) {
int a = as[i];
int j = *lower_bound(nx[a].begin(), nx[a].end(), i + 1);
if (j != N + 1 && j != i + 1) {
dp[j] += dp[i];
dp[j] %= mod;
}
dp[i + 1] += dp[i];
dp[i + 1] %= mod;
// cout <<i << ' ' << j << ' ' << dp[i] << endl;
}
cout << dp[N] << endl;
}
int main(void) {
solve();
// cout << "yui(*-v・)yui" << endl;
return 0;
}
| replace | 21 | 23 | 21 | 22 | TLE | |
p03096 | C++ | Runtime Error | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define pb push_back
#define mp make_pair
#define all(a) begin(a), end(a)
#define FOR(x, val, to) for (int x = (val); x < int((to)); ++x)
#define FORE(x, val, to) for (auto x = (val); x <= (to); ++x)
#define FORR(x, arr) for (auto &x : arr)
#define FORS(x, plus, arr) \
for (auto x = begin(arr) + (plus); x != end(arr); ++x)
#define FORREV(x, plus, arr) \
for (auto x = (arr).rbegin() + (plus); x != (arr).rend(); ++x)
#define REE(s_) \
{ \
cout << s_ << '\n'; \
exit(0); \
}
#define GET(arr) \
for (auto &i : (arr)) \
sc(i)
#define whatis(x) cerr << #x << " is " << (x) << endl;
#define e1 first
#define e2 second
#define INF 0x7f7f7f7f
typedef std::pair<int, int> pi;
typedef std::vector<int> vi;
typedef std::vector<std::string> vs;
typedef int64_t ll;
typedef uint64_t ull;
#define umap unordered_map
#define uset unordered_set
using namespace std;
using namespace __gnu_pbds;
#ifdef _WIN32
#define getchar_unlocked() _getchar_nolock()
#define _CRT_DISABLE_PERFCRIT_LOCKS
#endif
template <class L, class R> ostream &operator<<(ostream &os, map<L, R> P) {
for (auto const &vv : P)
os << "(" << vv.first << "," << vv.second << ")";
return os;
}
template <class T> ostream &operator<<(ostream &os, set<T> V) {
os << "[";
for (auto const &vv : V)
os << vv << ",";
os << "]";
return os;
}
template <class T> ostream &operator<<(ostream &os, vector<T> V) {
os << "[";
for (auto const &vv : V)
os << vv << ",";
os << "]";
return os;
}
template <class L, class R> ostream &operator<<(ostream &os, pair<L, R> P) {
os << "(" << P.first << "," << P.second << ")";
return os;
}
inline int fstoi(const string &str) {
auto it = str.begin();
bool neg = 0;
int num = 0;
if (*it == '-')
neg = 1;
else
num = *it - '0';
++it;
while (it < str.end())
num = num * 10 + (*it++ - '0');
if (neg)
num *= -1;
return num;
}
inline void getch(char &x) {
while (x = getchar_unlocked(), x < 33) {
;
}
}
inline void getstr(string &str) {
str.clear();
char cur;
while (cur = getchar_unlocked(), cur < 33) {
;
}
while (cur > 32) {
str += cur;
cur = getchar_unlocked();
}
}
template <typename T> inline bool sc(T &num) {
bool neg = 0;
int c;
num = 0;
while (c = getchar_unlocked(), c < 33) {
if (c == EOF)
return false;
}
if (c == '-') {
neg = 1;
c = getchar_unlocked();
}
for (; c > 47; c = getchar_unlocked())
num = num * 10 + c - 48;
if (neg)
num *= -1;
return true;
}
template <typename T, typename... Args> inline void sc(T &num, Args &...args) {
bool neg = 0;
int c;
num = 0;
while (c = getchar_unlocked(), c < 33) {
;
}
if (c == '-') {
neg = 1;
c = getchar_unlocked();
}
for (; c > 47; c = getchar_unlocked())
num = num * 10 + c - 48;
if (neg)
num *= -1;
sc(args...);
}
template <typename T>
using ordered_set =
tree<T, null_type, less<T>, rb_tree_tag,
tree_order_statistics_node_update>; // s.find_by_order(),
// s.order_of_key() <- works like
// lower_bound
template <typename T>
using ordered_map =
tree<T, int, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
#define N 1000001
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
sc(n);
ll scol[n];
memset(scol, 0, n << 3);
vi a(n);
GET(a);
a.erase(unique(all(a)), a.end());
FORR(i, a)-- i;
n = a.size();
ll mod = 1000000007;
ll dp[n];
scol[a[0]] = 1;
FOR(i, 0, n) {
dp[i] = scol[a[i]];
/* whatis(i) */
/* whatis(a[i]) */
/* whatis(dp[i]) */
/* if(i+1 < n){ */
/* if(i){ */
/* scol[a[i]] += dp[i-1]; */
/* scol[a[i]] %= mod; */
/* } */
/* else{ */
/* scol[a[i]]++; */
/* } */
if (i + 1 < n) {
scol[a[i + 1]] += dp[i];
scol[a[i + 1]] %= mod;
}
/* } */
}
ll ans = dp[n - 1];
/* FORR(i,scol){ */
/* /1* ans += max((ll)0,i-1); *1/ */
/* ans %= mod; */
/* } */
cout << ans << '\n';
}
| #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define pb push_back
#define mp make_pair
#define all(a) begin(a), end(a)
#define FOR(x, val, to) for (int x = (val); x < int((to)); ++x)
#define FORE(x, val, to) for (auto x = (val); x <= (to); ++x)
#define FORR(x, arr) for (auto &x : arr)
#define FORS(x, plus, arr) \
for (auto x = begin(arr) + (plus); x != end(arr); ++x)
#define FORREV(x, plus, arr) \
for (auto x = (arr).rbegin() + (plus); x != (arr).rend(); ++x)
#define REE(s_) \
{ \
cout << s_ << '\n'; \
exit(0); \
}
#define GET(arr) \
for (auto &i : (arr)) \
sc(i)
#define whatis(x) cerr << #x << " is " << (x) << endl;
#define e1 first
#define e2 second
#define INF 0x7f7f7f7f
typedef std::pair<int, int> pi;
typedef std::vector<int> vi;
typedef std::vector<std::string> vs;
typedef int64_t ll;
typedef uint64_t ull;
#define umap unordered_map
#define uset unordered_set
using namespace std;
using namespace __gnu_pbds;
#ifdef _WIN32
#define getchar_unlocked() _getchar_nolock()
#define _CRT_DISABLE_PERFCRIT_LOCKS
#endif
template <class L, class R> ostream &operator<<(ostream &os, map<L, R> P) {
for (auto const &vv : P)
os << "(" << vv.first << "," << vv.second << ")";
return os;
}
template <class T> ostream &operator<<(ostream &os, set<T> V) {
os << "[";
for (auto const &vv : V)
os << vv << ",";
os << "]";
return os;
}
template <class T> ostream &operator<<(ostream &os, vector<T> V) {
os << "[";
for (auto const &vv : V)
os << vv << ",";
os << "]";
return os;
}
template <class L, class R> ostream &operator<<(ostream &os, pair<L, R> P) {
os << "(" << P.first << "," << P.second << ")";
return os;
}
inline int fstoi(const string &str) {
auto it = str.begin();
bool neg = 0;
int num = 0;
if (*it == '-')
neg = 1;
else
num = *it - '0';
++it;
while (it < str.end())
num = num * 10 + (*it++ - '0');
if (neg)
num *= -1;
return num;
}
inline void getch(char &x) {
while (x = getchar_unlocked(), x < 33) {
;
}
}
inline void getstr(string &str) {
str.clear();
char cur;
while (cur = getchar_unlocked(), cur < 33) {
;
}
while (cur > 32) {
str += cur;
cur = getchar_unlocked();
}
}
template <typename T> inline bool sc(T &num) {
bool neg = 0;
int c;
num = 0;
while (c = getchar_unlocked(), c < 33) {
if (c == EOF)
return false;
}
if (c == '-') {
neg = 1;
c = getchar_unlocked();
}
for (; c > 47; c = getchar_unlocked())
num = num * 10 + c - 48;
if (neg)
num *= -1;
return true;
}
template <typename T, typename... Args> inline void sc(T &num, Args &...args) {
bool neg = 0;
int c;
num = 0;
while (c = getchar_unlocked(), c < 33) {
;
}
if (c == '-') {
neg = 1;
c = getchar_unlocked();
}
for (; c > 47; c = getchar_unlocked())
num = num * 10 + c - 48;
if (neg)
num *= -1;
sc(args...);
}
template <typename T>
using ordered_set =
tree<T, null_type, less<T>, rb_tree_tag,
tree_order_statistics_node_update>; // s.find_by_order(),
// s.order_of_key() <- works like
// lower_bound
template <typename T>
using ordered_map =
tree<T, int, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
#define N 1000001
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
sc(n);
ll scol[300000];
memset(scol, 0, 300000 << 3);
vi a(n);
GET(a);
a.erase(unique(all(a)), a.end());
FORR(i, a)-- i;
n = a.size();
ll mod = 1000000007;
ll dp[n];
scol[a[0]] = 1;
FOR(i, 0, n) {
dp[i] = scol[a[i]];
/* whatis(i) */
/* whatis(a[i]) */
/* whatis(dp[i]) */
/* if(i+1 < n){ */
/* if(i){ */
/* scol[a[i]] += dp[i-1]; */
/* scol[a[i]] %= mod; */
/* } */
/* else{ */
/* scol[a[i]]++; */
/* } */
if (i + 1 < n) {
scol[a[i + 1]] += dp[i];
scol[a[i + 1]] %= mod;
}
/* } */
}
ll ans = dp[n - 1];
/* FORR(i,scol){ */
/* /1* ans += max((ll)0,i-1); *1/ */
/* ans %= mod; */
/* } */
cout << ans << '\n';
}
| replace | 144 | 146 | 144 | 146 | 0 | |
p03096 | C++ | Runtime Error | #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
// #include<ext/pb_ds/assoc_container.hpp>
// #include<ext/pb_ds/tree_policy.hpp>
// #include<ext/pb_ds/tag_and_trait.hpp>
// using namespace __gnu_pbds;
// #include<boost/multiprecision/cpp_int.hpp>
// namespace multiprecisioninteger = boost::multiprecision;
// using cint=multiprecisioninteger::cpp_int;
using namespace std;
using ll = long long;
#define double long double
using datas = pair<ll, ll>;
using ddatas = pair<double, double>;
using tdata = pair<ll, datas>;
using vec = vector<ll>;
using mat = vector<vec>;
using pvec = vector<datas>;
using pmat = vector<pvec>;
// using
// llset=tree<ll,null_type,less<ll>,rb_tree_tag,tree_order_statistics_node_update>;
#define For(i, a, b) for (i = a; i < (ll)b; ++i)
#define bFor(i, b, a) for (i = b, --i; i >= (ll)a; --i)
#define rep(i, N) For(i, 0, N)
#define rep1(i, N) For(i, 1, N)
#define brep(i, N) bFor(i, N, 0)
#define brep1(i, N) bFor(i, N, 1)
#define all(v) (v).begin(), (v).end()
#define allr(v) (v).rbegin(), (v).rend()
#define vsort(v) sort(all(v))
#define vrsort(v) sort(allr(v))
#define endl "\n"
#define eb emplace_back
#define print(v) cout << v << endl
#define printyes cout << "Yes" << endl
#define printno cout << "No" << endl
#define printYES cout << "YES" << endl
#define printNO cout << "NO" << endl
#define output(v) \
do { \
bool f = 0; \
for (auto outi : v) { \
cout << (f ? " " : "") << outi; \
f = 1; \
} \
cout << endl; \
} while (0)
#define matoutput(v) \
do { \
for (auto outimat : v) \
output(outimat); \
} while (0)
const ll mod = 1000000007;
// const ll mod=998244353;
const ll inf = 1LL << 60;
const double PI = acos(-1);
const double eps = 1e-9;
template <class T> inline bool chmax(T &a, T b) {
bool x = a < b;
if (x)
a = b;
return x;
}
template <class T> inline bool chmin(T &a, T b) {
bool x = a > b;
if (x)
a = b;
return x;
}
void startupcpp() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
}
ll gcd(ll a, ll b) {
if (!b)
return abs(a);
return (a % b == 0) ? abs(b) : gcd(b, a % b);
}
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
int main() {
startupcpp();
int i, N, x;
cin >> N;
vec c(1e5 + 1, -1), ans(N, 0);
rep(i, N) {
cin >> x;
if (i)
ans[i] = ans[i - 1];
else
ans[i] = 1;
if (c[x] != -1 && c[x] != i - 1) {
(ans[i] += ans[c[x]]) %= mod;
}
c[x] = i;
}
print(ans[N - 1]);
} | #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
// #include<ext/pb_ds/assoc_container.hpp>
// #include<ext/pb_ds/tree_policy.hpp>
// #include<ext/pb_ds/tag_and_trait.hpp>
// using namespace __gnu_pbds;
// #include<boost/multiprecision/cpp_int.hpp>
// namespace multiprecisioninteger = boost::multiprecision;
// using cint=multiprecisioninteger::cpp_int;
using namespace std;
using ll = long long;
#define double long double
using datas = pair<ll, ll>;
using ddatas = pair<double, double>;
using tdata = pair<ll, datas>;
using vec = vector<ll>;
using mat = vector<vec>;
using pvec = vector<datas>;
using pmat = vector<pvec>;
// using
// llset=tree<ll,null_type,less<ll>,rb_tree_tag,tree_order_statistics_node_update>;
#define For(i, a, b) for (i = a; i < (ll)b; ++i)
#define bFor(i, b, a) for (i = b, --i; i >= (ll)a; --i)
#define rep(i, N) For(i, 0, N)
#define rep1(i, N) For(i, 1, N)
#define brep(i, N) bFor(i, N, 0)
#define brep1(i, N) bFor(i, N, 1)
#define all(v) (v).begin(), (v).end()
#define allr(v) (v).rbegin(), (v).rend()
#define vsort(v) sort(all(v))
#define vrsort(v) sort(allr(v))
#define endl "\n"
#define eb emplace_back
#define print(v) cout << v << endl
#define printyes cout << "Yes" << endl
#define printno cout << "No" << endl
#define printYES cout << "YES" << endl
#define printNO cout << "NO" << endl
#define output(v) \
do { \
bool f = 0; \
for (auto outi : v) { \
cout << (f ? " " : "") << outi; \
f = 1; \
} \
cout << endl; \
} while (0)
#define matoutput(v) \
do { \
for (auto outimat : v) \
output(outimat); \
} while (0)
const ll mod = 1000000007;
// const ll mod=998244353;
const ll inf = 1LL << 60;
const double PI = acos(-1);
const double eps = 1e-9;
template <class T> inline bool chmax(T &a, T b) {
bool x = a < b;
if (x)
a = b;
return x;
}
template <class T> inline bool chmin(T &a, T b) {
bool x = a > b;
if (x)
a = b;
return x;
}
void startupcpp() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
}
ll gcd(ll a, ll b) {
if (!b)
return abs(a);
return (a % b == 0) ? abs(b) : gcd(b, a % b);
}
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
int main() {
startupcpp();
int i, N, x;
cin >> N;
vec c(2e5 + 1, -1), ans(N, 0);
rep(i, N) {
cin >> x;
if (i)
ans[i] = ans[i - 1];
else
ans[i] = 1;
if (c[x] != -1 && c[x] != i - 1) {
(ans[i] += ans[c[x]]) %= mod;
}
c[x] = i;
}
print(ans[N - 1]);
} | replace | 87 | 88 | 87 | 88 | 0 | |
p03096 | C++ | Runtime Error | #pragma GCC optimize("Ofast,unroll-loops,no-stack-protector,fast-math")
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
// #pragma comment(linker, "/stack:200000000")
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef double ld;
typedef pair<int, int> pii;
typedef pair<unsigned, unsigned> puu;
typedef pair<ll, ll> pll;
typedef pair<ld, ld> pdd;
#define X first
#define Y second
// #include <boost/unordered_map.hpp>
// using namespace boost;
/*
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
typedef tree<int, null_type, less<int>, rb_tree_tag,
tree_order_statistics_node_update> rbtree; rbtree T;
*/
namespace io {
const int L = (1 << 20) + 1;
char buf[L], *S, *T, c;
char getchar() {
if (__builtin_expect(S == T, 0)) {
T = (S = buf) + fread(buf, 1, L, stdin);
return (S == T ? EOF : *S++);
}
return *S++;
}
int inp() {
int x = 0, f = 1;
char ch;
for (ch = getchar(); !isdigit(ch); ch = getchar())
if (ch == '-')
f = -1;
for (; isdigit(ch); x = x * 10 + ch - '0', ch = getchar())
;
return x * f;
}
unsigned inpu() {
unsigned x = 0;
char ch;
for (ch = getchar(); !isdigit(ch); ch = getchar())
;
for (; isdigit(ch); x = x * 10 + ch - '0', ch = getchar())
;
return x;
}
ll inp_ll() {
ll x = 0;
int f = 1;
char ch;
for (ch = getchar(); !isdigit(ch); ch = getchar())
if (ch == '-')
f = -1;
for (; isdigit(ch); x = x * 10 + ch - '0', ch = getchar())
;
return x * f;
}
char B[25], *outs = B + 20, *outr = B + 20;
template <class T> inline void print(register T a, register char x = 0) {
if (x)
*--outs = x, x = 0;
if (!a)
*--outs = '0';
else
while (a)
*--outs = (a % 10) + 48, a /= 10;
if (x)
*--outs = x;
fwrite(outs, outr - outs, 1, stdout);
outs = outr;
}
}; // namespace io
using io ::inp;
using io ::inp_ll;
using io ::inpu;
using io ::print;
using i32 = int;
using i64 = long long;
using u8 = unsigned char;
using u32 = unsigned;
using u64 = unsigned long long;
using f64 = double;
using f80 = long double;
// using i128 = __int128_t;
// using u128 = __uint128_t;
// using i128 = i64;
// using u128 = u64;
ll power(ll a, ll b, ll p) {
if (!b)
return 1;
ll t = power(a, b / 2, p);
t = t * t % p;
if (b & 1)
t = t * a % p;
return t;
}
ll exgcd(ll a, ll b, ll &x, ll &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
ll px, py;
ll d = exgcd(b, a % b, px, py);
x = py;
y = px - a / b * py;
return d;
}
template <class T> inline void freshmin(T &a, const T &b) {
if (a > b)
a = b;
}
template <class T> inline void freshmax(T &a, const T &b) {
if (a < b)
a = b;
}
const int MAXN = 100010;
const int MOD = 1000000007;
const f80 MI = f80(1) / MOD;
const int INV2 = (MOD + 1) / 2;
int n;
int a[MAXN], b[MAXN];
vector<int> v[MAXN];
int F[MAXN];
int main() {
int n = inp();
for (int i = 1; i <= n; ++i) {
a[i] = inp();
b[i] = v[a[i]].empty() ? 0 : v[a[i]].back();
v[a[i]].push_back(i);
}
F[0] = 1;
for (int i = 1; i <= n; ++i) {
F[i] = F[i - 1];
if (0 < b[i] && b[i] < i - 1)
F[i] = (F[b[i]] + F[i - 1]) % MOD;
}
cout << F[n] << endl;
return 0;
}
| #pragma GCC optimize("Ofast,unroll-loops,no-stack-protector,fast-math")
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
// #pragma comment(linker, "/stack:200000000")
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef double ld;
typedef pair<int, int> pii;
typedef pair<unsigned, unsigned> puu;
typedef pair<ll, ll> pll;
typedef pair<ld, ld> pdd;
#define X first
#define Y second
// #include <boost/unordered_map.hpp>
// using namespace boost;
/*
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
typedef tree<int, null_type, less<int>, rb_tree_tag,
tree_order_statistics_node_update> rbtree; rbtree T;
*/
namespace io {
const int L = (1 << 20) + 1;
char buf[L], *S, *T, c;
char getchar() {
if (__builtin_expect(S == T, 0)) {
T = (S = buf) + fread(buf, 1, L, stdin);
return (S == T ? EOF : *S++);
}
return *S++;
}
int inp() {
int x = 0, f = 1;
char ch;
for (ch = getchar(); !isdigit(ch); ch = getchar())
if (ch == '-')
f = -1;
for (; isdigit(ch); x = x * 10 + ch - '0', ch = getchar())
;
return x * f;
}
unsigned inpu() {
unsigned x = 0;
char ch;
for (ch = getchar(); !isdigit(ch); ch = getchar())
;
for (; isdigit(ch); x = x * 10 + ch - '0', ch = getchar())
;
return x;
}
ll inp_ll() {
ll x = 0;
int f = 1;
char ch;
for (ch = getchar(); !isdigit(ch); ch = getchar())
if (ch == '-')
f = -1;
for (; isdigit(ch); x = x * 10 + ch - '0', ch = getchar())
;
return x * f;
}
char B[25], *outs = B + 20, *outr = B + 20;
template <class T> inline void print(register T a, register char x = 0) {
if (x)
*--outs = x, x = 0;
if (!a)
*--outs = '0';
else
while (a)
*--outs = (a % 10) + 48, a /= 10;
if (x)
*--outs = x;
fwrite(outs, outr - outs, 1, stdout);
outs = outr;
}
}; // namespace io
using io ::inp;
using io ::inp_ll;
using io ::inpu;
using io ::print;
using i32 = int;
using i64 = long long;
using u8 = unsigned char;
using u32 = unsigned;
using u64 = unsigned long long;
using f64 = double;
using f80 = long double;
// using i128 = __int128_t;
// using u128 = __uint128_t;
// using i128 = i64;
// using u128 = u64;
ll power(ll a, ll b, ll p) {
if (!b)
return 1;
ll t = power(a, b / 2, p);
t = t * t % p;
if (b & 1)
t = t * a % p;
return t;
}
ll exgcd(ll a, ll b, ll &x, ll &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
ll px, py;
ll d = exgcd(b, a % b, px, py);
x = py;
y = px - a / b * py;
return d;
}
template <class T> inline void freshmin(T &a, const T &b) {
if (a > b)
a = b;
}
template <class T> inline void freshmax(T &a, const T &b) {
if (a < b)
a = b;
}
const int MAXN = 1000010;
const int MOD = 1000000007;
const f80 MI = f80(1) / MOD;
const int INV2 = (MOD + 1) / 2;
int n;
int a[MAXN], b[MAXN];
vector<int> v[MAXN];
int F[MAXN];
int main() {
int n = inp();
for (int i = 1; i <= n; ++i) {
a[i] = inp();
b[i] = v[a[i]].empty() ? 0 : v[a[i]].back();
v[a[i]].push_back(i);
}
F[0] = 1;
for (int i = 1; i <= n; ++i) {
F[i] = F[i - 1];
if (0 < b[i] && b[i] < i - 1)
F[i] = (F[b[i]] + F[i - 1]) % MOD;
}
cout << F[n] << endl;
return 0;
}
| replace | 145 | 146 | 145 | 146 | 0 | |
p03096 | C++ | Runtime Error | #include <algorithm>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
#define debug(x) std::cerr << #x << " = " << (x) << std::endl
using namespace std;
typedef long long LL;
const int MAXN = 1e5 + 17;
const int MOD = 1e9 + 7;
LL f[MAXN], lst[MAXN], pre[MAXN], a[MAXN];
int main(int argc, char const *argv[]) {
#ifdef noob
freopen("Input.txt", "r", stdin);
freopen("Output.txt", "w", stdout);
#endif
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
pre[i] = lst[a[i]];
lst[a[i]] = i;
}
f[0] = 1;
for (int i = 1; i <= n; ++i) {
f[i] = f[i - 1];
if (a[i - 1] != a[i] && pre[i] != 0)
f[i] = (f[i] + f[pre[i]]) % MOD;
}
cout << (f[n] % MOD) << endl;
return 0;
}
| #include <algorithm>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
#define debug(x) std::cerr << #x << " = " << (x) << std::endl
using namespace std;
typedef long long LL;
const int MAXN = 2e5 + 17;
const int MOD = 1e9 + 7;
LL f[MAXN], lst[MAXN], pre[MAXN], a[MAXN];
int main(int argc, char const *argv[]) {
#ifdef noob
freopen("Input.txt", "r", stdin);
freopen("Output.txt", "w", stdout);
#endif
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
pre[i] = lst[a[i]];
lst[a[i]] = i;
}
f[0] = 1;
for (int i = 1; i <= n; ++i) {
f[i] = f[i - 1];
if (a[i - 1] != a[i] && pre[i] != 0)
f[i] = (f[i] + f[pre[i]]) % MOD;
}
cout << (f[n] % MOD) << endl;
return 0;
}
| replace | 10 | 11 | 10 | 11 | 0 | |
p03096 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#define _USE_MATH_DEFINES
#include <functional>
#include <math.h>
using namespace std;
#define rep(i, x) for (ll i = 0; i < x; i++)
#define repn(i, x) for (ll i = 1; i <= x; i++)
typedef long long ll;
const ll INF = 1e17;
const ll MOD = 1000000007;
const ll MAX = 1000001;
ll max(ll a, ll b) {
if (a > b) {
return a;
}
return b;
}
ll min(ll a, ll b) {
if (a > b) {
return b;
}
return a;
}
ll gcd(ll a, ll b) {
if (b == 0) {
return a;
}
if (a < b) {
return gcd(b, a);
}
return gcd(b, a % b);
}
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
struct edge {
ll ind;
ll fr;
ll to;
ll d;
};
///////////////////////////
int main() {
ll N;
cin >> N;
vector<ll> C(N + 1);
repn(i, N) cin >> C[i];
vector<ll> pre(N + 1, -1), dp(N + 1, 0);
dp[0] = 1;
repn(i, N) {
dp[i] = dp[i - 1];
if (pre[C[i]] != -1 && pre[C[i]] != i - 1) {
dp[i] += dp[pre[C[i]]];
}
pre[C[i]] = i;
dp[i] %= MOD;
// cout << dp[i] << endl;
}
cout << dp[N];
system("PAUSE");
}
| #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#define _USE_MATH_DEFINES
#include <functional>
#include <math.h>
using namespace std;
#define rep(i, x) for (ll i = 0; i < x; i++)
#define repn(i, x) for (ll i = 1; i <= x; i++)
typedef long long ll;
const ll INF = 1e17;
const ll MOD = 1000000007;
const ll MAX = 1000001;
ll max(ll a, ll b) {
if (a > b) {
return a;
}
return b;
}
ll min(ll a, ll b) {
if (a > b) {
return b;
}
return a;
}
ll gcd(ll a, ll b) {
if (b == 0) {
return a;
}
if (a < b) {
return gcd(b, a);
}
return gcd(b, a % b);
}
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
struct edge {
ll ind;
ll fr;
ll to;
ll d;
};
///////////////////////////
int main() {
ll N;
cin >> N;
vector<ll> C(N + 1);
repn(i, N) cin >> C[i];
vector<ll> pre(300000, -1), dp(N + 1, 0);
dp[0] = 1;
repn(i, N) {
dp[i] = dp[i - 1];
if (pre[C[i]] != -1 && pre[C[i]] != i - 1) {
dp[i] += dp[pre[C[i]]];
}
pre[C[i]] = i;
dp[i] %= MOD;
// cout << dp[i] << endl;
}
cout << dp[N];
system("PAUSE");
}
| replace | 64 | 65 | 64 | 65 | 0 | sh: 1: PAUSE: not found
|
p03096 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define REP(i, n) for (int i = 0; i < (n); i++)
#define ALL(a) a.begin(), a.end()
const int MOD = 1e9 + 7;
struct mint {
int n;
mint(int n_ = 0) : n(n_) {}
};
mint operator+(mint a, mint b) {
a.n += b.n;
if (a.n >= MOD)
a.n -= MOD;
return a;
}
mint operator-(mint a, mint b) {
a.n -= b.n;
if (a.n < 0)
a.n += MOD;
return a;
}
mint operator*(mint a, mint b) { return (long long)a.n * b.n % MOD; }
mint &operator+=(mint &a, mint b) { return a = a + b; }
mint &operator-=(mint &a, mint b) { return a = a - b; }
mint &operator*=(mint &a, mint b) { return a = a * b; }
int main() {
int N;
cin >> N;
vector<int> C(N);
vector<set<int>> st(N);
REP(i, N) {
cin >> C[i];
st[C[i]].insert(i);
}
vector<mint> dp(N + 1);
dp[0] = 1;
for (int i = 0; i < N; i++) {
auto it = st[C[i]].upper_bound(i);
if (it != st[C[i]].end()) {
int j = *it;
if (j > i + 1) {
dp[j] += dp[i];
}
}
dp[i + 1] += dp[i];
}
cout << dp[N].n << endl;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define REP(i, n) for (int i = 0; i < (n); i++)
#define ALL(a) a.begin(), a.end()
const int MOD = 1e9 + 7;
struct mint {
int n;
mint(int n_ = 0) : n(n_) {}
};
mint operator+(mint a, mint b) {
a.n += b.n;
if (a.n >= MOD)
a.n -= MOD;
return a;
}
mint operator-(mint a, mint b) {
a.n -= b.n;
if (a.n < 0)
a.n += MOD;
return a;
}
mint operator*(mint a, mint b) { return (long long)a.n * b.n % MOD; }
mint &operator+=(mint &a, mint b) { return a = a + b; }
mint &operator-=(mint &a, mint b) { return a = a - b; }
mint &operator*=(mint &a, mint b) { return a = a * b; }
int main() {
int N;
cin >> N;
vector<int> C(N);
vector<set<int>> st(200001);
REP(i, N) {
cin >> C[i];
st[C[i]].insert(i);
}
vector<mint> dp(N + 1);
dp[0] = 1;
for (int i = 0; i < N; i++) {
auto it = st[C[i]].upper_bound(i);
if (it != st[C[i]].end()) {
int j = *it;
if (j > i + 1) {
dp[j] += dp[i];
}
}
dp[i + 1] += dp[i];
}
cout << dp[N].n << endl;
} | replace | 42 | 43 | 42 | 43 | 0 | |
p03096 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef complex<ld> cd;
typedef pair<int, int> ii;
typedef tuple<int, int, int> iii;
typedef vector<int> vi;
typedef vector<ii> vii;
typedef vector<ld> vd;
typedef vector<ll> vl;
typedef set<int> si;
typedef set<ii> sii;
typedef set<ld> sd;
typedef set<ll> sl;
typedef map<int, int> mii;
typedef priority_queue<int> pqi;
typedef queue<int> qi;
#define mp make_pair
#define pb push_back
#define f first
#define s second
mt19937 rng((int)std::chrono::steady_clock::now().time_since_epoch().count());
const ll MOD = 1e9 + 7;
ll addmod(ll a, ll b) { return (a % MOD + b % MOD) % MOD; }
ll mulmod(ll a, ll b) {
ll res = 0;
a %= MOD;
b %= MOD;
if (b > a)
swap(a, b);
while (b > 0) {
if (b % 2)
res = (res + a) % MOD;
a = (a * 2) % MOD;
b /= 2;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
vi a;
for (int i = 0, j; i < n; i++) {
cin >> j;
if (i == 0)
a.push_back(j);
else if (j != a.back())
a.push_back(j);
}
vl dp(n);
map<int, ll> ct;
ct[a[0]]++;
for (int i = 1; i < n; i++) {
dp[i] = addmod(dp[i], dp[i - 1]);
dp[i] = addmod(dp[i], ct[a[i]]);
ct[a[i]] = addmod(ct[a[i]], dp[i - 1] + 1);
}
cout << addmod(dp[n - 1], 1) << endl;
}
/*
1 3 1 2 3 2 4
1 1
3 3
2 2
USE LONG LONG!!!!
:pray: :fishy15:
:pray: :summitosity:
:pray: :prodakcin:
.= , =.
_ _ /'/ )\,/,/(_ \ \
`//-.| ( ,\\)\//\)\/_ ) |
//___\ `\\\/\\/\/\\///' /
,-"~`-._ `"--'_ `"""` _ \`'"~-,_
\ `-. '_`. .'_` \ ,-"~`/
`.__.-'`/ (-\ /-) |-.__,'
|| | \O) /^\ (O/ | . <- BESSIE THE COW
`\\ | / `\ /
\\ \ / `\ /
`\\ `-. /' .---.--.\
`\\/`~(, '() ('
/(O) \\ _,.-.,_)
// \\ `\'` /
/ | || `""""~"`
/' |__||
`o
*/ | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef complex<ld> cd;
typedef pair<int, int> ii;
typedef tuple<int, int, int> iii;
typedef vector<int> vi;
typedef vector<ii> vii;
typedef vector<ld> vd;
typedef vector<ll> vl;
typedef set<int> si;
typedef set<ii> sii;
typedef set<ld> sd;
typedef set<ll> sl;
typedef map<int, int> mii;
typedef priority_queue<int> pqi;
typedef queue<int> qi;
#define mp make_pair
#define pb push_back
#define f first
#define s second
mt19937 rng((int)std::chrono::steady_clock::now().time_since_epoch().count());
const ll MOD = 1e9 + 7;
ll addmod(ll a, ll b) { return (a % MOD + b % MOD) % MOD; }
ll mulmod(ll a, ll b) {
ll res = 0;
a %= MOD;
b %= MOD;
if (b > a)
swap(a, b);
while (b > 0) {
if (b % 2)
res = (res + a) % MOD;
a = (a * 2) % MOD;
b /= 2;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
vi a;
for (int i = 0, j; i < n; i++) {
cin >> j;
if (i == 0)
a.push_back(j);
else if (j != a.back())
a.push_back(j);
}
n = a.size();
vl dp(n);
map<int, ll> ct;
ct[a[0]]++;
for (int i = 1; i < n; i++) {
dp[i] = addmod(dp[i], dp[i - 1]);
dp[i] = addmod(dp[i], ct[a[i]]);
ct[a[i]] = addmod(ct[a[i]], dp[i - 1] + 1);
}
cout << addmod(dp[n - 1], 1) << endl;
}
/*
1 3 1 2 3 2 4
1 1
3 3
2 2
USE LONG LONG!!!!
:pray: :fishy15:
:pray: :summitosity:
:pray: :prodakcin:
.= , =.
_ _ /'/ )\,/,/(_ \ \
`//-.| ( ,\\)\//\)\/_ ) |
//___\ `\\\/\\/\/\\///' /
,-"~`-._ `"--'_ `"""` _ \`'"~-,_
\ `-. '_`. .'_` \ ,-"~`/
`.__.-'`/ (-\ /-) |-.__,'
|| | \O) /^\ (O/ | . <- BESSIE THE COW
`\\ | / `\ /
\\ \ / `\ /
`\\ `-. /' .---.--.\
`\\/`~(, '() ('
/(O) \\ _,.-.,_)
// \\ `\'` /
/ | || `""""~"`
/' |__||
`o
*/ | insert | 65 | 65 | 65 | 66 | 0 | |
p03096 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
#define rep(i, n) for (ll(i) = 0; (i) < (ll)(n); (i)++)
#define frep(i, m, n) for (ll(i) = (m); (i) <= (ll)(n); (i)++)
#define rrep(i, n) for (ll(i) = (n)-1; (i) > -1; (i)--)
#define frrep(i, m, n) for (ll(i) = (n); (i) > (ll)(m); (i)--)
#define ALL(x) (x).begin(), (x).end()
const ll INF = 100100100100100100;
const ll MOD = 1000000007;
// get abs
ll my_abs(ll a);
// a^n
ll a_n(ll a, ll n);
// get gcd
ll my_gcd(ll a, ll b);
// a^(-1) % MOD
ll inv(ll a);
// (a+b+c)%MOD
ll madd(ll a, ll b, ll c);
// (a-b)%MOD
ll msub(ll a, ll b);
// (a*b*c)%MOD
ll mtime(ll a, ll b, ll c);
int main() {
ll n;
cin >> n;
vector<ll> c;
vector<vector<ll>> place(n + 1, vector<ll>());
rep(i, n) {
ll tmp;
cin >> tmp;
if (i > 0)
if (c[c.size() - 1] == tmp)
continue;
c.push_back(tmp);
}
rep(i, c.size()) { place[c[i]].push_back(i); }
vector<ll> dp(c.size() + 1, 0);
dp[0] = 1;
frep(i, 1, c.size()) {
dp[i] = madd(dp[i], dp[i - 1], 0);
ll color = c[i - 1];
auto iter = lower_bound(ALL(place[color]), i - 1) - place[color].begin();
if (iter > 0 && place[color][iter - 1] + 1 != i - 1) {
dp[i] = madd(dp[i], dp[place[color][iter - 1] + 1], 0);
}
}
cout << dp[c.size()] << endl;
return 0;
}
ll my_abs(ll a) {
if (a >= 0)
return a;
else
return -1 * a;
}
ll a_n(ll a, ll n) {
if (n == 0)
return 1;
ll ret = a, count = 1;
while (count * 2 < n) {
ret *= ret;
count *= 2;
}
if (count == n)
return ret;
else
return (ret * a_n(a, n - count));
}
ll my_gcd(ll a, ll b) {
if (b == 0)
return a;
return my_gcd(b, a % b);
}
ll inv(ll a) { return a_n(a, MOD - 2); }
ll madd(ll a, ll b, ll c) {
ll ret = (a + b) % MOD;
return (ret + c) % MOD;
}
ll msub(ll a, ll b) {
if (a < b)
return (a - b + MOD) % MOD;
else
return (a - b) % MOD;
}
ll mtime(ll a, ll b, ll c) {
ll ret = (a * b) % MOD;
return (ret * c) % MOD;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
#define rep(i, n) for (ll(i) = 0; (i) < (ll)(n); (i)++)
#define frep(i, m, n) for (ll(i) = (m); (i) <= (ll)(n); (i)++)
#define rrep(i, n) for (ll(i) = (n)-1; (i) > -1; (i)--)
#define frrep(i, m, n) for (ll(i) = (n); (i) > (ll)(m); (i)--)
#define ALL(x) (x).begin(), (x).end()
const ll INF = 100100100100100100;
const ll MOD = 1000000007;
// get abs
ll my_abs(ll a);
// a^n
ll a_n(ll a, ll n);
// get gcd
ll my_gcd(ll a, ll b);
// a^(-1) % MOD
ll inv(ll a);
// (a+b+c)%MOD
ll madd(ll a, ll b, ll c);
// (a-b)%MOD
ll msub(ll a, ll b);
// (a*b*c)%MOD
ll mtime(ll a, ll b, ll c);
int main() {
ll n;
cin >> n;
vector<ll> c;
vector<vector<ll>> place(200005, vector<ll>());
rep(i, n) {
ll tmp;
cin >> tmp;
if (i > 0)
if (c[c.size() - 1] == tmp)
continue;
c.push_back(tmp);
}
rep(i, c.size()) { place[c[i]].push_back(i); }
vector<ll> dp(c.size() + 1, 0);
dp[0] = 1;
frep(i, 1, c.size()) {
dp[i] = madd(dp[i], dp[i - 1], 0);
ll color = c[i - 1];
auto iter = lower_bound(ALL(place[color]), i - 1) - place[color].begin();
if (iter > 0 && place[color][iter - 1] + 1 != i - 1) {
dp[i] = madd(dp[i], dp[place[color][iter - 1] + 1], 0);
}
}
cout << dp[c.size()] << endl;
return 0;
}
ll my_abs(ll a) {
if (a >= 0)
return a;
else
return -1 * a;
}
ll a_n(ll a, ll n) {
if (n == 0)
return 1;
ll ret = a, count = 1;
while (count * 2 < n) {
ret *= ret;
count *= 2;
}
if (count == n)
return ret;
else
return (ret * a_n(a, n - count));
}
ll my_gcd(ll a, ll b) {
if (b == 0)
return a;
return my_gcd(b, a % b);
}
ll inv(ll a) { return a_n(a, MOD - 2); }
ll madd(ll a, ll b, ll c) {
ll ret = (a + b) % MOD;
return (ret + c) % MOD;
}
ll msub(ll a, ll b) {
if (a < b)
return (a - b + MOD) % MOD;
else
return (a - b) % MOD;
}
ll mtime(ll a, ll b, ll c) {
ll ret = (a * b) % MOD;
return (ret * c) % MOD;
}
| replace | 34 | 35 | 34 | 35 | 0 | |
p03096 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <deque>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define ll int64_t
#define Rep(i, n) for (ll i = 0; i < n; i++)
using namespace std;
typedef vector<ll> vec;
typedef vector<vec> mat;
const int MOD = 1000000007;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll N;
cin >> N;
vector<ll> C(N);
Rep(i, N) { cin >> C[i]; }
vec pre(N + 1, -1);
vec check(N, -1);
Rep(i, N) {
check[i] = pre[C[i]];
pre[C[i]] = i;
}
// Rep (i, N) {
// cout << check[i] << " ";
// }
// cout << "\n";
vec dp(N + 1);
dp[0] = 1;
Rep(i, N) {
dp[i + 1] = dp[i];
ll j = check[i];
if (j == i - 1) {
continue;
}
if (j != -1) {
dp[i + 1] += dp[j + 1];
dp[i + 1] %= MOD;
}
}
cout << dp[N] << "\n";
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <deque>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define ll int64_t
#define Rep(i, n) for (ll i = 0; i < n; i++)
using namespace std;
typedef vector<ll> vec;
typedef vector<vec> mat;
const int MOD = 1000000007;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll N;
cin >> N;
vector<ll> C(N);
Rep(i, N) { cin >> C[i]; }
vec pre(2e5 + 1, -1);
vec check(N, -1);
Rep(i, N) {
check[i] = pre[C[i]];
pre[C[i]] = i;
}
// Rep (i, N) {
// cout << check[i] << " ";
// }
// cout << "\n";
vec dp(N + 1);
dp[0] = 1;
Rep(i, N) {
dp[i + 1] = dp[i];
ll j = check[i];
if (j == i - 1) {
continue;
}
if (j != -1) {
dp[i + 1] += dp[j + 1];
dp[i + 1] %= MOD;
}
}
cout << dp[N] << "\n";
} | replace | 32 | 33 | 32 | 33 | 0 | |
p03096 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 100050;
const ll MOD = 1e9 + 7;
int n;
int a[N], p[N];
ll f[N];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i)
scanf("%d", &a[i]);
f[0] = 0;
f[1] = 1;
memset(p, 0, sizeof(p));
p[a[1]] = 1;
for (int i = 2; i <= n; ++i) {
f[i] = f[i - 1];
if (a[i] != a[i - 1])
f[i] = (f[i] + f[p[a[i]]]) % MOD;
p[a[i]] = i;
}
printf("%lld\n", f[n]);
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 200050;
const ll MOD = 1e9 + 7;
int n;
int a[N], p[N];
ll f[N];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i)
scanf("%d", &a[i]);
f[0] = 0;
f[1] = 1;
memset(p, 0, sizeof(p));
p[a[1]] = 1;
for (int i = 2; i <= n; ++i) {
f[i] = f[i - 1];
if (a[i] != a[i - 1])
f[i] = (f[i] + f[p[a[i]]]) % MOD;
p[a[i]] = i;
}
printf("%lld\n", f[n]);
} | replace | 6 | 7 | 6 | 7 | 0 | |
p03096 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int MAXN = 1e5;
int N;
int C[MAXN + 10];
long long dp[MAXN + 10], ss[MAXN + 10];
int main() {
scanf("%d", &N);
for (int i = 0; i < N; i++) {
scanf("%d", &C[i]);
}
dp[N] = 1;
for (int i = N - 1; i >= 0; i--) {
int c = C[i];
if (c != C[i + 1]) {
ss[c] = (ss[c] + dp[i + 1]) % MOD;
}
dp[i] = ss[c];
}
printf("%lld\n", dp[0]);
} | #include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int MAXN = 2e5;
int N;
int C[MAXN + 10];
long long dp[MAXN + 10], ss[MAXN + 10];
int main() {
scanf("%d", &N);
for (int i = 0; i < N; i++) {
scanf("%d", &C[i]);
}
dp[N] = 1;
for (int i = N - 1; i >= 0; i--) {
int c = C[i];
if (c != C[i + 1]) {
ss[c] = (ss[c] + dp[i + 1]) % MOD;
}
dp[i] = ss[c];
}
printf("%lld\n", dp[0]);
}
| replace | 4 | 5 | 4 | 5 | 0 | |
p03096 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <queue>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define int long long
#define vel vector<int>
#define vvel vector<vel>
#define vvvel vector<vvel>
#define veb vector<bool>
long long rui(long long a, long long n, long long p) {
if (n == 0) {
return 1;
}
int x = rui(a, n / 2, p);
x = (x * x) % p;
if (n % 2 == 1) {
x = (x * a) % p;
}
return x;
}
signed main() {
int n;
cin >> n;
vel c(n);
for (int i = 0; i < n; i++) {
cin >> c[i];
}
int p = 1000;
p *= p * p;
p += 7;
vel qc(1, c[0]);
for (int i = 1; i < n; i++) {
if (c[i] != c[i - 1]) {
qc.push_back(c[i]);
}
}
c = qc;
n = c.size();
vel dp(n + 1, 1);
vel counter(20 * 1000 + 1, 0);
for (int i = 1; i <= n; i++) {
dp[i] = dp[i - 1];
dp[i] += counter[c[i - 1]];
dp[i] = dp[i] % p;
counter[c[i - 1]] += dp[i - 1];
counter[c[i - 1]] = counter[c[i - 1]] % p;
}
cout << dp[n] << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <queue>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define int long long
#define vel vector<int>
#define vvel vector<vel>
#define vvvel vector<vvel>
#define veb vector<bool>
long long rui(long long a, long long n, long long p) {
if (n == 0) {
return 1;
}
int x = rui(a, n / 2, p);
x = (x * x) % p;
if (n % 2 == 1) {
x = (x * a) % p;
}
return x;
}
signed main() {
int n;
cin >> n;
vel c(n);
for (int i = 0; i < n; i++) {
cin >> c[i];
}
int p = 1000;
p *= p * p;
p += 7;
vel qc(1, c[0]);
for (int i = 1; i < n; i++) {
if (c[i] != c[i - 1]) {
qc.push_back(c[i]);
}
}
c = qc;
n = c.size();
vel dp(n + 1, 1);
vel counter(20 * 10000 + 1, 0);
for (int i = 1; i <= n; i++) {
dp[i] = dp[i - 1];
dp[i] += counter[c[i - 1]];
dp[i] = dp[i] % p;
counter[c[i - 1]] += dp[i - 1];
counter[c[i - 1]] = counter[c[i - 1]] % p;
}
cout << dp[n] << endl;
return 0;
} | replace | 43 | 44 | 43 | 44 | 0 | |
p03096 | C++ | Runtime Error | #include <bits/stdc++.h>
#define INF 5000000000000000000
#define ll long long
#define pll pair<ll, ll>
using namespace std;
int main() {
ll mod = 1000000007;
ll N;
cin >> N;
vector<ll> C(N);
vector<vector<ll>> color(N);
for (ll i = 0; i < N; ++i) {
ll c;
cin >> c;
C.at(i) = c - 1;
color.at(c - 1).push_back(i);
}
vector<ll> dp(N + 1, 0);
dp.at(0) = 1;
for (ll i = 0; i < N; ++i) {
dp.at(i + 1) = dp.at(i);
ll index =
lower_bound(color.at(C.at(i)).begin(), color.at(C.at(i)).end(), i) -
color.at(C.at(i)).begin() - 1;
if (index >= 0) {
ll j = color.at(C.at(i)).at(index);
if (i - j > 1) {
// cout << i << ' ' << j << endl;
dp.at(i + 1) = (dp.at(i + 1) + dp.at(j + 1)) % mod;
}
}
}
cout << dp.at(N) << endl;
// for (ll i = 0; i < N + 1; ++i) {
// cout << dp.at(i) << ' ';
// }
// cout << endl;
}
| #include <bits/stdc++.h>
#define INF 5000000000000000000
#define ll long long
#define pll pair<ll, ll>
using namespace std;
int main() {
ll mod = 1000000007;
ll N;
cin >> N;
vector<ll> C(N);
vector<vector<ll>> color(2 * 100000);
for (ll i = 0; i < N; ++i) {
ll c;
cin >> c;
C.at(i) = c - 1;
color.at(c - 1).push_back(i);
}
vector<ll> dp(N + 1, 0);
dp.at(0) = 1;
for (ll i = 0; i < N; ++i) {
dp.at(i + 1) = dp.at(i);
ll index =
lower_bound(color.at(C.at(i)).begin(), color.at(C.at(i)).end(), i) -
color.at(C.at(i)).begin() - 1;
if (index >= 0) {
ll j = color.at(C.at(i)).at(index);
if (i - j > 1) {
// cout << i << ' ' << j << endl;
dp.at(i + 1) = (dp.at(i + 1) + dp.at(j + 1)) % mod;
}
}
}
cout << dp.at(N) << endl;
// for (ll i = 0; i < N + 1; ++i) {
// cout << dp.at(i) << ' ';
// }
// cout << endl;
}
| replace | 11 | 12 | 11 | 12 | 0 | |
p03096 | C++ | Runtime Error | #include <iostream>
#include <vector>
using namespace std;
#define ll long long
#define to_mod 1000000007
#define MAX_COLOR 200000
int main() {
int n;
cin >> n;
vector<int> each_color[MAX_COLOR];
int num_each_color[MAX_COLOR];
int color_coll[n];
int idx_each_color[n];
ll comb_points[n];
comb_points[0] = 1;
for (int i = 0; i < MAX_COLOR; i++)
num_each_color[i] = 0;
for (int i = 0; i < n; i++) {
int inp_color;
cin >> inp_color;
color_coll[i] = inp_color;
idx_each_color[i] = num_each_color[inp_color];
num_each_color[inp_color]++;
each_color[inp_color].push_back(i);
}
for (int i = 1; i < n; i++) {
int lst_color = color_coll[i];
int idx_in_color = idx_each_color[i];
if (idx_in_color == 0)
comb_points[i] = comb_points[i - 1];
else {
int prev_idx_in_color = each_color[lst_color][idx_in_color - 1];
int diff = each_color[lst_color][idx_in_color] - prev_idx_in_color;
if (diff > 1)
comb_points[i] = comb_points[prev_idx_in_color] + comb_points[i - 1];
else
comb_points[i] = comb_points[i - 1];
}
comb_points[i] = (comb_points[i] + to_mod) % to_mod;
}
cout << comb_points[n - 1] << endl;
return 0;
} | #include <iostream>
#include <vector>
using namespace std;
#define ll long long
#define to_mod 1000000007
#define MAX_COLOR 200001
int main() {
int n;
cin >> n;
vector<int> each_color[MAX_COLOR];
int num_each_color[MAX_COLOR];
int color_coll[n];
int idx_each_color[n];
ll comb_points[n];
comb_points[0] = 1;
for (int i = 0; i < MAX_COLOR; i++)
num_each_color[i] = 0;
for (int i = 0; i < n; i++) {
int inp_color;
cin >> inp_color;
color_coll[i] = inp_color;
idx_each_color[i] = num_each_color[inp_color];
num_each_color[inp_color]++;
each_color[inp_color].push_back(i);
}
for (int i = 1; i < n; i++) {
int lst_color = color_coll[i];
int idx_in_color = idx_each_color[i];
if (idx_in_color == 0)
comb_points[i] = comb_points[i - 1];
else {
int prev_idx_in_color = each_color[lst_color][idx_in_color - 1];
int diff = each_color[lst_color][idx_in_color] - prev_idx_in_color;
if (diff > 1)
comb_points[i] = comb_points[prev_idx_in_color] + comb_points[i - 1];
else
comb_points[i] = comb_points[i - 1];
}
comb_points[i] = (comb_points[i] + to_mod) % to_mod;
}
cout << comb_points[n - 1] << endl;
return 0;
} | replace | 5 | 6 | 5 | 6 | 0 | |
p03096 | C++ | Runtime Error | // Created by sz
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 2e1 + 5, mod = 1e9 + 7;
int n, c[N], dp[N], last[N];
int main() {
#ifdef LOCAL
freopen("./input.txt", "r", stdin);
#endif
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
int cnt = 1, temp;
for (int i = 1; i <= n; i++) {
cin >> temp;
if (temp != c[cnt - 1]) {
c[cnt++] = temp;
}
}
dp[0] = 1;
for (int i = 1; i < cnt; i++) {
dp[i] = dp[i - 1];
if (last[c[i]] != 0)
(dp[i] += dp[last[c[i]]]) %= mod;
last[c[i]] = i;
}
cout << dp[cnt - 1] << endl;
return 0;
}
| // Created by sz
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 2e5 + 5, mod = 1e9 + 7;
int n, c[N], dp[N], last[N];
int main() {
#ifdef LOCAL
freopen("./input.txt", "r", stdin);
#endif
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
int cnt = 1, temp;
for (int i = 1; i <= n; i++) {
cin >> temp;
if (temp != c[cnt - 1]) {
c[cnt++] = temp;
}
}
dp[0] = 1;
for (int i = 1; i < cnt; i++) {
dp[i] = dp[i - 1];
if (last[c[i]] != 0)
(dp[i] += dp[last[c[i]]]) %= mod;
last[c[i]] = i;
}
cout << dp[cnt - 1] << endl;
return 0;
}
| replace | 5 | 6 | 5 | 6 | 0 | |
p03096 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
// #define int long long
#define rep(i, a, b) for (int i = (a); i <= (b); i++)
#define per(i, a, b) for (int i = (a); i >= (b); i--)
#define loop(s, v, it) for (s::iterator it = v.begin(); it != v.end(); it++)
#define cont(i, x) for (int i = head[x]; i; i = e[i].nxt)
#define clr(a) memset(a, 0, sizeof(a))
#define ass(a, sum) memset(a, sum, sizeof(a))
#define lowbit(x) (x & -x)
#define all(x) x.begin(), x.end()
#define ub upper_bound
#define lb lower_bound
#define pq priority_queue
#define mp make_pair
#define pb push_back
#define fi first
#define se second
#define iv inline void
#define enter cout << endl
#define siz(x) ((int)x.size())
#define file(x) freopen(#x ".in", "r", stdin), freopen(#x ".out", "w", stdout)
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<pii> vii;
typedef queue<int> qi;
typedef queue<pii> qii;
typedef set<int> si;
typedef map<int, int> mii;
typedef map<string, int> msi;
const int N = 100010;
const int INF = 0x3f3f3f3f;
const int iinf = 1 << 30;
const ll linf = 2e18;
const int MOD = 1000000007;
const double eps = 1e-7;
void print(int x) {
cout << x << endl;
exit(0);
}
void PRINT(string x) {
cout << x << endl;
exit(0);
}
void douout(double x) { printf("%lf\n", x + 0.0000000001); }
template <class T> void chmin(T &a, T b) {
if (a > b)
a = b;
}
template <class T> void chmax(T &a, T b) {
if (a < b)
a = b;
}
void upd(int &a, int b) { (a += b) %= MOD; }
void mul(int &a, int b) { a = 1ll * a * b % MOD; }
int n;
int a[N], dp[N], pre[N];
signed main() {
// freopen("test.in", "r", stdin) ;
// freopen("test.out", "w", stdout) ;
scanf("%d", &n);
rep(i, 1, n) scanf("%d", &a[i]);
clr(dp);
clr(pre);
dp[1] = 1;
pre[a[1]] = 1;
rep(i, 2, n) {
if (a[i] == a[i - 1])
dp[i] = dp[i - 1];
else
dp[i] = dp[i - 1] + pre[a[i]];
dp[i] %= MOD;
pre[a[i]] = dp[i];
}
printf("%d\n", dp[n]);
return 0;
}
/*
写代码时请注意：
1.ll？数组大小，边界？数据范围？
2.精度？
3.特判？
4.至少做一些
思考提醒：
1.最大值最小->二分？
2.可以贪心么？不行dp可以么
3.可以优化么
4.维护区间用什么数据结构？
5.统计方案是用dp？模了么？
6.逆向思维？
*/
| #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
// #define int long long
#define rep(i, a, b) for (int i = (a); i <= (b); i++)
#define per(i, a, b) for (int i = (a); i >= (b); i--)
#define loop(s, v, it) for (s::iterator it = v.begin(); it != v.end(); it++)
#define cont(i, x) for (int i = head[x]; i; i = e[i].nxt)
#define clr(a) memset(a, 0, sizeof(a))
#define ass(a, sum) memset(a, sum, sizeof(a))
#define lowbit(x) (x & -x)
#define all(x) x.begin(), x.end()
#define ub upper_bound
#define lb lower_bound
#define pq priority_queue
#define mp make_pair
#define pb push_back
#define fi first
#define se second
#define iv inline void
#define enter cout << endl
#define siz(x) ((int)x.size())
#define file(x) freopen(#x ".in", "r", stdin), freopen(#x ".out", "w", stdout)
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<pii> vii;
typedef queue<int> qi;
typedef queue<pii> qii;
typedef set<int> si;
typedef map<int, int> mii;
typedef map<string, int> msi;
const int N = 200010;
const int INF = 0x3f3f3f3f;
const int iinf = 1 << 30;
const ll linf = 2e18;
const int MOD = 1000000007;
const double eps = 1e-7;
void print(int x) {
cout << x << endl;
exit(0);
}
void PRINT(string x) {
cout << x << endl;
exit(0);
}
void douout(double x) { printf("%lf\n", x + 0.0000000001); }
template <class T> void chmin(T &a, T b) {
if (a > b)
a = b;
}
template <class T> void chmax(T &a, T b) {
if (a < b)
a = b;
}
void upd(int &a, int b) { (a += b) %= MOD; }
void mul(int &a, int b) { a = 1ll * a * b % MOD; }
int n;
int a[N], dp[N], pre[N];
signed main() {
// freopen("test.in", "r", stdin) ;
// freopen("test.out", "w", stdout) ;
scanf("%d", &n);
rep(i, 1, n) scanf("%d", &a[i]);
clr(dp);
clr(pre);
dp[1] = 1;
pre[a[1]] = 1;
rep(i, 2, n) {
if (a[i] == a[i - 1])
dp[i] = dp[i - 1];
else
dp[i] = dp[i - 1] + pre[a[i]];
dp[i] %= MOD;
pre[a[i]] = dp[i];
}
printf("%d\n", dp[n]);
return 0;
}
/*
写代码时请注意：
1.ll？数组大小，边界？数据范围？
2.精度？
3.特判？
4.至少做一些
思考提醒：
1.最大值最小->二分？
2.可以贪心么？不行dp可以么
3.可以优化么
4.维护区间用什么数据结构？
5.统计方案是用dp？模了么？
6.逆向思维？
*/
| replace | 50 | 51 | 50 | 51 | 0 | |
p03096 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <queue>
#include <vector>
#define set0(x) memset(x, 0, sizeof(x))
#define FF first
#define SS second
#define PB push_back
#define MP make_pair
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pll;
template <typename T> void read(T &x) {
x = 0;
char ch = getchar();
int f = 1;
while (!isdigit(ch)) {
if (ch == '-')
f *= -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - 48;
ch = getchar();
}
x *= f;
}
int mod = 1000000007;
inline int sq(int x) { return 1ll * x * x % mod; }
inline int sub(int a, int b) { return a < b ? a - b + mod : a - b; }
inline int add(int a, int b) { return a + b >= mod ? a + b - mod : a + b; }
inline int mul(int a, int b) { return 1ll * a * b % mod; }
inline int pow(int a, int b) {
if (b == 0)
return 1;
return b & 1 ? mul(sq(pow(a, b / 2)), a) : sq(pow(a, b / 2));
}
inline int inv(int a) { return pow(a, mod - 2); }
int n, a[100010], dp[100010], last[100010];
int main() {
read(n);
dp[0] = 1;
for (int i = 1; i <= n; i++) {
read(a[i]);
dp[i] = add(dp[i], dp[i - 1]);
if (last[a[i]] && last[a[i]] != i - 1)
dp[i] = add(dp[i], dp[last[a[i]]]);
last[a[i]] = i;
// cout<<i<<' '<<dp[i]<<endl;
}
cout << dp[n] << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <queue>
#include <vector>
#define set0(x) memset(x, 0, sizeof(x))
#define FF first
#define SS second
#define PB push_back
#define MP make_pair
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pll;
template <typename T> void read(T &x) {
x = 0;
char ch = getchar();
int f = 1;
while (!isdigit(ch)) {
if (ch == '-')
f *= -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - 48;
ch = getchar();
}
x *= f;
}
int mod = 1000000007;
inline int sq(int x) { return 1ll * x * x % mod; }
inline int sub(int a, int b) { return a < b ? a - b + mod : a - b; }
inline int add(int a, int b) { return a + b >= mod ? a + b - mod : a + b; }
inline int mul(int a, int b) { return 1ll * a * b % mod; }
inline int pow(int a, int b) {
if (b == 0)
return 1;
return b & 1 ? mul(sq(pow(a, b / 2)), a) : sq(pow(a, b / 2));
}
inline int inv(int a) { return pow(a, mod - 2); }
int n, a[200010], dp[200010], last[200010];
int main() {
read(n);
dp[0] = 1;
for (int i = 1; i <= n; i++) {
read(a[i]);
dp[i] = add(dp[i], dp[i - 1]);
if (last[a[i]] && last[a[i]] != i - 1)
dp[i] = add(dp[i], dp[last[a[i]]]);
last[a[i]] = i;
// cout<<i<<' '<<dp[i]<<endl;
}
cout << dp[n] << endl;
return 0;
}
| replace | 41 | 42 | 41 | 42 | 0 | |
p03096 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i, l, r) for (int i = (int)(l); i < (int)(r); i++)
#define all(x) (x).begin(), (x).end()
#define sz(x) ((int)x.size())
template <class T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
const int inf = 1LL << 60;
const int mod = 1e9 + 7;
const double eps = 1e-9;
/*{
1 2 3
1 2
}*/
signed main() {
int n;
cin >> n;
vi c(n);
rep(i, 0, n) cin >> c[i];
vi dp(n + 1);
vi prev(n + 1, -1);
dp[0] = 1;
rep(i, 1, n + 1) {
(dp[i] += dp[i - 1]) %= mod;
int &p = prev[c[i - 1]];
if (p != -1 and i - p > 1) {
(dp[i] += dp[p]) %= mod;
}
p = i;
}
cout << dp[n] << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i, l, r) for (int i = (int)(l); i < (int)(r); i++)
#define all(x) (x).begin(), (x).end()
#define sz(x) ((int)x.size())
template <class T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
const int inf = 1LL << 60;
const int mod = 1e9 + 7;
const double eps = 1e-9;
/*{
1 2 3
1 2
}*/
signed main() {
int n;
cin >> n;
vi c(n);
rep(i, 0, n) cin >> c[i];
vi dp(n + 1);
vi prev(200001, -1);
dp[0] = 1;
rep(i, 1, n + 1) {
(dp[i] += dp[i - 1]) %= mod;
int &p = prev[c[i - 1]];
if (p != -1 and i - p > 1) {
(dp[i] += dp[p]) %= mod;
}
p = i;
}
cout << dp[n] << endl;
return 0;
}
| replace | 43 | 44 | 43 | 44 | 0 | |
p03096 | C++ | Runtime Error |
// #pragma GCC target("avx2")
#pragma GCC optimize("O3")
// #pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#include <prettyprint.hpp>
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]: ", d_err(__VA_ARGS__);
#else
#define debug(...) 83;
#endif
void d_err() { cerr << endl; }
template <typename H, typename... T> void d_err(H h, T... t) {
cerr << h << " ";
d_err(t...);
}
template <typename T> void print(T x) { cout << x << "\n"; }
#define ALL(x) (x).begin(), (x).end()
#define FOR(i, m, n) for (int i = (m); i < (n); ++i)
#define REVFOR(i, m, n) for (int i = (n - 1); i >= (m); --i)
#define REP(i, n) FOR(i, 0, n)
#define REVREP(i, n) REVFOR(i, 0, n)
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define bcnt __builtin_popcountll
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef pair<ll, ll> Pll;
typedef pair<int, int> Pin;
ll INF = 1e16;
int inf = 1e9;
const ll MOD = 1000000007;
// const ll MOD = 998244353;
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % MOD + MOD) % MOD) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint a) {
if ((x += a.x) >= MOD)
x -= MOD;
return *this;
}
mint &operator-=(const mint a) {
if ((x += MOD - a.x) >= MOD)
x -= MOD;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= MOD;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime MOD
mint inv() const { return pow(MOD - 2); }
mint &operator/=(const mint a) { return (*this) *= a.inv(); }
mint operator/(const mint a) const { return mint(*this) /= a; }
};
istream &operator>>(istream &is, mint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(20);
int n;
cin >> n;
vector<int> a(n);
REP(i, n) cin >> a[i];
vector<int> ca;
int prev = -1;
REP(i, n) {
if (prev == a[i])
continue;
ca.pb(a[i]);
prev = a[i];
}
vector<int> last(n + 1, -1);
vector<mint> dp(ca.size(), 0);
dp[0] = 1;
last[ca[0]] = 0;
FOR(i, 1, ca.size()) {
if (last[ca[i]] > -1)
dp[i] += dp[last[ca[i]]];
last[ca[i]] = i;
dp[i] += dp[i - 1];
}
print(dp[ca.size() - 1]);
}
|
// #pragma GCC target("avx2")
#pragma GCC optimize("O3")
// #pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#include <prettyprint.hpp>
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]: ", d_err(__VA_ARGS__);
#else
#define debug(...) 83;
#endif
void d_err() { cerr << endl; }
template <typename H, typename... T> void d_err(H h, T... t) {
cerr << h << " ";
d_err(t...);
}
template <typename T> void print(T x) { cout << x << "\n"; }
#define ALL(x) (x).begin(), (x).end()
#define FOR(i, m, n) for (int i = (m); i < (n); ++i)
#define REVFOR(i, m, n) for (int i = (n - 1); i >= (m); --i)
#define REP(i, n) FOR(i, 0, n)
#define REVREP(i, n) REVFOR(i, 0, n)
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define bcnt __builtin_popcountll
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef pair<ll, ll> Pll;
typedef pair<int, int> Pin;
ll INF = 1e16;
int inf = 1e9;
const ll MOD = 1000000007;
// const ll MOD = 998244353;
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % MOD + MOD) % MOD) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint a) {
if ((x += a.x) >= MOD)
x -= MOD;
return *this;
}
mint &operator-=(const mint a) {
if ((x += MOD - a.x) >= MOD)
x -= MOD;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= MOD;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime MOD
mint inv() const { return pow(MOD - 2); }
mint &operator/=(const mint a) { return (*this) *= a.inv(); }
mint operator/(const mint a) const { return mint(*this) /= a; }
};
istream &operator>>(istream &is, mint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(20);
int n;
cin >> n;
vector<int> a(n);
REP(i, n) cin >> a[i];
vector<int> ca;
int prev = -1;
REP(i, n) {
if (prev == a[i])
continue;
ca.pb(a[i]);
prev = a[i];
}
vector<int> last(2e5 + 5, -1);
vector<mint> dp(ca.size(), 0);
dp[0] = 1;
last[ca[0]] = 0;
FOR(i, 1, ca.size()) {
if (last[ca[i]] > -1)
dp[i] += dp[last[ca[i]]];
last[ca[i]] = i;
dp[i] += dp[i - 1];
}
print(dp[ca.size() - 1]);
}
| replace | 116 | 117 | 116 | 117 | 0 | |
p03096 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vb = vector<bool>;
using vvb = vector<vb>;
using vd = vector<double>;
using vvd = vector<vd>;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
using vvl = vector<vl>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using tll = tuple<ll, ll>;
using tlll = tuple<ll, ll, ll>;
using vs = vector<string>;
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define rep(i, n) range(i, 0, n)
#define rrep(i, n) for (int i = (n)-1; i >= 0; i--)
#define range(i, a, n) for (int i = (a); i < (n); i++)
#define LINF ((ll)1ll << 60)
#define INF ((int)1 << 30)
#define EPS (1e-9)
#define MOD (1000000007ll)
#define fcout(a) cout << setprecision(a) << fixed
#define fs first
#define sc second
#define PI 3.1415926535897932384
int dx[] = {1, 0, -1, 0, 1, -1, -1, 1}, dy[] = {0, 1, 0, -1, 1, 1, -1, -1};
template <class T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class S> S acm(vector<S> &a) { return accumulate(all(a), S()); }
template <class S> S max(vector<S> &a) { return *max_element(all(a)); }
template <class S> S min(vector<S> &a) { return *min_element(all(a)); }
void YN(bool b) { cout << (b ? "YES" : "NO") << "\n"; }
void Yn(bool b) { cout << (b ? "Yes" : "No") << "\n"; }
void yn(bool b) { cout << (b ? "yes" : "no") << "\n"; }
ll max(int a, ll b) { return max((ll)a, b); }
ll max(ll a, int b) { return max(a, (ll)b); }
template <class T> void puta(T &&t) { cout << t << "\n"; }
template <class H, class... T> void puta(H &&h, T &&...t) {
cout << h << ' ';
puta(t...);
}
template <class S, class T> ostream &operator<<(ostream &os, pair<S, T> p) {
os << "[" << p.first << ", " << p.second << "]";
return os;
};
template <class S> auto &operator<<(ostream &os, vector<S> t) {
bool a = 1;
for (auto s : t) {
os << (a ? "" : " ") << s;
a = 0;
}
return os;
}
#define _cTime (chrono::system_clock::now())
#define progress \
(chrono::duration_cast<chrono::milliseconds>(_cTime - _sTime).count())
#define reset _sTime = _cTime
auto reset;
ll dp[200005];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, in;
cin >> n;
vi v(n);
rep(i, n) cin >> v[i], v[i]--;
vi prev(n, -1);
dp[0] = 1;
rep(i, n) {
dp[i + 1] = dp[i];
if (prev[v[i]] != -1 && prev[v[i]] != i - 1) {
dp[i + 1] += dp[prev[v[i]] + 1];
dp[i + 1] %= MOD;
}
prev[v[i]] = i;
}
cout << dp[n] << endl;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vb = vector<bool>;
using vvb = vector<vb>;
using vd = vector<double>;
using vvd = vector<vd>;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
using vvl = vector<vl>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using tll = tuple<ll, ll>;
using tlll = tuple<ll, ll, ll>;
using vs = vector<string>;
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define rep(i, n) range(i, 0, n)
#define rrep(i, n) for (int i = (n)-1; i >= 0; i--)
#define range(i, a, n) for (int i = (a); i < (n); i++)
#define LINF ((ll)1ll << 60)
#define INF ((int)1 << 30)
#define EPS (1e-9)
#define MOD (1000000007ll)
#define fcout(a) cout << setprecision(a) << fixed
#define fs first
#define sc second
#define PI 3.1415926535897932384
int dx[] = {1, 0, -1, 0, 1, -1, -1, 1}, dy[] = {0, 1, 0, -1, 1, 1, -1, -1};
template <class T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class S> S acm(vector<S> &a) { return accumulate(all(a), S()); }
template <class S> S max(vector<S> &a) { return *max_element(all(a)); }
template <class S> S min(vector<S> &a) { return *min_element(all(a)); }
void YN(bool b) { cout << (b ? "YES" : "NO") << "\n"; }
void Yn(bool b) { cout << (b ? "Yes" : "No") << "\n"; }
void yn(bool b) { cout << (b ? "yes" : "no") << "\n"; }
ll max(int a, ll b) { return max((ll)a, b); }
ll max(ll a, int b) { return max(a, (ll)b); }
template <class T> void puta(T &&t) { cout << t << "\n"; }
template <class H, class... T> void puta(H &&h, T &&...t) {
cout << h << ' ';
puta(t...);
}
template <class S, class T> ostream &operator<<(ostream &os, pair<S, T> p) {
os << "[" << p.first << ", " << p.second << "]";
return os;
};
template <class S> auto &operator<<(ostream &os, vector<S> t) {
bool a = 1;
for (auto s : t) {
os << (a ? "" : " ") << s;
a = 0;
}
return os;
}
#define _cTime (chrono::system_clock::now())
#define progress \
(chrono::duration_cast<chrono::milliseconds>(_cTime - _sTime).count())
#define reset _sTime = _cTime
auto reset;
ll dp[200005];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, in;
cin >> n;
vi v(n);
rep(i, n) cin >> v[i], v[i]--;
vi prev(200001, -1);
dp[0] = 1;
rep(i, n) {
dp[i + 1] = dp[i];
if (prev[v[i]] != -1 && prev[v[i]] != i - 1) {
dp[i + 1] += dp[prev[v[i]] + 1];
dp[i + 1] %= MOD;
}
prev[v[i]] = i;
}
cout << dp[n] << endl;
}
| replace | 89 | 90 | 89 | 90 | 0 | |
p03096 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define mod 1000000007
int main() {
int N;
cin >> N;
int C[N], Sum[20001] = {}, DP[N];
for (int i = 0; i < N; i++) {
cin >> C[i];
}
DP[0] = 1;
Sum[C[0]] = 1;
for (int i = 1; i < N; i++) {
if (C[i] == C[i - 1]) {
DP[i] = DP[i - 1];
} else {
DP[i] = Sum[C[i]] + DP[i - 1];
DP[i] %= mod;
Sum[C[i]] = DP[i];
}
}
cout << DP[N - 1];
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define mod 1000000007
int main() {
int N;
cin >> N;
int C[N], Sum[200001] = {}, DP[N];
for (int i = 0; i < N; i++) {
cin >> C[i];
}
DP[0] = 1;
Sum[C[0]] = 1;
for (int i = 1; i < N; i++) {
if (C[i] == C[i - 1]) {
DP[i] = DP[i - 1];
} else {
DP[i] = Sum[C[i]] + DP[i - 1];
DP[i] %= mod;
Sum[C[i]] = DP[i];
}
}
cout << DP[N - 1];
return 0;
} | replace | 7 | 8 | 7 | 8 | 0 | |
p03096 | C++ | Runtime Error | // B.
#include <iostream>
#include <sstream>
#include <vector>
using namespace std;
typedef long long LL;
static const LL MOD = 1000000007LL;
int n;
vector<int> c;
LL solve() {
vector<LL> memo = vector<LL>(n + 1, 1);
vector<int> p(100001, -1);
LL r = 1;
int last = c[0];
p[c[0]] = 0;
memo[0] = r;
for (int i = 1; i < n; ++i) {
memo[i] = r;
if (c[i] != last) {
if (p[c[i]] >= 0) {
r = (r + memo[p[c[i]]]) % MOD;
}
p[c[i]] = i;
}
memo[i] = r;
last = c[i];
}
return r;
}
int main(int argc, char *argv[]) {
cin >> n;
c = vector<int>(n + 1, -1);
for (int i = 0; i < n; ++i) {
cin >> c[i];
}
LL ans = solve();
cout << ans << endl;
return 0;
}
| // B.
#include <iostream>
#include <sstream>
#include <vector>
using namespace std;
typedef long long LL;
static const LL MOD = 1000000007LL;
int n;
vector<int> c;
LL solve() {
vector<LL> memo = vector<LL>(n + 1, 1);
vector<int> p(200001, -1);
LL r = 1;
int last = c[0];
p[c[0]] = 0;
memo[0] = r;
for (int i = 1; i < n; ++i) {
memo[i] = r;
if (c[i] != last) {
if (p[c[i]] >= 0) {
r = (r + memo[p[c[i]]]) % MOD;
}
p[c[i]] = i;
}
memo[i] = r;
last = c[i];
}
return r;
}
int main(int argc, char *argv[]) {
cin >> n;
c = vector<int>(n + 1, -1);
for (int i = 0; i < n; ++i) {
cin >> c[i];
}
LL ans = solve();
cout << ans << endl;
return 0;
}
| replace | 16 | 17 | 16 | 17 | 0 | |
p03096 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#ifdef LOCAL
#define eprintf(...) fprintf(stderr, __VA_ARGS__)
#else
#define eprintf(...) 42
#endif
using ll = long long;
using vll = std::vector<ll>;
using vvll = std::vector<vll>;
using vvvll = std::vector<vvll>;
#define reps(i, S, E) for (ll i = (S); i <= (E); i++)
#define rep(i, N) reps(i, 0, N - 1)
#define deps(i, E, S) for (ll i = (E); i >= (S); i--)
#define dep(i, N) deps(i, N - 1, 0)
const ll INF = 1LL << 60;
const int INF_INT = 1 << 30;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
struct mll {
static ll MOD;
ll val;
mll(ll v = 0) : val(v % MOD) {
if (val < 0)
val += MOD;
}
mll operator-() const { return -val; }
mll operator+(const mll &b) const { return val + b.val; }
mll operator-(const mll &b) const { return val - b.val; }
mll operator*(const mll &b) const { return val * b.val; }
mll operator/(const mll &b) const { return mll(*this) /= b; }
mll operator+(ll b) const { return *this + mll(b); }
mll operator-(ll b) const { return *this - mll(b); }
mll operator*(ll b) const { return *this * mll(b); }
friend mll operator+(ll a, const mll &b) { return b + a; }
friend mll operator-(ll a, const mll &b) { return -b + a; }
friend mll operator*(ll a, const mll &b) { return b * a; }
mll &operator+=(const mll &b) {
val = (val + b.val) % MOD;
return *this;
}
mll &operator-=(const mll &b) {
val = (val + MOD - b.val) % MOD;
return *this;
}
mll &operator*=(const mll &b) {
val = (val * b.val) % MOD;
return *this;
}
mll &operator/=(const mll &b) {
ll c = b.val, d = MOD, u = 1, v = 0;
while (d) {
ll t = c / d;
c -= t * d;
swap(c, d);
u -= t * v;
swap(u, v);
}
val = val * u % MOD;
if (val < 0)
val += MOD;
return *this;
}
mll &operator+=(ll b) { return *this += mll(b); }
mll &operator-=(ll b) { return *this -= mll(b); }
mll &operator*=(ll b) { return *this *= mll(b); }
mll &operator/=(ll b) { return *this /= mll(b); }
bool operator==(const mll &b) { return val == b.val; }
bool operator!=(const mll &b) { return val != b.val; }
bool operator==(ll b) { return *this == mll(b); }
bool operator!=(ll b) { return *this != mll(b); }
friend bool operator==(ll a, const mll &b) { return mll(a) == b.val; }
friend bool operator!=(ll a, const mll &b) { return mll(a) != b.val; }
friend ostream &operator<<(ostream &os, const mll &a) { return os << a.val; }
friend istream &operator>>(istream &is, mll &a) { return is >> a.val; }
static mll Combination(ll a, ll b) {
chmin(b, a - b);
if (b < 0)
return mll(0);
mll c = 1;
rep(i, b) c *= a - i;
rep(i, b) c /= i + 1;
return c;
}
};
using vmll = std::vector<mll>;
using vvmll = std::vector<vmll>;
using vvvmll = std::vector<vvmll>;
using vvvvmll = std::vector<vvvmll>;
struct Fast {
Fast() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(std::numeric_limits<double>::max_digits10);
}
} fast; // cin,cout高速化のおまじない＋桁数指定
ll mll::MOD = (ll)(1e9 + 7); // 998244353ll;
int main() {
ll N;
cin >> N;
vector<ll> C(N);
rep(i, N) { cin >> C[i]; }
vll prevC(20010, -1);
vmll dp(N, 0);
dp[0] = 1;
rep(i, N) {
if (i > 0) {
dp[i] += dp[i - 1];
if (prevC[C[i]] >= 0 && prevC[C[i]] + 1 < i) {
dp[i] += dp[prevC[C[i]]];
}
}
prevC[C[i]] = i;
}
cout << dp[N - 1] << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#ifdef LOCAL
#define eprintf(...) fprintf(stderr, __VA_ARGS__)
#else
#define eprintf(...) 42
#endif
using ll = long long;
using vll = std::vector<ll>;
using vvll = std::vector<vll>;
using vvvll = std::vector<vvll>;
#define reps(i, S, E) for (ll i = (S); i <= (E); i++)
#define rep(i, N) reps(i, 0, N - 1)
#define deps(i, E, S) for (ll i = (E); i >= (S); i--)
#define dep(i, N) deps(i, N - 1, 0)
const ll INF = 1LL << 60;
const int INF_INT = 1 << 30;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
struct mll {
static ll MOD;
ll val;
mll(ll v = 0) : val(v % MOD) {
if (val < 0)
val += MOD;
}
mll operator-() const { return -val; }
mll operator+(const mll &b) const { return val + b.val; }
mll operator-(const mll &b) const { return val - b.val; }
mll operator*(const mll &b) const { return val * b.val; }
mll operator/(const mll &b) const { return mll(*this) /= b; }
mll operator+(ll b) const { return *this + mll(b); }
mll operator-(ll b) const { return *this - mll(b); }
mll operator*(ll b) const { return *this * mll(b); }
friend mll operator+(ll a, const mll &b) { return b + a; }
friend mll operator-(ll a, const mll &b) { return -b + a; }
friend mll operator*(ll a, const mll &b) { return b * a; }
mll &operator+=(const mll &b) {
val = (val + b.val) % MOD;
return *this;
}
mll &operator-=(const mll &b) {
val = (val + MOD - b.val) % MOD;
return *this;
}
mll &operator*=(const mll &b) {
val = (val * b.val) % MOD;
return *this;
}
mll &operator/=(const mll &b) {
ll c = b.val, d = MOD, u = 1, v = 0;
while (d) {
ll t = c / d;
c -= t * d;
swap(c, d);
u -= t * v;
swap(u, v);
}
val = val * u % MOD;
if (val < 0)
val += MOD;
return *this;
}
mll &operator+=(ll b) { return *this += mll(b); }
mll &operator-=(ll b) { return *this -= mll(b); }
mll &operator*=(ll b) { return *this *= mll(b); }
mll &operator/=(ll b) { return *this /= mll(b); }
bool operator==(const mll &b) { return val == b.val; }
bool operator!=(const mll &b) { return val != b.val; }
bool operator==(ll b) { return *this == mll(b); }
bool operator!=(ll b) { return *this != mll(b); }
friend bool operator==(ll a, const mll &b) { return mll(a) == b.val; }
friend bool operator!=(ll a, const mll &b) { return mll(a) != b.val; }
friend ostream &operator<<(ostream &os, const mll &a) { return os << a.val; }
friend istream &operator>>(istream &is, mll &a) { return is >> a.val; }
static mll Combination(ll a, ll b) {
chmin(b, a - b);
if (b < 0)
return mll(0);
mll c = 1;
rep(i, b) c *= a - i;
rep(i, b) c /= i + 1;
return c;
}
};
using vmll = std::vector<mll>;
using vvmll = std::vector<vmll>;
using vvvmll = std::vector<vvmll>;
using vvvvmll = std::vector<vvvmll>;
struct Fast {
Fast() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(std::numeric_limits<double>::max_digits10);
}
} fast; // cin,cout高速化のおまじない＋桁数指定
ll mll::MOD = (ll)(1e9 + 7); // 998244353ll;
int main() {
ll N;
cin >> N;
vector<ll> C(N);
rep(i, N) { cin >> C[i]; }
vll prevC(200010, -1);
vmll dp(N, 0);
dp[0] = 1;
rep(i, N) {
if (i > 0) {
dp[i] += dp[i - 1];
if (prevC[C[i]] >= 0 && prevC[C[i]] + 1 < i) {
dp[i] += dp[prevC[C[i]]];
}
}
prevC[C[i]] = i;
}
cout << dp[N - 1] << endl;
return 0;
}
| replace | 133 | 134 | 133 | 134 | 0 | |
p03096 | C++ | Runtime Error | #include "bits/stdc++.h"
using namespace std;
#ifdef _DEBUG
#define _GLIBCXX_DEBUG
#include "dump.hpp"
#else
#define dump(...)
#endif
#define int long long
#define ll long long
#define ll1 1ll
#define ONE 1ll
#define DBG 1
#define rep(i, a, b) for (int i = (a); i < (b); i++)
#define rrep(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define loop(n) rep(loop, (0), (n))
#define all(c) begin(c), end(c)
const int INF =
sizeof(int) == sizeof(long long) ? 0x3f3f3f3f3f3f3f3fLL : 0x3f3f3f3f;
const int MOD = (int)(1e9) + 7;
const double PI = acos(-1);
const double EPS = 1e-9;
#define fi first
#define se second
#define pb push_back
#define eb emplace_back
using pii = pair<int, int>;
// template<class T> ostream &operator<<(ostream &os,T &t){dump(t);return os;}
template <typename T, typename S>
istream &operator>>(istream &is, pair<T, S> &p) {
is >> p.first >> p.second;
return is;
}
template <typename T, typename S>
ostream &operator<<(ostream &os, pair<T, S> &p) {
os << p.first << " " << p.second;
return os;
}
template <typename T> void printvv(const vector<vector<T>> &v) {
cerr << endl;
rep(i, 0, v.size()) rep(j, 0, v[i].size()) {
if (typeid(v[i][j]).name() == typeid(INF).name() and v[i][j] == INF) {
cerr << "INF";
} else
cerr << v[i][j];
cerr << (j == v[i].size() - 1 ? '\n' : ' ');
}
cerr << endl;
}
/*
typedef __int128_t Int;
std::ostream &operator<<(std::ostream &dest, __int128_t value) {
std::ostream::sentry s(dest);
if (s) {
__uint128_t tmp = value < 0 ? -value : value;
char buffer[128];
char *d = std::end(buffer);
do {
--d;
*d = "0123456789"[tmp % 10];
tmp /= 10;
} while (tmp != 0);
if (value < 0) {
--d;
*d = '-';
}
int len = std::end(buffer) - d;
if (dest.rdbuf()->sputn(d, len) != len) {
dest.setstate(std::ios_base::badbit);
}
}
return dest;
}
__int128 parse(string &s) {
__int128 ret = 0;
for (int i = 0; i < s.length(); i++)
if ('0' <= s[i] && s[i] <= '9')
ret = 10 * ret + s[i] - '0';
return ret;
}
*/
#ifndef _DEBUG
#define printvv(...)
#endif
void YES(bool f) { cout << (f ? "YES" : "NO") << endl; }
void Yes(bool f) { cout << (f ? "Yes" : "No") << endl; }
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <int MOD> struct ModInt {
static const int Mod = MOD;
unsigned x;
ModInt() : x(0) {}
ModInt(signed sig) {
int sigt = sig % MOD;
if (sigt < 0)
sigt += MOD;
x = sigt;
}
ModInt(signed long long sig) {
int sigt = sig % MOD;
if (sigt < 0)
sigt += MOD;
x = sigt;
}
int get() const { return (int)x; }
ModInt &operator+=(ModInt that) {
if ((x += that.x) >= MOD)
x -= MOD;
return *this;
}
ModInt &operator-=(ModInt that) {
if ((x += MOD - that.x) >= MOD)
x -= MOD;
return *this;
}
ModInt &operator*=(ModInt that) {
x = (unsigned long long)x * that.x % MOD;
return *this;
}
ModInt &operator/=(ModInt that) { return *this *= that.inverse(); }
ModInt operator+(ModInt that) const { return ModInt(*this) += that; }
ModInt operator-(ModInt that) const { return ModInt(*this) -= that; }
ModInt operator*(ModInt that) const { return ModInt(*this) *= that; }
ModInt operator/(ModInt that) const { return ModInt(*this) /= that; }
ModInt inverse() const {
signed a = x, b = MOD, u = 1, v = 0;
while (b) {
signed t = a / b;
a -= t * b;
std::swap(a, b);
u -= t * v;
std::swap(u, v);
}
if (u < 0)
u += MOD;
ModInt res;
res.x = (unsigned)u;
return res;
}
};
template <int MOD> ostream &operator<<(ostream &os, const ModInt<MOD> &m) {
return os << m.x;
}
template <int MOD> istream &operator>>(istream &is, ModInt<MOD> &m) {
signed long long s;
is >> s;
m = ModInt<MOD>(s);
return is;
};
// pow(mint(2), 1000) のように
template <int MOD> ModInt<MOD> pow(ModInt<MOD> a, unsigned long long k) {
ModInt<MOD> r = 1;
while (k) {
if (k & 1)
r *= a;
a *= a;
k >>= 1;
}
return r;
}
// #define int long long を使っても大丈夫
using mint = ModInt<1000000007>;
// nCrで用いる
vector<mint> fact, factinv;
// nCrで用いる 予め計算しておく
void nCr_compute_factinv(int N) {
N = min(N, mint::Mod - 1);
fact.resize(N + 1);
factinv.resize(N + 1);
fact[0] = 1;
rep(i, 1, N + 1) fact[i] = fact[i - 1] * i;
factinv[N] = fact[N].inverse();
for (int i = N; i >= 1; i--)
factinv[i - 1] = factinv[i] * i;
}
mint nCr(int n, int r) {
if (n >= mint::Mod)
return nCr(n % mint::Mod, r % mint::Mod) *
nCr(n / mint::Mod, r / mint::Mod);
return r > n ? 0 : fact[n] * factinv[n - r] * factinv[r];
}
mint nHr(int n, int r) { return r == 0 ? 1 : nCr(n + r - 1, r); }
signed main(signed argc, char *argv[]) {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(12);
int N;
cin >> N;
vector<int> C(N);
rep(i, 0, N) {
cin >> C[i];
C[i]--;
}
vector<int> idx(N + 1, -1);
vector<mint> dp(N + 1);
dp[0] = 1;
rep(i, 1, N + 1) {
dp[i] = dp[i - 1];
if (idx[C[i - 1]] != -1)
assert(i - 2 >= 0);
if (idx[C[i - 1]] != -1 and idx[C[i - 1]] != i - 1) {
dump(idx[C[i - 1]]);
dp[i] += dp[idx[C[i - 1]]];
}
idx[C[i - 1]] = i;
dump(i, dp);
}
cout << dp[N] << endl;
return 0;
}
| #include "bits/stdc++.h"
using namespace std;
#ifdef _DEBUG
#define _GLIBCXX_DEBUG
#include "dump.hpp"
#else
#define dump(...)
#endif
#define int long long
#define ll long long
#define ll1 1ll
#define ONE 1ll
#define DBG 1
#define rep(i, a, b) for (int i = (a); i < (b); i++)
#define rrep(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define loop(n) rep(loop, (0), (n))
#define all(c) begin(c), end(c)
const int INF =
sizeof(int) == sizeof(long long) ? 0x3f3f3f3f3f3f3f3fLL : 0x3f3f3f3f;
const int MOD = (int)(1e9) + 7;
const double PI = acos(-1);
const double EPS = 1e-9;
#define fi first
#define se second
#define pb push_back
#define eb emplace_back
using pii = pair<int, int>;
// template<class T> ostream &operator<<(ostream &os,T &t){dump(t);return os;}
template <typename T, typename S>
istream &operator>>(istream &is, pair<T, S> &p) {
is >> p.first >> p.second;
return is;
}
template <typename T, typename S>
ostream &operator<<(ostream &os, pair<T, S> &p) {
os << p.first << " " << p.second;
return os;
}
template <typename T> void printvv(const vector<vector<T>> &v) {
cerr << endl;
rep(i, 0, v.size()) rep(j, 0, v[i].size()) {
if (typeid(v[i][j]).name() == typeid(INF).name() and v[i][j] == INF) {
cerr << "INF";
} else
cerr << v[i][j];
cerr << (j == v[i].size() - 1 ? '\n' : ' ');
}
cerr << endl;
}
/*
typedef __int128_t Int;
std::ostream &operator<<(std::ostream &dest, __int128_t value) {
std::ostream::sentry s(dest);
if (s) {
__uint128_t tmp = value < 0 ? -value : value;
char buffer[128];
char *d = std::end(buffer);
do {
--d;
*d = "0123456789"[tmp % 10];
tmp /= 10;
} while (tmp != 0);
if (value < 0) {
--d;
*d = '-';
}
int len = std::end(buffer) - d;
if (dest.rdbuf()->sputn(d, len) != len) {
dest.setstate(std::ios_base::badbit);
}
}
return dest;
}
__int128 parse(string &s) {
__int128 ret = 0;
for (int i = 0; i < s.length(); i++)
if ('0' <= s[i] && s[i] <= '9')
ret = 10 * ret + s[i] - '0';
return ret;
}
*/
#ifndef _DEBUG
#define printvv(...)
#endif
void YES(bool f) { cout << (f ? "YES" : "NO") << endl; }
void Yes(bool f) { cout << (f ? "Yes" : "No") << endl; }
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <int MOD> struct ModInt {
static const int Mod = MOD;
unsigned x;
ModInt() : x(0) {}
ModInt(signed sig) {
int sigt = sig % MOD;
if (sigt < 0)
sigt += MOD;
x = sigt;
}
ModInt(signed long long sig) {
int sigt = sig % MOD;
if (sigt < 0)
sigt += MOD;
x = sigt;
}
int get() const { return (int)x; }
ModInt &operator+=(ModInt that) {
if ((x += that.x) >= MOD)
x -= MOD;
return *this;
}
ModInt &operator-=(ModInt that) {
if ((x += MOD - that.x) >= MOD)
x -= MOD;
return *this;
}
ModInt &operator*=(ModInt that) {
x = (unsigned long long)x * that.x % MOD;
return *this;
}
ModInt &operator/=(ModInt that) { return *this *= that.inverse(); }
ModInt operator+(ModInt that) const { return ModInt(*this) += that; }
ModInt operator-(ModInt that) const { return ModInt(*this) -= that; }
ModInt operator*(ModInt that) const { return ModInt(*this) *= that; }
ModInt operator/(ModInt that) const { return ModInt(*this) /= that; }
ModInt inverse() const {
signed a = x, b = MOD, u = 1, v = 0;
while (b) {
signed t = a / b;
a -= t * b;
std::swap(a, b);
u -= t * v;
std::swap(u, v);
}
if (u < 0)
u += MOD;
ModInt res;
res.x = (unsigned)u;
return res;
}
};
template <int MOD> ostream &operator<<(ostream &os, const ModInt<MOD> &m) {
return os << m.x;
}
template <int MOD> istream &operator>>(istream &is, ModInt<MOD> &m) {
signed long long s;
is >> s;
m = ModInt<MOD>(s);
return is;
};
// pow(mint(2), 1000) のように
template <int MOD> ModInt<MOD> pow(ModInt<MOD> a, unsigned long long k) {
ModInt<MOD> r = 1;
while (k) {
if (k & 1)
r *= a;
a *= a;
k >>= 1;
}
return r;
}
// #define int long long を使っても大丈夫
using mint = ModInt<1000000007>;
// nCrで用いる
vector<mint> fact, factinv;
// nCrで用いる 予め計算しておく
void nCr_compute_factinv(int N) {
N = min(N, mint::Mod - 1);
fact.resize(N + 1);
factinv.resize(N + 1);
fact[0] = 1;
rep(i, 1, N + 1) fact[i] = fact[i - 1] * i;
factinv[N] = fact[N].inverse();
for (int i = N; i >= 1; i--)
factinv[i - 1] = factinv[i] * i;
}
mint nCr(int n, int r) {
if (n >= mint::Mod)
return nCr(n % mint::Mod, r % mint::Mod) *
nCr(n / mint::Mod, r / mint::Mod);
return r > n ? 0 : fact[n] * factinv[n - r] * factinv[r];
}
mint nHr(int n, int r) { return r == 0 ? 1 : nCr(n + r - 1, r); }
signed main(signed argc, char *argv[]) {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(12);
int N;
cin >> N;
vector<int> C(N);
rep(i, 0, N) {
cin >> C[i];
C[i]--;
}
vector<int> idx(2 * 1e5 + 1, -1);
vector<mint> dp(N + 1);
dp[0] = 1;
rep(i, 1, N + 1) {
dp[i] = dp[i - 1];
if (idx[C[i - 1]] != -1)
assert(i - 2 >= 0);
if (idx[C[i - 1]] != -1 and idx[C[i - 1]] != i - 1) {
dump(idx[C[i - 1]]);
dp[i] += dp[idx[C[i - 1]]];
}
idx[C[i - 1]] = i;
dump(i, dp);
}
cout << dp[N] << endl;
return 0;
}
| replace | 218 | 219 | 218 | 219 | 0 | |
p03096 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
#define ll long long
const double EPS = 1e-10;
const ll MOD = 7 + (1e+9);
int main() {
ll n;
cin >> n;
vector<ll> c(n, 0);
for (ll i = 0; i < n; i++) {
cin >> c[i];
c[i]--;
}
vector<ll> dp(n, 0);
vector<ll> v(n, 0);
vector<ll> vv(n, -1);
dp[n - 1] = 1;
v[c[n - 1]] = 1;
vv[c[n - 1]] = n - 1;
for (ll i = n - 2; i >= 0; i--) {
if (v[c[i]] == 0 || vv[c[i]] - i == 1) {
dp[i] = dp[i + 1];
v[c[i]] = dp[i];
} else {
dp[i] = dp[i + 1] + v[c[i]];
v[c[i]] = dp[i];
}
vv[c[i]] = i;
dp[i] %= MOD;
v[c[i]] %= MOD;
}
cout << dp[0] << endl;
}
| #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
#define ll long long
const double EPS = 1e-10;
const ll MOD = 7 + (1e+9);
int main() {
ll n;
cin >> n;
if (n == 1 || n == 2) {
cout << 1 << endl;
return 0;
}
vector<ll> c(n, 0);
for (ll i = 0; i < n; i++) {
cin >> c[i];
c[i]--;
}
vector<ll> dp(n, 0);
vector<ll> v(n, 0);
vector<ll> vv(n, -1);
dp[n - 1] = 1;
v[c[n - 1]] = 1;
vv[c[n - 1]] = n - 1;
for (ll i = n - 2; i >= 0; i--) {
if (v[c[i]] == 0 || vv[c[i]] - i == 1) {
dp[i] = dp[i + 1];
v[c[i]] = dp[i];
} else {
dp[i] = dp[i + 1] + v[c[i]];
v[c[i]] = dp[i];
}
vv[c[i]] = i;
dp[i] %= MOD;
v[c[i]] %= MOD;
}
cout << dp[0] << endl;
}
| insert | 18 | 18 | 18 | 22 | 0 | |
p03096 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define MAX 200005
#define MOD 1000000007
#define pb push_back
#define mp make_pair
#define f first
#define s second
ll n, m, i, j, k, t, l, r, tmp, ans, cnt, curr, flag, sum, mn, mx, mxi, x, pre,
strt, en;
ll brr[MAX], arr[MAX], lst[MAX], dp[MAX];
string s;
queue<pair<pair<ll, ll>, ll>> q, q2;
pair<pair<ll, ll>, ll> pp;
map<ll, multiset<ll>> mpp;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
#ifndef ONLINE_JUDGE
freopen("in.txt", "r", stdin);
#endif
cin >> n;
for (i = 1; i <= n; i++) {
cin >> arr[i];
brr[i] = lst[arr[i]];
lst[arr[i]] = i;
}
dp[0] = 1;
for (i = 1; i <= n; i++) {
if (!brr[i] || brr[i] == i - 1)
dp[i] = dp[i - 1];
else
dp[i] = (dp[i - 1] + dp[brr[i]]) % MOD;
}
cout << dp[n];
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define MAX 200005
#define MOD 1000000007
#define pb push_back
#define mp make_pair
#define f first
#define s second
ll n, m, i, j, k, t, l, r, tmp, ans, cnt, curr, flag, sum, mn, mx, mxi, x, pre,
strt, en;
ll brr[MAX], arr[MAX], lst[MAX], dp[MAX];
string s;
queue<pair<pair<ll, ll>, ll>> q, q2;
pair<pair<ll, ll>, ll> pp;
map<ll, multiset<ll>> mpp;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (i = 1; i <= n; i++) {
cin >> arr[i];
brr[i] = lst[arr[i]];
lst[arr[i]] = i;
}
dp[0] = 1;
for (i = 1; i <= n; i++) {
if (!brr[i] || brr[i] == i - 1)
dp[i] = dp[i - 1];
else
dp[i] = (dp[i - 1] + dp[brr[i]]) % MOD;
}
cout << dp[n];
return 0;
} | delete | 22 | 25 | 22 | 22 | 0 | |
p03096 | C++ | Runtime Error | /*input
7
1
3
1
2
3
3
2
*/
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 3;
const int MOD = 1e9 + 7;
int add(int a, int b) {
int r = a + b;
if (r >= MOD)
r -= MOD;
return r;
}
int mul(int a, int b) { return int((long long)a * b % MOD); }
int sub(int a, int b) {
int r = MOD + a - b;
if (r >= MOD)
r -= MOD;
return r;
}
map<int, int> last;
int c[N], prv[N], dp[N];
int main(int argc, char const *argv[]) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
int x;
cin >> x;
int l = last[x];
prv[i] = l;
last[x] = i;
c[i] = x;
}
dp[0] = 1;
for (int i = 1; i <= n; ++i) {
if (!prv[i] || (prv[i] + 1 == i)) {
dp[i] = dp[i - 1];
continue;
}
int p = prv[i];
// cout << i << p << endl;
dp[i] = add(dp[i - 1], dp[p]);
}
cout << dp[n];
return 0;
} | /*input
7
1
3
1
2
3
3
2
*/
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 3;
const int MOD = 1e9 + 7;
int add(int a, int b) {
int r = a + b;
if (r >= MOD)
r -= MOD;
return r;
}
int mul(int a, int b) { return int((long long)a * b % MOD); }
int sub(int a, int b) {
int r = MOD + a - b;
if (r >= MOD)
r -= MOD;
return r;
}
map<int, int> last;
int c[N], prv[N], dp[N];
int main(int argc, char const *argv[]) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
int x;
cin >> x;
int l = last[x];
prv[i] = l;
last[x] = i;
c[i] = x;
}
dp[0] = 1;
for (int i = 1; i <= n; ++i) {
if (!prv[i] || (prv[i] + 1 == i)) {
dp[i] = dp[i - 1];
continue;
}
int p = prv[i];
// cout << i << p << endl;
dp[i] = add(dp[i - 1], dp[p]);
}
cout << dp[n];
return 0;
} | replace | 15 | 16 | 15 | 16 | 0 | |
p03096 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long unsigned int ll;
// definition {{{ 1
// scaning {{{ 2
#define Scd(x) scanf("%d", &x)
#define Scd2(x, y) scanf("%d%d", &x, &y)
#define Scd3(x, y, z) scanf("%d%d%d", &x, &y, &z)
#define Scll(x) scanf("%llu", &x)
#define Scll2(x, y) scanf("%llu%llu", &x, &y)
#define Scll3(x, y, z) scanf("%llu%llu%llu", &x, &y, &z)
#define Scc(c) scanf("%c", &c);
#define Scs(s) scanf("%s", s);
#define Scstr(s) scanf("%s", &s);
// }}} 2
// constants {{{ 2
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
// }}} 2
// systems {{{ 2
#define Rep(x, y) for (int x = 0; x < y; x++)
#define Repe(x, y, z) for (int x = z; x < y; x++)
// }}} 2
// output {{{ 2
#define YesNo(a) (a) ? printf("Yes\n") : printf("No\n");
// }}} 2
// }}} 1
int main() {
int N;
Scd(N);
vector<int> c(N);
Rep(i, N) Scd(c[i]);
vector<int> mass(N, 0);
vector<int> trans(233333, 0);
int tmp = 0;
for (int i = N - 1; i >= 0; i--) {
if (tmp == c[i]) {
mass[tmp] = i;
continue;
}
tmp = c[i];
trans[i] = mass[c[i]];
mass[c[i]] = i;
}
ll mod = 1000000007;
vector<ll> dp(N + 1, 0);
dp[0] = 1;
Rep(i, N) {
dp[i + 1] += dp[i];
if (trans[i]) {
dp[trans[i]] += dp[i];
dp[trans[i]] %= mod;
}
dp[i + 1] %= mod;
}
printf("%llu\n", dp[N] % mod);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long unsigned int ll;
// definition {{{ 1
// scaning {{{ 2
#define Scd(x) scanf("%d", &x)
#define Scd2(x, y) scanf("%d%d", &x, &y)
#define Scd3(x, y, z) scanf("%d%d%d", &x, &y, &z)
#define Scll(x) scanf("%llu", &x)
#define Scll2(x, y) scanf("%llu%llu", &x, &y)
#define Scll3(x, y, z) scanf("%llu%llu%llu", &x, &y, &z)
#define Scc(c) scanf("%c", &c);
#define Scs(s) scanf("%s", s);
#define Scstr(s) scanf("%s", &s);
// }}} 2
// constants {{{ 2
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
// }}} 2
// systems {{{ 2
#define Rep(x, y) for (int x = 0; x < y; x++)
#define Repe(x, y, z) for (int x = z; x < y; x++)
// }}} 2
// output {{{ 2
#define YesNo(a) (a) ? printf("Yes\n") : printf("No\n");
// }}} 2
// }}} 1
int main() {
int N;
Scd(N);
vector<int> c(N);
Rep(i, N) Scd(c[i]);
vector<int> mass(200002, 0);
vector<int> trans(N, 0);
int tmp = 0;
for (int i = N - 1; i >= 0; i--) {
if (tmp == c[i]) {
mass[tmp] = i;
continue;
}
tmp = c[i];
trans[i] = mass[c[i]];
mass[c[i]] = i;
}
ll mod = 1000000007;
vector<ll> dp(N + 1, 0);
dp[0] = 1;
Rep(i, N) {
dp[i + 1] += dp[i];
if (trans[i]) {
dp[trans[i]] += dp[i];
dp[trans[i]] %= mod;
}
dp[i + 1] %= mod;
}
printf("%llu\n", dp[N] % mod);
return 0;
}
| replace | 44 | 46 | 44 | 46 | 0 | |
p03096 | C++ | Runtime Error | #include "bits/stdc++.h"
using namespace std;
void solve() {
int N;
cin >> N;
vector<int> C(N + 1);
for (int i = 1; i <= N; i++)
cin >> C.at(i);
vector<int> DP(N + 1), s(N + 1);
DP.at(0) = 1;
for (int i = 1; i <= N; i++) {
if (C.at(i) != C.at(i - 1)) {
s.at(C.at(i)) += DP.at(i - 1);
s.at(C.at(i)) %= 1000000007;
// cout << "s.at(" << C.at(i) << ")=" << s.at(C.at(i)) << endl;
}
DP.at(i) = s.at(C.at(i));
// cout << "DP.at(" << i << ")=" << DP.at(i) << endl;
}
// cout << "DP.at(N)=" << DP.at(N) << endl;
cout << DP.at(N) << endl;
return;
}
int main() { solve(); } | #include "bits/stdc++.h"
using namespace std;
void solve() {
int N;
cin >> N;
vector<int> C(N + 1);
for (int i = 1; i <= N; i++)
cin >> C.at(i);
vector<int> DP(N + 1), s(200001);
DP.at(0) = 1;
for (int i = 1; i <= N; i++) {
if (C.at(i) != C.at(i - 1)) {
s.at(C.at(i)) += DP.at(i - 1);
s.at(C.at(i)) %= 1000000007;
// cout << "s.at(" << C.at(i) << ")=" << s.at(C.at(i)) << endl;
}
DP.at(i) = s.at(C.at(i));
// cout << "DP.at(" << i << ")=" << DP.at(i) << endl;
}
// cout << "DP.at(N)=" << DP.at(N) << endl;
cout << DP.at(N) << endl;
return;
}
int main() { solve(); } | replace | 9 | 10 | 9 | 10 | 0 | |
p03096 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
vector<long long> factors;
#define ll long long
#define pii pair<int, int>
#define pll pair<ll, ll>
#define _ << '\n'
#define __ << ' '
#define all(x) (x).begin(), (x).end()
#define gcd __gcd
int IT_MAX = 1 << 17;
int MOD = 1000'000'007;
const int INF = 0x3f3f3f3f;
const ll LL_INF = 0x3f3f3f3f3f3f3f3f;
const double PI = acos(-1);
const double ERR = 1e-10;
#define szz(x) (int)(x).size()
#define IOS \
ios_base::sync_with_stdio(false); \
cout.tie(0); \
cin.tie(0);
#define flush fflush(stdout)
ll mod(ll a, ll m) { return (a + (abs(a) / m) * m + m) % m; }
//****************************don't use int!!!!!!!****************************//
//***************************code starts here!!!!!****************************//
int main() {
IOS
ll n;
cin >> n;
vector<ll> c(n);
for (ll i = 0; i < n; ++i) {
cin >> c[i];
}
vector<ll> no_rep;
for (ll i = 0; i < n; ++i) {
ll ind = i;
no_rep.push_back(c[i]);
while (ind < n && c[i] == c[ind]) {
++ind;
}
--ind;
i = ind;
}
vector<ll> last(n + 100, -1);
vector<ll> prev(202020 + 10, -1);
for (ll i = 0; i < no_rep.size(); ++i) {
prev[i] = last[no_rep[i]];
last[no_rep[i]] = i;
}
vector<ll> dp(n + 200, 0);
dp[0] = 1;
for (ll i = 1; i < no_rep.size(); ++i) {
if (prev[i] == -1) {
dp[i] = dp[i - 1];
dp[i] %= MOD;
} else {
dp[i] = dp[i - 1] + dp[prev[i]];
dp[i] %= MOD;
}
}
cout << dp[no_rep.size() - 1];
return 0;
} | #include <bits/stdc++.h>
using namespace std;
vector<long long> factors;
#define ll long long
#define pii pair<int, int>
#define pll pair<ll, ll>
#define _ << '\n'
#define __ << ' '
#define all(x) (x).begin(), (x).end()
#define gcd __gcd
int IT_MAX = 1 << 17;
int MOD = 1000'000'007;
const int INF = 0x3f3f3f3f;
const ll LL_INF = 0x3f3f3f3f3f3f3f3f;
const double PI = acos(-1);
const double ERR = 1e-10;
#define szz(x) (int)(x).size()
#define IOS \
ios_base::sync_with_stdio(false); \
cout.tie(0); \
cin.tie(0);
#define flush fflush(stdout)
ll mod(ll a, ll m) { return (a + (abs(a) / m) * m + m) % m; }
//****************************don't use int!!!!!!!****************************//
//***************************code starts here!!!!!****************************//
int main() {
IOS
ll n;
cin >> n;
vector<ll> c(n);
for (ll i = 0; i < n; ++i) {
cin >> c[i];
}
vector<ll> no_rep;
for (ll i = 0; i < n; ++i) {
ll ind = i;
no_rep.push_back(c[i]);
while (ind < n && c[i] == c[ind]) {
++ind;
}
--ind;
i = ind;
}
vector<ll> last(202020 + 100, -1);
vector<ll> prev(202020 + 10, -1);
for (ll i = 0; i < no_rep.size(); ++i) {
prev[i] = last[no_rep[i]];
last[no_rep[i]] = i;
}
vector<ll> dp(n + 200, 0);
dp[0] = 1;
for (ll i = 1; i < no_rep.size(); ++i) {
if (prev[i] == -1) {
dp[i] = dp[i - 1];
dp[i] %= MOD;
} else {
dp[i] = dp[i - 1] + dp[prev[i]];
dp[i] %= MOD;
}
}
cout << dp[no_rep.size() - 1];
return 0;
} | replace | 50 | 51 | 50 | 51 | 0 | |
p03096 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
// #define int long long
typedef long long ll;
typedef unsigned long long ul;
typedef unsigned int ui;
const ll mod = 1000000007;
const ll INF = mod * mod;
const int INF_N = 1e+9;
typedef pair<int, int> P;
#define stop \
char nyaa; \
cin >> nyaa;
#define rep(i, n) for (int i = 0; i < n; i++)
#define per(i, n) for (int i = n - 1; i >= 0; i--)
#define Rep(i, sta, n) for (int i = sta; i < n; i++)
#define rep1(i, n) for (int i = 1; i <= n; i++)
#define per1(i, n) for (int i = n; i >= 1; i--)
#define Rep1(i, sta, n) for (int i = sta; i <= n; i++)
#define all(v) (v).begin(), (v).end()
typedef pair<ll, ll> LP;
typedef long double ld;
typedef pair<ld, ld> LDP;
const ld eps = 1e-12;
const ld pi = acos(-1.0);
// typedef vector<vector<ll>> mat;
typedef vector<int> vec;
// 繰り返し二乗法
ll mod_pow(ll a, ll n, ll m) {
ll res = 1;
while (n) {
if (n & 1)
res = res * a % m;
a = a * a % m;
n >>= 1;
}
return res;
}
struct modint {
ll n;
modint() : n(0) { ; }
modint(ll m) : n(m) {
if (n >= mod)
n %= mod;
else if (n < 0)
n = (n % mod + mod) % mod;
}
operator int() { return n; }
};
bool operator==(modint a, modint b) { return a.n == b.n; }
modint operator+=(modint &a, modint b) {
a.n += b.n;
if (a.n >= mod)
a.n -= mod;
return a;
}
modint operator-=(modint &a, modint b) {
a.n -= b.n;
if (a.n < 0)
a.n += mod;
return a;
}
modint operator*=(modint &a, modint b) {
a.n = ((ll)a.n * b.n) % mod;
return a;
}
modint operator+(modint a, modint b) { return a += b; }
modint operator-(modint a, modint b) { return a -= b; }
modint operator*(modint a, modint b) { return a *= b; }
modint operator^(modint a, int n) {
if (n == 0)
return modint(1);
modint res = (a * a) ^ (n / 2);
if (n % 2)
res = res * a;
return res;
}
// 逆元(Eucledean algorithm)
ll inv(ll a, ll p) { return (a == 1 ? 1 : (1 - p * inv(p % a, a)) / a + p); }
modint operator/(modint a, modint b) { return a * modint(inv(b, mod)); }
const int max_n = 1 << 18;
modint fact[max_n], factinv[max_n];
void init_f() {
fact[0] = modint(1);
for (int i = 0; i < max_n - 1; i++) {
fact[i + 1] = fact[i] * modint(i + 1);
}
factinv[max_n - 1] = modint(1) / fact[max_n - 1];
for (int i = max_n - 2; i >= 0; i--) {
factinv[i] = factinv[i + 1] * modint(i + 1);
}
}
modint comb(int a, int b) {
if (a < 0 || b < 0 || a < b)
return 0;
return fact[a] * factinv[b] * factinv[a - b];
}
using mP = pair<modint, modint>;
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
const int MAXN = 100;
int c[MAXN], seen[MAXN];
modint dp[MAXN];
void solve() {
int N;
cin >> N;
dp[0] = 1;
memset(seen, -1, sizeof(seen));
rep(i, N) cin >> c[i];
rep(i, N) {
dp[i + 1] = dp[i];
if (c[i] != c[i + 1]) {
if (seen[c[i]] != -1) {
dp[i + 1] = dp[i + 1] + dp[seen[c[i]] + 1];
}
seen[c[i]] = i;
}
}
cout << dp[N].n << endl;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
// cout << fixed << setprecision(10);
// init_f();
// init();
// int t; cin >> t; rep(i, t)solve();
solve();
// stop
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
// #define int long long
typedef long long ll;
typedef unsigned long long ul;
typedef unsigned int ui;
const ll mod = 1000000007;
const ll INF = mod * mod;
const int INF_N = 1e+9;
typedef pair<int, int> P;
#define stop \
char nyaa; \
cin >> nyaa;
#define rep(i, n) for (int i = 0; i < n; i++)
#define per(i, n) for (int i = n - 1; i >= 0; i--)
#define Rep(i, sta, n) for (int i = sta; i < n; i++)
#define rep1(i, n) for (int i = 1; i <= n; i++)
#define per1(i, n) for (int i = n; i >= 1; i--)
#define Rep1(i, sta, n) for (int i = sta; i <= n; i++)
#define all(v) (v).begin(), (v).end()
typedef pair<ll, ll> LP;
typedef long double ld;
typedef pair<ld, ld> LDP;
const ld eps = 1e-12;
const ld pi = acos(-1.0);
// typedef vector<vector<ll>> mat;
typedef vector<int> vec;
// 繰り返し二乗法
ll mod_pow(ll a, ll n, ll m) {
ll res = 1;
while (n) {
if (n & 1)
res = res * a % m;
a = a * a % m;
n >>= 1;
}
return res;
}
struct modint {
ll n;
modint() : n(0) { ; }
modint(ll m) : n(m) {
if (n >= mod)
n %= mod;
else if (n < 0)
n = (n % mod + mod) % mod;
}
operator int() { return n; }
};
bool operator==(modint a, modint b) { return a.n == b.n; }
modint operator+=(modint &a, modint b) {
a.n += b.n;
if (a.n >= mod)
a.n -= mod;
return a;
}
modint operator-=(modint &a, modint b) {
a.n -= b.n;
if (a.n < 0)
a.n += mod;
return a;
}
modint operator*=(modint &a, modint b) {
a.n = ((ll)a.n * b.n) % mod;
return a;
}
modint operator+(modint a, modint b) { return a += b; }
modint operator-(modint a, modint b) { return a -= b; }
modint operator*(modint a, modint b) { return a *= b; }
modint operator^(modint a, int n) {
if (n == 0)
return modint(1);
modint res = (a * a) ^ (n / 2);
if (n % 2)
res = res * a;
return res;
}
// 逆元(Eucledean algorithm)
ll inv(ll a, ll p) { return (a == 1 ? 1 : (1 - p * inv(p % a, a)) / a + p); }
modint operator/(modint a, modint b) { return a * modint(inv(b, mod)); }
const int max_n = 1 << 18;
modint fact[max_n], factinv[max_n];
void init_f() {
fact[0] = modint(1);
for (int i = 0; i < max_n - 1; i++) {
fact[i + 1] = fact[i] * modint(i + 1);
}
factinv[max_n - 1] = modint(1) / fact[max_n - 1];
for (int i = max_n - 2; i >= 0; i--) {
factinv[i] = factinv[i + 1] * modint(i + 1);
}
}
modint comb(int a, int b) {
if (a < 0 || b < 0 || a < b)
return 0;
return fact[a] * factinv[b] * factinv[a - b];
}
using mP = pair<modint, modint>;
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
const int MAXN = 200005;
int c[MAXN], seen[MAXN];
modint dp[MAXN];
void solve() {
int N;
cin >> N;
dp[0] = 1;
memset(seen, -1, sizeof(seen));
rep(i, N) cin >> c[i];
rep(i, N) {
dp[i + 1] = dp[i];
if (c[i] != c[i + 1]) {
if (seen[c[i]] != -1) {
dp[i + 1] = dp[i + 1] + dp[seen[c[i]] + 1];
}
seen[c[i]] = i;
}
}
cout << dp[N].n << endl;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
// cout << fixed << setprecision(10);
// init_f();
// init();
// int t; cin >> t; rep(i, t)solve();
solve();
// stop
return 0;
}
| replace | 108 | 109 | 108 | 109 | 0 | |
p03096 | C++ | Runtime Error | #pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define debug(x) cout << #x << " " << x << endl
#define fast ios_base::sync_with_stdio(false);
#define iscan1(x) scanf("%d", &x);
#define lscan1(x) scanf("%lld", &x);
#define iscan2(x, y) scanf("d", &x, &y);
#define lscan2(x, y) scanf("lld", &x, &y);
#define csprint(x) printf("Case %d: ", x);
#define iprint(x) printf("%d", x);
#define lprint(x) printf("%lld", x);
#define pnl printf("\n");
#define pg printf(" ");
ll ara[100005], dp[100005], lastpos[100005];
ll mod = 1000000007;
int main() {
memset(lastpos, -1, sizeof lastpos);
int n;
cin >> n;
int idx = 1;
for (int i = 1; i <= n; i++) {
ll a;
cin >> a;
if (a == ara[idx])
continue;
ara[++idx] = a;
}
for (int i = 1; i <= idx; i++) {
if (lastpos[ara[i]] != -1) {
dp[i] = (dp[i - 1] % mod + dp[lastpos[ara[i]]] % mod + 1) % mod;
lastpos[ara[i]] = i;
} else {
lastpos[ara[i]] = i;
dp[i] = dp[i - 1];
}
}
cout << (dp[idx] + 1) % mod << endl;
}
| #pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define debug(x) cout << #x << " " << x << endl
#define fast ios_base::sync_with_stdio(false);
#define iscan1(x) scanf("%d", &x);
#define lscan1(x) scanf("%lld", &x);
#define iscan2(x, y) scanf("d", &x, &y);
#define lscan2(x, y) scanf("lld", &x, &y);
#define csprint(x) printf("Case %d: ", x);
#define iprint(x) printf("%d", x);
#define lprint(x) printf("%lld", x);
#define pnl printf("\n");
#define pg printf(" ");
ll ara[200005], dp[200005], lastpos[200005];
ll mod = 1000000007;
int main() {
memset(lastpos, -1, sizeof lastpos);
int n;
cin >> n;
int idx = 1;
for (int i = 1; i <= n; i++) {
ll a;
cin >> a;
if (a == ara[idx])
continue;
ara[++idx] = a;
}
for (int i = 1; i <= idx; i++) {
if (lastpos[ara[i]] != -1) {
dp[i] = (dp[i - 1] % mod + dp[lastpos[ara[i]]] % mod + 1) % mod;
lastpos[ara[i]] = i;
} else {
lastpos[ara[i]] = i;
dp[i] = dp[i - 1];
}
}
cout << (dp[idx] + 1) % mod << endl;
}
| replace | 18 | 19 | 18 | 19 | 0 | |
p03096 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
typedef long long ll;
#define pb push_back
using namespace std;
ll n, a[200006];
ll dp[200006];
ll c[200006];
const ll mod = 1e9 + 7;
int main() {
cin >> n;
for (ll i = 1; i <= n; i++)
cin >> a[i];
dp[0] = 1;
for (ll i = 1; i <= n; i++) {
ll j = i;
while (j <= n && a[j] == a[i])
j++;
dp[j - 1] = dp[i - 1];
dp[j - 1] += c[a[i]];
dp[j - 1] %= mod;
c[a[i]] += dp[i - 1];
c[a[i]] %= mod;
}
cout << (dp[n] % mod + mod) % mod << endl;
return 0;
}
| #include <bits/stdc++.h>
typedef long long ll;
#define pb push_back
using namespace std;
ll n, a[200006];
ll dp[200006];
ll c[200006];
const ll mod = 1e9 + 7;
int main() {
cin >> n;
for (ll i = 1; i <= n; i++)
cin >> a[i];
dp[0] = 1;
for (ll i = 1; i <= n; i++) {
ll j = i;
while (j <= n && a[j] == a[i])
j++;
dp[j - 1] = dp[i - 1];
dp[j - 1] += c[a[i]];
dp[j - 1] %= mod;
c[a[i]] += dp[i - 1];
c[a[i]] %= mod;
i = j - 1;
}
cout << (dp[n] % mod + mod) % mod << endl;
return 0;
}
| insert | 23 | 23 | 23 | 24 | TLE | |
p03096 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 2e5 + 10;
#define mod 1000000007
int C[maxn], lst[maxn];
ll dp[maxn], sum[maxn];
bool hsr[maxn];
struct seg {
int l, r;
seg() {}
seg(int l, int r) : l(l), r(r) {}
bool operator<(const seg &t) const { return l < t.l; }
};
vector<seg> all;
int main() {
memset(lst, -1, sizeof(lst));
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &C[i]);
if (lst[C[i]] != -1 && lst[C[i]] != i - 1) {
all.push_back(seg(lst[C[i]], i));
}
lst[C[i]] = i;
}
sort(all.begin(), all.end());
// for(int i=0;i<all.size();i++)
// cout<<all[i].l<<" "<<all[i].r<<endl;
// dp[i] last right pos
memset(dp, 0, sizeof(dp));
memset(sum, 0, sizeof(sum));
int j = 0;
for (int i = 0; i < n; i++) {
if (i)
sum[i] = sum[i - 1];
else
sum[i] = 1;
sum[i] += dp[i];
if (sum[i] >= mod)
sum[i] -= mod;
if (all[j].l == i) {
dp[all[j].r] += sum[i];
// cout<<all[j].r<<" "<<dp[all[j].r]<<endl;
if (dp[all[j].r] >= mod)
dp[all[j].r] -= mod;
j++;
}
// cout<<dp[i]<<" "<<sum[i]<<endl;system("pause");
}
printf("%lld\n", (sum[n - 1]) % mod);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 2e5 + 10;
#define mod 1000000007
int C[maxn], lst[maxn];
ll dp[maxn], sum[maxn];
bool hsr[maxn];
struct seg {
int l, r;
seg() {}
seg(int l, int r) : l(l), r(r) {}
bool operator<(const seg &t) const { return l < t.l; }
};
vector<seg> all;
int main() {
memset(lst, -1, sizeof(lst));
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &C[i]);
if (lst[C[i]] != -1 && lst[C[i]] != i - 1) {
all.push_back(seg(lst[C[i]], i));
}
lst[C[i]] = i;
}
sort(all.begin(), all.end());
// for(int i=0;i<all.size();i++)
// cout<<all[i].l<<" "<<all[i].r<<endl;
// dp[i] last right pos
memset(dp, 0, sizeof(dp));
memset(sum, 0, sizeof(sum));
int j = 0;
for (int i = 0; i < n; i++) {
if (i)
sum[i] = sum[i - 1];
else
sum[i] = 1;
sum[i] += dp[i];
if (sum[i] >= mod)
sum[i] -= mod;
if (j < all.size() && all[j].l == i) {
dp[all[j].r] += sum[i];
// cout<<all[j].r<<" "<<dp[all[j].r]<<endl;
if (dp[all[j].r] >= mod)
dp[all[j].r] -= mod;
j++;
}
// cout<<dp[i]<<" "<<sum[i]<<endl;system("pause");
}
printf("%lld\n", (sum[n - 1]) % mod);
return 0;
} | replace | 41 | 42 | 41 | 42 | 0 | |
p03096 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
int main() {
long long n, c;
vector<long long> v;
cin >> n;
long long prev = -1;
for (int i = 0; i < n; i++) {
cin >> c;
if (c != prev) {
v.push_back(c);
prev = c;
}
}
if (n == 1) {
cout << 1 << endl;
return 0;
}
long long dp[100009];
map<long long, long long> mp;
dp[0] = 1;
mp[v[0]] = 1;
for (int i = 1; i < v.size(); i++) {
dp[i] = (mp[v[i]] + dp[i - 1]) % MOD;
mp[v[i]] = (dp[i - 1] + mp[v[i]]) % MOD;
}
cout << dp[v.size() - 1] << endl;
}
| #include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
int main() {
long long n, c;
vector<long long> v;
cin >> n;
long long prev = -1;
for (int i = 0; i < n; i++) {
cin >> c;
if (c != prev) {
v.push_back(c);
prev = c;
}
}
if (n == 1) {
cout << 1 << endl;
return 0;
}
long long dp[200009];
map<long long, long long> mp;
dp[0] = 1;
mp[v[0]] = 1;
for (int i = 1; i < v.size(); i++) {
dp[i] = (mp[v[i]] + dp[i - 1]) % MOD;
mp[v[i]] = (dp[i - 1] + mp[v[i]]) % MOD;
}
cout << dp[v.size() - 1] << endl;
}
| replace | 21 | 22 | 21 | 22 | 0 | |
p03096 | C++ | Runtime Error | #include <bits/stdc++.h>
#define FOR(v, a, b) for (int v = (a); v < (b); ++v)
#define FORE(v, a, b) for (int v = (a); v <= (b); ++v)
#define REP(v, n) FOR(v, 0, n)
#define REPE(v, n) FORE(v, 0, n)
#define REV(v, a, b) for (int v = (a); v >= (b); --v)
#define ALL(x) (x).begin(), (x).end()
#define ITR(it, c) for (auto it = (c).begin(); it != (c).end(); ++it)
#define RITR(it, c) for (auto it = (c).rbegin(); it != (c).rend(); ++it)
#define EXIST(c, x) ((c).find(x) != (c).end())
#define LLI long long int
#define fst first
#define snd second
#ifdef DEBUG
#include <misc/C++/Debug.cpp>
#else
#define dump(x)
#endif
#define gcd __gcd
using namespace std;
template <class T> constexpr T lcm(T m, T n) { return m / gcd(m, n) * n; }
template <typename I> void join(ostream &ost, I s, I t, string d = " ") {
for (auto i = s; i != t; ++i) {
if (i != s)
ost << d;
ost << *i;
}
ost << endl;
}
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &a : v)
is >> a;
return is;
}
template <typename T, typename U>
istream &operator>>(istream &is, pair<T, U> &p) {
is >> p.first >> p.second;
return is;
}
template <typename T, typename U> T &chmin(T &a, const U &b) {
return a = (a <= b ? a : b);
}
template <typename T, typename U> T &chmax(T &a, const U &b) {
return a = (a >= b ? a : b);
}
template <typename T, size_t N, typename U>
void fill_array(T (&a)[N], const U &v) {
fill((U *)a, (U *)(a + N), v);
}
const LLI mod = 1e9 + 7;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
while (cin >> N) {
vector<int> c(N);
cin >> c;
for (auto &x : c)
--x;
vector<LLI> dp(N + 1);
vector<int> prev(N, -1);
vector<vector<int>> chain(N);
REP(i, N) {
if (!chain[c[i]].empty())
prev[i] = chain[c[i]].back();
chain[c[i]].push_back(i);
}
/*
dump(chain);
dump(prev);
*/
dp[0] = 1;
REP(i, N) {
dp[i + 1] = dp[i];
if (prev[i] >= 0 and prev[i] < i - 1)
(dp[i + 1] += dp[prev[i] + 1]) %= mod;
}
cout << dp[N] << endl;
}
return 0;
}
| #include <bits/stdc++.h>
#define FOR(v, a, b) for (int v = (a); v < (b); ++v)
#define FORE(v, a, b) for (int v = (a); v <= (b); ++v)
#define REP(v, n) FOR(v, 0, n)
#define REPE(v, n) FORE(v, 0, n)
#define REV(v, a, b) for (int v = (a); v >= (b); --v)
#define ALL(x) (x).begin(), (x).end()
#define ITR(it, c) for (auto it = (c).begin(); it != (c).end(); ++it)
#define RITR(it, c) for (auto it = (c).rbegin(); it != (c).rend(); ++it)
#define EXIST(c, x) ((c).find(x) != (c).end())
#define LLI long long int
#define fst first
#define snd second
#ifdef DEBUG
#include <misc/C++/Debug.cpp>
#else
#define dump(x)
#endif
#define gcd __gcd
using namespace std;
template <class T> constexpr T lcm(T m, T n) { return m / gcd(m, n) * n; }
template <typename I> void join(ostream &ost, I s, I t, string d = " ") {
for (auto i = s; i != t; ++i) {
if (i != s)
ost << d;
ost << *i;
}
ost << endl;
}
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &a : v)
is >> a;
return is;
}
template <typename T, typename U>
istream &operator>>(istream &is, pair<T, U> &p) {
is >> p.first >> p.second;
return is;
}
template <typename T, typename U> T &chmin(T &a, const U &b) {
return a = (a <= b ? a : b);
}
template <typename T, typename U> T &chmax(T &a, const U &b) {
return a = (a >= b ? a : b);
}
template <typename T, size_t N, typename U>
void fill_array(T (&a)[N], const U &v) {
fill((U *)a, (U *)(a + N), v);
}
const LLI mod = 1e9 + 7;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
while (cin >> N) {
vector<int> c(N);
cin >> c;
for (auto &x : c)
--x;
vector<LLI> dp(N + 1);
vector<int> prev(N, -1);
vector<vector<int>> chain(200000);
REP(i, N) {
if (!chain[c[i]].empty())
prev[i] = chain[c[i]].back();
chain[c[i]].push_back(i);
}
/*
dump(chain);
dump(prev);
*/
dp[0] = 1;
REP(i, N) {
dp[i + 1] = dp[i];
if (prev[i] >= 0 and prev[i] < i - 1)
(dp[i + 1] += dp[prev[i] + 1]) %= mod;
}
cout << dp[N] << endl;
}
return 0;
}
| replace | 71 | 72 | 71 | 72 | 0 | |
p03096 | C++ | Runtime Error | /*------------------------------------
........Bismillahir Rahmanir Rahim....
..........created by Abdul Aziz.......
------------------------------------*/
#include <algorithm>
#include <cmath>
#include <cstring>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <unordered_map>
#include <vector>
#define mod 998244353
#define int long long
#define ld long double
#define pb push_back
#define vi vector<int>
#define co(x) cout << x << '\n'
#define dbg(x) cerr << #x << " = " << x << '\n'
#define bitcount(x) (int)__builtin_popcount(x)
#define sz(x) (int)x.size()
#define all(a) a.begin(), a.end()
#define ff first
#define ss second
#define pii pair<int, int>
#define lcm(a, b) (a * b) / __gcd(a, b)
using namespace std;
inline void solve() {
int n, pre = -1;
cin >> n;
vector<int> dp(100005, 0), c(100005, -1);
dp[0] = 1;
for (int i = 1, x; i <= n; i++) {
cin >> x;
dp[i] = dp[i - 1];
if (c[x] != -1 and pre != x)
dp[i] = dp[c[x]] + dp[i - 1];
c[x] = i;
pre = x;
dp[i] %= 1000000007;
}
cout << dp[n] << endl;
}
signed main() {
int n = 1; // cin>>n;
while (n--)
solve();
return 0;
}
| /*------------------------------------
........Bismillahir Rahmanir Rahim....
..........created by Abdul Aziz.......
------------------------------------*/
#include <algorithm>
#include <cmath>
#include <cstring>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <unordered_map>
#include <vector>
#define mod 998244353
#define int long long
#define ld long double
#define pb push_back
#define vi vector<int>
#define co(x) cout << x << '\n'
#define dbg(x) cerr << #x << " = " << x << '\n'
#define bitcount(x) (int)__builtin_popcount(x)
#define sz(x) (int)x.size()
#define all(a) a.begin(), a.end()
#define ff first
#define ss second
#define pii pair<int, int>
#define lcm(a, b) (a * b) / __gcd(a, b)
using namespace std;
inline void solve() {
int n, pre = -1;
cin >> n;
vector<int> dp(200005, 0), c(200005, -1);
dp[0] = 1;
for (int i = 1, x; i <= n; i++) {
cin >> x;
dp[i] = dp[i - 1];
if (c[x] != -1 and pre != x)
dp[i] = dp[c[x]] + dp[i - 1];
c[x] = i;
pre = x;
dp[i] %= 1000000007;
}
cout << dp[n] << endl;
}
signed main() {
int n = 1; // cin>>n;
while (n--)
solve();
return 0;
}
| replace | 36 | 37 | 36 | 37 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.