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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
p01767 | C++ | Runtime Error | #include <algorithm>
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
typedef long long ll;
#include <cstdio>
#include <queue>
inline ll getLL() {
ll s;
scanf("%lld", &s);
return s;
}
inline int getInt() {
int s;
scanf("%d", &s);
return s;
}
#include <set>
using namespace std;
int main() {
const int n = getInt();
vector<ll> a(n);
REP(i, n) a[i] = getLL();
sort(a.begin(), a.end());
vector<ll> as(n);
as[0] = a[0];
REP(i, n - 1) as[i + 1] = as[i] + a[i + 1];
const int m = getInt();
vector<ll> b(n);
vector<ll> c(n);
REP(i, m) b[i] = getLL();
REP(i, m) c[i] = getLL();
REP(i, m) {
const int idx = lower_bound(a.begin(), a.end(), b[i] + 1) - a.begin();
const ll g = idx == 0 ? 0 : as[idx - 1];
puts(c[i] <= g ? "Yes" : "No");
}
return 0;
} | #include <algorithm>
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
typedef long long ll;
#include <cstdio>
#include <queue>
inline ll getLL() {
ll s;
scanf("%lld", &s);
return s;
}
inline int getInt() {
int s;
scanf("%d", &s);
return s;
}
#include <set>
using namespace std;
int main() {
const int n = getInt();
vector<ll> a(n);
REP(i, n) a[i] = getLL();
sort(a.begin(), a.end());
vector<ll> as(n);
as[0] = a[0];
REP(i, n - 1) as[i + 1] = as[i] + a[i + 1];
const int m = getInt();
vector<ll> b(m);
vector<ll> c(m);
REP(i, m) b[i] = getLL();
REP(i, m) c[i] = getLL();
REP(i, m) {
const int idx = lower_bound(a.begin(), a.end(), b[i] + 1) - a.begin();
const ll g = idx == 0 ? 0 : as[idx - 1];
puts(c[i] <= g ? "Yes" : "No");
}
return 0;
} | replace | 32 | 34 | 32 | 34 | 0 | |
p01767 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M, b[300000];
long long Counter[1000001] = {}, c[300000];
cin >> N;
for (int i = 0; i < N; i++) {
int a;
cin >> a;
Counter[a] += a;
}
for (int i = 1; i < 1000001; i++) {
Counter[i] += Counter[i - 1];
}
cin >> M;
for (int i = 0; i < M; i++) {
cin >> b[i];
}
for (int i = 0; i < M; i++) {
cin >> c[i];
}
for (int i = 0; i < M; i++) {
if (Counter[b[i]] >= c[i])
cout << "Yes" << endl;
else
cout << "No" << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M, b[300000];
static long long Counter[1000001] = {};
long long c[300000];
cin >> N;
for (int i = 0; i < N; i++) {
int a;
cin >> a;
Counter[a] += a;
}
for (int i = 1; i < 1000001; i++) {
Counter[i] += Counter[i - 1];
}
cin >> M;
for (int i = 0; i < M; i++) {
cin >> b[i];
}
for (int i = 0; i < M; i++) {
cin >> c[i];
}
for (int i = 0; i < M; i++) {
if (Counter[b[i]] >= c[i])
cout << "Yes" << endl;
else
cout << "No" << endl;
}
} | replace | 5 | 6 | 5 | 7 | -11 | |
p01767 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long int64;
class Fenwick_Tree {
private:
vector<int64> p;
public:
Fenwick_Tree(int size) { p.resize(size + 2, 0); }
int64 sum(int x) {
int64 ret = 0;
for (++x; x > 0; x -= x & -x)
ret += p[x];
return (ret);
}
void add(int k, int a) {
for (++k; k < p.size(); k += k & -k)
p[k] += a;
}
};
int main() {
int N, M;
Fenwick_Tree BIT(300004);
cin >> N;
vector<int> a(N);
for (int i = 0; i < N; i++) {
cin >> a[i];
BIT.add(a[i], a[i]);
}
cin >> M;
vector<int64> b(M), c(M);
for (int i = 0; i < M; i++)
cin >> b[i];
for (int i = 0; i < M; i++)
cin >> c[i];
for (int i = 0; i < M; i++) {
int64 get = BIT.sum(b[i]);
if (get >= c[i])
cout << "Yes" << endl;
else
cout << "No" << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
typedef long long int64;
class Fenwick_Tree {
private:
vector<int64> p;
public:
Fenwick_Tree(int size) { p.resize(size + 2, 0); }
int64 sum(int x) {
int64 ret = 0;
for (++x; x > 0; x -= x & -x)
ret += p[x];
return (ret);
}
void add(int k, int a) {
for (++k; k < p.size(); k += k & -k)
p[k] += a;
}
};
int main() {
int N, M;
Fenwick_Tree BIT(1000004);
cin >> N;
vector<int> a(N);
for (int i = 0; i < N; i++) {
cin >> a[i];
BIT.add(a[i], a[i]);
}
cin >> M;
vector<int64> b(M), c(M);
for (int i = 0; i < M; i++)
cin >> b[i];
for (int i = 0; i < M; i++)
cin >> c[i];
for (int i = 0; i < M; i++) {
int64 get = BIT.sum(b[i]);
if (get >= c[i])
cout << "Yes" << endl;
else
cout << "No" << endl;
}
} | replace | 24 | 25 | 24 | 25 | 0 | |
p01768 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define REP(i, a, b) for (int i = a; i < (int)b; i++)
#define rep(i, n) REP(i, 0, n)
#define all(c) (c).begin(), (c).end()
#define zero(a) memset(a, 0, sizeof a)
#define minus(a) memset(a, -1, sizeof a)
#define watch(a) \
{ cout << #a << " = " << a << endl; }
template <class T1, class T2> inline bool minimize(T1 &a, T2 b) {
return b < a && (a = b, 1);
}
template <class T1, class T2> inline bool maximize(T1 &a, T2 b) {
return a < b && (a = b, 1);
}
typedef long long ll;
int const inf = 1 << 29;
const int MAX = 1010;
class Union_Find {
public:
int par[MAX], rank[MAX], size[MAX], gnum;
int info[MAX];
Union_Find(int N) {
gnum = N;
for (int i = 0; i < N; i++) {
par[i] = i;
rank[i] = 0;
size[i] = 1;
}
}
int find(int x) {
if (par[x] == x) {
return x;
}
return par[x] = find(par[x]);
}
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y)
return;
if (rank[x] < rank[y]) {
par[x] = y;
info[y] = min(info[y], info[x]);
size[y] += size[x];
} else {
par[y] = x;
size[x] += size[y];
info[x] = min(info[y], info[x]);
if (rank[x] == rank[y]) {
rank[x]++;
}
}
gnum--;
}
bool same(int x, int y) { return (find(x) == find(y)); }
int getSize(int x) { return size[find(x)]; }
int groups() { return gnum; }
};
int main() {
int N;
cin >> N;
Union_Find uf(N);
map<string, int> mp;
int A[N];
int v = 0;
rep(i, N) {
string s;
cin >> s;
if (mp.find(s) == mp.end()) {
mp[s] = v++;
}
cin >> A[i];
uf.info[mp[s]] = A[i];
}
assert(v == N);
int M;
cin >> M;
rep(i, M) {
string s, t;
cin >> s >> t;
uf.unite(mp[s], mp[t]);
}
ll sum = 0;
rep(i, N) { sum += uf.info[uf.find(i)]; }
cout << sum << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define REP(i, a, b) for (int i = a; i < (int)b; i++)
#define rep(i, n) REP(i, 0, n)
#define all(c) (c).begin(), (c).end()
#define zero(a) memset(a, 0, sizeof a)
#define minus(a) memset(a, -1, sizeof a)
#define watch(a) \
{ cout << #a << " = " << a << endl; }
template <class T1, class T2> inline bool minimize(T1 &a, T2 b) {
return b < a && (a = b, 1);
}
template <class T1, class T2> inline bool maximize(T1 &a, T2 b) {
return a < b && (a = b, 1);
}
typedef long long ll;
int const inf = 1 << 29;
const int MAX = 5010;
class Union_Find {
public:
int par[MAX], rank[MAX], size[MAX], gnum;
int info[MAX];
Union_Find(int N) {
gnum = N;
for (int i = 0; i < N; i++) {
par[i] = i;
rank[i] = 0;
size[i] = 1;
}
}
int find(int x) {
if (par[x] == x) {
return x;
}
return par[x] = find(par[x]);
}
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y)
return;
if (rank[x] < rank[y]) {
par[x] = y;
info[y] = min(info[y], info[x]);
size[y] += size[x];
} else {
par[y] = x;
size[x] += size[y];
info[x] = min(info[y], info[x]);
if (rank[x] == rank[y]) {
rank[x]++;
}
}
gnum--;
}
bool same(int x, int y) { return (find(x) == find(y)); }
int getSize(int x) { return size[find(x)]; }
int groups() { return gnum; }
};
int main() {
int N;
cin >> N;
Union_Find uf(N);
map<string, int> mp;
int A[N];
int v = 0;
rep(i, N) {
string s;
cin >> s;
if (mp.find(s) == mp.end()) {
mp[s] = v++;
}
cin >> A[i];
uf.info[mp[s]] = A[i];
}
assert(v == N);
int M;
cin >> M;
rep(i, M) {
string s, t;
cin >> s >> t;
uf.unite(mp[s], mp[t]);
}
ll sum = 0;
rep(i, N) { sum += uf.info[uf.find(i)]; }
cout << sum << endl;
return 0;
} | replace | 21 | 22 | 21 | 22 | 0 | |
p01768 | C++ | Runtime Error | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
class UnionFind {
vector<int> par, sz;
public:
UnionFind(int n) {
par = sz = vector<int>(n);
for (int i = 0; i < n; i++) {
par[i] = i;
sz[i] = 1;
}
}
int find(int x) {
if (par[x] == x)
return x;
return par[x] = find(par[x]);
}
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y)
return;
if (sz[x] > sz[y]) {
par[y] = x;
sz[x] += sz[y];
} else {
par[x] = y;
sz[y] += sz[x];
}
}
bool same(int x, int y) { return find(x) == find(y); }
int size(int x) { return sz[find(x)]; }
};
string a[5000];
int x[5000];
int Min[5000], cnt[5000];
int main() {
int n;
scanf("%d", &n);
map<string, int> mp;
rep(i, n) {
cin >> a[i] >> x[i];
mp[a[i]] = mp.size();
}
int m;
scanf("%d", &m);
UnionFind uf(n);
rep(i, m) {
string s, t;
cin >> s >> t;
uf.unite(mp[s], mp[t]);
}
memset(Min, 0x3f, sizeof(Min));
rep(i, n) {
Min[uf.find(i)] = min(Min[uf.find(i)], x[i]);
cnt[uf.find(i)]++;
}
int ans = 0;
rep(i, n) ans += Min[i] * cnt[i];
cout << ans << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
class UnionFind {
vector<int> par, sz;
public:
UnionFind(int n) {
par = sz = vector<int>(n);
for (int i = 0; i < n; i++) {
par[i] = i;
sz[i] = 1;
}
}
int find(int x) {
if (par[x] == x)
return x;
return par[x] = find(par[x]);
}
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y)
return;
if (sz[x] > sz[y]) {
par[y] = x;
sz[x] += sz[y];
} else {
par[x] = y;
sz[y] += sz[x];
}
}
bool same(int x, int y) { return find(x) == find(y); }
int size(int x) { return sz[find(x)]; }
};
string a[5000];
int x[5000];
int Min[5000], cnt[5000];
int main() {
int n;
scanf("%d", &n);
map<string, int> mp;
rep(i, n) {
cin >> a[i] >> x[i];
int b = mp.size();
mp[a[i]] = b;
}
int m;
scanf("%d", &m);
UnionFind uf(n);
rep(i, m) {
string s, t;
cin >> s >> t;
uf.unite(mp[s], mp[t]);
}
memset(Min, 0x3f, sizeof(Min));
rep(i, n) {
Min[uf.find(i)] = min(Min[uf.find(i)], x[i]);
cnt[uf.find(i)]++;
}
int ans = 0;
rep(i, n) ans += Min[i] * cnt[i];
cout << ans << endl;
} | replace | 44 | 45 | 44 | 46 | 0 | |
p01768 | C++ | Runtime Error | #include <algorithm>
#include <cstdlib>
#include <iostream>
#include <map>
#include <set>
#include <string>
using namespace std;
map<string, int> cost;
multimap<string, string> rule;
set<string> his, his2;
int flg;
void update(string a) {
his2.insert(a);
multimap<string, string>::iterator it = rule.find(a);
while (it != rule.end() && it->first == a) {
if (his2.count(it->second) == 0 && cost[it->second] > cost[a])
cost[it->second] = cost[a], update(it->second);
it++;
}
}
int mk_rule(string a) {
if (his.count(a) == 0) {
his.insert(a);
multimap<string, string>::iterator it = rule.find(a);
while (it != rule.end() && it->first == a) {
cost[a] = min(cost[a], mk_rule(it->second));
it++;
}
update(a);
it = rule.find(a);
while (it != rule.end() && it->first == a) {
if (cost[it->second] > cost[a])
exit(1);
it++;
}
}
return cost[a];
}
int main() {
int n, m, b;
cin >> n;
string a, c, ls[5002];
for (int i = 0; i < n; i++) {
cin >> a >> b;
cost[a] = b, ls[i] = a;
}
cin >> m;
for (int i = 0; i < m; i++) {
cin >> a >> c;
rule.insert(pair<string, string>(a, c));
rule.insert(pair<string, string>(c, a));
}
int ans = 0;
for (int i = 0; i < n; i++)
ans += mk_rule(ls[i]);
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <cstdlib>
#include <iostream>
#include <map>
#include <set>
#include <string>
using namespace std;
map<string, int> cost;
multimap<string, string> rule;
set<string> his, his2;
int flg;
void update(string a) {
his2.insert(a);
multimap<string, string>::iterator it = rule.find(a);
while (it != rule.end() && it->first == a) {
if (his2.count(it->second) == 0 && cost[it->second] > cost[a])
cost[it->second] = cost[a], update(it->second);
it++;
}
}
int mk_rule(string a) {
if (his.count(a) == 0) {
his.insert(a);
multimap<string, string>::iterator it = rule.find(a);
while (it != rule.end() && it->first == a) {
cost[a] = min(cost[a], mk_rule(it->second));
it++;
}
his2.clear();
update(a);
it = rule.find(a);
while (it != rule.end() && it->first == a) {
if (cost[it->second] > cost[a])
exit(1);
it++;
}
}
return cost[a];
}
int main() {
int n, m, b;
cin >> n;
string a, c, ls[5002];
for (int i = 0; i < n; i++) {
cin >> a >> b;
cost[a] = b, ls[i] = a;
}
cin >> m;
for (int i = 0; i < m; i++) {
cin >> a >> c;
rule.insert(pair<string, string>(a, c));
rule.insert(pair<string, string>(c, a));
}
int ans = 0;
for (int i = 0; i < n; i++)
ans += mk_rule(ls[i]);
cout << ans << endl;
return 0;
} | insert | 30 | 30 | 30 | 31 | 0 | |
p01768 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cstdlib>
#include <iostream>
#include <map>
#include <string>
#define f first
#define s second
using namespace std;
typedef pair<string, int> P;
map<string, P> mp;
string find(string x) {
if (mp[x].f != x)
mp[x] = mp[find(mp[x].f)];
return mp[x].f;
}
bool unite(string x, string y) {
bool flg = 0;
mp[x] = mp[find(x)], mp[y] = mp[find(y)];
if (mp[x] != mp[y])
flg = 1;
if (mp[x].s < mp[y].s)
swap(mp[x], mp[y]);
mp[x] = mp[y];
return flg;
}
int main() {
int n, m, a;
cin >> n;
string str;
for (int i = 0; i < n; i++) {
cin >> str >> a;
mp[str].f = str;
mp[str].s = a;
}
cin >> m;
string in[2][1001];
for (int i = 0; i < m; i++)
cin >> in[0][i] >> in[1][i], unite(in[0][i], in[1][i]);
for (int i = 0; i < m; i++) {
bool flg = 0;
if (unite(in[0][i], in[1][i]))
flg = 1;
if (flg)
i = -1;
}
int ans = 0;
map<string, P>::iterator it;
for (it = mp.begin(); it != mp.end(); it++)
ans += mp[find(it->f)].s;
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <cstdlib>
#include <iostream>
#include <map>
#include <string>
#define f first
#define s second
using namespace std;
typedef pair<string, int> P;
map<string, P> mp;
string find(string x) {
if (mp[x].f != x)
mp[x] = mp[find(mp[x].f)];
return mp[x].f;
}
bool unite(string x, string y) {
bool flg = 0;
mp[x] = mp[find(x)], mp[y] = mp[find(y)];
if (mp[x].s != mp[y].s)
flg = 1;
if (mp[x].s < mp[y].s)
swap(mp[x], mp[y]);
mp[x] = mp[y];
return flg;
}
int main() {
int n, m, a;
cin >> n;
string str;
for (int i = 0; i < n; i++) {
cin >> str >> a;
mp[str].f = str;
mp[str].s = a;
}
cin >> m;
string in[2][1001];
for (int i = 0; i < m; i++)
cin >> in[0][i] >> in[1][i], unite(in[0][i], in[1][i]);
for (int i = 0; i < m; i++) {
bool flg = 0;
if (unite(in[0][i], in[1][i]))
flg = 1;
if (flg)
i = -1;
}
int ans = 0;
map<string, P>::iterator it;
for (it = mp.begin(); it != mp.end(); it++)
ans += mp[find(it->f)].s;
cout << ans << endl;
return 0;
} | replace | 20 | 21 | 20 | 21 | TLE | |
p01769 | C++ | Runtime Error | // include
//--------------------------------------------------
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define int long long
// conversion
//--------------------------------------------------
inline int toInt(const string &s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
// math
//--------------------------------------------------
template <class T> inline T sqr(T x) { return x * x; }
// typedef
//--------------------------------------------------
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef long long LL;
// container util
//--------------------------------------------------
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define MP make_pair
#define SZ(a) int((a).size())
#define EACH(i, c) \
for (typeof((c).begin()) i = (c).begin(); i != (c).end(); i++)
#define EXIST(s, e) ((s).find(e) != (s).end())
#define SORT(c) sort((c).begin(), (c).end())
// repetition
//--------------------------------------------------
#define REP(i, n) for (int i = 0; i < (n); i++)
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define RREP(i, n) for (int i = (int)(n)-1; i >= 0; i--)
#define RFOR(i, a, b) for (int i = (a)-1; i >= (b); i--)
// clear memory
//--------------------------------------------------
#define CLR(a) memset((a), 0, sizeof(a))
#define CLRM(a) memset((a), -1, sizeof(a))
// end-----------------------------------------------
int bit_n, dat[10000];
void init(int n) {
bit_n = n;
CLR(dat);
}
void add(int k, int x) {
for (k++; k <= bit_n; k += k & -k)
dat[k] += x;
}
int sum(int k) {
int ret = 0;
for (k++; k; k -= k & -k)
ret += dat[k];
return ret;
}
int del(int k) {
int v = sum(k) - sum(k - 1);
add(k, -v);
}
const int mod = 1e9 + 7;
int N, L;
int x[5000], a[5000];
signed main() {
cin >> N >> L;
REP(i, N) cin >> x[i];
REP(i, N) cin >> a[i];
init(L + 114);
add(L, 1);
RREP(i, N) {
REP(j, L + 1) {
del(j);
if (j < x[i] || (j - x[i]) % a[i])
continue;
int v = sum(L) - sum(j);
add(j, v % mod);
}
}
cout << sum(L) % mod << endl;
return 0;
} | // include
//--------------------------------------------------
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define int long long
// conversion
//--------------------------------------------------
inline int toInt(const string &s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
// math
//--------------------------------------------------
template <class T> inline T sqr(T x) { return x * x; }
// typedef
//--------------------------------------------------
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef long long LL;
// container util
//--------------------------------------------------
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define MP make_pair
#define SZ(a) int((a).size())
#define EACH(i, c) \
for (typeof((c).begin()) i = (c).begin(); i != (c).end(); i++)
#define EXIST(s, e) ((s).find(e) != (s).end())
#define SORT(c) sort((c).begin(), (c).end())
// repetition
//--------------------------------------------------
#define REP(i, n) for (int i = 0; i < (n); i++)
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define RREP(i, n) for (int i = (int)(n)-1; i >= 0; i--)
#define RFOR(i, a, b) for (int i = (a)-1; i >= (b); i--)
// clear memory
//--------------------------------------------------
#define CLR(a) memset((a), 0, sizeof(a))
#define CLRM(a) memset((a), -1, sizeof(a))
// end-----------------------------------------------
int bit_n, dat[10000];
void init(int n) {
bit_n = n;
CLR(dat);
}
void add(int k, int x) {
for (k++; k <= bit_n; k += k & -k)
dat[k] += x;
}
int sum(int k) {
int ret = 0;
for (k++; k; k -= k & -k)
ret += dat[k];
return ret;
}
int del(int k) {
int v = sum(k) - sum(k - 1);
add(k, -v);
}
const int mod = 1e9 + 7;
int N, L;
int x[5000], a[5000];
signed main() {
cin >> N >> L;
REP(i, N) cin >> x[i];
REP(i, N) cin >> a[i];
init(L + 114);
add(L, 1);
RREP(i, N) {
REP(j, L + 1) {
del(j);
if (j < x[i] || (a[i] == 0 && j != x[i]) || (j - x[i]) % a[i])
continue;
int v = sum(L) - sum(j);
add(j, v % mod);
}
}
cout << sum(L) % mod << endl;
return 0;
} | replace | 113 | 114 | 113 | 114 | 0 | |
p01769 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <utility>
#include <vector>
#define loop(i, a, b) for (int i = a; i < b; i++)
#define rep(i, a) loop(i, 0, a)
#define pb push_back
#define mp make_pair
#define all(in) in.begin(), in.end()
const double PI = acos(-1);
const double EPS = 1e-10;
const int inf = 1e9;
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int, int> pii;
int dp[5010][5010] = {0};
int main() {
int n, l;
cin >> n >> l;
int MOD = 1000000007;
vi x(n), a(n);
rep(i, n) cin >> x[i];
rep(i, n) cin >> a[i];
rep(i, 5010) dp[0][i] = 1;
rep(i, n) {
for (int j = x[i] + 1; j <= l; j++) {
if ((j - x[i] - 1) % a[i] == 0)
dp[i + 1][j] = (dp[i + 1][j] + dp[i][j - 1]) % MOD;
dp[i + 1][j] = (dp[i + 1][j] + dp[i + 1][j - 1]) % MOD;
}
}
cout << dp[n][l] << endl;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <utility>
#include <vector>
#define loop(i, a, b) for (int i = a; i < b; i++)
#define rep(i, a) loop(i, 0, a)
#define pb push_back
#define mp make_pair
#define all(in) in.begin(), in.end()
const double PI = acos(-1);
const double EPS = 1e-10;
const int inf = 1e9;
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int, int> pii;
int dp[5010][5010] = {0};
int main() {
int n, l;
cin >> n >> l;
int MOD = 1000000007;
vi x(n), a(n);
rep(i, n) cin >> x[i];
rep(i, n) cin >> a[i];
rep(i, 5010) dp[0][i] = 1;
rep(i, n) {
for (int j = x[i] + 1; j <= l; j++) {
if (j == x[i] + 1 || a[i] && (j - x[i] - 1) % a[i] == 0)
dp[i + 1][j] = (dp[i + 1][j] + dp[i][j - 1]) % MOD;
dp[i + 1][j] = (dp[i + 1][j] + dp[i + 1][j - 1]) % MOD;
}
}
cout << dp[n][l] << endl;
} | replace | 36 | 37 | 36 | 37 | 127 | /tmp/992f28b9-45b3-49bb-a528-55d30e73c493.out: error while loading shared libraries: libc.so.6: failed to map segment from shared object
|
p01769 | C++ | Runtime Error | #include <algorithm> // other
#include <bitset>
#include <cassert> // c
#include <complex>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream> // io
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <sstream>
#include <stack>
#include <vector> // container
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
#define ALL(c) (begin(c)), (end(c))
#define REP(i, n) FOR(i, 0, n)
#define REPr(i, n) FORr(i, 0, n)
#define FOR(i, l, r) for (int i = (int)(l); i < (int)(r); ++i)
#define FORr(i, l, r) for (int i = (int)(r)-1; i >= (int)(l); --i)
#define EACH(it, o) for (auto it = (o).begin(); it != (o).end(); ++it)
#define IN(l, v, r) ((l) <= (v) && (v) < (r))
#define UNIQUE(v) v.erase(unique(ALL(v)), v.end())
// debug
#define DUMP(x) cerr << #x << " = " << (x)
#define LINE() cerr << " (L" << __LINE__ << ")"
class range {
private:
struct Iter {
int v;
int operator*() { return v; }
bool operator!=(Iter &itr) { return v < itr.v; }
void operator++() { ++v; }
};
Iter i, n;
public:
range(int n) : i({0}), n({n}) {}
range(int i, int n) : i({i}), n({n}) {}
Iter &begin() { return i; }
Iter &end() { return n; }
};
// input
template <typename T1, typename T2>
istream &operator>>(istream &is, pair<T1, T2> &p) {
is >> p.first >> p.second;
return is;
}
template <typename T1> istream &operator>>(istream &is, tuple<T1> &t) {
is >> get<0>(t);
return is;
}
template <typename T1, typename T2>
istream &operator>>(istream &is, tuple<T1, T2> &t) {
is >> get<0>(t) >> get<1>(t);
return is;
}
template <typename T1, typename T2, typename T3>
istream &operator>>(istream &is, tuple<T1, T2, T3> &t) {
is >> get<0>(t) >> get<1>(t) >> get<2>(t);
return is;
}
template <typename T1, typename T2, typename T3, typename T4>
istream &operator>>(istream &is, tuple<T1, T2, T3, T4> &t) {
is >> get<0>(t) >> get<1>(t) >> get<2>(t) >> get<3>(t);
return is;
}
template <typename T1, typename T2, typename T3, typename T4, typename T5>
istream &operator>>(istream &is, const tuple<T1, T2, T3, T4, T5> &t) {
is >> get<0>(t) >> get<1>(t) >> get<2>(t) >> get<3>(t) >> get<4>(t);
return is;
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6>
istream &operator>>(istream &is, const tuple<T1, T2, T3, T4, T5, T6> &t) {
is >> get<0>(t) >> get<1>(t) >> get<2>(t) >> get<3>(t) >> get<4>(t) >>
get<5>(t);
return is;
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7>
istream &operator>>(istream &is, const tuple<T1, T2, T3, T4, T5, T6, T7> &t) {
is >> get<0>(t) >> get<1>(t) >> get<2>(t) >> get<3>(t) >> get<4>(t) >>
get<5>(t) >> get<6>(t);
return is;
}
template <typename T> istream &operator>>(istream &is, vector<T> &as) {
REP(i, as.size()) is >> as[i];
return is;
}
// output
template <typename T> ostream &operator<<(ostream &os, const set<T> &ss) {
for (auto a : ss) {
if (a != ss.begin())
os << " ";
os << a;
}
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
os << p.first << " " << p.second;
return os;
}
template <typename K, typename V>
ostream &operator<<(ostream &os, const map<K, V> &m) {
bool isF = true;
for (auto &p : m) {
if (!isF)
os << endl;
os << p;
isF = false;
}
return os;
}
template <typename T1> ostream &operator<<(ostream &os, const tuple<T1> &t) {
os << get<0>(t);
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const tuple<T1, T2> &t) {
os << get<0>(t) << " " << get<1>(t);
return os;
}
template <typename T1, typename T2, typename T3>
ostream &operator<<(ostream &os, const tuple<T1, T2, T3> &t) {
os << get<0>(t) << " " << get<1>(t) << " " << get<2>(t);
return os;
}
template <typename T1, typename T2, typename T3, typename T4>
ostream &operator<<(ostream &os, const tuple<T1, T2, T3, T4> &t) {
os << get<0>(t) << " " << get<1>(t) << " " << get<2>(t) << " " << get<3>(t);
return os;
}
template <typename T1, typename T2, typename T3, typename T4, typename T5>
ostream &operator<<(ostream &os, const tuple<T1, T2, T3, T4, T5> &t) {
os << get<0>(t) << " " << get<1>(t) << " " << get<2>(t) << " " << get<3>(t)
<< " " << get<4>(t);
return os;
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6>
ostream &operator<<(ostream &os, const tuple<T1, T2, T3, T4, T5, T6> &t) {
os << get<0>(t) << " " << get<1>(t) << " " << get<2>(t) << " " << get<3>(t)
<< " " << get<4>(t) << " " << get<5>(t);
return os;
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7>
ostream &operator<<(ostream &os, const tuple<T1, T2, T3, T4, T5, T6, T7> &t) {
os << get<0>(t) << " " << get<1>(t) << " " << get<2>(t) << " " << get<3>(t)
<< " " << get<4>(t) << " " << get<5>(t) << " " << get<6>(t);
return os;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &as) {
REP(i, as.size()) {
if (i != 0)
os << " ";
os << as[i];
}
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<vector<T>> &as) {
REP(i, as.size()) {
if (i != 0)
os << endl;
os << as[i];
}
return os;
}
// values
template <typename T> T INF() { assert(false); };
template <> int INF<int>() { return 1 << 28; };
template <> ll INF<ll>() { return 1LL << 58; };
template <> double INF<double>() { return 1e16; };
template <> long double INF<long double>() { return 1e16; };
template <class T> T EPS() { assert(false); };
template <> int EPS<int>() { return 1; };
template <> ll EPS<ll>() { return 1LL; };
template <> double EPS<double>() { return 1e-8; };
template <> long double EPS<long double>() { return 1e-8; };
template <typename T, typename U> T pmod(T v, U M) { return (v % M + M) % M; }
int MOD = 1e9 + 7;
class Main {
public:
vector<vector<int>> dp;
vector<int> xs, as;
// i?????????<=l
int dfs(int i, int l) {
if (as[i] != 0 && (l - xs[i]) % as[i] != 0)
return dfs(i, xs[i] + (l - xs[i]) / as[i] * as[i]);
if (as[i] == 0 && xs[i] < l)
return dfs(i, xs[i]);
if (i < 0)
return 1;
if (dp[i][l] != -1)
return dp[i][l];
ll res = 0;
if (as[i] != 0 && xs[i] <= l - as[i])
res = (res + dfs(i, l - as[i])) % MOD;
if (xs[i] <= l)
res = (res + dfs(i - 1, l - 1)) % MOD;
return dp[i][l] = res;
}
void run() {
int N, L;
cin >> N >> L;
dp = vector<vector<int>>(N, vector<int>(L + 1, -1));
xs = vector<int>(N);
cin >> xs;
as = vector<int>(N);
cin >> as;
cout << dfs(N - 1, xs[N - 1] + (L - 1 - xs[N - 1]) / as[N - 1] * as[N - 1])
<< endl;
}
};
int main() {
cout << fixed << setprecision(20);
cin.tie(0);
ios::sync_with_stdio(false);
Main().run();
return 0;
} | #include <algorithm> // other
#include <bitset>
#include <cassert> // c
#include <complex>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream> // io
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <sstream>
#include <stack>
#include <vector> // container
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
#define ALL(c) (begin(c)), (end(c))
#define REP(i, n) FOR(i, 0, n)
#define REPr(i, n) FORr(i, 0, n)
#define FOR(i, l, r) for (int i = (int)(l); i < (int)(r); ++i)
#define FORr(i, l, r) for (int i = (int)(r)-1; i >= (int)(l); --i)
#define EACH(it, o) for (auto it = (o).begin(); it != (o).end(); ++it)
#define IN(l, v, r) ((l) <= (v) && (v) < (r))
#define UNIQUE(v) v.erase(unique(ALL(v)), v.end())
// debug
#define DUMP(x) cerr << #x << " = " << (x)
#define LINE() cerr << " (L" << __LINE__ << ")"
class range {
private:
struct Iter {
int v;
int operator*() { return v; }
bool operator!=(Iter &itr) { return v < itr.v; }
void operator++() { ++v; }
};
Iter i, n;
public:
range(int n) : i({0}), n({n}) {}
range(int i, int n) : i({i}), n({n}) {}
Iter &begin() { return i; }
Iter &end() { return n; }
};
// input
template <typename T1, typename T2>
istream &operator>>(istream &is, pair<T1, T2> &p) {
is >> p.first >> p.second;
return is;
}
template <typename T1> istream &operator>>(istream &is, tuple<T1> &t) {
is >> get<0>(t);
return is;
}
template <typename T1, typename T2>
istream &operator>>(istream &is, tuple<T1, T2> &t) {
is >> get<0>(t) >> get<1>(t);
return is;
}
template <typename T1, typename T2, typename T3>
istream &operator>>(istream &is, tuple<T1, T2, T3> &t) {
is >> get<0>(t) >> get<1>(t) >> get<2>(t);
return is;
}
template <typename T1, typename T2, typename T3, typename T4>
istream &operator>>(istream &is, tuple<T1, T2, T3, T4> &t) {
is >> get<0>(t) >> get<1>(t) >> get<2>(t) >> get<3>(t);
return is;
}
template <typename T1, typename T2, typename T3, typename T4, typename T5>
istream &operator>>(istream &is, const tuple<T1, T2, T3, T4, T5> &t) {
is >> get<0>(t) >> get<1>(t) >> get<2>(t) >> get<3>(t) >> get<4>(t);
return is;
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6>
istream &operator>>(istream &is, const tuple<T1, T2, T3, T4, T5, T6> &t) {
is >> get<0>(t) >> get<1>(t) >> get<2>(t) >> get<3>(t) >> get<4>(t) >>
get<5>(t);
return is;
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7>
istream &operator>>(istream &is, const tuple<T1, T2, T3, T4, T5, T6, T7> &t) {
is >> get<0>(t) >> get<1>(t) >> get<2>(t) >> get<3>(t) >> get<4>(t) >>
get<5>(t) >> get<6>(t);
return is;
}
template <typename T> istream &operator>>(istream &is, vector<T> &as) {
REP(i, as.size()) is >> as[i];
return is;
}
// output
template <typename T> ostream &operator<<(ostream &os, const set<T> &ss) {
for (auto a : ss) {
if (a != ss.begin())
os << " ";
os << a;
}
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
os << p.first << " " << p.second;
return os;
}
template <typename K, typename V>
ostream &operator<<(ostream &os, const map<K, V> &m) {
bool isF = true;
for (auto &p : m) {
if (!isF)
os << endl;
os << p;
isF = false;
}
return os;
}
template <typename T1> ostream &operator<<(ostream &os, const tuple<T1> &t) {
os << get<0>(t);
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const tuple<T1, T2> &t) {
os << get<0>(t) << " " << get<1>(t);
return os;
}
template <typename T1, typename T2, typename T3>
ostream &operator<<(ostream &os, const tuple<T1, T2, T3> &t) {
os << get<0>(t) << " " << get<1>(t) << " " << get<2>(t);
return os;
}
template <typename T1, typename T2, typename T3, typename T4>
ostream &operator<<(ostream &os, const tuple<T1, T2, T3, T4> &t) {
os << get<0>(t) << " " << get<1>(t) << " " << get<2>(t) << " " << get<3>(t);
return os;
}
template <typename T1, typename T2, typename T3, typename T4, typename T5>
ostream &operator<<(ostream &os, const tuple<T1, T2, T3, T4, T5> &t) {
os << get<0>(t) << " " << get<1>(t) << " " << get<2>(t) << " " << get<3>(t)
<< " " << get<4>(t);
return os;
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6>
ostream &operator<<(ostream &os, const tuple<T1, T2, T3, T4, T5, T6> &t) {
os << get<0>(t) << " " << get<1>(t) << " " << get<2>(t) << " " << get<3>(t)
<< " " << get<4>(t) << " " << get<5>(t);
return os;
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7>
ostream &operator<<(ostream &os, const tuple<T1, T2, T3, T4, T5, T6, T7> &t) {
os << get<0>(t) << " " << get<1>(t) << " " << get<2>(t) << " " << get<3>(t)
<< " " << get<4>(t) << " " << get<5>(t) << " " << get<6>(t);
return os;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &as) {
REP(i, as.size()) {
if (i != 0)
os << " ";
os << as[i];
}
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<vector<T>> &as) {
REP(i, as.size()) {
if (i != 0)
os << endl;
os << as[i];
}
return os;
}
// values
template <typename T> T INF() { assert(false); };
template <> int INF<int>() { return 1 << 28; };
template <> ll INF<ll>() { return 1LL << 58; };
template <> double INF<double>() { return 1e16; };
template <> long double INF<long double>() { return 1e16; };
template <class T> T EPS() { assert(false); };
template <> int EPS<int>() { return 1; };
template <> ll EPS<ll>() { return 1LL; };
template <> double EPS<double>() { return 1e-8; };
template <> long double EPS<long double>() { return 1e-8; };
template <typename T, typename U> T pmod(T v, U M) { return (v % M + M) % M; }
int MOD = 1e9 + 7;
class Main {
public:
vector<vector<int>> dp;
vector<int> xs, as;
// i?????????<=l
int dfs(int i, int l) {
if (as[i] != 0 && (l - xs[i]) % as[i] != 0)
return dfs(i, xs[i] + (l - xs[i]) / as[i] * as[i]);
if (as[i] == 0 && xs[i] < l)
return dfs(i, xs[i]);
if (i < 0)
return 1;
if (dp[i][l] != -1)
return dp[i][l];
ll res = 0;
if (as[i] != 0 && xs[i] <= l - as[i])
res = (res + dfs(i, l - as[i])) % MOD;
if (xs[i] <= l)
res = (res + dfs(i - 1, l - 1)) % MOD;
return dp[i][l] = res;
}
void run() {
int N, L;
cin >> N >> L;
dp = vector<vector<int>>(N, vector<int>(L + 1, -1));
xs = vector<int>(N);
cin >> xs;
as = vector<int>(N);
cin >> as;
cout << dfs(N - 1, L - 1) << endl;
}
};
int main() {
cout << fixed << setprecision(20);
cin.tie(0);
ios::sync_with_stdio(false);
Main().run();
return 0;
} | replace | 228 | 231 | 228 | 229 | 0 | |
p01769 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define int long long
int dp[5010][5010];
signed main() {
int n, l, p = 1000000007;
cin >> n >> l;
vector<int> x(n), a(n);
for (int i = 0; i < n; i++)
cin >> x[n - 1 - i];
for (int i = 0; i < n; i++)
cin >> a[n - 1 - i];
if (a[0] == 0)
dp[0][x[0]] = 1;
else
for (int i = x[0]; i < l; i += a[0])
dp[0][i] = 1;
for (int i = 1; i < n; i++) {
int sum = 0;
for (int j = l - 1; j >= x[i]; j--) {
if ((j - x[i]) % a[i] == 0) {
if (a[i] > 0 || x[i] == j) {
dp[i][j] += sum;
dp[i][j] %= p;
}
}
sum += dp[i - 1][j];
sum %= p;
}
}
int ans = 0;
for (int i = 0; i < l; i++) {
ans += dp[n - 1][i];
ans %= p;
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
int dp[5010][5010];
signed main() {
int n, l, p = 1000000007;
cin >> n >> l;
vector<int> x(n), a(n);
for (int i = 0; i < n; i++)
cin >> x[n - 1 - i];
for (int i = 0; i < n; i++)
cin >> a[n - 1 - i];
if (a[0] == 0)
dp[0][x[0]] = 1;
else
for (int i = x[0]; i < l; i += a[0])
dp[0][i] = 1;
for (int i = 1; i < n; i++) {
int sum = 0;
for (int j = l - 1; j >= x[i]; j--) {
if ((a[i] > 0 && (j - x[i]) % a[i] == 0) || x[i] == j) {
dp[i][j] += sum;
dp[i][j] %= p;
}
sum += dp[i - 1][j];
sum %= p;
}
}
int ans = 0;
for (int i = 0; i < l; i++) {
ans += dp[n - 1][i];
ans %= p;
}
cout << ans << endl;
return 0;
}
| replace | 22 | 27 | 22 | 25 | -11 | |
p01769 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, L;
int x[5010], a[5010];
scanf("%d %d", &N, &L);
for (int i = 0; i < N; i++)
scanf("%d", x + i);
for (int i = 0; i < N; i++)
scanf("%d", a + i);
int dp[2][5010] = {{0}};
int prev = 0, now = 1;
dp[prev][L] = 1;
for (int i = N - 1; i >= 0; i--) {
for (int j = L; j >= 0; j--) {
dp[now][j] = 0;
dp[prev][j] = (dp[prev][j] + dp[prev][j + 1]) % 1000000007;
}
for (int j = x[i]; j < L; j += a[i]) {
dp[now][j] = dp[prev][j + 1];
}
now = 1 - now;
prev = 1 - prev;
}
int ans = 0;
for (int i = 0; i < L; i++)
ans = (ans + dp[prev][i]) % 1000000007;
printf("%d\n", ans);
return (0);
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, L;
int x[5010], a[5010];
scanf("%d %d", &N, &L);
for (int i = 0; i < N; i++)
scanf("%d", x + i);
for (int i = 0; i < N; i++)
scanf("%d", a + i);
int dp[2][5010] = {{0}};
int prev = 0, now = 1;
dp[prev][L] = 1;
for (int i = N - 1; i >= 0; i--) {
for (int j = L; j >= 0; j--) {
dp[now][j] = 0;
dp[prev][j] = (dp[prev][j] + dp[prev][j + 1]) % 1000000007;
}
for (int j = x[i]; j < L; j += a[i]) {
dp[now][j] = dp[prev][j + 1];
if (!a[i])
break;
}
now = 1 - now;
prev = 1 - prev;
}
int ans = 0;
for (int i = 0; i < L; i++)
ans = (ans + dp[prev][i]) % 1000000007;
printf("%d\n", ans);
return (0);
} | insert | 26 | 26 | 26 | 28 | TLE | |
p01769 | C++ | Time Limit Exceeded | #define _USE_MATH_DEFINES
#define _CRT_SECURE_NO_DEPRECATE
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> Pii;
typedef pair<ll, ll> Pll;
#define FOR(i, n) for (int i = 0; i < (n); i++)
#define sz(c) ((int)(c).size())
#define ten(x) ((int)1e##x)
#define tenll(x) ((ll)1e##x)
int x[5000], a[5000];
int dp[2][5010];
const int MOD = ten(9) + 7;
int main() {
int n, l;
scanf("%d%d", &n, &l);
FOR(i, n) scanf("%d", x + i);
FOR(i, n) scanf("%d", a + i);
FOR(i, n) x[i]++;
FOR(i, l + 1) dp[0][i] = 1;
auto pv = dp[0], nt = dp[1];
FOR(i, n) {
memset(nt, 0, sizeof(dp[0]));
for (int dist = 0; x[i] + dist <= l; dist += a[i]) {
int cur = x[i] + dist;
nt[cur] = pv[cur - 1];
}
FOR(j, l) {
nt[j + 1] += nt[j];
if (nt[j + 1] >= MOD)
nt[j + 1] -= MOD;
}
swap(pv, nt);
}
cout << pv[l] << endl;
} | #define _USE_MATH_DEFINES
#define _CRT_SECURE_NO_DEPRECATE
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> Pii;
typedef pair<ll, ll> Pll;
#define FOR(i, n) for (int i = 0; i < (n); i++)
#define sz(c) ((int)(c).size())
#define ten(x) ((int)1e##x)
#define tenll(x) ((ll)1e##x)
int x[5000], a[5000];
int dp[2][5010];
const int MOD = ten(9) + 7;
int main() {
int n, l;
scanf("%d%d", &n, &l);
FOR(i, n) scanf("%d", x + i);
FOR(i, n) scanf("%d", a + i);
FOR(i, n) x[i]++;
FOR(i, l + 1) dp[0][i] = 1;
auto pv = dp[0], nt = dp[1];
FOR(i, n) {
memset(nt, 0, sizeof(dp[0]));
if (a[i]) {
for (int dist = 0; x[i] + dist <= l; dist += a[i]) {
int cur = x[i] + dist;
nt[cur] = pv[cur - 1];
}
} else {
nt[x[i]] = pv[x[i] - 1];
}
FOR(j, l) {
nt[j + 1] += nt[j];
if (nt[j + 1] >= MOD)
nt[j + 1] -= MOD;
}
swap(pv, nt);
}
cout << pv[l] << endl;
} | replace | 58 | 61 | 58 | 65 | TLE | |
p01769 | C++ | Runtime Error | #include <algorithm>
#include <cstring>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
static const int MOD = 1000000007;
static int dp[5001][5001];
int main() {
ios_base::sync_with_stdio(false);
int n, l;
cin >> n >> l;
vector<int> x(n), a(n);
for (int i = 0; i < n; ++i) {
cin >> x[i];
}
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
memset(dp, 0, sizeof(dp));
dp[n][l] = 1;
for (int i = n - 1; i >= 0; --i) {
int sum = dp[i + 1][l];
for (int j = l - 1; j >= x[i]; --j) {
if ((j - x[i]) % a[i] == 0) {
dp[i][j] = (dp[i][j] + sum) % MOD;
}
sum = (sum + dp[i + 1][j]) % MOD;
}
}
int answer = 0;
for (int i = 0; i <= l; ++i) {
answer = (answer + dp[0][i]) % MOD;
}
cout << answer << endl;
return 0;
} | #include <algorithm>
#include <cstring>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
static const int MOD = 1000000007;
static int dp[5001][5001];
int main() {
ios_base::sync_with_stdio(false);
int n, l;
cin >> n >> l;
vector<int> x(n), a(n);
for (int i = 0; i < n; ++i) {
cin >> x[i];
}
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
memset(dp, 0, sizeof(dp));
dp[n][l] = 1;
for (int i = n - 1; i >= 0; --i) {
int sum = dp[i + 1][l];
for (int j = l - 1; j >= x[i]; --j) {
if (a[i] == 0) {
if (j == x[i]) {
dp[i][j] = (dp[i][j] + sum) % MOD;
}
} else if ((j - x[i]) % a[i] == 0) {
dp[i][j] = (dp[i][j] + sum) % MOD;
}
sum = (sum + dp[i + 1][j]) % MOD;
}
}
int answer = 0;
for (int i = 0; i <= l; ++i) {
answer = (answer + dp[0][i]) % MOD;
}
cout << answer << endl;
return 0;
} | replace | 27 | 28 | 27 | 32 | 127 | /tmp/6525004b-86ef-407c-94b0-66ee7ca97ed9.out: error while loading shared libraries: libc.so.6: failed to map segment from shared object
|
p01769 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
#define X first
#define Y second
#define pb push_back
#define rep(X, Y) for (int(X) = 0; (X) < (Y); ++(X))
#define rrep(X, Y) for (int(X) = (Y - 1); (X) >= 0; --(X))
#define repe(X, Y) for ((X) = 0; (X) < (Y); ++(X))
#define peat(X, Y) for (; (X) < (Y); ++(X))
#define all(X) (X).begin(), (X).end()
#define rall(X) (X).rbegin(), (X).rend()
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
// template<class T> using vv=vector<vector<T>>;
template <class T> ostream &operator<<(ostream &os, const vector<T> &t) {
os << "{";
rep(i, t.size()) { os << t[i] << ","; }
os << "}" << endl;
return os;
}
template <class S, class T>
ostream &operator<<(ostream &os, const pair<S, T> &t) {
return os << "(" << t.first << "," << t.second << ")";
}
const ll MOD = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(0);
int i, j, k;
int n, l;
cin >> n >> l;
vector<ll> dp[2], x(n), a(n);
rep(i, n) cin >> x[i];
rep(i, n) cin >> a[i];
rep(i, 2) dp[i].resize(l + 1);
dp[0][0] = 1;
// cout<<dp[0];
rep(i, n) {
ll sum = 0, val = 0;
fill(all(dp[1 - i % 2]), 0ll);
rep(j, l) {
sum += dp[i % 2][j];
if ((j - x[i]) % a[i] == 0) {
dp[1 - i % 2][j + 1] = sum;
}
}
// cout<<dp[1-i%2];
}
ll re = 0;
rep(i, l + 1)(re += dp[n % 2][i]) %= MOD;
cout << re << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
#define X first
#define Y second
#define pb push_back
#define rep(X, Y) for (int(X) = 0; (X) < (Y); ++(X))
#define rrep(X, Y) for (int(X) = (Y - 1); (X) >= 0; --(X))
#define repe(X, Y) for ((X) = 0; (X) < (Y); ++(X))
#define peat(X, Y) for (; (X) < (Y); ++(X))
#define all(X) (X).begin(), (X).end()
#define rall(X) (X).rbegin(), (X).rend()
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
// template<class T> using vv=vector<vector<T>>;
template <class T> ostream &operator<<(ostream &os, const vector<T> &t) {
os << "{";
rep(i, t.size()) { os << t[i] << ","; }
os << "}" << endl;
return os;
}
template <class S, class T>
ostream &operator<<(ostream &os, const pair<S, T> &t) {
return os << "(" << t.first << "," << t.second << ")";
}
const ll MOD = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(0);
int i, j, k;
int n, l;
cin >> n >> l;
vector<ll> dp[2], x(n), a(n);
rep(i, n) cin >> x[i];
rep(i, n) cin >> a[i];
rep(i, 2) dp[i].resize(l + 1);
dp[0][0] = 1;
// cout<<dp[0];
rep(i, n) {
ll sum = 0, val = 0;
fill(all(dp[1 - i % 2]), 0ll);
rep(j, l) {
(sum += dp[i % 2][j]) %= MOD;
if (a[i] && j > x[i] && (j - x[i]) % a[i] == 0 || j == x[i]) {
dp[1 - i % 2][j + 1] = sum;
}
}
// cout<<dp[1-i%2];
}
ll re = 0;
rep(i, l + 1)(re += dp[n % 2][i]) %= MOD;
cout << re << endl;
return 0;
} | replace | 65 | 67 | 65 | 67 | 0 | |
p01769 | C++ | Memory Limit Exceeded | long long dp[5000][5000];
int main() {
for (int i = 0; i < 5000; i++)
for (int j = 0; j < 5000; j++)
dp[i][j] = 1;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define int ll
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define all(c) begin(c), end(c)
#define dump(x) cerr << __LINE__ << ":\t" #x " = " << (x) << endl
const int MOD = 1000000007;
int n, l;
int x[5010], a[5010];
int dp[5010][5010];
signed main() {
while (cin >> n >> l) {
rep(i, n) cin >> x[i], ++x[i];
rep(i, n) cin >> a[i], a[i] ? 0 : a[i] = l;
memset(dp, 0, sizeof dp);
for (int i = 0; i <= l; ++i)
dp[0][i] = 1;
for (int i = 1; i <= n; ++i) {
int a = ::a[i - 1], x = ::x[i - 1];
for (int j = x; j <= l; ++j) {
if (j == x) {
dp[i][j] = dp[i - 1][j - 1];
} else {
if ((j - x) % a == 0) {
dp[i][j] += dp[i - 1][j - 1];
}
dp[i][j] += dp[i][j - 1];
dp[i][j] %= MOD;
}
}
}
// for(int i = 0; i <= n; ++i){
// for(int j = 0; j <= l; ++j){
// cout << dp[i][j] << ' ';
// }
// cout << endl;
// }
cout << dp[n][l] << endl;
}
} | replace | 0 | 5 | 0 | 45 | MLE | |
p01769 | C++ | Runtime Error | #include <algorithm>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#define rep(i, n) for (int(i) = 0; (i) < (int)(n); ++(i))
#define rer(i, l, u) for (int(i) = (int)(l); (i) <= (int)(u); ++(i))
#define reu(i, l, u) for (int(i) = (int)(l); (i) < (int)(u); ++(i))
#if defined(_MSC_VER) || __cplusplus > 199711L
#define aut(r, v) auto r = (v)
#else
#define aut(r, v) __typeof(v) r = (v)
#endif
#define each(it, o) for (aut(it, (o).begin()); it != (o).end(); ++it)
#define all(o) (o).begin(), (o).end()
#define pb(x) push_back(x)
#define mp(x, y) make_pair((x), (y))
#define mset(m, v) memset(m, v, sizeof(m))
#define INF 0x3f3f3f3f
#define INFL 0x3f3f3f3f3f3f3f3fLL
using namespace std;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef vector<pair<int, int>> vpii;
typedef long long ll;
template <typename T, typename U> inline void amin(T &x, U y) {
if (y < x)
x = y;
}
template <typename T, typename U> inline void amax(T &x, U y) {
if (x < y)
x = y;
}
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;
}
bool operator==(ModInt that) const { return x == that.x; }
bool operator!=(ModInt that) const { return x != that.x; }
ModInt operator-() const {
ModInt t;
t.x = x == 0 ? 0 : Mod - x;
return t;
}
};
template <int MOD> ModInt<MOD> operator^(ModInt<MOD> a, unsigned long long k) {
ModInt<MOD> r = 1;
while (k) {
if (k & 1)
r *= a;
a *= a;
k >>= 1;
}
return r;
}
typedef ModInt<1000000007> mint;
int main() {
int N, L;
scanf("%d%d", &N, &L);
vector<int> x(N), a(N);
rep(i, N) scanf("%d", &x[i]);
rep(i, N) scanf("%d", &a[i]);
vector<vector<mint>> dp(N + 1, vector<mint>(L + 1));
dp[N][L] = 1;
for (int i = N - 1; i >= 0; --i) {
int cx = x[i], ca = a[i];
mint y;
for (int j = L; j >= cx; --j) {
if ((j - cx) % ca == 0)
dp[i][j] = y;
y += dp[i + 1][j];
}
}
mint ans = accumulate(all(dp[0]), mint());
printf("%d\n", ans.get());
return 0;
} | #include <algorithm>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#define rep(i, n) for (int(i) = 0; (i) < (int)(n); ++(i))
#define rer(i, l, u) for (int(i) = (int)(l); (i) <= (int)(u); ++(i))
#define reu(i, l, u) for (int(i) = (int)(l); (i) < (int)(u); ++(i))
#if defined(_MSC_VER) || __cplusplus > 199711L
#define aut(r, v) auto r = (v)
#else
#define aut(r, v) __typeof(v) r = (v)
#endif
#define each(it, o) for (aut(it, (o).begin()); it != (o).end(); ++it)
#define all(o) (o).begin(), (o).end()
#define pb(x) push_back(x)
#define mp(x, y) make_pair((x), (y))
#define mset(m, v) memset(m, v, sizeof(m))
#define INF 0x3f3f3f3f
#define INFL 0x3f3f3f3f3f3f3f3fLL
using namespace std;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef vector<pair<int, int>> vpii;
typedef long long ll;
template <typename T, typename U> inline void amin(T &x, U y) {
if (y < x)
x = y;
}
template <typename T, typename U> inline void amax(T &x, U y) {
if (x < y)
x = y;
}
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;
}
bool operator==(ModInt that) const { return x == that.x; }
bool operator!=(ModInt that) const { return x != that.x; }
ModInt operator-() const {
ModInt t;
t.x = x == 0 ? 0 : Mod - x;
return t;
}
};
template <int MOD> ModInt<MOD> operator^(ModInt<MOD> a, unsigned long long k) {
ModInt<MOD> r = 1;
while (k) {
if (k & 1)
r *= a;
a *= a;
k >>= 1;
}
return r;
}
typedef ModInt<1000000007> mint;
int main() {
int N, L;
scanf("%d%d", &N, &L);
vector<int> x(N), a(N);
rep(i, N) scanf("%d", &x[i]);
rep(i, N) scanf("%d", &a[i]);
vector<vector<mint>> dp(N + 1, vector<mint>(L + 1));
dp[N][L] = 1;
for (int i = N - 1; i >= 0; --i) {
int cx = x[i], ca = a[i];
if (ca == 0) {
mint y;
for (int j = L; j >= cx; --j) {
if (j == cx)
dp[i][j] = y;
y += dp[i + 1][j];
}
} else {
mint y;
for (int j = L; j >= cx; --j) {
if ((j - cx) % ca == 0)
dp[i][j] = y;
y += dp[i + 1][j];
}
}
}
mint ans = accumulate(all(dp[0]), mint());
printf("%d\n", ans.get());
return 0;
} | replace | 131 | 136 | 131 | 145 | 0 | |
p01769 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define foreach(it, c) \
for (__typeof__((c).begin()) it = (c).begin(); it != (c).end(); ++it)
template <typename T> void print_container(ostream &os, const T &c) {
const char *_s = " ";
if (!c.empty()) {
__typeof__(c.begin()) last = --c.end();
foreach (it, c) {
os << *it;
if (it != last)
os << _s;
}
}
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &c) {
print_container(os, c);
return os;
}
template <typename T> ostream &operator<<(ostream &os, const set<T> &c) {
print_container(os, c);
return os;
}
template <typename T> ostream &operator<<(ostream &os, const multiset<T> &c) {
print_container(os, c);
return os;
}
template <typename T> ostream &operator<<(ostream &os, const deque<T> &c) {
print_container(os, c);
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const map<T, U> &c) {
print_container(os, c);
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
template <typename T> void print(T a, int n, const string &split = " ") {
for (int i = 0; i < n; i++) {
cout << a[i];
if (i + 1 != n)
cout << split;
}
cout << endl;
}
template <typename T>
void print2d(T a, int w, int h, int width = -1, int br = 0) {
for (int i = 0; i < h; ++i) {
for (int j = 0; j < w; ++j) {
if (width != -1)
cout.width(width);
cout << a[i][j] << ' ';
}
cout << endl;
}
while (br--)
cout << endl;
}
template <typename T> void input(T &a, int n) {
for (int i = 0; i < n; ++i)
cin >> a[i];
}
#define dump(v) (cerr << #v << ": " << v << endl)
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define erep(i, n) for (int i = 0; i <= (int)(n); ++i)
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define clr(a, x) memset(a, x, sizeof(a))
#define sz(a) ((int)(a).size())
#define mp(a, b) make_pair(a, b)
#define ten(n) ((long long)(1e##n))
template <typename T, typename U> void upmin(T &a, const U &b) {
a = min<T>(a, b);
}
template <typename T, typename U> void upmax(T &a, const U &b) {
a = max<T>(a, b);
}
template <typename T> void uniq(T &a) {
sort(a.begin(), a.end());
a.erase(unique(a.begin(), a.end()), a.end());
}
template <class T> string to_s(const T &a) {
ostringstream os;
os << a;
return os.str();
}
template <class T> T to_T(const string &s) {
istringstream is(s);
T res;
is >> res;
return res;
}
void fast_io() {
cin.tie(0);
ios::sync_with_stdio(false);
}
bool in_rect(int x, int y, int w, int h) {
return 0 <= x && x < w && 0 <= y && y < h;
}
typedef long long ll;
typedef pair<int, int> pint;
const int dx[] = {0, 1, 0, -1};
const int dy[] = {1, 0, -1, 0};
int main() {
int n, l;
cin >> n >> l;
vector<int> x(n), a(n);
input(x, n);
input(a, n);
const int mod = ten(9) + 7;
static int dp[5555][5555];
dp[n][l] = 1;
for (int i = n - 1; i >= 0; --i) {
int ways = 0;
for (int p = l; p >= x[i]; --p) {
if ((p - x[i]) % a[i] == 0)
dp[i][p] = ways;
(ways += dp[i + 1][p]) %= mod;
}
}
int res = 0;
rep(p, l)(res += dp[0][p]) %= mod;
cout << res << endl;
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define foreach(it, c) \
for (__typeof__((c).begin()) it = (c).begin(); it != (c).end(); ++it)
template <typename T> void print_container(ostream &os, const T &c) {
const char *_s = " ";
if (!c.empty()) {
__typeof__(c.begin()) last = --c.end();
foreach (it, c) {
os << *it;
if (it != last)
os << _s;
}
}
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &c) {
print_container(os, c);
return os;
}
template <typename T> ostream &operator<<(ostream &os, const set<T> &c) {
print_container(os, c);
return os;
}
template <typename T> ostream &operator<<(ostream &os, const multiset<T> &c) {
print_container(os, c);
return os;
}
template <typename T> ostream &operator<<(ostream &os, const deque<T> &c) {
print_container(os, c);
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const map<T, U> &c) {
print_container(os, c);
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
template <typename T> void print(T a, int n, const string &split = " ") {
for (int i = 0; i < n; i++) {
cout << a[i];
if (i + 1 != n)
cout << split;
}
cout << endl;
}
template <typename T>
void print2d(T a, int w, int h, int width = -1, int br = 0) {
for (int i = 0; i < h; ++i) {
for (int j = 0; j < w; ++j) {
if (width != -1)
cout.width(width);
cout << a[i][j] << ' ';
}
cout << endl;
}
while (br--)
cout << endl;
}
template <typename T> void input(T &a, int n) {
for (int i = 0; i < n; ++i)
cin >> a[i];
}
#define dump(v) (cerr << #v << ": " << v << endl)
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define erep(i, n) for (int i = 0; i <= (int)(n); ++i)
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define clr(a, x) memset(a, x, sizeof(a))
#define sz(a) ((int)(a).size())
#define mp(a, b) make_pair(a, b)
#define ten(n) ((long long)(1e##n))
template <typename T, typename U> void upmin(T &a, const U &b) {
a = min<T>(a, b);
}
template <typename T, typename U> void upmax(T &a, const U &b) {
a = max<T>(a, b);
}
template <typename T> void uniq(T &a) {
sort(a.begin(), a.end());
a.erase(unique(a.begin(), a.end()), a.end());
}
template <class T> string to_s(const T &a) {
ostringstream os;
os << a;
return os.str();
}
template <class T> T to_T(const string &s) {
istringstream is(s);
T res;
is >> res;
return res;
}
void fast_io() {
cin.tie(0);
ios::sync_with_stdio(false);
}
bool in_rect(int x, int y, int w, int h) {
return 0 <= x && x < w && 0 <= y && y < h;
}
typedef long long ll;
typedef pair<int, int> pint;
const int dx[] = {0, 1, 0, -1};
const int dy[] = {1, 0, -1, 0};
int main() {
int n, l;
cin >> n >> l;
vector<int> x(n), a(n);
input(x, n);
input(a, n);
const int mod = ten(9) + 7;
static int dp[5555][5555];
dp[n][l] = 1;
for (int i = n - 1; i >= 0; --i) {
int ways = 0;
for (int p = l; p >= x[i]; --p) {
if (a[i] == 0 && p == x[i] || a[i] != 0 && (p - x[i]) % a[i] == 0)
dp[i][p] = ways;
(ways += dp[i + 1][p]) %= mod;
}
}
int res = 0;
rep(p, l)(res += dp[0][p]) %= mod;
cout << res << endl;
} | replace | 154 | 155 | 154 | 155 | -11 | |
p01769 | C++ | Time Limit Exceeded | #define REP(i, n) for (int i = 0; i < (int)(n); i++)
#include <queue>
typedef long long ll;
#include <cstdio>
inline int getInt() {
int s;
scanf("%d", &s);
return s;
}
#include <set>
using namespace std;
const ll mod = 1000000007;
class BIT {
vector<ll> bit;
public:
BIT(int n) : bit(n + 1) {}
void add(int idx, ll val) {
idx++;
while (idx < (int)bit.size()) {
(bit[idx] += val) %= mod;
idx += idx & -idx;
}
}
ll sum(int i) {
ll s = 0;
i++;
while (i > 0) {
(s += bit[i]) %= mod;
i -= i & -i;
}
return s;
}
void swap(BIT &other) { bit.swap(other.bit); }
};
int main() {
const int n = getInt();
const int l = getInt();
vector<int> x(n);
vector<int> a(n);
REP(i, n) x[i] = getInt();
REP(i, n) a[i] = getInt();
BIT dp(l + 1);
dp.add(0, 1);
REP(i, n) {
BIT next(l + 1);
const int xx = x[i];
const int aa = a[i];
for (int p = xx; p < l; p += aa) {
next.add(p + 1, dp.sum(p));
}
dp.swap(next);
}
printf("%d\n", (int)dp.sum(l));
return 0;
} | #define REP(i, n) for (int i = 0; i < (int)(n); i++)
#include <queue>
typedef long long ll;
#include <cstdio>
inline int getInt() {
int s;
scanf("%d", &s);
return s;
}
#include <set>
using namespace std;
const ll mod = 1000000007;
class BIT {
vector<ll> bit;
public:
BIT(int n) : bit(n + 1) {}
void add(int idx, ll val) {
idx++;
while (idx < (int)bit.size()) {
(bit[idx] += val) %= mod;
idx += idx & -idx;
}
}
ll sum(int i) {
ll s = 0;
i++;
while (i > 0) {
(s += bit[i]) %= mod;
i -= i & -i;
}
return s;
}
void swap(BIT &other) { bit.swap(other.bit); }
};
int main() {
const int n = getInt();
const int l = getInt();
vector<int> x(n);
vector<int> a(n);
REP(i, n) x[i] = getInt();
REP(i, n) a[i] = getInt();
BIT dp(l + 1);
dp.add(0, 1);
REP(i, n) {
BIT next(l + 1);
const int xx = x[i];
const int aa = a[i];
if (aa != 0) {
for (int p = xx; p < l; p += aa) {
next.add(p + 1, dp.sum(p));
}
} else {
next.add(xx + 1, dp.sum(xx));
}
dp.swap(next);
}
printf("%d\n", (int)dp.sum(l));
return 0;
} | replace | 59 | 61 | 59 | 65 | TLE | |
p01769 | C++ | Time Limit Exceeded | #include <algorithm>
#include <iostream>
#include <vector>
#define REP(i, N) for (int i = 0; i < N; ++i)
#define REPA(i, N) for (int i = 1; i < N; ++i)
#define MOD ((int)1e9 + 7)
using namespace std;
int main() {
int N, L;
cin >> N >> L;
vector<int> sp(N), ran(N);
REP(i, N) { cin >> sp[i]; }
REP(i, N) { cin >> ran[i]; }
vector<vector<int>> dp(N, vector<int>(L, 0));
for (int i = sp[0]; i < L; i += ran[0]) {
dp[0][i] = 1;
}
REPA(i, N) {
for (int j = sp[i]; j < L; j += ran[i]) {
int sum = 0;
if (ran[i] == 0) {
REP(k, sp[i]) { sum = (sum + dp[i - 1][k]) % MOD; }
dp[i][j] = sum;
break;
} else if (j == sp[i]) {
REP(k, sp[i]) { sum = (sum + dp[i - 1][k]) % MOD; }
dp[i][j] = sum;
} else {
for (int k = j - ran[i]; k < j; ++k) {
sum = (sum + dp[i - 1][k]) % MOD;
}
dp[i][j] = (dp[i][j - ran[i]] + sum) % MOD;
}
}
}
int ans = 0;
REP(i, L) { ans = (ans + dp[N - 1][i]) % MOD; }
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <vector>
#define REP(i, N) for (int i = 0; i < N; ++i)
#define REPA(i, N) for (int i = 1; i < N; ++i)
#define MOD ((int)1e9 + 7)
using namespace std;
int main() {
int N, L;
cin >> N >> L;
vector<int> sp(N), ran(N);
REP(i, N) { cin >> sp[i]; }
REP(i, N) { cin >> ran[i]; }
vector<vector<int>> dp(N, vector<int>(L, 0));
for (int i = sp[0]; i < L; i += ran[0]) {
dp[0][i] = 1;
if (ran[0] == 0)
break;
}
REPA(i, N) {
for (int j = sp[i]; j < L; j += ran[i]) {
int sum = 0;
if (ran[i] == 0) {
REP(k, sp[i]) { sum = (sum + dp[i - 1][k]) % MOD; }
dp[i][j] = sum;
break;
} else if (j == sp[i]) {
REP(k, sp[i]) { sum = (sum + dp[i - 1][k]) % MOD; }
dp[i][j] = sum;
} else {
for (int k = j - ran[i]; k < j; ++k) {
sum = (sum + dp[i - 1][k]) % MOD;
}
dp[i][j] = (dp[i][j - ran[i]] + sum) % MOD;
}
}
}
int ans = 0;
REP(i, L) { ans = (ans + dp[N - 1][i]) % MOD; }
cout << ans << endl;
return 0;
}
| insert | 16 | 16 | 16 | 18 | TLE | |
p01770 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <queue>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef pair<int, int> pii;
static const int INF = 1000000000;
static int g_dist[256][102][100];
int main() {
ios_base::sync_with_stdio(false);
int n, m, e, s, t, r;
cin >> n >> m >> e >> s >> t >> r;
vector<int> a(m), b(m);
for (int i = 0; i < m; ++i) {
cin >> a[i] >> b[i];
}
vector<int> x(m), y(m), z(m);
for (int i = 0; i < e; ++i) {
cin >> x[i] >> y[i] >> z[i];
}
vector<int> has_event(n, -1);
for (int i = 0; i < e; ++i) {
has_event[z[i]] = i;
}
for (int i = 0; i < (1 << e); ++i) {
for (int j = 0; j <= r; ++j) {
for (int k = 0; k < n; ++k) {
g_dist[i][j][k] = INF;
}
}
}
const int init = (has_event[s] >= 0 ? (1 << has_event[s]) : 0);
g_dist[init][0][s] = 0;
int answer = INF;
for (int i = 0; i < (1 << e); ++i) {
vector<vector<int>> conn(n);
for (int j = 0; j < m; ++j) {
conn[a[j]].push_back(b[j]);
conn[b[j]].push_back(a[j]);
}
for (int j = 0; j < e; ++j) {
if (!(i & (1 << j))) {
continue;
}
conn[x[j]].push_back(y[j]);
conn[y[j]].push_back(x[j]);
}
for (int j = 0; j <= r; ++j) {
for (int u = 0; u < n; ++u) {
if (g_dist[i][j][u] >= INF) {
continue;
}
g_dist[i][0][s] = min(g_dist[i][0][s], g_dist[i][j][u] + 1);
}
}
for (int j = 0; j <= r; ++j) {
for (int u = 0; u < n; ++u) {
if (g_dist[i][j][u] >= INF) {
continue;
}
if (has_event[u] >= 0) {
const int mask = i | (1 << has_event[u]);
g_dist[mask][j][u] = min(g_dist[mask][j][u], g_dist[i][j][u]);
}
for (int t = 0; t < conn[u].size(); ++t) {
const int v = conn[u][t];
g_dist[i][j + 1][v] = min(g_dist[i][j + 1][v], g_dist[i][j][u] + 1);
}
}
}
for (int j = 0; j <= r; ++j) {
answer = min(answer, g_dist[i][j][t]);
}
}
if (answer >= INF) {
answer = -1;
}
cout << answer << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <queue>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef pair<int, int> pii;
static const int INF = 1000000000;
static int g_dist[256][102][100];
int main() {
ios_base::sync_with_stdio(false);
int n, m, e, s, t, r;
cin >> n >> m >> e >> s >> t >> r;
vector<int> a(m), b(m);
for (int i = 0; i < m; ++i) {
cin >> a[i] >> b[i];
}
vector<int> x(e), y(e), z(e);
for (int i = 0; i < e; ++i) {
cin >> x[i] >> y[i] >> z[i];
}
vector<int> has_event(n, -1);
for (int i = 0; i < e; ++i) {
has_event[z[i]] = i;
}
for (int i = 0; i < (1 << e); ++i) {
for (int j = 0; j <= r; ++j) {
for (int k = 0; k < n; ++k) {
g_dist[i][j][k] = INF;
}
}
}
const int init = (has_event[s] >= 0 ? (1 << has_event[s]) : 0);
g_dist[init][0][s] = 0;
int answer = INF;
for (int i = 0; i < (1 << e); ++i) {
vector<vector<int>> conn(n);
for (int j = 0; j < m; ++j) {
conn[a[j]].push_back(b[j]);
conn[b[j]].push_back(a[j]);
}
for (int j = 0; j < e; ++j) {
if (!(i & (1 << j))) {
continue;
}
conn[x[j]].push_back(y[j]);
conn[y[j]].push_back(x[j]);
}
for (int j = 0; j <= r; ++j) {
for (int u = 0; u < n; ++u) {
if (g_dist[i][j][u] >= INF) {
continue;
}
g_dist[i][0][s] = min(g_dist[i][0][s], g_dist[i][j][u] + 1);
}
}
for (int j = 0; j <= r; ++j) {
for (int u = 0; u < n; ++u) {
if (g_dist[i][j][u] >= INF) {
continue;
}
if (has_event[u] >= 0) {
const int mask = i | (1 << has_event[u]);
g_dist[mask][j][u] = min(g_dist[mask][j][u], g_dist[i][j][u]);
}
for (int t = 0; t < conn[u].size(); ++t) {
const int v = conn[u][t];
g_dist[i][j + 1][v] = min(g_dist[i][j + 1][v], g_dist[i][j][u] + 1);
}
}
}
for (int j = 0; j <= r; ++j) {
answer = min(answer, g_dist[i][j][t]);
}
}
if (answer >= INF) {
answer = -1;
}
cout << answer << endl;
return 0;
} | replace | 20 | 21 | 20 | 21 | 0 | |
p01770 | C++ | Runtime Error | #include <bits/stdc++.h>
#define REP(i, s, n) for (int i = s; i < n; i++)
#define rep(i, n) REP(i, 0, n)
using namespace std;
struct Edge {
int src, dst, bitmask;
};
struct Data {
int cur, weight, bitmask, step;
bool operator<(const Data &data) const { return weight > data.weight; }
};
const int MAX_V = 101;
const int MAX_R = 101;
const int IINF = INT_MAX;
int V, E, M, S, T, R, bits[MAX_V];
vector<Edge> G[MAX_V];
int mini[MAX_V][MAX_R][1 << 4];
void compute() {
// rep(i,V) rep(k,R+1) rep(j,(1<<4)) mini[i][k][j] = IINF;
rep(i, MAX_V) rep(k, MAX_R) rep(j, (1 << 4)) mini[i][k][j] = IINF;
mini[S][0][bits[S]] = 0;
priority_queue<Data> Q;
Q.push((Data){S, 0, bits[S], 0});
while (!Q.empty()) {
Data data = Q.top();
Q.pop();
if (data.cur == T) {
cout << data.weight << endl;
return;
}
rep(i, (int)G[data.cur].size()) {
Edge &v = G[data.cur][i];
if (v.bitmask != -1) {
if ((v.bitmask & data.bitmask) == 0)
continue;
}
int bitmask = data.bitmask | bits[v.dst];
if (data.step + 1 <= R &&
mini[v.dst][data.step + 1][bitmask] > data.weight + 1) {
mini[v.dst][data.step + 1][bitmask] = data.weight + 1;
Q.push((Data){v.dst, data.weight + 1, bitmask, data.step + 1});
}
}
if (mini[S][0][data.bitmask] > data.weight + 1) {
mini[S][0][data.bitmask] = data.weight + 1;
Q.push((Data){S, data.weight + 1, data.bitmask, 0});
}
}
assert(false);
}
int main() {
cin >> V >> E >> M >> S >> T >> R;
rep(i, E) {
int s, t;
cin >> s >> t;
G[s].push_back((Edge){s, t, -1});
G[t].push_back((Edge){t, s, -1});
}
rep(i, M) {
int s, t, c;
cin >> s >> t >> c;
bits[c] |= (1 << i);
G[s].push_back((Edge){s, t, (1 << i)});
G[t].push_back((Edge){t, s, (1 << i)});
}
compute();
return 0;
} | #include <bits/stdc++.h>
#define REP(i, s, n) for (int i = s; i < n; i++)
#define rep(i, n) REP(i, 0, n)
using namespace std;
struct Edge {
int src, dst, bitmask;
};
struct Data {
int cur, weight, bitmask, step;
bool operator<(const Data &data) const { return weight > data.weight; }
};
const int MAX_V = 101;
const int MAX_R = 101;
const int IINF = INT_MAX;
int V, E, M, S, T, R, bits[MAX_V];
vector<Edge> G[MAX_V];
int mini[MAX_V][MAX_R][1 << 4];
void compute() {
// rep(i,V) rep(k,R+1) rep(j,(1<<4)) mini[i][k][j] = IINF;
rep(i, MAX_V) rep(k, MAX_R) rep(j, (1 << 4)) mini[i][k][j] = IINF;
mini[S][0][bits[S]] = 0;
priority_queue<Data> Q;
Q.push((Data){S, 0, bits[S], 0});
while (!Q.empty()) {
Data data = Q.top();
Q.pop();
if (data.cur == T) {
cout << data.weight << endl;
return;
}
rep(i, (int)G[data.cur].size()) {
Edge &v = G[data.cur][i];
if (v.bitmask != -1) {
if ((v.bitmask & data.bitmask) == 0)
continue;
}
int bitmask = data.bitmask | bits[v.dst];
if (data.step + 1 <= R &&
mini[v.dst][data.step + 1][bitmask] > data.weight + 1) {
mini[v.dst][data.step + 1][bitmask] = data.weight + 1;
Q.push((Data){v.dst, data.weight + 1, bitmask, data.step + 1});
}
}
if (mini[S][0][data.bitmask] > data.weight + 1) {
mini[S][0][data.bitmask] = data.weight + 1;
Q.push((Data){S, data.weight + 1, data.bitmask, 0});
}
}
cout << -1 << endl;
}
int main() {
cin >> V >> E >> M >> S >> T >> R;
rep(i, E) {
int s, t;
cin >> s >> t;
G[s].push_back((Edge){s, t, -1});
G[t].push_back((Edge){t, s, -1});
}
rep(i, M) {
int s, t, c;
cin >> s >> t >> c;
bits[c] |= (1 << i);
G[s].push_back((Edge){s, t, (1 << i)});
G[t].push_back((Edge){t, s, (1 << i)});
}
compute();
return 0;
} | replace | 53 | 54 | 53 | 54 | 0 | |
p01770 | C++ | Time Limit Exceeded | // Template {{{
#include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
using namespace std;
typedef long long LL;
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
os << "{";
for (int i = 0; i < v.size(); i++)
os << v[i] << (i + 1 < v.size() ? ", " : "");
os << "}";
return os;
}
class range {
struct Iterator {
int val, inc;
int operator*() { return val; }
bool operator!=(Iterator &rhs) { return val < rhs.val; }
void operator++() { val += inc; }
};
Iterator i, n;
public:
range(int e) : i({0, 1}), n({e, 1}) {}
range(int b, int e) : i({b, 1}), n({e, 1}) {}
range(int b, int e, int inc) : i({b, inc}), n({e, inc}) {}
Iterator &begin() { return i; }
Iterator &end() { return n; }
};
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
inline bool valid(int x, int w) { return 0 <= x && x < w; }
void iostream_init() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.setf(ios::fixed);
cout.precision(12);
}
//}}}
struct Edge {
int dst, type;
};
typedef vector<Edge> Node;
typedef vector<Node> Graph;
typedef tuple<int, int, int, int> TP;
const int INF = 1000000000;
int main() {
iostream_init();
int N, M, E, S, T, R;
while (cin >> N >> M >> E >> S >> T >> R) {
R++; // < R
Graph G(N);
REP(i, M) {
int a, b;
cin >> a >> b;
G[a].push_back({b, -1});
G[b].push_back({a, -1});
}
vector<int> eve[101];
REP(i, E) {
int a, b, c;
cin >> a >> b >> c;
eve[c].push_back(i);
G[a].push_back({b, i});
G[b].push_back({a, i});
}
static int dist[102][102][1 << 8] = {};
REP(i, N) REP(j, R) REP(s, 1 << E) dist[i][j][s] = INF;
priority_queue<TP> que;
auto insert = [&](int a, int b, int c, int d) {
for (int e : eve[b])
d |= 1 << e;
if (a < dist[b][c][d]) {
dist[b][c][d] = a;
que.push(make_tuple(a, b, c, d));
}
};
insert(0, S, 0, 0);
while (!que.empty()) {
int cost, cur, time, state;
tie(cost, cur, time, state) = que.top();
que.pop();
if (dist[cur][time][state] < cost)
continue;
// back
insert(cost + 1, S, 0, state);
if (time + 1 < R) {
for (Edge ed : G[cur]) {
int next = ed.dst;
int type = ed.type;
if (type != -1 && !(state >> type & 1))
continue;
insert(cost + 1, next, time + 1, state);
}
}
}
int ans = INF;
REP(i, R) REP(s, 1 << E) ans = min(ans, dist[T][i][s]);
if (ans == INF)
ans = -1;
cout << ans << endl;
}
return 0;
}
/* vim:set foldmethod=marker: */ | // Template {{{
#include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
using namespace std;
typedef long long LL;
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
os << "{";
for (int i = 0; i < v.size(); i++)
os << v[i] << (i + 1 < v.size() ? ", " : "");
os << "}";
return os;
}
class range {
struct Iterator {
int val, inc;
int operator*() { return val; }
bool operator!=(Iterator &rhs) { return val < rhs.val; }
void operator++() { val += inc; }
};
Iterator i, n;
public:
range(int e) : i({0, 1}), n({e, 1}) {}
range(int b, int e) : i({b, 1}), n({e, 1}) {}
range(int b, int e, int inc) : i({b, inc}), n({e, inc}) {}
Iterator &begin() { return i; }
Iterator &end() { return n; }
};
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
inline bool valid(int x, int w) { return 0 <= x && x < w; }
void iostream_init() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.setf(ios::fixed);
cout.precision(12);
}
//}}}
struct Edge {
int dst, type;
};
typedef vector<Edge> Node;
typedef vector<Node> Graph;
typedef tuple<int, int, int, int> TP;
const int INF = 1000000000;
int main() {
iostream_init();
int N, M, E, S, T, R;
while (cin >> N >> M >> E >> S >> T >> R) {
R++; // < R
Graph G(N);
REP(i, M) {
int a, b;
cin >> a >> b;
G[a].push_back({b, -1});
G[b].push_back({a, -1});
}
vector<int> eve[101];
REP(i, E) {
int a, b, c;
cin >> a >> b >> c;
eve[c].push_back(i);
G[a].push_back({b, i});
G[b].push_back({a, i});
}
static int dist[102][102][1 << 8] = {};
REP(i, N) REP(j, R) REP(s, 1 << E) dist[i][j][s] = INF;
priority_queue<TP, vector<TP>, greater<TP>> que;
auto insert = [&](int a, int b, int c, int d) {
for (int e : eve[b])
d |= 1 << e;
if (a < dist[b][c][d]) {
dist[b][c][d] = a;
que.push(make_tuple(a, b, c, d));
}
};
insert(0, S, 0, 0);
while (!que.empty()) {
int cost, cur, time, state;
tie(cost, cur, time, state) = que.top();
que.pop();
if (dist[cur][time][state] < cost)
continue;
// back
insert(cost + 1, S, 0, state);
if (time + 1 < R) {
for (Edge ed : G[cur]) {
int next = ed.dst;
int type = ed.type;
if (type != -1 && !(state >> type & 1))
continue;
insert(cost + 1, next, time + 1, state);
}
}
}
int ans = INF;
REP(i, R) REP(s, 1 << E) ans = min(ans, dist[T][i][s]);
if (ans == INF)
ans = -1;
cout << ans << endl;
}
return 0;
}
/* vim:set foldmethod=marker: */ | replace | 79 | 80 | 79 | 80 | TLE | |
p01771 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define rep(i, x, y) for (int i = (x); i < (y); ++i)
#define debug(x) #x << "=" << (x)
#ifdef DEBUG
#define _GLIBCXX_DEBUG
#define print(x) std::cerr << debug(x) << " (L:" << __LINE__ << ")" << std::endl
#else
#define print(x)
#endif
const int inf = 1e9;
const int64_t inf64 = 1e18;
const double eps = 1e-9;
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "[";
for (const auto &v : vec) {
os << v << ",";
}
os << "]";
return os;
}
class lca_solver {
public:
vector<vector<int>> children;
int root;
// if root,parent is -1.
vector<int> parent;
vector<int64_t> depth;
vector<vector<int>> parent_pow2;
lca_solver(vector<vector<int>> &children_, int root_)
: children(children_), root(root_) {
calc_parent_and_depth();
calc_parent_pow2();
};
int lca(int u, int v) {
// make sure depth(u) > depth(v).
if (depth[u] < depth[v])
swap(u, v);
for (size_t k = 0; k < parent_pow2.size(); k++) {
if (((depth[u] - depth[v]) >> k) & 1) {
u = parent_pow2[k][u];
}
}
if (u == v)
return u;
for (int k = (int)parent_pow2.size() - 1; k >= 0; k--) {
if (parent_pow2[k][u] != parent_pow2[k][v]) {
u = parent_pow2[k][u];
v = parent_pow2[k][v];
}
}
return parent_pow2[0][u];
}
int dist(int u, int v) { return depth[u] + depth[v] - depth[lca(u, v)] * 2; }
private:
void calc_parent_and_depth() {
parent = vector<int>(children.size(), -1);
depth = vector<int64_t>(children.size(), -1);
sub_calc_parent_and_depth();
}
void sub_calc_parent_and_depth() {
// stack<tuple<int,int,int>> stk;
// stk.push(make_tuple(root,-1,0));
tuple<int, int, int> stk_pool[150000];
int idx = 0;
stk_pool[idx++] = make_tuple(root, -1, 0);
while (idx > 0) {
int cur, par, dep;
tie(cur, par, dep) = stk_pool[--idx];
parent[cur] = par;
depth[cur] = dep;
for (int child : children[cur]) {
if (child != par) {
// stk.push(make_tuple(child,cur,dep+1));
stk_pool[idx++] = make_tuple(child, cur, dep + 1);
}
}
}
}
void calc_parent_pow2() {
// parent_pow2[k][i] = 2^k parent of node i.
parent_pow2 = vector<vector<int>>(ceil(log(children.size()) / log(2) + 1),
vector<int>(children.size(), -1));
parent_pow2[0] = parent;
for (size_t k = 0; k + 1 < parent_pow2.size(); k++) {
for (size_t v = 0; v < children.size(); v++) {
if (parent_pow2[k][v] >= 0) {
parent_pow2[k + 1][v] = parent_pow2[k][parent_pow2[k][v]];
}
}
}
}
};
void solve() {
int n, q;
cin >> n >> q;
vector<vector<int>> graph(n);
rep(i, 0, n - 1) {
int a, b;
cin >> a >> b;
graph[a].push_back(b);
}
lca_solver ls(graph, 0);
auto contraction = [&](vector<int> &cont_parent, bool used[]) {
// stack<pair<int,int>> stk;
// stk.push(make_pair(0,0));
pair<int, int> stk_pool[150000];
int idx = 0;
stk_pool[idx++] = make_pair(0, 0);
while (idx > 0) {
auto p = stk_pool[--idx];
int u = p.first, v = p.second;
for (int w : graph[v]) {
if (used[w]) {
cont_parent[w] = u;
// stk.push(make_pair(w,w));
stk_pool[idx++] = make_pair(w, w);
} else {
// stk.push(make_pair(u,w));
stk_pool[idx++] = make_pair(u, w);
}
}
}
};
int b = 3000, r = q;
vector<int64_t> d(n);
bool used[150000];
rep(i, 0, (q + b - 1) / b) {
int size = min(b, r);
vector<int> fs(size), us(size), vs(size), lcas(size);
set<int> appear;
used[0] = true;
appear.insert(0);
rep(j, 0, size) {
cin >> fs[j] >> us[j] >> vs[j];
used[us[j]] = true;
appear.insert(us[j]);
if (fs[j] == 0) {
lcas[j] = ls.lca(us[j], vs[j]);
used[vs[j]] = used[lcas[j]] = true;
appear.insert(vs[j]);
appear.insert(lcas[j]);
}
}
vector<int> cont_parent(n, -1);
contraction(cont_parent, used);
vector<int64_t> add_lazy(n);
auto calc_dist = [&](int u) {
int64_t res = d[u];
int v = cont_parent[u];
while (v != -1) {
res += add_lazy[v] * (ls.depth[u] - ls.depth[v]);
v = cont_parent[v];
}
return res;
};
rep(j, 0, size) {
if (fs[j] == 1)
add_lazy[us[j]] += vs[j];
else
cout << calc_dist(us[j]) + calc_dist(vs[j]) - calc_dist(lcas[j]) * 2
<< endl;
}
auto propagate = [&]() {
static tuple<int, int64_t, int64_t> stk_pool[150000];
int idx = 0;
stk_pool[idx++] = make_tuple(0, 0, 0);
while (idx > 0) {
int u;
int64_t s, t;
tie(u, s, t) = stk_pool[--idx];
d[u] += s;
for (int v : graph[u]) {
// stk.push(make_pair(v,s+add_lazy[u]));
stk_pool[idx++] = make_tuple(v, s + t + add_lazy[u], t + add_lazy[u]);
}
}
};
propagate();
for (int u : appear)
used[u] = false;
r -= b;
}
}
int main() {
std::cin.tie(0);
std::ios::sync_with_stdio(false);
cout.setf(ios::fixed);
cout.precision(10);
solve();
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, x, y) for (int i = (x); i < (y); ++i)
#define debug(x) #x << "=" << (x)
#ifdef DEBUG
#define _GLIBCXX_DEBUG
#define print(x) std::cerr << debug(x) << " (L:" << __LINE__ << ")" << std::endl
#else
#define print(x)
#endif
const int inf = 1e9;
const int64_t inf64 = 1e18;
const double eps = 1e-9;
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "[";
for (const auto &v : vec) {
os << v << ",";
}
os << "]";
return os;
}
class lca_solver {
public:
vector<vector<int>> children;
int root;
// if root,parent is -1.
vector<int> parent;
vector<int64_t> depth;
vector<vector<int>> parent_pow2;
lca_solver(vector<vector<int>> &children_, int root_)
: children(children_), root(root_) {
calc_parent_and_depth();
calc_parent_pow2();
};
int lca(int u, int v) {
// make sure depth(u) > depth(v).
if (depth[u] < depth[v])
swap(u, v);
for (size_t k = 0; k < parent_pow2.size(); k++) {
if (((depth[u] - depth[v]) >> k) & 1) {
u = parent_pow2[k][u];
}
}
if (u == v)
return u;
for (int k = (int)parent_pow2.size() - 1; k >= 0; k--) {
if (parent_pow2[k][u] != parent_pow2[k][v]) {
u = parent_pow2[k][u];
v = parent_pow2[k][v];
}
}
return parent_pow2[0][u];
}
int dist(int u, int v) { return depth[u] + depth[v] - depth[lca(u, v)] * 2; }
private:
void calc_parent_and_depth() {
parent = vector<int>(children.size(), -1);
depth = vector<int64_t>(children.size(), -1);
sub_calc_parent_and_depth();
}
void sub_calc_parent_and_depth() {
// stack<tuple<int,int,int>> stk;
// stk.push(make_tuple(root,-1,0));
tuple<int, int, int> stk_pool[150000];
int idx = 0;
stk_pool[idx++] = make_tuple(root, -1, 0);
while (idx > 0) {
int cur, par, dep;
tie(cur, par, dep) = stk_pool[--idx];
parent[cur] = par;
depth[cur] = dep;
for (int child : children[cur]) {
if (child != par) {
// stk.push(make_tuple(child,cur,dep+1));
stk_pool[idx++] = make_tuple(child, cur, dep + 1);
}
}
}
}
void calc_parent_pow2() {
// parent_pow2[k][i] = 2^k parent of node i.
parent_pow2 = vector<vector<int>>(ceil(log(children.size()) / log(2) + 1),
vector<int>(children.size(), -1));
parent_pow2[0] = parent;
for (size_t k = 0; k + 1 < parent_pow2.size(); k++) {
for (size_t v = 0; v < children.size(); v++) {
if (parent_pow2[k][v] >= 0) {
parent_pow2[k + 1][v] = parent_pow2[k][parent_pow2[k][v]];
}
}
}
}
};
void solve() {
int n, q;
cin >> n >> q;
vector<vector<int>> graph(n);
rep(i, 0, n - 1) {
int a, b;
cin >> a >> b;
graph[a].push_back(b);
}
lca_solver ls(graph, 0);
auto contraction = [&](vector<int> &cont_parent, bool used[]) {
// stack<pair<int,int>> stk;
// stk.push(make_pair(0,0));
pair<int, int> stk_pool[150000];
int idx = 0;
stk_pool[idx++] = make_pair(0, 0);
while (idx > 0) {
auto p = stk_pool[--idx];
int u = p.first, v = p.second;
for (int w : graph[v]) {
if (used[w]) {
cont_parent[w] = u;
// stk.push(make_pair(w,w));
stk_pool[idx++] = make_pair(w, w);
} else {
// stk.push(make_pair(u,w));
stk_pool[idx++] = make_pair(u, w);
}
}
}
};
int b = 2500, r = q;
vector<int64_t> d(n);
bool used[150000];
rep(i, 0, (q + b - 1) / b) {
int size = min(b, r);
vector<int> fs(size), us(size), vs(size), lcas(size);
set<int> appear;
used[0] = true;
appear.insert(0);
rep(j, 0, size) {
cin >> fs[j] >> us[j] >> vs[j];
used[us[j]] = true;
appear.insert(us[j]);
if (fs[j] == 0) {
lcas[j] = ls.lca(us[j], vs[j]);
used[vs[j]] = used[lcas[j]] = true;
appear.insert(vs[j]);
appear.insert(lcas[j]);
}
}
vector<int> cont_parent(n, -1);
contraction(cont_parent, used);
vector<int64_t> add_lazy(n);
auto calc_dist = [&](int u) {
int64_t res = d[u];
int v = cont_parent[u];
while (v != -1) {
res += add_lazy[v] * (ls.depth[u] - ls.depth[v]);
v = cont_parent[v];
}
return res;
};
rep(j, 0, size) {
if (fs[j] == 1)
add_lazy[us[j]] += vs[j];
else
cout << calc_dist(us[j]) + calc_dist(vs[j]) - calc_dist(lcas[j]) * 2
<< endl;
}
auto propagate = [&]() {
static tuple<int, int64_t, int64_t> stk_pool[150000];
int idx = 0;
stk_pool[idx++] = make_tuple(0, 0, 0);
while (idx > 0) {
int u;
int64_t s, t;
tie(u, s, t) = stk_pool[--idx];
d[u] += s;
for (int v : graph[u]) {
// stk.push(make_pair(v,s+add_lazy[u]));
stk_pool[idx++] = make_tuple(v, s + t + add_lazy[u], t + add_lazy[u]);
}
}
};
propagate();
for (int u : appear)
used[u] = false;
r -= b;
}
}
int main() {
std::cin.tie(0);
std::ios::sync_with_stdio(false);
cout.setf(ios::fixed);
cout.precision(10);
solve();
return 0;
} | replace | 135 | 136 | 135 | 136 | TLE | |
p01771 | C++ | Time Limit Exceeded | // http://rippro.org/event/ritscamp2015/F.pdf
// http://tubo28.me/blog/post/2015/10/28/aoj2667/
#include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
#define DEBUG(x) cerr << #x << " = " << x << endl
#define int long long
struct LCA {
int N, logN;
vector<vector<int>> G;
vector<int> depth;
vector<vector<int>> parent;
LCA(int size) : N(size), G(size), depth(size) {
logN = 0;
for (int x = 1; x < N; x *= 2)
logN++;
parent.assign(max<int>(logN, 1), vector<int>(N));
}
void add_edge(int u, int v) {
G[u].push_back(v);
G[v].push_back(u);
}
void build(int root) {
stack<pair<int, int>> Q;
Q.emplace(root, -1);
while (!Q.empty()) {
pair<int, int> p = Q.top();
Q.pop();
int cur = p.first, prev = p.second;
parent[0][cur] = prev;
if (prev == -1)
depth[cur] = 0;
else
depth[cur] = depth[prev] + 1;
for (int next : G[cur]) {
if (next != prev)
Q.emplace(next, cur);
}
}
for (int k = 1; k < logN; k++) {
for (int v = 0; v < N; v++) {
if (parent[k - 1][v] == -1)
parent[k][v] = -1;
else
parent[k][v] = parent[k - 1][parent[k - 1][v]];
}
}
}
int lca(int u, int v) {
if (depth[u] > depth[v])
swap(u, v);
for (int k = 0; k < logN; k++) {
if (((depth[v] - depth[u]) >> k) & 1) {
v = parent[k][v];
}
}
if (u == v)
return u;
for (int k = logN - 1; k >= 0; k--) {
if (parent[k][u] != parent[k][v]) {
u = parent[k][u];
v = parent[k][v];
}
}
return parent[0][u];
}
};
struct Compact {
const vector<vector<int>> &G;
const vector<bool> &V;
vector<int> parent;
Compact(const vector<vector<int>> &g, const vector<bool> &v) : G(g), V(v) {}
void build(int root) {
parent.assign(G.size(), -1);
stack<tuple<int, int, int>> Q;
Q.emplace(root, -1, -1);
while (!Q.empty()) {
int cur, prev, p;
tie(cur, prev, p) = Q.top();
Q.pop();
if (V[cur]) {
parent[cur] = p;
p = cur;
}
for (int next : G[cur]) {
if (next != prev)
Q.emplace(next, cur, p);
}
}
}
int getWeight(const int v, const vector<int> &addNow,
const vector<int> &addLazy, const vector<int> &depth) {
int w = addNow[v];
for (int cur = v; cur != -1; cur = parent[cur]) {
w += addLazy[cur] * (depth[v] - depth[cur]);
}
return w;
}
void propagate(const int root, vector<int> &addNow,
const vector<int> &addLazy) {
stack<tuple<int, int, int, int>> Q;
Q.emplace(root, -1, 0, 0);
while (!Q.empty()) {
int cur, prev, add, addDiff;
tie(cur, prev, add, addDiff) = Q.top();
Q.pop();
addNow[cur] += add;
for (int next : G[cur]) {
if (next != prev)
Q.emplace(next, cur, add + addDiff + addLazy[cur],
addDiff + addLazy[cur]);
}
}
}
};
const int MAX_N = 150000;
const int SQRT_Q = 400;
int T[SQRT_Q], A[SQRT_Q], B[SQRT_Q];
signed main() {
ios::sync_with_stdio(false);
int N, Q;
cin >> N >> Q;
vector<vector<int>> G(N);
LCA lca(N);
REP(i, N - 1) {
int a, b;
cin >> a >> b;
G[a].push_back(b);
G[b].push_back(a);
lca.add_edge(a, b);
}
lca.build(0);
vector<int> addNow(N, 0);
vector<int> addLazy(N);
vector<bool> V(N);
for (int qb = 0; qb < Q; qb += SQRT_Q) {
V.assign(N, false);
for (int i = 0; qb + i < Q && i < SQRT_Q; ++i) {
cin >> T[i] >> A[i] >> B[i];
if (T[i] == 0) {
V[A[i]] = true;
V[B[i]] = true;
V[lca.lca(A[i], B[i])] = true;
} else {
V[A[i]] = true;
}
}
Compact c(G, V);
c.build(0);
fill(addLazy.begin(), addLazy.end(), 0);
for (int i = 0; qb + i < Q && i < SQRT_Q; ++i) {
if (T[i] == 0) {
int d = 0;
d += c.getWeight(A[i], addNow, addLazy, lca.depth);
d += c.getWeight(B[i], addNow, addLazy, lca.depth);
d -= 2 * c.getWeight(lca.lca(A[i], B[i]), addNow, addLazy, lca.depth);
cout << d << '\n';
} else {
addLazy[A[i]] += B[i];
}
}
c.propagate(0, addNow, addLazy);
}
} | // http://rippro.org/event/ritscamp2015/F.pdf
// http://tubo28.me/blog/post/2015/10/28/aoj2667/
#include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
#define DEBUG(x) cerr << #x << " = " << x << endl
#define int long long
struct LCA {
int N, logN;
vector<vector<int>> G;
vector<int> depth;
vector<vector<int>> parent;
LCA(int size) : N(size), G(size), depth(size) {
logN = 0;
for (int x = 1; x < N; x *= 2)
logN++;
parent.assign(max<int>(logN, 1), vector<int>(N));
}
void add_edge(int u, int v) {
G[u].push_back(v);
G[v].push_back(u);
}
void build(int root) {
stack<pair<int, int>> Q;
Q.emplace(root, -1);
while (!Q.empty()) {
pair<int, int> p = Q.top();
Q.pop();
int cur = p.first, prev = p.second;
parent[0][cur] = prev;
if (prev == -1)
depth[cur] = 0;
else
depth[cur] = depth[prev] + 1;
for (int next : G[cur]) {
if (next != prev)
Q.emplace(next, cur);
}
}
for (int k = 1; k < logN; k++) {
for (int v = 0; v < N; v++) {
if (parent[k - 1][v] == -1)
parent[k][v] = -1;
else
parent[k][v] = parent[k - 1][parent[k - 1][v]];
}
}
}
int lca(int u, int v) {
if (depth[u] > depth[v])
swap(u, v);
for (int k = 0; k < logN; k++) {
if (((depth[v] - depth[u]) >> k) & 1) {
v = parent[k][v];
}
}
if (u == v)
return u;
for (int k = logN - 1; k >= 0; k--) {
if (parent[k][u] != parent[k][v]) {
u = parent[k][u];
v = parent[k][v];
}
}
return parent[0][u];
}
};
struct Compact {
const vector<vector<int>> &G;
const vector<bool> &V;
vector<int> parent;
Compact(const vector<vector<int>> &g, const vector<bool> &v) : G(g), V(v) {}
void build(int root) {
parent.assign(G.size(), -1);
stack<tuple<int, int, int>> Q;
Q.emplace(root, -1, -1);
while (!Q.empty()) {
int cur, prev, p;
tie(cur, prev, p) = Q.top();
Q.pop();
if (V[cur]) {
parent[cur] = p;
p = cur;
}
for (int next : G[cur]) {
if (next != prev)
Q.emplace(next, cur, p);
}
}
}
int getWeight(const int v, const vector<int> &addNow,
const vector<int> &addLazy, const vector<int> &depth) {
int w = addNow[v];
for (int cur = v; cur != -1; cur = parent[cur]) {
w += addLazy[cur] * (depth[v] - depth[cur]);
}
return w;
}
void propagate(const int root, vector<int> &addNow,
const vector<int> &addLazy) {
stack<tuple<int, int, int, int>> Q;
Q.emplace(root, -1, 0, 0);
while (!Q.empty()) {
int cur, prev, add, addDiff;
tie(cur, prev, add, addDiff) = Q.top();
Q.pop();
addNow[cur] += add;
for (int next : G[cur]) {
if (next != prev)
Q.emplace(next, cur, add + addDiff + addLazy[cur],
addDiff + addLazy[cur]);
}
}
}
};
const int MAX_N = 150000;
const int SQRT_Q = 800;
int T[SQRT_Q], A[SQRT_Q], B[SQRT_Q];
signed main() {
ios::sync_with_stdio(false);
int N, Q;
cin >> N >> Q;
vector<vector<int>> G(N);
LCA lca(N);
REP(i, N - 1) {
int a, b;
cin >> a >> b;
G[a].push_back(b);
G[b].push_back(a);
lca.add_edge(a, b);
}
lca.build(0);
vector<int> addNow(N, 0);
vector<int> addLazy(N);
vector<bool> V(N);
for (int qb = 0; qb < Q; qb += SQRT_Q) {
V.assign(N, false);
for (int i = 0; qb + i < Q && i < SQRT_Q; ++i) {
cin >> T[i] >> A[i] >> B[i];
if (T[i] == 0) {
V[A[i]] = true;
V[B[i]] = true;
V[lca.lca(A[i], B[i])] = true;
} else {
V[A[i]] = true;
}
}
Compact c(G, V);
c.build(0);
fill(addLazy.begin(), addLazy.end(), 0);
for (int i = 0; qb + i < Q && i < SQRT_Q; ++i) {
if (T[i] == 0) {
int d = 0;
d += c.getWeight(A[i], addNow, addLazy, lca.depth);
d += c.getWeight(B[i], addNow, addLazy, lca.depth);
d -= 2 * c.getWeight(lca.lca(A[i], B[i]), addNow, addLazy, lca.depth);
cout << d << '\n';
} else {
addLazy[A[i]] += B[i];
}
}
c.propagate(0, addNow, addLazy);
}
} | replace | 116 | 117 | 116 | 117 | TLE | |
p01772 | C++ | Runtime Error | #include <iostream>
#include <string>
using namespace std;
int main() {
string row;
cin >> row;
int f = 0, cnt = 0;
// cout<<row.size();
for (int i = 0; row.size(); i++) {
if (row[i] == 'A')
f = 1;
if (f == 1 && row[i] == 'Z') {
cnt++;
f = 0;
}
}
if (cnt != 0) {
for (int i = 0; i < cnt; i++) {
cout << "AZ";
}
cout << endl;
} else
cout << -1 << endl;
return 0;
}
| #include <iostream>
#include <string>
using namespace std;
int main() {
string row;
cin >> row;
int f = 0, cnt = 0;
// cout<<row.size();
for (int i = 0; i < row.size(); i++) {
if (row[i] == 'A')
f = 1;
if (f == 1 && row[i] == 'Z') {
cnt++;
f = 0;
}
}
if (cnt != 0) {
for (int i = 0; i < cnt; i++) {
cout << "AZ";
}
cout << endl;
} else
cout << -1 << endl;
return 0;
}
| replace | 9 | 10 | 9 | 10 | -11 | |
p01773 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> Pi;
int main() {
int a, n, m;
scanf("%d", &a);
vector<Pi> datas;
for (int i = 0; i < a; i++) {
int H1, H2, M1, M2;
scanf("%d:%d-%d:%d", &H1, &M1, &H2, &M2);
datas.push_back(make_pair(H1 * 60 + M1, H2 * 60 + M2));
}
scanf("%d", &n);
vector<vector<Pi>> teacher(n);
for (int i = 0; i < n; i++) {
int k;
scanf("%d", &k);
while (k--) {
int H1, H2, M1, M2;
scanf("%d:%d-%d:%d", &H1, &M1, &H2, &M2);
teacher[i].push_back(make_pair(H1 * 60 + M1, H2 * 60 + M2));
}
}
scanf("%d", &m);
vector<vector<Pi>> student(m);
for (int i = 0; i < m; i++) {
int k;
scanf("%d", &k);
while (k--) {
int H1, H2, M1, M2;
scanf("%d:%d-%d:%d", &H1, &M1, &H2, &M2);
student[i].push_back(make_pair(H1 * 60 + M1, H2 * 60 + M2));
}
}
int ret = 0;
for (int i = 0; i < a; i++) {
int t = 0, s = 0;
for (int j = 0; j < n; j++) {
for (int k = 0; k < teacher[j].size(); k++) {
if (teacher[j][k].first <= datas[i].first &&
datas[i].second <= teacher[j][k].second) {
++t;
break;
}
}
}
for (int j = 0; j < n; j++) {
for (int k = 0; k < student[j].size(); k++) {
if (student[j][k].first <= datas[i].first &&
datas[i].second <= student[j][k].second) {
++s;
break;
}
}
}
ret += min(t, s);
}
printf("%d\n", ret);
} | #include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> Pi;
int main() {
int a, n, m;
scanf("%d", &a);
vector<Pi> datas;
for (int i = 0; i < a; i++) {
int H1, H2, M1, M2;
scanf("%d:%d-%d:%d", &H1, &M1, &H2, &M2);
datas.push_back(make_pair(H1 * 60 + M1, H2 * 60 + M2));
}
scanf("%d", &n);
vector<vector<Pi>> teacher(n);
for (int i = 0; i < n; i++) {
int k;
scanf("%d", &k);
while (k--) {
int H1, H2, M1, M2;
scanf("%d:%d-%d:%d", &H1, &M1, &H2, &M2);
teacher[i].push_back(make_pair(H1 * 60 + M1, H2 * 60 + M2));
}
}
scanf("%d", &m);
vector<vector<Pi>> student(m);
for (int i = 0; i < m; i++) {
int k;
scanf("%d", &k);
while (k--) {
int H1, H2, M1, M2;
scanf("%d:%d-%d:%d", &H1, &M1, &H2, &M2);
student[i].push_back(make_pair(H1 * 60 + M1, H2 * 60 + M2));
}
}
int ret = 0;
for (int i = 0; i < a; i++) {
int t = 0, s = 0;
for (int j = 0; j < n; j++) {
for (int k = 0; k < teacher[j].size(); k++) {
if (teacher[j][k].first <= datas[i].first &&
datas[i].second <= teacher[j][k].second) {
++t;
break;
}
}
}
for (int j = 0; j < m; j++) {
for (int k = 0; k < student[j].size(); k++) {
if (student[j][k].first <= datas[i].first &&
datas[i].second <= student[j][k].second) {
++s;
break;
}
}
}
ret += min(t, s);
}
printf("%d\n", ret);
} | replace | 48 | 49 | 48 | 49 | 0 | |
p01773 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
P s2p(string s) { return P(stoi(s.substr(0, 2)), stoi(s.substr(3, 2))); }
bool contain(string c, string p) {
P stc = s2p(c.substr(0, 5));
P enc = s2p(c.substr(6, 5));
P stp = s2p(p.substr(0, 5));
P enp = s2p(p.substr(6, 5));
// cout<<stc.first<<" "<<stc.second<<endl;
// cout<<enc.first<<" "<<enc.second<<endl;
// cout<<stp.first<<" "<<stp.second<<endl;
// cout<<enp.first<<" "<<enp.second<<endl;
return stp <= stc && enc <= enp;
}
int main() {
int k, n, m;
cin >> k;
string c[k];
for (int i = 0; i < k; i++)
cin >> c[i];
cin >> n;
vector<string> t[n];
for (int i = 0, j; i < n; i++) {
string tmp;
cin >> j;
for (int a = 0; a < j; a++) {
cin >> tmp;
t[i].push_back(tmp);
}
}
cin >> m;
vector<string> s[m];
for (int i = 0, j; i < m; i++) {
string tmp;
cin >> j;
for (int a = 0; a < j; a++) {
cin >> tmp;
s[i].push_back(tmp);
}
}
int ans = 0;
for (int i = 0; i < k; i++) {
int a = 0, b = 0;
for (int l = 0; l < n; l++) {
bool f = 0;
for (int j = 0; j < (int)t[l].size(); j++) {
f |= contain(c[i], t[l][j]);
}
if (f)
a++;
}
for (int l = 0; l < n; l++) {
bool f = 0;
for (int j = 0; j < (int)s[l].size(); j++) {
f |= contain(c[i], s[l][j]);
}
if (f)
b++;
}
// cout<<a<<" "<<b<<endl;
ans += min(a, b);
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
P s2p(string s) { return P(stoi(s.substr(0, 2)), stoi(s.substr(3, 2))); }
bool contain(string c, string p) {
P stc = s2p(c.substr(0, 5));
P enc = s2p(c.substr(6, 5));
P stp = s2p(p.substr(0, 5));
P enp = s2p(p.substr(6, 5));
// cout<<stc.first<<" "<<stc.second<<endl;
// cout<<enc.first<<" "<<enc.second<<endl;
// cout<<stp.first<<" "<<stp.second<<endl;
// cout<<enp.first<<" "<<enp.second<<endl;
return stp <= stc && enc <= enp;
}
int main() {
int k, n, m;
cin >> k;
string c[k];
for (int i = 0; i < k; i++)
cin >> c[i];
cin >> n;
vector<string> t[n];
for (int i = 0, j; i < n; i++) {
string tmp;
cin >> j;
for (int a = 0; a < j; a++) {
cin >> tmp;
t[i].push_back(tmp);
}
}
cin >> m;
vector<string> s[m];
for (int i = 0, j; i < m; i++) {
string tmp;
cin >> j;
for (int a = 0; a < j; a++) {
cin >> tmp;
s[i].push_back(tmp);
}
}
int ans = 0;
for (int i = 0; i < k; i++) {
int a = 0, b = 0;
for (int l = 0; l < n; l++) {
bool f = 0;
for (int j = 0; j < (int)t[l].size(); j++) {
f |= contain(c[i], t[l][j]);
}
if (f)
a++;
}
for (int l = 0; l < m; l++) {
bool f = 0;
for (int j = 0; j < (int)s[l].size(); j++) {
f |= contain(c[i], s[l][j]);
}
if (f)
b++;
}
// cout<<a<<" "<<b<<endl;
ans += min(a, b);
}
cout << ans << endl;
return 0;
} | replace | 53 | 54 | 53 | 54 | 0 | |
p01775 | C++ | Runtime Error | /* attention to overflow */
#include <algorithm>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#define dump(x) cerr << #x << " = " << x << endl
using namespace std;
const int INF = 1 << 25;
void io() {
cin.tie(0);
ios::sync_with_stdio(false);
}
/*printf("%.9Lf\n",cf);*/
const int MOD = 1000000007;
#define P pair<int, int>
const int V = 1010;
struct edge {
int to, cost;
};
vector<edge> G[V];
int d[V];
void dijkstra(int src) {
priority_queue<P, vector<P>, greater<P>> q;
for (int i = 0; i < V; i++) {
d[i] = INF;
}
d[src] = 0;
q.push(P(0, src));
while (!q.empty()) {
P s = q.top();
q.pop();
int v = s.second;
if (s.first > d[v])
continue;
for (int i = 0; i < G[v].size(); i++) {
edge e = G[v][i];
if (d[e.to] > d[v] + e.cost) {
d[e.to] = d[v] + e.cost;
q.push(P(d[e.to], e.to));
}
}
}
}
int dp[1 << 14][14];
int main() {
io();
int n, m, k, p;
cin >> n >> m >> k >> p;
p--;
for (int i = 0; i < m; i++) {
int x, y, w;
cin >> x >> y >> w;
x--;
y--;
G[x].push_back((edge){y, w});
G[y].push_back((edge){x, w});
}
int a[15];
int dist[10][10];
for (int i = 0; i < k; i++) {
int s, t;
cin >> s >> t;
s--, t--;
a[2 * i] = s;
a[2 * i + 1] = t;
}
for (int i = 0; i < 2 * k; i++) {
for (int j = i; j < 2 * k; j++) {
if (i == j) {
dist[i][j] = 0;
} else {
dijkstra(a[i]);
dist[i][j] = d[a[j]];
dist[j][i] = dist[i][j];
}
}
}
for (int i = 0; i < (1 << 14); i++) {
fill_n(dp[i], 14, INF);
}
dijkstra(p);
for (int i = 0; i < k; i++) {
dp[1 << 2 * i][2 * i] = d[a[2 * i]];
}
for (int i = 2; i <= 2 * k; i++) {
for (int j = 0; j < (1 << 2 * k); j++) {
for (int u = 0; u < 2 * k; u++) {
if ((j & (1 << u)) == 0)
continue;
for (int v = 0; v < k; v++) {
int s = 2 * v;
int t = s + 1;
if ((j & (1 << s)) == 0) {
dp[j | (1 << s)][s] =
min(dp[j | (1 << s)][s], dp[j][u] + dist[u][s]);
} else if ((j & (1 << t)) == 0) {
dp[j | (1 << t)][t] =
min(dp[j | (1 << t)][t], dp[j][u] + dist[u][t]);
}
}
}
}
}
int ret = INF;
for (int i = 0; i < 2 * k; i++) {
ret = min(ret, dp[(1 << (2 * k)) - 1][i]);
}
if (ret == INF) {
cout << "Cannot deliver" << endl;
} else {
cout << ret << endl;
}
return 0;
} | /* attention to overflow */
#include <algorithm>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#define dump(x) cerr << #x << " = " << x << endl
using namespace std;
const int INF = 1 << 25;
void io() {
cin.tie(0);
ios::sync_with_stdio(false);
}
/*printf("%.9Lf\n",cf);*/
const int MOD = 1000000007;
#define P pair<int, int>
const int V = 1010;
struct edge {
int to, cost;
};
vector<edge> G[V];
int d[V];
void dijkstra(int src) {
priority_queue<P, vector<P>, greater<P>> q;
for (int i = 0; i < V; i++) {
d[i] = INF;
}
d[src] = 0;
q.push(P(0, src));
while (!q.empty()) {
P s = q.top();
q.pop();
int v = s.second;
if (s.first > d[v])
continue;
for (int i = 0; i < G[v].size(); i++) {
edge e = G[v][i];
if (d[e.to] > d[v] + e.cost) {
d[e.to] = d[v] + e.cost;
q.push(P(d[e.to], e.to));
}
}
}
}
int dp[1 << 14][14];
int main() {
io();
int n, m, k, p;
cin >> n >> m >> k >> p;
p--;
for (int i = 0; i < m; i++) {
int x, y, w;
cin >> x >> y >> w;
x--;
y--;
G[x].push_back((edge){y, w});
G[y].push_back((edge){x, w});
}
int a[15];
int dist[20][20];
for (int i = 0; i < k; i++) {
int s, t;
cin >> s >> t;
s--, t--;
a[2 * i] = s;
a[2 * i + 1] = t;
}
for (int i = 0; i < 2 * k; i++) {
for (int j = i; j < 2 * k; j++) {
if (i == j) {
dist[i][j] = 0;
} else {
dijkstra(a[i]);
dist[i][j] = d[a[j]];
dist[j][i] = dist[i][j];
}
}
}
for (int i = 0; i < (1 << 14); i++) {
fill_n(dp[i], 14, INF);
}
dijkstra(p);
for (int i = 0; i < k; i++) {
dp[1 << 2 * i][2 * i] = d[a[2 * i]];
}
for (int i = 2; i <= 2 * k; i++) {
for (int j = 0; j < (1 << 2 * k); j++) {
for (int u = 0; u < 2 * k; u++) {
if ((j & (1 << u)) == 0)
continue;
for (int v = 0; v < k; v++) {
int s = 2 * v;
int t = s + 1;
if ((j & (1 << s)) == 0) {
dp[j | (1 << s)][s] =
min(dp[j | (1 << s)][s], dp[j][u] + dist[u][s]);
} else if ((j & (1 << t)) == 0) {
dp[j | (1 << t)][t] =
min(dp[j | (1 << t)][t], dp[j][u] + dist[u][t]);
}
}
}
}
}
int ret = INF;
for (int i = 0; i < 2 * k; i++) {
ret = min(ret, dp[(1 << (2 * k)) - 1][i]);
}
if (ret == INF) {
cout << "Cannot deliver" << endl;
} else {
cout << ret << endl;
}
return 0;
} | replace | 71 | 72 | 71 | 72 | 0 | |
p01777 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define MAX 114514
int n;
vector<int> dat[MAX * 2 - 1];
int query(int a, int b, int u, int d, int k = 0, int l = 0, int r = n) {
// cout<<a<<" "<<b<<" "<<k<<" "<<l<<" "<<r<<endl;
if (r <= a || b <= l)
return 0;
if (a <= l && r <= b) {
// cout<<a<<" "<<b<<" "<<k<<" "<<l<<" "<<r<<endl;
return upper_bound(dat[k].begin(), dat[k].end(), u) -
lower_bound(dat[k].begin(), dat[k].end(), d);
}
return query(a, b, u, d, k * 2 + 1, l, (l + r) / 2) +
query(a, b, u, d, k * 2 + 2, (l + r) / 2, r);
}
int x[MAX], l[MAX], r[MAX], e[MAX];
signed main() {
int d, q;
cin >> d;
vector<int> v;
for (int i = 0; i < d; i++) {
cin >> x[i];
v.push_back(x[i]);
}
cin >> q;
for (int i = 0; i < q; i++) {
cin >> l[i] >> r[i] >> e[i];
l[i]--;
v.push_back(min(x[l[i]], x[r[i] - 1]) - e[i]);
v.push_back(max(x[l[i]], x[r[i] - 1]) + e[i]);
}
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
map<int, int> m;
for (int i = 0; i < (int)v.size(); i++)
m[v[i]] = i;
n = 1;
while (n < d)
n *= 2;
// cout<<n<<endl;
for (int i = 0; i < d; i++) {
dat[n - 1 + i].push_back(m[x[i]]);
}
for (int i = n - 2; i >= 0; i--) {
for (int k = 1; k <= 2; k++) {
for (int j = 0; j < (int)dat[i * 2 + k].size(); j++)
dat[i].push_back(dat[i * 2 + k][j]);
}
sort(dat[i].begin(), dat[i].end());
}
/*//
for(int i=0;i<n*2-1;i++){
cout<<i<<"-"<<endl;
for(int j=0;j<(int)dat[i].size();j++){
cout<<dat[i][j]<<" ";
}
cout<<endl;
}
//*/
for (int i = 0; i < q; i++) {
// cout<<r[i]-l[i]<<endl;
int inner = query(l[i], r[i], m[max(x[l[i]], x[r[i] - 1]) + e[i]],
m[min(x[l[i]], x[r[i] - 1]) - e[i]]);
int outer = query(l[i], r[i], v.size(), 0);
// cout<<outer<<":"<<inner<<endl;
cout << outer - inner << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define MAX 414514
int n;
vector<int> dat[MAX * 2 - 1];
int query(int a, int b, int u, int d, int k = 0, int l = 0, int r = n) {
// cout<<a<<" "<<b<<" "<<k<<" "<<l<<" "<<r<<endl;
if (r <= a || b <= l)
return 0;
if (a <= l && r <= b) {
// cout<<a<<" "<<b<<" "<<k<<" "<<l<<" "<<r<<endl;
return upper_bound(dat[k].begin(), dat[k].end(), u) -
lower_bound(dat[k].begin(), dat[k].end(), d);
}
return query(a, b, u, d, k * 2 + 1, l, (l + r) / 2) +
query(a, b, u, d, k * 2 + 2, (l + r) / 2, r);
}
int x[MAX], l[MAX], r[MAX], e[MAX];
signed main() {
int d, q;
cin >> d;
vector<int> v;
for (int i = 0; i < d; i++) {
cin >> x[i];
v.push_back(x[i]);
}
cin >> q;
for (int i = 0; i < q; i++) {
cin >> l[i] >> r[i] >> e[i];
l[i]--;
v.push_back(min(x[l[i]], x[r[i] - 1]) - e[i]);
v.push_back(max(x[l[i]], x[r[i] - 1]) + e[i]);
}
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
map<int, int> m;
for (int i = 0; i < (int)v.size(); i++)
m[v[i]] = i;
n = 1;
while (n < d)
n *= 2;
// cout<<n<<endl;
for (int i = 0; i < d; i++) {
dat[n - 1 + i].push_back(m[x[i]]);
}
for (int i = n - 2; i >= 0; i--) {
for (int k = 1; k <= 2; k++) {
for (int j = 0; j < (int)dat[i * 2 + k].size(); j++)
dat[i].push_back(dat[i * 2 + k][j]);
}
sort(dat[i].begin(), dat[i].end());
}
/*//
for(int i=0;i<n*2-1;i++){
cout<<i<<"-"<<endl;
for(int j=0;j<(int)dat[i].size();j++){
cout<<dat[i][j]<<" ";
}
cout<<endl;
}
//*/
for (int i = 0; i < q; i++) {
// cout<<r[i]-l[i]<<endl;
int inner = query(l[i], r[i], m[max(x[l[i]], x[r[i] - 1]) + e[i]],
m[min(x[l[i]], x[r[i] - 1]) - e[i]]);
int outer = query(l[i], r[i], v.size(), 0);
// cout<<outer<<":"<<inner<<endl;
cout << outer - inner << endl;
}
return 0;
} | replace | 3 | 4 | 3 | 4 | 0 | |
p01777 | C++ | Runtime Error | /* attention to overflow */
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#define dump(x) cerr << #x << " = " << x << endl
using namespace std;
const int INF = 1 << 25;
void io() {
cin.tie(0);
ios::sync_with_stdio(false);
}
/*printf("%.9Lf\n",cf);*/
const int MOD = 1000000007;
struct st {
vector<int> sorted;
vector<int> ns;
};
int main() {
io();
int n;
cin >> n;
vector<st> ar;
int bak = (int)sqrt(n);
for (int i = 0; i < n; i++) {
int x;
cin >> x;
if (i % bak == 0) {
ar.push_back(st());
}
ar[i / bak].ns.push_back(x);
}
int size = ar.size();
for (int i = 0; i < size; i++) {
ar[i].sorted = ar[i].ns;
sort(ar[i].sorted.begin(), ar[i].sorted.end());
}
/*for (int i = 0; i < ar.size(); i++) {
for (int j = 0; j < ar[i].ns.size(); j++) {
cerr << ar[i].ns[j] << ' ';
}
cerr << endl;
}*/
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int l, r, e;
cin >> l >> r >> e;
l--, r--;
int f = l / bak;
int s = r / bak;
int down = min(ar[f].ns[l % bak], ar[s].ns[r % bak]) - e;
int up = max(ar[f].ns[l % bak], ar[s].ns[r % bak]) + e;
dump(down);
dump(up);
// cerr<<1<<endl;
int cnt = 0;
if (f != s) {
for (int j = l % bak; j < ar[f].ns.size(); j++) {
if (down > ar[f].ns[j] || up < ar[f].ns[j]) {
cnt++;
}
}
for (int j = 0; j < r % bak; j++) {
if (down > ar[s].ns[j] || up < ar[s].ns[j]) {
cnt++;
}
}
for (int j = f + 1; j < s; j++) {
cnt +=
bak - (upper_bound(ar[j].sorted.begin(), ar[j].sorted.end(), up) -
lower_bound(ar[j].sorted.begin(), ar[j].sorted.end(), down));
}
} else {
for (int j = l % bak; j < r % bak; j++) {
if (down > ar[f].ns[j] || up < ar[f].ns[j]) {
cnt++;
}
}
}
cout << cnt << endl;
}
return 0;
} | /* attention to overflow */
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#define dump(x) cerr << #x << " = " << x << endl
using namespace std;
const int INF = 1 << 25;
void io() {
cin.tie(0);
ios::sync_with_stdio(false);
}
/*printf("%.9Lf\n",cf);*/
const int MOD = 1000000007;
struct st {
vector<int> sorted;
vector<int> ns;
};
int main() {
io();
int n;
cin >> n;
vector<st> ar;
int bak = (int)sqrt(n);
for (int i = 0; i < n; i++) {
int x;
cin >> x;
if (i % bak == 0) {
ar.push_back(st());
}
ar[i / bak].ns.push_back(x);
}
int size = ar.size();
for (int i = 0; i < size; i++) {
ar[i].sorted = ar[i].ns;
sort(ar[i].sorted.begin(), ar[i].sorted.end());
}
/*for (int i = 0; i < ar.size(); i++) {
for (int j = 0; j < ar[i].ns.size(); j++) {
cerr << ar[i].ns[j] << ' ';
}
cerr << endl;
}*/
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int l, r, e;
cin >> l >> r >> e;
l--, r--;
int f = l / bak;
int s = r / bak;
int down = min(ar[f].ns[l % bak], ar[s].ns[r % bak]) - e;
int up = max(ar[f].ns[l % bak], ar[s].ns[r % bak]) + e;
// dump(down);
// dump(up);
// cerr<<1<<endl;
int cnt = 0;
if (f != s) {
for (int j = l % bak; j < ar[f].ns.size(); j++) {
if (down > ar[f].ns[j] || up < ar[f].ns[j]) {
cnt++;
}
}
for (int j = 0; j < r % bak; j++) {
if (down > ar[s].ns[j] || up < ar[s].ns[j]) {
cnt++;
}
}
for (int j = f + 1; j < s; j++) {
cnt +=
bak - (upper_bound(ar[j].sorted.begin(), ar[j].sorted.end(), up) -
lower_bound(ar[j].sorted.begin(), ar[j].sorted.end(), down));
}
} else {
for (int j = l % bak; j < r % bak; j++) {
if (down > ar[f].ns[j] || up < ar[f].ns[j]) {
cnt++;
}
}
}
cout << cnt << endl;
}
return 0;
} | replace | 65 | 67 | 65 | 67 | 0 | down = 1
up = 7
down = 6
up = 11
down = 5
up = 12
down = 1
up = 6
down = -2
up = 9
|
p01777 | C++ | Runtime Error | #include <algorithm>
#include <array>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define REP(i, a, b) for (int i = a; i < (int)b; i++)
#define rep(i, n) REP(i, 0, n)
#define all(c) (c).begin(), (c).end()
#define zero(a) memset(a, 0, sizeof a)
#define minus(a) memset(a, -1, sizeof a)
#define watch(a) \
{ cout << #a << " = " << a << endl; }
template <class T1, class T2> inline bool minimize(T1 &a, T2 b) {
return b < a && (a = b, 1);
}
template <class T1, class T2> inline bool maximize(T1 &a, T2 b) {
return a < b && (a = b, 1);
}
typedef long long ll;
int const inf = 1 << 29;
int D;
int A[100001];
vector<int> dat[1 << 17];
void init(int k, int l, int r) {
if (r - l == 1) {
dat[k].push_back(A[l]);
} else {
int lch = k * 2 + 1, rch = k * 2 + 2;
init(lch, l, (l + r) / 2);
init(rch, (l + r) / 2, r);
dat[k].resize(r - l);
merge(dat[lch].begin(), dat[lch].end(), dat[rch].begin(), dat[rch].end(),
dat[k].begin());
}
}
int query(int i, int j, int x, int k, int l, int r) {
if (j <= l || r <= i) {
return 0;
} else if (i <= l && r <= j) {
return upper_bound(dat[k].begin(), dat[k].end(), x) - dat[k].begin();
} else {
int lc = query(i, j, x, k * 2 + 1, l, (l + r) / 2);
int rc = query(i, j, x, k * 2 + 2, (l + r) / 2, r);
return lc + rc;
}
}
int main() {
cin >> D;
rep(i, D) cin >> A[i];
init(0, 0, D);
int Q;
cin >> Q;
rep(_, Q) {
int l, r, e;
cin >> l >> r >> e;
l--, r--;
int a = min(A[l], A[r]) - e;
int b = max(A[l], A[r]) + e;
cout << (query(l, r + 1, a - 1, 0, 0, D) - query(l, r + 1, b, 0, 0, D) +
(r - l + 1))
<< endl;
}
return 0;
} | #include <algorithm>
#include <array>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define REP(i, a, b) for (int i = a; i < (int)b; i++)
#define rep(i, n) REP(i, 0, n)
#define all(c) (c).begin(), (c).end()
#define zero(a) memset(a, 0, sizeof a)
#define minus(a) memset(a, -1, sizeof a)
#define watch(a) \
{ cout << #a << " = " << a << endl; }
template <class T1, class T2> inline bool minimize(T1 &a, T2 b) {
return b < a && (a = b, 1);
}
template <class T1, class T2> inline bool maximize(T1 &a, T2 b) {
return a < b && (a = b, 1);
}
typedef long long ll;
int const inf = 1 << 29;
int D;
int A[100001];
vector<int> dat[1 << 20];
void init(int k, int l, int r) {
if (r - l == 1) {
dat[k].push_back(A[l]);
} else {
int lch = k * 2 + 1, rch = k * 2 + 2;
init(lch, l, (l + r) / 2);
init(rch, (l + r) / 2, r);
dat[k].resize(r - l);
merge(dat[lch].begin(), dat[lch].end(), dat[rch].begin(), dat[rch].end(),
dat[k].begin());
}
}
int query(int i, int j, int x, int k, int l, int r) {
if (j <= l || r <= i) {
return 0;
} else if (i <= l && r <= j) {
return upper_bound(dat[k].begin(), dat[k].end(), x) - dat[k].begin();
} else {
int lc = query(i, j, x, k * 2 + 1, l, (l + r) / 2);
int rc = query(i, j, x, k * 2 + 2, (l + r) / 2, r);
return lc + rc;
}
}
int main() {
cin >> D;
rep(i, D) cin >> A[i];
init(0, 0, D);
int Q;
cin >> Q;
rep(_, Q) {
int l, r, e;
cin >> l >> r >> e;
l--, r--;
int a = min(A[l], A[r]) - e;
int b = max(A[l], A[r]) + e;
cout << (query(l, r + 1, a - 1, 0, 0, D) - query(l, r + 1, b, 0, 0, D) +
(r - l + 1))
<< endl;
}
return 0;
} | replace | 43 | 44 | 43 | 44 | 0 | |
p01777 | C++ | Runtime Error | #include <algorithm>
#include <cfloat>
#include <cmath>
#include <iostream>
#include <queue>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;
#define NUM 2147483647
int N, input[100000];
vector<int> SegTree[263000];
void construct_segtree(int node_id, int node_left, int node_right) {
if (node_left == node_right) {
SegTree[node_id].push_back(input[node_left]);
} else {
construct_segtree(2 * node_id + 1, node_left, (node_left + node_right) / 2);
construct_segtree(2 * node_id + 2, (node_left + node_right) / 2 + 1,
node_right);
SegTree[node_id].resize(node_right - node_left + 1);
merge(SegTree[2 * node_id + 1].begin(), SegTree[2 * node_id + 1].end(),
SegTree[2 * node_id + 2].begin(), SegTree[2 * node_id + 2].end(),
SegTree[node_id].begin());
}
}
int calc(int base_value, int search_left, int search_right, int node_id,
int node_left, int node_right, bool isUpper) {
if (search_right < node_left || search_left > node_right) {
return 0;
}
if (search_left <= node_left && search_right >= node_right) {
int left = 0, right = SegTree[node_id].size() - 1, m = (left + right) / 2,
index = -1;
if (isUpper) {
while (left <= right) {
if (SegTree[node_id][m] > base_value) {
index = m;
right = m - 1;
} else {
left = m + 1;
}
m = (left + right) / 2;
}
if (index == -1) {
return 0;
} else {
return SegTree[node_id].size() - index;
}
} else {
while (left <= right) {
if (SegTree[node_id][m] < base_value) {
index = m;
left = m + 1;
} else {
right = m - 1;
}
m = (left + right) / 2;
}
if (index == -1) {
return 0;
} else {
return index + 1;
}
}
}
int left_num = calc(base_value, search_left, search_right, 2 * node_id + 1,
node_left, (node_left + node_right) / 2, isUpper);
int right_num = calc(base_value, search_left, search_right, 2 * node_id + 2,
(node_left + node_right) / 2 + 1, node_right, isUpper);
return left_num + right_num;
}
int main() {
int first_N;
scanf("%d", &first_N);
N = 1;
while (N < first_N)
N *= 2;
for (int i = 0; i < N; i++)
input[i] = BIG_NUM;
for (int i = 0; i < first_N; i++) {
scanf("%d", &input[i]);
}
construct_segtree(0, 0, N - 1);
int Q;
scanf("%d", &Q);
int left, right, diff, ans;
for (int i = 0; i < Q; i++) {
scanf("%d %d %d", &left, &right, &diff);
left--;
right--;
ans = calc(max(input[left], input[right]) + diff, left, right, 0, 0, N - 1,
true);
ans += calc(min(input[left], input[right]) - diff, left, right, 0, 0, N - 1,
false);
printf("%d\n", ans);
}
return 0;
} | #include <algorithm>
#include <cfloat>
#include <cmath>
#include <iostream>
#include <queue>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;
#define NUM 2147483647
int N, input[263000];
vector<int> SegTree[263000];
void construct_segtree(int node_id, int node_left, int node_right) {
if (node_left == node_right) {
SegTree[node_id].push_back(input[node_left]);
} else {
construct_segtree(2 * node_id + 1, node_left, (node_left + node_right) / 2);
construct_segtree(2 * node_id + 2, (node_left + node_right) / 2 + 1,
node_right);
SegTree[node_id].resize(node_right - node_left + 1);
merge(SegTree[2 * node_id + 1].begin(), SegTree[2 * node_id + 1].end(),
SegTree[2 * node_id + 2].begin(), SegTree[2 * node_id + 2].end(),
SegTree[node_id].begin());
}
}
int calc(int base_value, int search_left, int search_right, int node_id,
int node_left, int node_right, bool isUpper) {
if (search_right < node_left || search_left > node_right) {
return 0;
}
if (search_left <= node_left && search_right >= node_right) {
int left = 0, right = SegTree[node_id].size() - 1, m = (left + right) / 2,
index = -1;
if (isUpper) {
while (left <= right) {
if (SegTree[node_id][m] > base_value) {
index = m;
right = m - 1;
} else {
left = m + 1;
}
m = (left + right) / 2;
}
if (index == -1) {
return 0;
} else {
return SegTree[node_id].size() - index;
}
} else {
while (left <= right) {
if (SegTree[node_id][m] < base_value) {
index = m;
left = m + 1;
} else {
right = m - 1;
}
m = (left + right) / 2;
}
if (index == -1) {
return 0;
} else {
return index + 1;
}
}
}
int left_num = calc(base_value, search_left, search_right, 2 * node_id + 1,
node_left, (node_left + node_right) / 2, isUpper);
int right_num = calc(base_value, search_left, search_right, 2 * node_id + 2,
(node_left + node_right) / 2 + 1, node_right, isUpper);
return left_num + right_num;
}
int main() {
int first_N;
scanf("%d", &first_N);
N = 1;
while (N < first_N)
N *= 2;
for (int i = 0; i < N; i++)
input[i] = BIG_NUM;
for (int i = 0; i < first_N; i++) {
scanf("%d", &input[i]);
}
construct_segtree(0, 0, N - 1);
int Q;
scanf("%d", &Q);
int left, right, diff, ans;
for (int i = 0; i < Q; i++) {
scanf("%d %d %d", &left, &right, &diff);
left--;
right--;
ans = calc(max(input[left], input[right]) + diff, left, right, 0, 0, N - 1,
true);
ans += calc(min(input[left], input[right]) - diff, left, right, 0, 0, N - 1,
false);
printf("%d\n", ans);
}
return 0;
} | replace | 18 | 19 | 18 | 19 | 0 | |
p01780 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define rep(i, x, y) for (int i = (x); i < (y); ++i)
#define debug(x) #x << "=" << (x)
#ifdef DEBUG
#define _GLIBCXX_DEBUG
#define dump(x) std::cerr << debug(x) << " (L:" << __LINE__ << ")" << std::endl
#else
#define dump(x)
#endif
typedef long long int ll;
typedef pair<int, int> pii;
// template<typename T> using vec=std::vector<T>;
const int inf = 1 << 30;
const long long int infll = 1LL << 58;
const double eps = 1e-9;
const int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "[";
for (const auto &v : vec) {
os << v << ",";
}
os << "]";
return os;
}
struct lca_solver {
vector<vector<int>> children;
int root;
// if root,parent is -1.
vector<int> parent;
vector<int> depth;
vector<vector<int>> parent_pow2;
lca_solver(vector<vector<int>> children_, int root_)
: children(children_), root(root_) {
calc_parent_and_depth();
calc_parent_pow2();
};
int lca(int u, int v) {
// make sure depth(u) > depth(v).
if (depth[u] < depth[v])
swap(u, v);
for (size_t k = 0; k < parent_pow2.size(); k++) {
if (((depth[u] - depth[v]) >> k) & 1) {
u = parent_pow2[k][u];
}
}
if (u == v)
return u;
for (int k = (int)parent_pow2.size() - 1; k >= 0; k--) {
if (parent_pow2[k][u] != parent_pow2[k][v]) {
u = parent_pow2[k][u];
v = parent_pow2[k][v];
}
}
return parent_pow2[0][u];
}
private:
void calc_parent_and_depth() {
parent = vector<int>(children.size(), -1);
depth = vector<int>(children.size(), -1);
sub_calc_parent_and_depth(root, -1, 0);
}
void sub_calc_parent_and_depth(int cur, int par, int dep) {
parent[cur] = par;
depth[cur] = dep;
for (int child : children[cur]) {
if (child != par) {
sub_calc_parent_and_depth(child, cur, dep + 1);
}
}
}
void calc_parent_pow2() {
// parent_pow2[k][i] = 2^k parent of node i.
parent_pow2 = vector<vector<int>>(ceil(log(children.size()) / log(2)),
vector<int>(children.size(), -1));
parent_pow2[0] = parent;
for (size_t k = 0; k + 1 < parent_pow2.size(); k++) {
for (size_t v = 0; v < children.size(); v++) {
if (parent_pow2[k][v] >= 0) {
parent_pow2[k + 1][v] = parent_pow2[k][parent_pow2[k][v]];
}
}
}
}
};
void solve() {
int n;
cin >> n;
if (n == 0) {
cout << 0 << endl;
return;
}
vector<vector<int>> children(n);
rep(i, 0, n - 1) {
int p;
cin >> p;
--p;
children[p].emplace_back(i + 1);
}
for (auto &x : children)
sort(x.begin(), x.end());
lca_solver ls(children, 0);
queue<int> q;
int pos = 0;
ll ans = 0;
q.push(0);
while (!q.empty()) {
const int v = q.front();
q.pop();
ans += ls.depth[pos] + ls.depth[v] - ls.depth[ls.lca(pos, v)] * 2;
pos = v;
for (const int u : children[v])
q.push(u);
}
cout << ans << endl;
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
cout << fixed << setprecision(8);
solve();
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, x, y) for (int i = (x); i < (y); ++i)
#define debug(x) #x << "=" << (x)
#ifdef DEBUG
#define _GLIBCXX_DEBUG
#define dump(x) std::cerr << debug(x) << " (L:" << __LINE__ << ")" << std::endl
#else
#define dump(x)
#endif
typedef long long int ll;
typedef pair<int, int> pii;
// template<typename T> using vec=std::vector<T>;
const int inf = 1 << 30;
const long long int infll = 1LL << 58;
const double eps = 1e-9;
const int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "[";
for (const auto &v : vec) {
os << v << ",";
}
os << "]";
return os;
}
struct lca_solver {
vector<vector<int>> children;
int root;
// if root,parent is -1.
vector<int> parent;
vector<int> depth;
vector<vector<int>> parent_pow2;
lca_solver(vector<vector<int>> children_, int root_)
: children(children_), root(root_) {
calc_parent_and_depth();
calc_parent_pow2();
};
int lca(int u, int v) {
// make sure depth(u) > depth(v).
if (depth[u] < depth[v])
swap(u, v);
for (size_t k = 0; k < parent_pow2.size(); k++) {
if (((depth[u] - depth[v]) >> k) & 1) {
u = parent_pow2[k][u];
}
}
if (u == v)
return u;
for (int k = (int)parent_pow2.size() - 1; k >= 0; k--) {
if (parent_pow2[k][u] != parent_pow2[k][v]) {
u = parent_pow2[k][u];
v = parent_pow2[k][v];
}
}
return parent_pow2[0][u];
}
private:
void calc_parent_and_depth() {
parent = vector<int>(children.size(), -1);
depth = vector<int>(children.size(), -1);
sub_calc_parent_and_depth(root, -1, 0);
}
void sub_calc_parent_and_depth(int cur, int par, int dep) {
parent[cur] = par;
depth[cur] = dep;
for (int child : children[cur]) {
if (child != par) {
sub_calc_parent_and_depth(child, cur, dep + 1);
}
}
}
void calc_parent_pow2() {
// parent_pow2[k][i] = 2^k parent of node i.
parent_pow2 = vector<vector<int>>(ceil(log(children.size()) / log(2)),
vector<int>(children.size(), -1));
parent_pow2[0] = parent;
for (size_t k = 0; k + 1 < parent_pow2.size(); k++) {
for (size_t v = 0; v < children.size(); v++) {
if (parent_pow2[k][v] >= 0) {
parent_pow2[k + 1][v] = parent_pow2[k][parent_pow2[k][v]];
}
}
}
}
};
void solve() {
int n;
cin >> n;
if (n == 1) {
cout << 0 << endl;
return;
}
vector<vector<int>> children(n);
rep(i, 0, n - 1) {
int p;
cin >> p;
--p;
children[p].emplace_back(i + 1);
}
for (auto &x : children)
sort(x.begin(), x.end());
lca_solver ls(children, 0);
queue<int> q;
int pos = 0;
ll ans = 0;
q.push(0);
while (!q.empty()) {
const int v = q.front();
q.pop();
ans += ls.depth[pos] + ls.depth[v] - ls.depth[ls.lca(pos, v)] * 2;
pos = v;
for (const int u : children[v])
q.push(u);
}
cout << ans << endl;
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
cout << fixed << setprecision(8);
solve();
return 0;
} | replace | 100 | 101 | 100 | 101 | 0 | |
p01780 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for (int i = a; i < b; i++)
typedef long long ll;
int N;
vector<pair<int, int>> E[101010];
class LCA {
public:
int NV;
int logNV;
vector<int> D;
vector<long long> L;
vector<vector<int>> P;
LCA(int N) {
NV = N;
logNV = 0;
while (NV > (1LL << logNV))
logNV++;
D = vector<int>(NV);
L = vector<long long>(NV);
P = vector<vector<int>>(logNV, vector<int>(NV));
}
void init() {
dfs(0, -1, 0, 0);
build();
}
void dfs(int v, int par, int d, long long l) {
D[v] = d;
P[0][v] = par;
L[v] = l;
for (int i = 0; i < (int)E[v].size(); i++) {
int w = E[v][i].first;
int lc = E[v][i].second;
if (w == par)
continue;
dfs(w, v, d + 1, lc + l);
}
}
void build() {
for (int k = 0; k + 1 < logNV; k++) {
for (int v = 0; v < NV; v++) {
if (P[k][v] < 0)
P[k + 1][v] = -1;
else
P[k + 1][v] = P[k][P[k][v]];
}
}
}
int query(int u, int v) {
if (D[u] > D[v])
swap(u, v);
for (int k = 0; k < logNV; k++) {
if ((D[v] - D[u]) >> k & 1)
v = P[k][v];
}
if (u == v)
return u;
for (int k = logNV - 1; k >= 0; k--) {
if (P[k][u] != P[k][v]) {
u = P[k][u];
v = P[k][v];
}
}
return P[0][u];
}
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
while (cin >> N) {
rep(i, 0, N) E[i].clear();
rep(i, 1, N) {
int p;
cin >> p;
p--;
E[p].push_back(make_pair(i, 1));
E[i].push_back(make_pair(p, 1));
}
LCA lca(N);
lca.init();
ll ans = 0;
queue<int> que;
que.push(0);
int prev = -1;
while (!que.empty()) {
int p = que.front();
que.pop();
for (auto _p : E[p]) {
int pp = _p.first;
if (lca.L[p] < lca.L[pp])
que.push(pp);
}
if (0 <= prev) {
ans += (ll)(lca.L[p] + lca.L[prev] - 2 * lca.L[lca.query(p, prev)]);
}
prev = p;
}
cout << ans << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for (int i = a; i < b; i++)
typedef long long ll;
int N;
vector<pair<int, int>> E[101010];
class LCA {
public:
int NV;
int logNV;
vector<int> D;
vector<long long> L;
vector<vector<int>> P;
LCA(int N) {
NV = N;
logNV = 0;
while (NV > (1LL << logNV))
logNV++;
D = vector<int>(NV);
L = vector<long long>(NV);
P = vector<vector<int>>(logNV, vector<int>(NV));
}
void init() {
dfs(0, -1, 0, 0);
build();
}
void dfs(int v, int par, int d, long long l) {
D[v] = d;
P[0][v] = par;
L[v] = l;
for (int i = 0; i < (int)E[v].size(); i++) {
int w = E[v][i].first;
int lc = E[v][i].second;
if (w == par)
continue;
dfs(w, v, d + 1, lc + l);
}
}
void build() {
for (int k = 0; k + 1 < logNV; k++) {
for (int v = 0; v < NV; v++) {
if (P[k][v] < 0)
P[k + 1][v] = -1;
else
P[k + 1][v] = P[k][P[k][v]];
}
}
}
int query(int u, int v) {
if (D[u] > D[v])
swap(u, v);
for (int k = 0; k < logNV; k++) {
if ((D[v] - D[u]) >> k & 1)
v = P[k][v];
}
if (u == v)
return u;
for (int k = logNV - 1; k >= 0; k--) {
if (P[k][u] != P[k][v]) {
u = P[k][u];
v = P[k][v];
}
}
return P[0][u];
}
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
while (cin >> N) {
if (N == 1) {
cout << 0 << endl;
continue;
}
rep(i, 0, N) E[i].clear();
rep(i, 1, N) {
int p;
cin >> p;
p--;
E[p].push_back(make_pair(i, 1));
E[i].push_back(make_pair(p, 1));
}
LCA lca(N);
lca.init();
ll ans = 0;
queue<int> que;
que.push(0);
int prev = -1;
while (!que.empty()) {
int p = que.front();
que.pop();
for (auto _p : E[p]) {
int pp = _p.first;
if (lca.L[p] < lca.L[pp])
que.push(pp);
}
if (0 <= prev) {
ans += (ll)(lca.L[p] + lca.L[prev] - 2 * lca.L[lca.query(p, prev)]);
}
prev = p;
}
cout << ans << endl;
}
} | insert | 81 | 81 | 81 | 85 | 0 | |
p01780 | C++ | Runtime Error | #include <algorithm>
#include <array>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define REP(i, a, b) for (int i = a; i < (int)b; i++)
#define rep(i, n) REP(i, 0, n)
#define all(c) (c).begin(), (c).end()
#define zero(a) memset(a, 0, sizeof a)
#define minus(a) memset(a, -1, sizeof a)
#define watch(a) \
{ cout << #a << " = " << a << endl; }
template <class T1, class T2> inline bool minimize(T1 &a, T2 b) {
return b < a && (a = b, 1);
}
template <class T1, class T2> inline bool maximize(T1 &a, T2 b) {
return a < b && (a = b, 1);
}
typedef long long ll;
int const inf = 1 << 29;
int N;
vector<int> G[100010];
int dist[100010];
vector<int> T;
void bfs() {
queue<int> q;
q.push(0);
rep(i, N) dist[i] = inf;
dist[0] = 0;
while (!q.empty()) {
auto p = q.front();
q.pop();
T.push_back(p);
for (auto e : G[p]) {
if (dist[e] < inf)
continue;
dist[e] = dist[p] + 1;
q.push(e);
}
}
}
int parent[22][10010];
int depth[100010];
void dfs(int v, int p, int d) {
parent[0][v] = p;
depth[v] = d;
for (auto &&e : G[v])
if (e != p) {
dfs(e, v, d + 1);
}
}
void init() {
dfs(0, -1, 0);
rep(k, 20) rep(v, N) if (parent[k][v] == -1) parent[k + 1][v] = -1;
else parent[k + 1][v] = parent[k][parent[k][v]];
}
int lca(int u, int v) {
if (depth[u] > depth[v])
swap(u, v);
rep(k, 22) if ((depth[v] - depth[u]) >> k & 1) { v = parent[k][v]; }
if (u == v)
return u;
for (int k = 21; k >= 0; k--)
if (parent[k][u] != parent[k][v])
u = parent[k][u], v = parent[k][v];
return parent[0][u];
}
int main() {
cin >> N;
rep(i, N - 1) {
int x;
cin >> x;
x--;
G[x].push_back(i + 1);
}
init();
bfs();
ll ans = 0;
REP(i, 1, T.size()) {
int a = T[i - 1];
int b = T[i];
ans += dist[a] + dist[b] - 2 * dist[lca(a, b)];
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <array>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define REP(i, a, b) for (int i = a; i < (int)b; i++)
#define rep(i, n) REP(i, 0, n)
#define all(c) (c).begin(), (c).end()
#define zero(a) memset(a, 0, sizeof a)
#define minus(a) memset(a, -1, sizeof a)
#define watch(a) \
{ cout << #a << " = " << a << endl; }
template <class T1, class T2> inline bool minimize(T1 &a, T2 b) {
return b < a && (a = b, 1);
}
template <class T1, class T2> inline bool maximize(T1 &a, T2 b) {
return a < b && (a = b, 1);
}
typedef long long ll;
int const inf = 1 << 29;
int N;
vector<int> G[100010];
int dist[100010];
vector<int> T;
void bfs() {
queue<int> q;
q.push(0);
rep(i, N) dist[i] = inf;
dist[0] = 0;
while (!q.empty()) {
auto p = q.front();
q.pop();
T.push_back(p);
for (auto e : G[p]) {
if (dist[e] < inf)
continue;
dist[e] = dist[p] + 1;
q.push(e);
}
}
}
int parent[22][100010];
int depth[100010];
void dfs(int v, int p, int d) {
parent[0][v] = p;
depth[v] = d;
for (auto &&e : G[v])
if (e != p) {
dfs(e, v, d + 1);
}
}
void init() {
dfs(0, -1, 0);
rep(k, 20) rep(v, N) if (parent[k][v] == -1) parent[k + 1][v] = -1;
else parent[k + 1][v] = parent[k][parent[k][v]];
}
int lca(int u, int v) {
if (depth[u] > depth[v])
swap(u, v);
rep(k, 22) if ((depth[v] - depth[u]) >> k & 1) { v = parent[k][v]; }
if (u == v)
return u;
for (int k = 21; k >= 0; k--)
if (parent[k][u] != parent[k][v])
u = parent[k][u], v = parent[k][v];
return parent[0][u];
}
int main() {
cin >> N;
rep(i, N - 1) {
int x;
cin >> x;
x--;
G[x].push_back(i + 1);
}
init();
bfs();
ll ans = 0;
REP(i, 1, T.size()) {
int a = T[i - 1];
int b = T[i];
ans += dist[a] + dist[b] - 2 * dist[lca(a, b)];
}
cout << ans << endl;
return 0;
} | replace | 64 | 65 | 64 | 65 | 0 | |
p01780 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#define maxn 100005
#define MOD 1000000007
#define hashm 17982571
using namespace std;
int n, l, tot = 0, cnt = 0;
long long ans = 0;
int f[maxn], p[maxn], b[2 * maxn], dis[maxn], a[maxn], dp[20][2 * maxn];
vector<int> e[maxn];
void dfs(int now, int fa, int dep) {
dis[now] = dep;
int tt = tot++;
f[tt] = now;
p[now] = cnt;
b[cnt++] = tt;
for (int i = 0; i < e[now].size(); i++) {
dfs(e[now][i], now, dep + 1);
b[cnt++] = tt;
}
return;
}
void rmq(int n) {
for (int i = 0; i < n; i++)
dp[i][0] = b[i];
int m = int(log(n * 1.0) / log(2.0));
for (int i = 1; i <= m; i++)
for (int j = 0; j < n - (1 << i) + 1; j++)
dp[j][i] = min(dp[j][i - 1], dp[j + (1 << (i - 1))][i - 1]);
return;
}
int lca(int l, int r) {
if (l > r)
swap(l, r);
int m = (int)(log(r - l + 1.0) / log(2.0));
return f[min(dp[l][m], dp[r - (1 << m) + 1][m])];
}
void bfs() {
queue<int> q;
q.push(1);
l = 1;
while (!q.empty()) {
int x = q.front();
q.pop();
for (int i = 0; i < e[x].size(); i++) {
q.push(e[x][i]);
int yy = lca(p[l], p[e[x][i]]);
ans += dis[l] + dis[e[x][i]] - 2 * dis[yy];
l = e[x][i];
}
}
}
int main() {
int i, j;
scanf("%d", &n);
for (i = 2; i <= n; i++) {
scanf("%d", &j);
e[j].push_back(i);
}
dfs(1, 0, 0);
rmq(cnt - 1);
bfs();
printf("%lld\n", ans);
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#define maxn 100005
#define MOD 1000000007
#define hashm 17982571
using namespace std;
int n, l, tot = 0, cnt = 0;
long long ans = 0;
int f[maxn], p[maxn], b[2 * maxn], dis[maxn], a[maxn], dp[2 * maxn][20];
vector<int> e[maxn];
void dfs(int now, int fa, int dep) {
dis[now] = dep;
int tt = tot++;
f[tt] = now;
p[now] = cnt;
b[cnt++] = tt;
for (int i = 0; i < e[now].size(); i++) {
dfs(e[now][i], now, dep + 1);
b[cnt++] = tt;
}
return;
}
void rmq(int n) {
for (int i = 0; i < n; i++)
dp[i][0] = b[i];
int m = int(log(n * 1.0) / log(2.0));
for (int i = 1; i <= m; i++)
for (int j = 0; j < n - (1 << i) + 1; j++)
dp[j][i] = min(dp[j][i - 1], dp[j + (1 << (i - 1))][i - 1]);
return;
}
int lca(int l, int r) {
if (l > r)
swap(l, r);
int m = (int)(log(r - l + 1.0) / log(2.0));
return f[min(dp[l][m], dp[r - (1 << m) + 1][m])];
}
void bfs() {
queue<int> q;
q.push(1);
l = 1;
while (!q.empty()) {
int x = q.front();
q.pop();
for (int i = 0; i < e[x].size(); i++) {
q.push(e[x][i]);
int yy = lca(p[l], p[e[x][i]]);
ans += dis[l] + dis[e[x][i]] - 2 * dis[yy];
l = e[x][i];
}
}
}
int main() {
int i, j;
scanf("%d", &n);
for (i = 2; i <= n; i++) {
scanf("%d", &j);
e[j].push_back(i);
}
dfs(1, 0, 0);
rmq(cnt - 1);
bfs();
printf("%lld\n", ans);
return 0;
} | replace | 19 | 20 | 19 | 20 | 0 | |
p01781 | C++ | Time Limit Exceeded | #include "bits/stdc++.h"
using namespace std;
using ll = long long;
using ld = long double;
using P = pair<int, int>;
constexpr ld EPS = 1e-12;
constexpr int INF = numeric_limits<int>::max() / 2;
constexpr int MOD = 1e9 + 7;
ll X, Y, Z, A, B, C, N;
ll cnt_x[1000], cnt_y[1000], cnt_z[1000], res[1000];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> X >> Y >> Z >> A >> B >> C >> N;
for (int i = 0; i < X; i++) {
int diff = abs(i - A) % N;
cnt_x[diff]++;
}
for (int i = 0; i < Y; i++) {
int diff = abs(i - B) % N;
cnt_y[diff]++;
}
for (int i = 0; i < Z; i++) {
int diff = abs(i - C) % N;
cnt_z[diff]++;
}
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
for (int k = 0; k < N; k++) {
res[(i + j + k) % N] += cnt_x[i] * cnt_y[j] * cnt_z[k];
}
}
}
for (int i = 0; i < N; i++) {
cout << res[i] << " \n"[i == N - 1];
}
}
| #include "bits/stdc++.h"
using namespace std;
using ll = long long;
using ld = long double;
using P = pair<int, int>;
constexpr ld EPS = 1e-12;
constexpr int INF = numeric_limits<int>::max() / 2;
constexpr int MOD = 1e9 + 7;
ll X, Y, Z, A, B, C, N;
ll cnt_x[1000], cnt_y[1000], cnt_z[1000], res[1000];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> X >> Y >> Z >> A >> B >> C >> N;
for (int i = 0; i < X; i++) {
int diff = abs(i - A) % N;
cnt_x[diff]++;
}
for (int i = 0; i < Y; i++) {
int diff = abs(i - B) % N;
cnt_y[diff]++;
}
for (int i = 0; i < Z; i++) {
int diff = abs(i - C) % N;
cnt_z[diff]++;
}
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
for (int k = 0; k < N; k++) {
int idx = i + j + k;
if (idx >= 2 * N)
idx -= 2 * N;
else if (idx >= N)
idx -= N;
res[idx] += cnt_x[i] * cnt_y[j] * cnt_z[k];
}
}
}
for (int i = 0; i < N; i++) {
cout << res[i] << " \n"[i == N - 1];
}
}
| replace | 34 | 35 | 34 | 40 | TLE | |
p01785 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> P;
typedef pair<int, P> P1;
typedef pair<P, P> P2;
typedef long long ll;
#define pu push
#define pb push_back
#define mp make_pair
#define rep(i, x) for (int i = 0; i < x; i++)
typedef complex<double> pt;
typedef pair<pt, pt> L;
typedef vector<P> poly;
const double EPS = 1e-9;
#define x real()
#define y imag()
bool eq(double a, double b) { return -EPS < a - b && a - b < EPS; }
double dot(pt a, pt b) { return (conj(a) * b).x; }
double cross(pt a, pt b) { return (conj(a) * b).y; }
bool on_segment(pair<pt, pt> a, pt p) {
return eq(abs(a.first - a.second) - abs(a.first - p) - abs(a.second - p), 0);
}
bool contain_point(vector<pt> ps, pt p) {
double sum = 0;
// arg no sum wo keisan
for (int i = 0; i < ps.size(); i++) {
if (on_segment(mp(ps[i], ps[(i + 1) % ps.size()]), p))
return 1;
sum += arg((ps[(i + 1) % ps.size()] - p) / (ps[i] - p));
}
return (abs(sum) > 1);
}
bool LCMP(const pt &a, const pt &b) {
if (eq(a.x, b.x))
return a.y < b.y;
else
return a.x < b.x;
}
int ccw(pt a, pt b, pt c) {
b -= a;
c -= a;
if (cross(b, c) > EPS)
return 1; // counter clockwise
if (cross(b, c) < -EPS)
return -1; // clockwise
if (dot(b, c) < -EPS)
return 2; // c-a-b
if (norm(b) < norm(c))
return -2; // a-b-c
return 0; // a-c-b
}
pt crossPoint(pt a, pt b, pt c, pt d) {
double A = cross(b - a, d - c);
double B = cross(b - a, b - c);
if (fabs(A) < EPS && fabs(B) < EPS)
return c;
else if (fabs(A) >= EPS)
return c + B / A * (d - c);
else
pt(1e9, 1e9);
}
bool contain_segment(vector<pt> ps, pt p, pt q) {
vector<pt> qs;
// if(p == pt(1,2) && q == pt(0,0)) cout << "J" << endl;
qs.pb(p);
qs.pb(q);
for (int i = 0; i < ps.size(); i++) {
// on-segment
if (ccw(p, q, ps[i]) == 0)
qs.pb(ps[i]);
}
for (int i = 0; i < ps.size(); i++) {
pt r = crossPoint(p, q, ps[i], ps[(i + 1) % ps.size()]);
if (r.x > 1e8)
continue;
if (ccw(p, q, r) == 0)
qs.pb(r);
}
sort(qs.begin(), qs.end(), LCMP);
for (int i = 1; i < qs.size(); i++) {
pt r = (qs[i] + qs[i - 1]) / 2.0;
if (!contain_point(ps, r))
return 0;
}
return 1;
}
int n;
vector<pt> f;
ll ok[45];
int ans = 40;
void dfs(int v, int num, ll state) {
if (state == (1LL << n) - 1) {
ans = min(ans, num);
return;
}
if (v == n)
return;
if (ans <= num)
return;
dfs(v + 1, num, state);
dfs(v + 1, num + 1, state | ok[v]);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
double X, Y;
scanf("%lf%lf", &X, &Y);
f.pb(pt(X, Y));
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i == j)
ok[i] ^= (1LL << j);
else {
if (contain_segment(f, f[i], f[j])) {
ok[i] ^= (1LL << j);
}
}
}
// cout << ok[i] << endl;
} // return 0;
dfs(0, 0, 0);
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> P;
typedef pair<int, P> P1;
typedef pair<P, P> P2;
typedef long long ll;
#define pu push
#define pb push_back
#define mp make_pair
#define rep(i, x) for (int i = 0; i < x; i++)
typedef complex<double> pt;
typedef pair<pt, pt> L;
typedef vector<P> poly;
const double EPS = 1e-9;
#define x real()
#define y imag()
bool eq(double a, double b) { return -EPS < a - b && a - b < EPS; }
double dot(pt a, pt b) { return (conj(a) * b).x; }
double cross(pt a, pt b) { return (conj(a) * b).y; }
bool on_segment(pair<pt, pt> a, pt p) {
return eq(abs(a.first - a.second) - abs(a.first - p) - abs(a.second - p), 0);
}
bool contain_point(vector<pt> ps, pt p) {
double sum = 0;
// arg no sum wo keisan
for (int i = 0; i < ps.size(); i++) {
if (on_segment(mp(ps[i], ps[(i + 1) % ps.size()]), p))
return 1;
sum += arg((ps[(i + 1) % ps.size()] - p) / (ps[i] - p));
}
return (abs(sum) > 1);
}
bool LCMP(const pt &a, const pt &b) {
if (eq(a.x, b.x))
return a.y < b.y;
else
return a.x < b.x;
}
int ccw(pt a, pt b, pt c) {
b -= a;
c -= a;
if (cross(b, c) > EPS)
return 1; // counter clockwise
if (cross(b, c) < -EPS)
return -1; // clockwise
if (dot(b, c) < -EPS)
return 2; // c-a-b
if (norm(b) < norm(c))
return -2; // a-b-c
return 0; // a-c-b
}
pt crossPoint(pt a, pt b, pt c, pt d) {
double A = cross(b - a, d - c);
double B = cross(b - a, b - c);
if (fabs(A) < EPS && fabs(B) < EPS)
return c;
else if (fabs(A) >= EPS)
return c + B / A * (d - c);
else
pt(1e9, 1e9);
}
bool contain_segment(vector<pt> ps, pt p, pt q) {
vector<pt> qs;
// if(p == pt(1,2) && q == pt(0,0)) cout << "J" << endl;
qs.pb(p);
qs.pb(q);
for (int i = 0; i < ps.size(); i++) {
// on-segment
if (ccw(p, q, ps[i]) == 0)
qs.pb(ps[i]);
}
for (int i = 0; i < ps.size(); i++) {
pt r = crossPoint(p, q, ps[i], ps[(i + 1) % ps.size()]);
if (r.x > 1e8)
continue;
if (ccw(p, q, r) == 0)
qs.pb(r);
}
sort(qs.begin(), qs.end(), LCMP);
for (int i = 1; i < qs.size(); i++) {
pt r = (qs[i] + qs[i - 1]) / 2.0;
if (!contain_point(ps, r))
return 0;
}
return 1;
}
int n;
vector<pt> f;
ll ok[45];
int ans = 40;
void dfs(int v, int num, ll state) {
if (state == (1LL << n) - 1) {
ans = min(ans, num);
return;
}
if (v == n)
return;
if (ans <= num || num >= 10)
return;
dfs(v + 1, num, state);
dfs(v + 1, num + 1, state | ok[v]);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
double X, Y;
scanf("%lf%lf", &X, &Y);
f.pb(pt(X, Y));
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i == j)
ok[i] ^= (1LL << j);
else {
if (contain_segment(f, f[i], f[j])) {
ok[i] ^= (1LL << j);
}
}
}
// cout << ok[i] << endl;
} // return 0;
dfs(0, 0, 0);
cout << ans << endl;
} | replace | 98 | 99 | 98 | 99 | TLE | |
p01786 | C++ | Runtime Error | #include <algorithm>
#include <array>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <valarray>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
constexpr int TEN(int n) { return (n == 0) ? 1 : 10 * TEN(n - 1); }
using R = long double;
const R EPS = 1e-9;
const int MS = 30030;
using P = array<ll, 2>;
namespace StopWatch {
clock_t st;
bool f = false;
void start() {
f = true;
st = clock();
}
int msecs() {
assert(f);
return (clock() - st) * 1000 / CLOCKS_PER_SEC;
}
} // namespace StopWatch
vector<P> solve(int N, vector<ll> s) {
int M = (int)s.size();
vector<P> rng(M);
fill_n(rng.begin(), M, P{0, N});
ll ssm = 0;
for (int i = 0; i < M; i++) {
ssm += s[i];
}
int deg[MS];
fill_n(deg, MS, 0);
for (int i = 0; i < M; i++) {
deg[s[i]]++;
}
map<int, ll> mp;
StopWatch::start();
for (int i = 0; i < M; i++) {
if (s[i] == 0)
continue;
if (mp.count(s[i])) {
rng[i][0] = mp[s[i]];
continue;
}
if (i % 1000 == 0) {
// printf("end %d %d\n", i, StopWatch::msecs());
}
ll l = (N * s[i] - 1) / (ssm + M - 1);
while (l < N) {
l++;
ll sm = (ssm - s[i] + M - 1) * l - (M - 1) * (s[i] - 1) - s[i] * (N - l);
/* for (int j = 0; j < M; j++) {
if (i == j) continue;
sm += s[i]-1-(s[j]+1)*l%s[i];
if (0 <= sm) {
break;
}
}*/
sm -= s[i] - 1 - (s[i] + 1) * l % s[i];
int l2 = l % s[i];
int now = 0;
for (int j = 0; j < MS; j++) {
now += l2;
if (now >= s[i])
now -= s[i];
sm += (s[i] - 1 - now) * deg[j];
if (0 <= sm)
break;
}
if (0 <= sm)
break;
}
mp[s[i]] = rng[i][0] = l;
}
mp.clear();
StopWatch::start();
for (int i = 0; i < M; i++) {
if (mp.count(s[i])) {
rng[i][1] = mp[s[i]];
continue;
}
if (i % 1000 == 0) {
// printf("end %d %d\n", i, StopWatch::msecs());
}
ll l = (N * (s[i] + 1) - (M - 1) * s[i]) / (ssm + 1);
while (l <= N) {
l++;
ll sm = (ssm - s[i]) * l - (s[i] + 1) * (N - l);
sm -= s[i] - (s[i] * l + s[i]) % (s[i] + 1);
int l2 = l % (s[i]) + 1;
int now = s[i];
/* for (int j = 0; j < M; j++) {
if (i == j) continue;
sm += s[i] - (s[j]*l+s[i])%(s[i]+1);
if (0 < sm) {
break;
}
}*/
for (int j = 0; j < MS; j++) {
sm += (s[i] - now) * deg[j];
now += l2;
if (now >= s[i] + 1)
now -= s[i] + 1;
if (0 < sm)
break;
}
if (0 < sm)
break;
}
mp[s[i]] = rng[i][1] = l - 1;
}
return rng;
}
int main2() {
int N, M;
cin >> N >> M;
assert(M <= 30000);
vector<ll> s;
for (int i = 0; i < M; i++) {
int x;
cin >> x;
s.push_back(x);
}
int idx[M], ridx[M];
iota(idx, idx + M, 0);
sort(idx, idx + M, [&](const int &l, const int &r) { return s[l] < s[r]; });
for (int i = 0; i < M; i++) {
ridx[idx[i]] = i;
}
vector<ll> s2(M);
for (int i = 0; i < M; i++) {
s2[i] = s[idx[i]];
}
auto rng = solve(N, s2);
for (int i = 0; i < M; i++) {
if (rng[i][0] > rng[i][1]) {
printf("impossible\n");
return 0;
}
}
for (int i = 0; i < M; i++) {
printf("%lld %lld\n", rng[ridx[i]][0], rng[ridx[i]][1]);
}
return 0;
}
/*stack size???????????????*/
int main() {
static ll eord, enew;
const int sz = 32 * 1024 * 1024;
static unsigned char *p = (unsigned char *)malloc(sz);
enew = ((ll)(p + sz - 1) & ~0xff);
__asm__ volatile("mov %%rsp, %0" : "=r"(eord));
__asm__ volatile("mov %0, %%rsp" : : "r"(enew));
main2();
__asm__ volatile("mov %0, %%rsp" : : "r"(eord));
return 0;
} | #include <algorithm>
#include <array>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <valarray>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
constexpr int TEN(int n) { return (n == 0) ? 1 : 10 * TEN(n - 1); }
using R = long double;
const R EPS = 1e-9;
const int MS = 30030;
using P = array<ll, 2>;
namespace StopWatch {
clock_t st;
bool f = false;
void start() {
f = true;
st = clock();
}
int msecs() {
assert(f);
return (clock() - st) * 1000 / CLOCKS_PER_SEC;
}
} // namespace StopWatch
vector<P> solve(int N, vector<ll> s) {
int M = (int)s.size();
vector<P> rng(M);
fill_n(rng.begin(), M, P{0, N});
ll ssm = 0;
for (int i = 0; i < M; i++) {
ssm += s[i];
}
int deg[MS];
fill_n(deg, MS, 0);
for (int i = 0; i < M; i++) {
deg[s[i]]++;
}
map<int, ll> mp;
StopWatch::start();
for (int i = 0; i < M; i++) {
if (s[i] == 0)
continue;
if (mp.count(s[i])) {
rng[i][0] = mp[s[i]];
continue;
}
if (i % 1000 == 0) {
// printf("end %d %d\n", i, StopWatch::msecs());
}
ll l = (N * s[i] - 1) / (ssm + M - 1);
while (l < N) {
l++;
ll sm = (ssm - s[i] + M - 1) * l - (M - 1) * (s[i] - 1) - s[i] * (N - l);
/* for (int j = 0; j < M; j++) {
if (i == j) continue;
sm += s[i]-1-(s[j]+1)*l%s[i];
if (0 <= sm) {
break;
}
}*/
sm -= s[i] - 1 - (s[i] + 1) * l % s[i];
int l2 = l % s[i];
int now = 0;
for (int j = 0; j < MS; j++) {
now += l2;
if (now >= s[i])
now -= s[i];
sm += (s[i] - 1 - now) * deg[j];
if (0 <= sm)
break;
}
if (0 <= sm)
break;
}
mp[s[i]] = rng[i][0] = l;
}
mp.clear();
StopWatch::start();
for (int i = 0; i < M; i++) {
if (mp.count(s[i])) {
rng[i][1] = mp[s[i]];
continue;
}
if (i % 1000 == 0) {
// printf("end %d %d\n", i, StopWatch::msecs());
}
ll l = (N * (s[i] + 1) - (M - 1) * s[i]) / (ssm + 1);
while (l <= N) {
l++;
ll sm = (ssm - s[i]) * l - (s[i] + 1) * (N - l);
sm -= s[i] - (s[i] * l + s[i]) % (s[i] + 1);
int l2 = l % (s[i] + 1);
int now = s[i];
/* for (int j = 0; j < M; j++) {
if (i == j) continue;
sm += s[i] - (s[j]*l+s[i])%(s[i]+1);
if (0 < sm) {
break;
}
}*/
for (int j = 0; j < MS; j++) {
sm += (s[i] - now) * deg[j];
now += l2;
if (now >= s[i] + 1)
now -= s[i] + 1;
if (0 < sm)
break;
}
if (0 < sm)
break;
}
mp[s[i]] = rng[i][1] = l - 1;
}
return rng;
}
int main2() {
int N, M;
cin >> N >> M;
assert(M <= 30000);
vector<ll> s;
for (int i = 0; i < M; i++) {
int x;
cin >> x;
s.push_back(x);
}
int idx[M], ridx[M];
iota(idx, idx + M, 0);
sort(idx, idx + M, [&](const int &l, const int &r) { return s[l] < s[r]; });
for (int i = 0; i < M; i++) {
ridx[idx[i]] = i;
}
vector<ll> s2(M);
for (int i = 0; i < M; i++) {
s2[i] = s[idx[i]];
}
auto rng = solve(N, s2);
for (int i = 0; i < M; i++) {
if (rng[i][0] > rng[i][1]) {
printf("impossible\n");
return 0;
}
}
for (int i = 0; i < M; i++) {
printf("%lld %lld\n", rng[ridx[i]][0], rng[ridx[i]][1]);
}
return 0;
}
/*stack size???????????????*/
int main() {
static ll eord, enew;
const int sz = 32 * 1024 * 1024;
static unsigned char *p = (unsigned char *)malloc(sz);
enew = ((ll)(p + sz - 1) & ~0xff);
__asm__ volatile("mov %%rsp, %0" : "=r"(eord));
__asm__ volatile("mov %0, %%rsp" : : "r"(enew));
main2();
__asm__ volatile("mov %0, %%rsp" : : "r"(eord));
return 0;
} | replace | 108 | 109 | 108 | 109 | 0 | |
p01787 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define f first
#define s second
#define mp make_pair
using namespace std;
int main() {
vector<pair<char, long long>> A, B, C;
char c;
int a;
while (1) {
cin >> c;
if (c == '$')
break;
cin >> a;
A.push_back(mp(c, a));
}
while (1) {
cin >> c;
if (c == '$')
break;
cin >> a;
B.push_back(mp(c, a));
}
while (1) {
cin >> c;
if (c == '$')
break;
cin >> a;
C.push_back(mp(c, a));
}
int size = A.size() - B.size() + 1;
for (int i = 0; i < size; i++) {
bool flag = true;
for (int j = 0; j < B.size(); j++) {
if (j == 0 || j == B.size() - 1) {
if (A[i + j].f != B[j].f || A[i + j].s < B[j].s)
flag = false;
} else {
if (A[i + j].f != B[j].f || A[i + j].s != B[j].s)
flag = false;
}
}
if (flag) {
for (int j = 0; j < B.size(); j++)
A[i + j].s -= B[j].s;
if (B.size() == 1)
A.insert(A.begin() + i, C.begin(), C.end());
else
A.insert(A.begin() + i + 1, C.begin(), C.end());
size += C.size();
for (int j = 0; j < A.size(); j++) {
if (A[j].s == 0) {
A.erase(A.begin() + j);
j--;
size--;
}
}
for (int j = 1; j < A.size(); j++) {
if (A[j].f == A[j - 1].f) {
A[j - 1].s += A[j].s;
A.erase(A.begin() + j);
j--;
size--;
}
}
i--;
}
}
for (int j = 0; j < A.size(); j++)
cout << A[j].f << " " << A[j].s << " ";
cout << "$" << endl;
return 0;
} | #include <bits/stdc++.h>
#define f first
#define s second
#define mp make_pair
using namespace std;
int main() {
vector<pair<char, long long>> A, B, C;
char c;
int a;
while (1) {
cin >> c;
if (c == '$')
break;
cin >> a;
A.push_back(mp(c, a));
}
while (1) {
cin >> c;
if (c == '$')
break;
cin >> a;
B.push_back(mp(c, a));
}
while (1) {
cin >> c;
if (c == '$')
break;
cin >> a;
C.push_back(mp(c, a));
}
int size = A.size() - B.size() + 1;
for (int i = 0; i < size; i++) {
bool flag = true;
for (int j = 0; j < B.size(); j++) {
if (j == 0 || j == B.size() - 1) {
if (A[i + j].f != B[j].f || A[i + j].s < B[j].s)
flag = false;
} else {
if (A[i + j].f != B[j].f || A[i + j].s != B[j].s)
flag = false;
}
}
if (flag) {
for (int j = 0; j < B.size(); j++)
A[i + j].s -= B[j].s;
if (B.size() == 1)
A.insert(A.begin() + i, C.begin(), C.end());
else
A.insert(A.begin() + i + 1, C.begin(), C.end());
size += C.size();
for (int j = 0; j < A.size(); j++) {
if (A[j].s == 0) {
A.erase(A.begin() + j);
j--;
size--;
}
}
for (int j = 1; j < A.size(); j++) {
if (A[j].f == A[j - 1].f) {
A[j - 1].s += A[j].s;
A.erase(A.begin() + j);
j--;
size--;
}
}
break;
}
}
for (int j = 0; j < A.size(); j++)
cout << A[j].f << " " << A[j].s << " ";
cout << "$" << endl;
return 0;
} | replace | 70 | 71 | 70 | 71 | TLE | |
p01791 | C++ | Runtime Error | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
#define all(c) c.begin(), c.end()
#define pb push_back
#define fs first
#define sc second
#define show(x) cout << #x << " = " << x << endl
using namespace std;
template <class S, class T>
ostream &operator<<(ostream &o, const pair<S, T> &p) {
return o << "(" << p.fs << "," << p.sc << ")";
}
template <class T> ostream &operator<<(ostream &o, const vector<T> &vc) {
o << "sz = " << vc.size() << endl << "[";
for (const T &v : vc)
o << v << ",";
o << "]";
return o;
}
template <class S, class T> bool chmax(S &x, T y) {
if (x < y) {
x = y;
return 1;
}
return 0;
}
template <class S, class T> bool chmin(S &x, T y) {
if (x > y) {
x = y;
return 1;
}
return 0;
}
const int MAX_N = 600, MAX_S = 180000;
int N, K, A, B, a[MAX_N];
short inf = 1000;
short dp0[MAX_N + 1][MAX_S + 1], a0[MAX_N + 1][MAX_S + 1];
short dp1[MAX_N + 1][MAX_S + 1], a1[MAX_N + 1][MAX_S + 1];
int l[MAX_S + 1], r[MAX_S + 1];
bool can[MAX_S + 1];
bool sel[MAX_N];
int main() {
cin >> N >> K >> A >> B;
rep(i, N) cin >> a[i];
int S = accumulate(a, a + N, 0);
for (int j = K; j <= N; j++)
rep(s, S + 1) dp0[j][s] = dp1[j][s] = inf;
dp0[K][accumulate(a, a + K, 0)] = 0;
for (int j = K; j <= N; j++) {
rep(s, S + 1) {
if (dp1[j][s] == inf)
continue;
if (chmin(dp1[j + 1][s], dp1[j][s]))
a1[j + 1][s] = -1;
int l = dp1[j][s], r = K;
if (j > K)
chmin(r, dp1[j - 1][s]);
for (int i = l; i < r; i++)
if (chmin(dp0[j][s - a[i]], i + 1))
a0[j][s - a[i]] = i;
}
rep(s, S + 1) {
if (dp0[j][s] == inf)
continue;
if (chmin(dp0[j + 1][s], dp0[j][s]))
a0[j + 1][s] = -1;
if (chmin(dp1[j + 1][s + a[j]], dp0[j][s]))
a1[j + 1][s + a[j]] = -2;
}
}
rep(s, S + 1) can[s] = (dp0[N][s] != inf);
rep(i, MAX_S + 1) {
l[i] = 1e9;
if (can[i])
l[i] = 0;
if (i > 0)
chmin(l[i], l[i - 1] + 1);
}
rep(i, MAX_S + 1) {
r[MAX_S - i] = 1e9;
if (can[MAX_S - i])
r[MAX_S - i] = 0;
if (i > 0)
chmin(r[MAX_S - i], r[MAX_S - i + 1] + 1);
}
int ans = -1, x;
for (int i = A; i <= B; i++) {
if (chmax(ans, min(l[i], r[i])))
x = i;
}
cout << x << endl;
int s = x - ans;
if (s < 0 || !can[s])
s = x + ans;
// assert(can[s]);
rep(i, K) sel[i] = 1;
int t = 0, j = N;
while (!(t == 0 && j == K && s == accumulate(a, a + K, 0))) {
// printf("t,j,s=%d,%d,%d\n",t,j,s);
if (t == 0) {
short x = a0[j][s];
if (x == -1)
j--;
else {
// assert(x>=0);
s += a[x];
t = 1;
sel[x] = 0;
}
} else {
short x = a1[j][s];
if (x == -1)
j--;
else {
// assert(x==-2);
j--;
s -= a[j];
t = 0;
sel[j] = 1;
}
}
}
rep(i, N) if (sel[i]) cout << i + 1 << " ";
puts("");
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
#define all(c) c.begin(), c.end()
#define pb push_back
#define fs first
#define sc second
#define show(x) cout << #x << " = " << x << endl
using namespace std;
template <class S, class T>
ostream &operator<<(ostream &o, const pair<S, T> &p) {
return o << "(" << p.fs << "," << p.sc << ")";
}
template <class T> ostream &operator<<(ostream &o, const vector<T> &vc) {
o << "sz = " << vc.size() << endl << "[";
for (const T &v : vc)
o << v << ",";
o << "]";
return o;
}
template <class S, class T> bool chmax(S &x, T y) {
if (x < y) {
x = y;
return 1;
}
return 0;
}
template <class S, class T> bool chmin(S &x, T y) {
if (x > y) {
x = y;
return 1;
}
return 0;
}
const int MAX_N = 610, MAX_S = 181000;
int N, K, A, B, a[MAX_N];
short inf = 1000;
short dp0[MAX_N + 1][MAX_S + 1], a0[MAX_N + 1][MAX_S + 1];
short dp1[MAX_N + 1][MAX_S + 1], a1[MAX_N + 1][MAX_S + 1];
int l[MAX_S + 1], r[MAX_S + 1];
bool can[MAX_S + 1];
bool sel[MAX_N];
int main() {
cin >> N >> K >> A >> B;
rep(i, N) cin >> a[i];
int S = accumulate(a, a + N, 0);
for (int j = K; j <= N; j++)
rep(s, S + 1) dp0[j][s] = dp1[j][s] = inf;
dp0[K][accumulate(a, a + K, 0)] = 0;
for (int j = K; j <= N; j++) {
rep(s, S + 1) {
if (dp1[j][s] == inf)
continue;
if (chmin(dp1[j + 1][s], dp1[j][s]))
a1[j + 1][s] = -1;
int l = dp1[j][s], r = K;
if (j > K)
chmin(r, dp1[j - 1][s]);
for (int i = l; i < r; i++)
if (chmin(dp0[j][s - a[i]], i + 1))
a0[j][s - a[i]] = i;
}
rep(s, S + 1) {
if (dp0[j][s] == inf)
continue;
if (chmin(dp0[j + 1][s], dp0[j][s]))
a0[j + 1][s] = -1;
if (chmin(dp1[j + 1][s + a[j]], dp0[j][s]))
a1[j + 1][s + a[j]] = -2;
}
}
rep(s, S + 1) can[s] = (dp0[N][s] != inf);
rep(i, MAX_S + 1) {
l[i] = 1e9;
if (can[i])
l[i] = 0;
if (i > 0)
chmin(l[i], l[i - 1] + 1);
}
rep(i, MAX_S + 1) {
r[MAX_S - i] = 1e9;
if (can[MAX_S - i])
r[MAX_S - i] = 0;
if (i > 0)
chmin(r[MAX_S - i], r[MAX_S - i + 1] + 1);
}
int ans = -1, x;
for (int i = A; i <= B; i++) {
if (chmax(ans, min(l[i], r[i])))
x = i;
}
cout << x << endl;
int s = x - ans;
if (s < 0 || !can[s])
s = x + ans;
// assert(can[s]);
rep(i, K) sel[i] = 1;
int t = 0, j = N;
while (!(t == 0 && j == K && s == accumulate(a, a + K, 0))) {
// printf("t,j,s=%d,%d,%d\n",t,j,s);
if (t == 0) {
short x = a0[j][s];
if (x == -1)
j--;
else {
// assert(x>=0);
s += a[x];
t = 1;
sel[x] = 0;
}
} else {
short x = a1[j][s];
if (x == -1)
j--;
else {
// assert(x==-2);
j--;
s -= a[j];
t = 0;
sel[j] = 1;
}
}
}
rep(i, N) if (sel[i]) cout << i + 1 << " ";
puts("");
} | replace | 34 | 35 | 34 | 35 | -11 | |
p01794 | C++ | Runtime Error | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <queue>
#include <vector>
#define FOR(i, a, b) for (int i = (a); i < (int)(b); i++)
#define rep(i, a) FOR(i, 0, a)
#define all(a) (a).begin(), (a).end()
#define pb push_back
#define sz size()
#define MP make_pair
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pll;
typedef vector<ll> vll;
const static ll INF = 1e18;
struct edge {
ll from, to, cost, cap, rev;
edge(ll a, ll b, ll c, ll d, ll e)
: from(a), to(b), cost(c), cap(d), rev(e) {}
};
// Based on Dijkstra (using potential)
struct minFlow {
ll v;
vector<vector<edge>> graph;
vll d, use, h, pv, pe;
minFlow(ll n) : v(n) {
graph = vector<vector<edge>>(n);
pv.resize(v);
pe.resize(v);
}
void add(ll s, ll g, ll c, ll p) {
graph[s].pb(edge(s, g, c, p, graph[g].sz));
graph[g].pb(edge(g, s, -c, 0, graph[s].sz - 1));
}
void cal(ll s, ll t, vll &w, vll &b, vll &x) {
ll cost = 0, flow = 0;
x.pb(0);
h = vll(v, 0);
while (1) {
priority_queue<pll, vector<pll>, greater<pll>> q;
d = vll(v, INF);
d[s] = 0;
q.push(MP(0, s));
while (q.sz) {
pll p = q.top();
q.pop();
ll u = p.second;
if (d[u] < p.first)
continue;
rep(i, graph[u].sz) {
edge &e = graph[u][i];
if (e.cap > 0 && d[e.to] > d[u] + e.cost + h[u] - h[e.to]) {
d[e.to] = d[u] + e.cost + h[u] - h[e.to];
pv[e.to] = u;
pe[e.to] = i;
q.push(MP(d[e.to], e.to));
}
}
}
if (d[t] == INF)
return;
rep(u, v) h[u] += d[u];
ll f = INF;
for (int u = t; u != s; u = pv[u])
f = min(f, graph[pv[u]][pe[u]].cap);
flow += f;
w.pb(h[t]);
b.pb(cost);
x.pb(flow);
cost += f * h[t];
for (int u = t; u != s; u = pv[u]) {
edge &e = graph[pv[u]][pe[u]];
e.cap -= f;
graph[u][e.rev].cap += f;
}
}
}
};
bool Less(ll u1, ll d1, ll u2, ll d2) {
// u1/d1 < u2/d2
ll p1 = u1 / d1, q1 = u1 % d1, p2 = u2 / d2, q2 = u2 % d2;
if (p1 != p2)
return p1 < p2;
return q1 * d2 < q2 * d1;
}
int main() {
ll n, m, s, t;
scanf("%lld %lld %lld %lld", &n, &m, &s, &t);
s--;
t--;
minFlow mf(n);
rep(i, m) {
ll a, b, u, c;
scanf("%lld %lld %lld %lld", &a, &b, &u, &c);
a--;
b--;
mf.add(a, b, c, u);
}
vector<ll> a, b, x;
mf.cal(s, t, a, b, x);
ll M = x.back();
ll ansu = INF, ansd = 1;
rep(i, b.size()) {
ll b1 = b[i], f1 = M - x[i];
ansu = min(ansu, b1 * b1 + f1 * f1);
ll b2 = b[i] + a[i] * (x[i + 1] - x[i]), f2 = M - x[i + 1];
ansu = min(ansu, b2 * b2 + f2 * f2);
cerr << b2 * b2 + f2 * f2 << endl;
}
rep(i, b.size()) {
ll xu = M - a[i] * b[i] + a[i] * a[i] * x[i], xd = a[i] * a[i] + 1;
if (Less(xu, xd, x[i], 1) || Less(x[i + 1], 1, xu, xd))
continue;
ll tmpu = (a[i] * M + b[i] - a[i] * x[i]) * (a[i] * M + b[i] - a[i] * x[i]),
tmpd = xd;
if (Less(tmpu, tmpd, ansu, ansd)) {
ansu = tmpu;
ansd = tmpd;
}
}
if (a.empty()) {
ansu = 0;
ansd = 1;
}
ll gcd = __gcd(ansu, ansd);
printf("%lld/%lld\n", ansu / gcd, ansd / gcd);
} | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <queue>
#include <vector>
#define FOR(i, a, b) for (int i = (a); i < (int)(b); i++)
#define rep(i, a) FOR(i, 0, a)
#define all(a) (a).begin(), (a).end()
#define pb push_back
#define sz size()
#define MP make_pair
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pll;
typedef vector<ll> vll;
const static ll INF = 1e18;
struct edge {
ll from, to, cost, cap, rev;
edge(ll a, ll b, ll c, ll d, ll e)
: from(a), to(b), cost(c), cap(d), rev(e) {}
};
// Based on Dijkstra (using potential)
struct minFlow {
ll v;
vector<vector<edge>> graph;
vll d, use, h, pv, pe;
minFlow(ll n) : v(n) {
graph = vector<vector<edge>>(n);
pv.resize(v);
pe.resize(v);
}
void add(ll s, ll g, ll c, ll p) {
graph[s].pb(edge(s, g, c, p, graph[g].sz));
graph[g].pb(edge(g, s, -c, 0, graph[s].sz - 1));
}
void cal(ll s, ll t, vll &w, vll &b, vll &x) {
ll cost = 0, flow = 0;
x.pb(0);
h = vll(v, 0);
while (1) {
priority_queue<pll, vector<pll>, greater<pll>> q;
d = vll(v, INF);
d[s] = 0;
q.push(MP(0, s));
while (q.sz) {
pll p = q.top();
q.pop();
ll u = p.second;
if (d[u] < p.first)
continue;
rep(i, graph[u].sz) {
edge &e = graph[u][i];
if (e.cap > 0 && d[e.to] > d[u] + e.cost + h[u] - h[e.to]) {
d[e.to] = d[u] + e.cost + h[u] - h[e.to];
pv[e.to] = u;
pe[e.to] = i;
q.push(MP(d[e.to], e.to));
}
}
}
if (d[t] == INF)
return;
rep(u, v) h[u] += d[u];
ll f = INF;
for (int u = t; u != s; u = pv[u])
f = min(f, graph[pv[u]][pe[u]].cap);
flow += f;
w.pb(h[t]);
b.pb(cost);
x.pb(flow);
cost += f * h[t];
for (int u = t; u != s; u = pv[u]) {
edge &e = graph[pv[u]][pe[u]];
e.cap -= f;
graph[u][e.rev].cap += f;
}
}
}
};
bool Less(ll u1, ll d1, ll u2, ll d2) {
// u1/d1 < u2/d2
ll p1 = u1 / d1, q1 = u1 % d1, p2 = u2 / d2, q2 = u2 % d2;
if (p1 != p2)
return p1 < p2;
return q1 * d2 < q2 * d1;
}
int main() {
ll n, m, s, t;
scanf("%lld %lld %lld %lld", &n, &m, &s, &t);
s--;
t--;
minFlow mf(n);
rep(i, m) {
ll a, b, u, c;
scanf("%lld %lld %lld %lld", &a, &b, &u, &c);
a--;
b--;
mf.add(a, b, c, u);
}
vector<ll> a, b, x;
mf.cal(s, t, a, b, x);
ll M = x.back();
ll ansu = INF, ansd = 1;
rep(i, b.size()) {
ll b1 = b[i], f1 = M - x[i];
ansu = min(ansu, b1 * b1 + f1 * f1);
ll b2 = b[i] + a[i] * (x[i + 1] - x[i]), f2 = M - x[i + 1];
ansu = min(ansu, b2 * b2 + f2 * f2);
}
rep(i, b.size()) {
ll xu = M - a[i] * b[i] + a[i] * a[i] * x[i], xd = a[i] * a[i] + 1;
if (Less(xu, xd, x[i], 1) || Less(x[i + 1], 1, xu, xd))
continue;
ll tmpu = (a[i] * M + b[i] - a[i] * x[i]) * (a[i] * M + b[i] - a[i] * x[i]),
tmpd = xd;
if (Less(tmpu, tmpd, ansu, ansd)) {
ansu = tmpu;
ansd = tmpd;
}
}
if (a.empty()) {
ansu = 0;
ansd = 1;
}
ll gcd = __gcd(ansu, ansd);
printf("%lld/%lld\n", ansu / gcd, ansd / gcd);
} | delete | 123 | 124 | 123 | 123 | 0 | 1 |
p01806 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
struct Dice {
int x, y;
int l, r, f, b, d, u;
void RollF() {
--y;
int buff = d;
d = f;
f = u;
u = b;
b = buff;
}
void RollB() {
++y;
int buff = d;
d = b;
b = u;
u = f;
f = buff;
}
void RollL() {
--x;
int buff = d;
d = l;
l = u;
u = r;
r = buff;
}
void RollR() {
++x;
int buff = d;
d = r;
r = u;
u = l;
l = buff;
}
};
int N;
Dice dice[15];
string rot[15];
int dp[1 << 15];
int v[2100][2100], buff[2100][2100];
void Roll(Dice &obj, char c) {
switch (c) {
case 'L':
obj.RollL();
return;
case 'R':
obj.RollR();
return;
case 'B':
obj.RollB();
return;
case 'F':
obj.RollF();
return;
default:
return;
}
}
int AddDice(int idx) {
int ret = 0;
Dice obj = dice[idx];
for (char c : rot[idx]) {
Roll(obj, c);
if (v[obj.y][obj.x] == -1) {
v[obj.y][obj.x] = idx;
buff[obj.y][obj.x] = obj.d;
ret += obj.d;
} else if (v[obj.y][obj.x] == idx) {
ret -= buff[obj.y][obj.x];
ret += obj.d;
buff[obj.y][obj.x] = obj.d;
}
}
return (ret);
}
void DeleteDice(int idx) {
Dice obj = dice[idx];
for (char c : rot[idx]) {
Roll(obj, c);
if (v[obj.y][obj.x] == idx) {
v[obj.y][obj.x] = -1;
}
}
}
int rec(int bit) {
if (bit == (1 << N) - 1)
return (0);
if (~dp[bit])
return (dp[bit]);
int ret = 0;
for (int i = 0; i < N; i++) {
if ((bit >> i) & 1)
continue;
int get = AddDice(i);
ret = max(ret, rec(bit | (1 << i)) + get);
DeleteDice(i);
}
return (ret);
}
int main() {
memset(v, -1, sizeof(v));
while (cin >> N, N) {
for (int i = 0; i < N; ++i) {
cin >> dice[i].x >> dice[i].y;
cin >> dice[i].l >> dice[i].r >> dice[i].f >> dice[i].b >> dice[i].d >>
dice[i].u;
cin >> rot[i];
rot[i] = "~" + rot[i];
dice[i].x += 1050, dice[i].y += 1050;
}
memset(dp, -1, sizeof(dp));
cout << rec(0) << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
struct Dice {
int x, y;
int l, r, f, b, d, u;
void RollF() {
--y;
int buff = d;
d = f;
f = u;
u = b;
b = buff;
}
void RollB() {
++y;
int buff = d;
d = b;
b = u;
u = f;
f = buff;
}
void RollL() {
--x;
int buff = d;
d = l;
l = u;
u = r;
r = buff;
}
void RollR() {
++x;
int buff = d;
d = r;
r = u;
u = l;
l = buff;
}
};
int N;
Dice dice[15];
string rot[15];
int dp[1 << 15];
int v[2100][2100], buff[2100][2100];
void Roll(Dice &obj, char c) {
switch (c) {
case 'L':
obj.RollL();
return;
case 'R':
obj.RollR();
return;
case 'B':
obj.RollB();
return;
case 'F':
obj.RollF();
return;
default:
return;
}
}
int AddDice(int idx) {
int ret = 0;
Dice obj = dice[idx];
for (char c : rot[idx]) {
Roll(obj, c);
if (v[obj.y][obj.x] == -1) {
v[obj.y][obj.x] = idx;
buff[obj.y][obj.x] = obj.d;
ret += obj.d;
} else if (v[obj.y][obj.x] == idx) {
ret -= buff[obj.y][obj.x];
ret += obj.d;
buff[obj.y][obj.x] = obj.d;
}
}
return (ret);
}
void DeleteDice(int idx) {
Dice obj = dice[idx];
for (char c : rot[idx]) {
Roll(obj, c);
if (v[obj.y][obj.x] == idx) {
v[obj.y][obj.x] = -1;
}
}
}
int rec(int bit) {
if (bit == (1 << N) - 1)
return (0);
if (~dp[bit])
return (dp[bit]);
int ret = 0;
for (int i = 0; i < N; i++) {
if ((bit >> i) & 1)
continue;
int get = AddDice(i);
ret = max(ret, rec(bit | (1 << i)) + get);
DeleteDice(i);
}
return (dp[bit] = ret);
}
int main() {
memset(v, -1, sizeof(v));
while (cin >> N, N) {
for (int i = 0; i < N; ++i) {
cin >> dice[i].x >> dice[i].y;
cin >> dice[i].l >> dice[i].r >> dice[i].f >> dice[i].b >> dice[i].d >>
dice[i].u;
cin >> rot[i];
rot[i] = "~" + rot[i];
dice[i].x += 1050, dice[i].y += 1050;
}
memset(dp, -1, sizeof(dp));
cout << rec(0) << endl;
}
} | replace | 111 | 112 | 111 | 112 | TLE | |
p01806 | C++ | Memory Limit Exceeded | #include <algorithm>
#include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
short p[4][6] = {{5, 4, 2, 3, 0, 1},
{4, 5, 2, 3, 1, 0},
{0, 1, 5, 4, 2, 3},
{0, 1, 4, 5, 3, 2}};
short n, C[20][6], cx[20], cy[20];
string px[20];
map<pair<short, short>, short> D[20], E[1 << 16];
vector<tuple<short, short, short>> _D[20];
vector<pair<short, short>> _E[1 << 15];
short dx[4] = {-1, 1, 0, 0}, dy[4] = {0, 0, -1, 1}, dp[1 << 15];
void Init1(int I) {
vector<tuple<short, short, short, short>> __D;
__D.push_back(make_tuple(cx[I], cy[I], -1, C[I][4]));
D[I][make_pair(cx[I], cy[I])] = C[I][4];
for (int j = 0; j < px[I].size(); j++) {
int A = 3, F[6] = {0, 0, 0, 0, 0, 0};
if (px[I][j] == 'L')
A = 0;
if (px[I][j] == 'R')
A = 1;
if (px[I][j] == 'F')
A = 2;
if (px[I][j] == 'B')
A = 3;
for (int k = 0; k < 6; k++)
F[k] = C[I][p[A][k]];
for (int k = 0; k < 6; k++)
C[I][k] = F[k];
cx[I] += dx[A];
cy[I] += dy[A];
__D.push_back(make_tuple(cx[I], cy[I], j, C[I][4]));
D[I][make_pair(cx[I], cy[I])] = C[I][4];
}
sort(__D.begin(), __D.end());
for (int i = 0; i < __D.size(); i++) {
if (i == __D.size() - 1)
_D[I].push_back(
make_tuple(get<0>(__D[i]), get<1>(__D[i]), get<3>(__D[i])));
else if (get<0>(__D[i]) != get<0>(__D[i + 1]) ||
get<1>(__D[i]) != get<1>(__D[i + 1])) {
_D[I].push_back(
make_tuple(get<0>(__D[i]), get<1>(__D[i]), get<3>(__D[i])));
}
}
return;
}
void Init2(int p) {
for (int j = 0; j < n; j++) {
if ((p / (1 << j)) % 2 == 0)
continue;
for (int k = 0; k < _D[j].size(); k++) {
pair<short, short> pa = make_pair(get<0>(_D[j][k]), get<1>(_D[j][k]));
if (E[p][pa] == 0) {
_E[p].push_back(pa);
}
E[p][pa] = 1;
}
}
sort(_E[p].begin(), _E[p].end());
}
int main() {
while (true) {
for (int i = 0; i < 15; i++) {
D[i].clear();
_D[i].clear();
}
for (int i = 0; i < 32768; i++) {
E[i].clear();
_E[i].clear();
}
for (int i = 0; i < 32768; i++)
dp[i] = -1;
cin >> n;
if (n == 0)
break;
for (int i = 0; i < n; i++) {
cin >> cx[i] >> cy[i];
for (int j = 0; j < 6; j++)
cin >> C[i][j];
cin >> px[i];
Init1(i);
}
for (int i = 0; i < (1 << n); i++)
Init2(i);
dp[0] = 0;
for (int i = 0; i < (1 << n); i++) {
for (int j = 0; j < n; j++) {
if ((i / (1 << j)) % 2 == 1)
continue;
short cnt = 0;
for (int k = 0; k < _D[j].size(); k++) {
pair<short, short> pa = make_pair(get<0>(_D[j][k]), get<1>(_D[j][k]));
int pos1 =
lower_bound(_E[i].begin(), _E[i].end(), pa) - _E[i].begin();
if (_E[i].size() == pos1 || _E[i][pos1] != pa)
cnt += get<2>(_D[j][k]);
}
dp[i + (1 << j)] = max(dp[i + (1 << j)], (short)(dp[i] + cnt));
}
}
cout << dp[(1 << n) - 1] << endl;
}
return 0;
} | #include <algorithm>
#include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
short p[4][6] = {{5, 4, 2, 3, 0, 1},
{4, 5, 2, 3, 1, 0},
{0, 1, 5, 4, 2, 3},
{0, 1, 4, 5, 3, 2}};
short n, C[20][6], cx[20], cy[20];
string px[20];
map<pair<short, short>, short> D[20], E[1 << 16];
vector<tuple<short, short, short>> _D[20];
vector<pair<short, short>> _E[1 << 15];
short dx[4] = {-1, 1, 0, 0}, dy[4] = {0, 0, -1, 1}, dp[1 << 15];
void Init1(int I) {
vector<tuple<short, short, short, short>> __D;
__D.push_back(make_tuple(cx[I], cy[I], -1, C[I][4]));
D[I][make_pair(cx[I], cy[I])] = C[I][4];
for (int j = 0; j < px[I].size(); j++) {
int A = 3, F[6] = {0, 0, 0, 0, 0, 0};
if (px[I][j] == 'L')
A = 0;
if (px[I][j] == 'R')
A = 1;
if (px[I][j] == 'F')
A = 2;
if (px[I][j] == 'B')
A = 3;
for (int k = 0; k < 6; k++)
F[k] = C[I][p[A][k]];
for (int k = 0; k < 6; k++)
C[I][k] = F[k];
cx[I] += dx[A];
cy[I] += dy[A];
__D.push_back(make_tuple(cx[I], cy[I], j, C[I][4]));
D[I][make_pair(cx[I], cy[I])] = C[I][4];
}
sort(__D.begin(), __D.end());
for (int i = 0; i < __D.size(); i++) {
if (i == __D.size() - 1)
_D[I].push_back(
make_tuple(get<0>(__D[i]), get<1>(__D[i]), get<3>(__D[i])));
else if (get<0>(__D[i]) != get<0>(__D[i + 1]) ||
get<1>(__D[i]) != get<1>(__D[i + 1])) {
_D[I].push_back(
make_tuple(get<0>(__D[i]), get<1>(__D[i]), get<3>(__D[i])));
}
}
return;
}
void Init2(int p) {
for (int j = 0; j < n; j++) {
if ((p / (1 << j)) % 2 == 0)
continue;
for (int k = 0; k < _D[j].size(); k++) {
pair<short, short> pa = make_pair(get<0>(_D[j][k]), get<1>(_D[j][k]));
if (E[p][pa] == 0) {
_E[p].push_back(pa);
}
E[p][pa] = 1;
}
}
E[p].clear();
sort(_E[p].begin(), _E[p].end());
}
int main() {
while (true) {
for (int i = 0; i < 15; i++) {
D[i].clear();
_D[i].clear();
}
for (int i = 0; i < 32768; i++) {
E[i].clear();
_E[i].clear();
}
for (int i = 0; i < 32768; i++)
dp[i] = -1;
cin >> n;
if (n == 0)
break;
for (int i = 0; i < n; i++) {
cin >> cx[i] >> cy[i];
for (int j = 0; j < 6; j++)
cin >> C[i][j];
cin >> px[i];
Init1(i);
}
for (int i = 0; i < (1 << n); i++)
Init2(i);
dp[0] = 0;
for (int i = 0; i < (1 << n); i++) {
for (int j = 0; j < n; j++) {
if ((i / (1 << j)) % 2 == 1)
continue;
short cnt = 0;
for (int k = 0; k < _D[j].size(); k++) {
pair<short, short> pa = make_pair(get<0>(_D[j][k]), get<1>(_D[j][k]));
int pos1 =
lower_bound(_E[i].begin(), _E[i].end(), pa) - _E[i].begin();
if (_E[i].size() == pos1 || _E[i][pos1] != pa)
cnt += get<2>(_D[j][k]);
}
dp[i + (1 << j)] = max(dp[i + (1 << j)], (short)(dp[i] + cnt));
}
}
cout << dp[(1 << n) - 1] << endl;
}
return 0;
} | insert | 64 | 64 | 64 | 65 | MLE | |
p01806 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
enum { U, B, L, F, R, D };
struct Dice {
int face[6];
Dice() {
face[F] = 1;
face[R] = 2;
face[U] = 3;
face[B] = 6;
face[L] = 5;
face[D] = 4;
}
int find_face(int f) {
for (int i = 0; i < 6; i++) {
if (face[i] == f)
return i;
}
return -1;
}
void turn(int dir) {
switch (dir) {
case R:
rotate(U, R, D, L);
break;
case B:
rotate(U, B, D, F);
break;
case L:
rotate(U, L, D, R);
break;
case F:
rotate(U, F, D, B);
break;
case U:
rotate(F, R, B, L);
break; // ??????????????????????¨???????
case D:
rotate(F, L, B, R);
break; // ??????????????????????¨???????
default:
assert(false);
}
}
int &operator[](int n) { return face[n]; }
const int &operator[](int n) const { return face[n]; }
std::vector<Dice> all_rolls() {
std::vector<Dice> res;
for (int k = 0; k < 6; k++) {
for (int i = 0; i < 4; i++) {
res.push_back(*this);
turn(R);
}
turn(k % 2 == 1 ? U : F);
}
return res;
}
void rotate(int a, int b, int c, int d) {
int t = face[d];
face[d] = face[c];
face[c] = face[b];
face[b] = face[a];
face[a] = t;
}
};
typedef pair<int, int> P;
Dice dice[15];
int X[15], Y[15];
string rot[15];
map<P, int> pos[15];
int dp[16][1 << 15];
set<P> used[1 << 15];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
while (cin >> N, N) {
for (int i = 0; i < N; i++) {
int l, r, f, b, d, u;
cin >> X[i] >> Y[i];
cin >> l >> r >> f >> b >> d >> u;
cin >> rot[i];
dice[i][L] = l;
dice[i][R] = r;
dice[i][F] = f;
dice[i][B] = b;
dice[i][D] = d;
dice[i][U] = u;
Dice t = dice[i];
int x = X[i], y = Y[i];
pos[i].clear();
pos[i][{x, y}] = t[D];
for (auto c : rot[i]) {
if (c == 'L')
t.turn(L), x--;
if (c == 'R')
t.turn(R), x++;
if (c == 'F')
t.turn(F), y--;
if (c == 'B')
t.turn(B), y++;
pos[i][{x, y}] = t[D];
}
}
for (int i = 0; i < 1 << N; i++) {
used[i].clear();
for (int j = 0; j < N; j++) {
if (i >> j & 1) {
for (auto p : pos[j]) {
int x = p.first.first, y = p.first.second;
used[i].insert({x, y});
}
}
}
}
memset(dp, -1, sizeof dp);
dp[0][0] = 0;
for (int i = 0; i < N; i++) {
for (int j = 0; j < 1 << N; j++) {
if (dp[i][j] == -1)
continue;
int s = dp[i][j];
for (int k = 0; k < N; k++) {
int ns = s;
for (auto p : pos[k]) {
int x = p.first.first, y = p.first.second;
int point = p.second;
if (used[j].count({x, y}))
continue;
ns += point;
}
dp[i + 1][j | (1 << k)] = max(dp[i + 1][j | (1 << k)], ns);
}
}
}
int ans = 0;
for (int j = 0; j < 1 << N; j++) {
ans = max(ans, dp[N][j]);
}
cout << ans << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
enum { U, B, L, F, R, D };
struct Dice {
int face[6];
Dice() {
face[F] = 1;
face[R] = 2;
face[U] = 3;
face[B] = 6;
face[L] = 5;
face[D] = 4;
}
int find_face(int f) {
for (int i = 0; i < 6; i++) {
if (face[i] == f)
return i;
}
return -1;
}
void turn(int dir) {
switch (dir) {
case R:
rotate(U, R, D, L);
break;
case B:
rotate(U, B, D, F);
break;
case L:
rotate(U, L, D, R);
break;
case F:
rotate(U, F, D, B);
break;
case U:
rotate(F, R, B, L);
break; // ??????????????????????¨???????
case D:
rotate(F, L, B, R);
break; // ??????????????????????¨???????
default:
assert(false);
}
}
int &operator[](int n) { return face[n]; }
const int &operator[](int n) const { return face[n]; }
std::vector<Dice> all_rolls() {
std::vector<Dice> res;
for (int k = 0; k < 6; k++) {
for (int i = 0; i < 4; i++) {
res.push_back(*this);
turn(R);
}
turn(k % 2 == 1 ? U : F);
}
return res;
}
void rotate(int a, int b, int c, int d) {
int t = face[d];
face[d] = face[c];
face[c] = face[b];
face[b] = face[a];
face[a] = t;
}
};
typedef pair<int, int> P;
Dice dice[15];
int X[15], Y[15];
string rot[15];
map<P, int> pos[15];
int dp[16][1 << 15];
set<P> used[1 << 15];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
while (cin >> N, N) {
for (int i = 0; i < N; i++) {
int l, r, f, b, d, u;
cin >> X[i] >> Y[i];
cin >> l >> r >> f >> b >> d >> u;
cin >> rot[i];
dice[i][L] = l;
dice[i][R] = r;
dice[i][F] = f;
dice[i][B] = b;
dice[i][D] = d;
dice[i][U] = u;
Dice t = dice[i];
int x = X[i], y = Y[i];
pos[i].clear();
pos[i][{x, y}] = t[D];
for (auto c : rot[i]) {
if (c == 'L')
t.turn(L), x--;
if (c == 'R')
t.turn(R), x++;
if (c == 'F')
t.turn(F), y--;
if (c == 'B')
t.turn(B), y++;
pos[i][{x, y}] = t[D];
}
}
for (int i = 0; i < 1 << N; i++) {
used[i].clear();
for (int j = 0; j < N; j++) {
if (i >> j & 1) {
for (auto p : pos[j]) {
int x = p.first.first, y = p.first.second;
used[i].insert({x, y});
}
}
}
}
memset(dp, -1, sizeof dp);
dp[0][0] = 0;
for (int i = 0; i < N; i++) {
for (int j = 0; j < 1 << N; j++) {
if (dp[i][j] == -1)
continue;
int s = dp[i][j];
for (int k = 0; k < N; k++) {
if (j >> k & 1)
continue;
int ns = s;
for (auto p : pos[k]) {
int x = p.first.first, y = p.first.second;
int point = p.second;
if (used[j].count({x, y}))
continue;
ns += point;
}
dp[i + 1][j | (1 << k)] = max(dp[i + 1][j | (1 << k)], ns);
}
}
}
int ans = 0;
for (int j = 0; j < 1 << N; j++) {
ans = max(ans, dp[N][j]);
}
cout << ans << endl;
}
} | insert | 139 | 139 | 139 | 141 | TLE | |
p01809 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int main() {
int p, q;
cin >> p >> q;
p = gcd(p, q);
q /= p;
set<int> s;
for (int i = 2; i <= q;) {
if (q % i == 0) {
q /= i;
s.insert(i);
} else {
i++;
}
}
int r = 1;
for (auto it = begin(s); it != end(s); it++) {
r *= *it;
}
cout << r << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int main() {
int p, q;
cin >> p >> q;
p = gcd(p, q);
q /= p;
set<int> s;
for (int i = 2; i <= q;) {
if (i * i > q) {
i = q;
}
if (q % i == 0) {
q /= i;
s.insert(i);
} else {
i++;
}
}
int r = 1;
for (auto it = begin(s); it != end(s); it++) {
r *= *it;
}
cout << r << endl;
return 0;
} | insert | 12 | 12 | 12 | 15 | TLE | |
p01809 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define INF 1001000100010001000
#define MOD 1000000007
#define EPS 1e-10
#define int long long
#define rep(i, N) for (int i = 0; i < N; i++)
#define Rep(i, N) for (int i = 1; i < N; i++)
#define For(i, a, b) for (int i = (a); i < (b); i++)
#define pb push_back
#define mp make_pair
#define i_i pair<int, int>
#define vi vector<int>
#define vvi vector<vi>
#define vb vector<bool>
#define vvb vector<vb>
#define vp vector<i_i>
#define all(a) (a).begin(), (a).end()
#define Int(x) \
int x; \
scanf("%lld", &x);
// int dxy[5] = {0, 1, 0, -1, 0};
// assign
int gcd(int a, int b);
signed main() {
Int(p);
Int(q);
while (p && q) {
int base = gcd(p, q);
q /= base;
for (int i = 2; i * i <= q; i++) {
if (!(q % i)) {
int ret = q / i;
while (!(ret % i)) {
q /= i;
ret /= i;
}
}
}
cout << q << endl;
cin >> p >> q;
}
return 0;
}
int gcd(int a, int b) {
if (!b) {
return a;
} else {
gcd(b, a % b);
}
} | #include <bits/stdc++.h>
using namespace std;
#define INF 1001000100010001000
#define MOD 1000000007
#define EPS 1e-10
#define int long long
#define rep(i, N) for (int i = 0; i < N; i++)
#define Rep(i, N) for (int i = 1; i < N; i++)
#define For(i, a, b) for (int i = (a); i < (b); i++)
#define pb push_back
#define mp make_pair
#define i_i pair<int, int>
#define vi vector<int>
#define vvi vector<vi>
#define vb vector<bool>
#define vvb vector<vb>
#define vp vector<i_i>
#define all(a) (a).begin(), (a).end()
#define Int(x) \
int x; \
scanf("%lld", &x);
// int dxy[5] = {0, 1, 0, -1, 0};
// assign
int gcd(int a, int b);
signed main() {
Int(p);
Int(q);
while (p && q) {
int base = gcd(p, q);
q /= base;
for (int i = 2; i * i <= q; i++) {
if (!(q % i)) {
int ret = q / i;
while (!(ret % i)) {
q /= i;
ret /= i;
}
}
}
cout << q << endl;
p = 0;
q = 0;
}
return 0;
}
int gcd(int a, int b) {
if (!b) {
return a;
} else {
gcd(b, a % b);
}
} | replace | 46 | 47 | 46 | 48 | TLE | |
p01810 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define CH(N, A, B) (A <= N && N < B)
#define REP(i, a, b) for (int i = a; i < b; i++)
#define RREP(i, a, b) for (int i = (b - 1); a <= i; i--)
#define F first
#define S second
#define ll long long;
const int INF = 1e9;
const long long LLINF = 1e15;
using namespace std;
long long N, k, a[5] = {0, 0, 1, 2, 1};
int main() {
cin >> N >> k;
long long num = 0;
REP(i, 0, N - 1) {
while (a[0] * k - a[1] > num || num > a[2] * k - a[3]) {
REP(j, 0, 5) a[j]++;
}
num += a[4];
}
cout << num << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define CH(N, A, B) (A <= N && N < B)
#define REP(i, a, b) for (int i = a; i < b; i++)
#define RREP(i, a, b) for (int i = (b - 1); a <= i; i--)
#define F first
#define S second
#define ll long long;
const int INF = 1e9;
const long long LLINF = 1e15;
using namespace std;
long long N, k, a[5] = {0, 0, 1, 2, 1};
int main() {
cin >> N >> k;
long long num = 0;
REP(i, 0, N - 1) {
if (a[0] * k - a[1] > num || num > a[2] * k - a[3]) {
long long inc = (k * a[0] - a[1] - num) / (1 - k);
REP(j, 0, 5) a[j] += inc;
}
num += a[4];
}
cout << num << endl;
return 0;
} | replace | 30 | 32 | 30 | 33 | TLE | |
p01811 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define REP(i, n, N) for (int i = n; i < N; i++)
#define p(S) cout << (S) << endl
#define ck(a, b) (0 <= (a) && (a) < b)
using namespace std;
string abcgene(string anss) {
queue<string> q;
q.push(anss);
string c[3] = {"A", "B", "C"};
map<string, bool> m;
m[anss] = true;
while (!q.empty()) {
string s = q.front();
q.pop();
if (s == "ABC")
return "Yes";
REP(j, 0, 3) {
string tmps = s;
int cnt = 0;
REP(i, 0, (int)tmps.size() - 2) {
if (tmps.substr(i, 3) == "ABC") {
tmps.replace(i, 3, c[j]);
cnt++;
}
}
if (tmps[tmps.size() - 1] != 'C' || tmps[tmps.size() - 2] == 'A')
continue;
if (!m[tmps]) {
m[tmps] = true;
q.push(tmps);
}
}
}
return "No";
}
int main() {
string ans;
cin >> ans;
p(abcgene(ans));
return 0;
} | #include <bits/stdc++.h>
#define REP(i, n, N) for (int i = n; i < N; i++)
#define p(S) cout << (S) << endl
#define ck(a, b) (0 <= (a) && (a) < b)
using namespace std;
string abcgene(string anss) {
queue<string> q;
q.push(anss);
string c[3] = {"A", "B", "C"};
map<string, bool> m;
m[anss] = true;
while (!q.empty()) {
string s = q.front();
q.pop();
if (s == "ABC")
return "Yes";
REP(j, 0, 3) {
string tmps = s;
int cnt = 0;
REP(i, 0, (int)tmps.size() - 2) {
if (tmps.substr(i, 3) == "ABC") {
tmps.replace(i, 3, c[j]);
cnt++;
}
}
if (cnt != count(tmps.begin(), tmps.end(), 'A' + j))
continue;
if (!m[tmps]) {
m[tmps] = true;
q.push(tmps);
}
}
}
return "No";
}
int main() {
string ans;
cin >> ans;
p(abcgene(ans));
return 0;
} | replace | 26 | 27 | 26 | 27 | TLE | |
p01811 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <string>
using namespace std;
string s;
int cnt[3];
bool ok(string s, int a, int b, int c) {
if (s == "ABC")
return true;
string nxt;
char to;
int abc;
if (a < b && a < c)
to = 'A', abc = a, b -= a, c -= a;
else if (b < a && b < c)
to = 'B', abc = b, a -= b, c -= b;
else if (c < a && c < b)
to = 'C', abc = c, a -= c, b -= c;
else
return false;
int p = 0;
while (p < s.size()) {
if (p + 2 < s.size() && s[p] == 'A' && s[p + 1] == 'B' && s[p + 2] == 'C') {
nxt += to;
p += 3;
abc--;
} else {
nxt += s[p];
p++;
}
}
if (abc != 0)
return false;
return ok(nxt, a, b, c);
}
int main() {
cin >> s;
for (int i = 0; i < s.size(); i++) {
cnt[s[i] - 'A']++;
}
if (ok(s, cnt[0], cnt[1], cnt[2]))
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <string>
using namespace std;
string s;
int cnt[3];
bool ok(string s, int a, int b, int c) {
if (s == "ABC")
return true;
string nxt;
char to;
int abc;
if (a < b && a < c)
to = 'A', abc = a, b -= a, c -= a;
else if (b < a && b < c)
to = 'B', abc = b, a -= b, c -= b;
else if (c < a && c < b)
to = 'C', abc = c, a -= c, b -= c;
else
return false;
if (abc == 0)
return false;
int p = 0;
while (p < s.size()) {
if (p + 2 < s.size() && s[p] == 'A' && s[p + 1] == 'B' && s[p + 2] == 'C') {
nxt += to;
p += 3;
abc--;
} else {
nxt += s[p];
p++;
}
}
if (abc != 0)
return false;
return ok(nxt, a, b, c);
}
int main() {
cin >> s;
for (int i = 0; i < s.size(); i++) {
cnt[s[i] - 'A']++;
}
if (ok(s, cnt[0], cnt[1], cnt[2]))
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
| insert | 20 | 20 | 20 | 22 | 0 | |
p01811 | C++ | Memory Limit Exceeded | #include <algorithm>
#include <bits/stdc++.h>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <string>
#include <vector>
// #include <boost/multiprecision/cpp_int.hpp>
#include <functional>
#define int long long
#define inf 1000000007
#define pa pair<int, int>
#define ll long long
#define pal pair<double, pa>
#define ppa pair<pa, int>
#define ppap pair<int, pa>
#define ssa pair<string, int>
#define mp make_pair
#define pb push_back
#define EPS (1e-10)
#define equals(a, b) (fabs((a) - (b)) < EPS)
using namespace std;
// priority_queue<int, vector<int>, greater<int> > que;
class Point {
public:
double x, y;
Point(double x = 0, double y = 0) : x(x), y(y) {}
Point operator+(Point p) { return Point(x + p.x, y + p.y); }
Point operator-(Point p) { return Point(x - p.x, y - p.y); }
Point operator*(double a) { return Point(x * a, y * a); }
Point operator/(double a) { return Point(x / a, y / a); }
double absv() { return sqrt(norm()); }
double norm() { return x * x + y * y; }
bool operator<(const Point &p) const { return x != p.x ? x < p.x : y < p.y; }
bool operator==(const Point &p) const {
return fabs(x - p.x) < EPS && fabs(y - p.y) < EPS;
}
};
typedef Point Vector;
struct Segment {
Point p1, p2;
};
double hen(Vector a) {
if (fabs(a.x) < EPS && a.y > 0)
return acos(0);
else if (fabs(a.x) < EPS && a.y < 0)
return 3 * acos(0);
else if (fabs(a.y) < EPS && a.x < 0)
return 2 * acos(0);
else if (fabs(a.y) < EPS && a.x > 0)
return 0.0;
else if (a.y > 0)
return acos(a.x / a.absv());
else
return 2 * acos(0) + acos(-a.x / a.absv());
}
string itos(int i) {
ostringstream s;
s << i;
return s.str();
}
int gcd(int v, int b) {
if (v > b)
return gcd(b, v);
if (v == b)
return b;
if (b % v == 0)
return v;
return gcd(v, b % v);
}
double dot(Vector a, Vector b) { return a.x * b.x + a.y * b.y; }
double cross(Vector a, Vector b) { return a.x * b.y - a.y * b.x; }
double distans(double x1, double y1, double x2, double y2) {
double rr = (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);
return sqrt(rr);
}
/*}
int pr[100010];
//int inv[100010];
int beki(int wa,int rr){
if(rr==0) return 1ll;
if(rr==1) return wa;
if(rr%2==1) return (beki(wa,rr-1)*wa)%inf;
int zx=beki(wa,rr/2);
return (zx*zx)%inf;
}
void gya(){
pr[0]=1;
for(int i=1;i<100010;i++){
pr[i]=(pr[i-1]*i)%inf;
}
for(int i=0;i<100010;i++) inv[i]=beki(pr[i],inf-2);
}
*/
//----------------kokomade tenpure------------
bool b = false;
void ch(string s) {
// cout<<s<<endl;
if (b)
return;
if (s == "ABC") {
b = true;
return;
}
if (s.length() <= 4)
return;
int l = s.length();
vector<int> ve;
int z[3] = {0};
for (int i = 0; i < l; i++) {
if (s.substr(i, 3) == "ABC") {
ve.pb(i);
// cout<<i<<endl;
i += 2;
} else {
z[s[i] - 'A']++;
}
}
for (int i = 0; i < 3; i++) {
string st = s;
string xc = "A";
xc[0] += i;
if (z[i] > 0)
continue;
for (int j = ve.size() - 1; j >= 0; j--) {
string s2 = st.substr(ve[j] + 3);
// cout<<s2<<endl;
st = st.substr(0, ve[j]) + xc + s2;
}
ch(st);
}
return;
}
signed main() {
string s;
cin >> s;
ch(s);
if (b)
cout << "Yes" << endl;
else
cout << "No" << endl;
/*
while(1){
cin>>n>>m;
if(n==0&&m==0) return 0;
}
*/
return 0;
} | #include <algorithm>
#include <bits/stdc++.h>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <string>
#include <vector>
// #include <boost/multiprecision/cpp_int.hpp>
#include <functional>
#define int long long
#define inf 1000000007
#define pa pair<int, int>
#define ll long long
#define pal pair<double, pa>
#define ppa pair<pa, int>
#define ppap pair<int, pa>
#define ssa pair<string, int>
#define mp make_pair
#define pb push_back
#define EPS (1e-10)
#define equals(a, b) (fabs((a) - (b)) < EPS)
using namespace std;
// priority_queue<int, vector<int>, greater<int> > que;
class Point {
public:
double x, y;
Point(double x = 0, double y = 0) : x(x), y(y) {}
Point operator+(Point p) { return Point(x + p.x, y + p.y); }
Point operator-(Point p) { return Point(x - p.x, y - p.y); }
Point operator*(double a) { return Point(x * a, y * a); }
Point operator/(double a) { return Point(x / a, y / a); }
double absv() { return sqrt(norm()); }
double norm() { return x * x + y * y; }
bool operator<(const Point &p) const { return x != p.x ? x < p.x : y < p.y; }
bool operator==(const Point &p) const {
return fabs(x - p.x) < EPS && fabs(y - p.y) < EPS;
}
};
typedef Point Vector;
struct Segment {
Point p1, p2;
};
double hen(Vector a) {
if (fabs(a.x) < EPS && a.y > 0)
return acos(0);
else if (fabs(a.x) < EPS && a.y < 0)
return 3 * acos(0);
else if (fabs(a.y) < EPS && a.x < 0)
return 2 * acos(0);
else if (fabs(a.y) < EPS && a.x > 0)
return 0.0;
else if (a.y > 0)
return acos(a.x / a.absv());
else
return 2 * acos(0) + acos(-a.x / a.absv());
}
string itos(int i) {
ostringstream s;
s << i;
return s.str();
}
int gcd(int v, int b) {
if (v > b)
return gcd(b, v);
if (v == b)
return b;
if (b % v == 0)
return v;
return gcd(v, b % v);
}
double dot(Vector a, Vector b) { return a.x * b.x + a.y * b.y; }
double cross(Vector a, Vector b) { return a.x * b.y - a.y * b.x; }
double distans(double x1, double y1, double x2, double y2) {
double rr = (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);
return sqrt(rr);
}
/*}
int pr[100010];
//int inv[100010];
int beki(int wa,int rr){
if(rr==0) return 1ll;
if(rr==1) return wa;
if(rr%2==1) return (beki(wa,rr-1)*wa)%inf;
int zx=beki(wa,rr/2);
return (zx*zx)%inf;
}
void gya(){
pr[0]=1;
for(int i=1;i<100010;i++){
pr[i]=(pr[i-1]*i)%inf;
}
for(int i=0;i<100010;i++) inv[i]=beki(pr[i],inf-2);
}
*/
//----------------kokomade tenpure------------
bool b = false;
void ch(string s) {
// cout<<s<<endl;
if (b)
return;
if (s == "ABC") {
b = true;
return;
}
if (s.length() <= 4)
return;
int l = s.length();
vector<int> ve;
int z[3] = {0};
for (int i = 0; i < l; i++) {
if (s.substr(i, 3) == "ABC") {
ve.pb(i);
// cout<<i<<endl;
i += 2;
} else {
z[s[i] - 'A']++;
}
}
if (ve.size() == 0)
return;
for (int i = 0; i < 3; i++) {
string st = s;
string xc = "A";
xc[0] += i;
if (z[i] > 0)
continue;
for (int j = ve.size() - 1; j >= 0; j--) {
string s2 = st.substr(ve[j] + 3);
// cout<<s2<<endl;
st = st.substr(0, ve[j]) + xc + s2;
}
ch(st);
}
return;
}
signed main() {
string s;
cin >> s;
ch(s);
if (b)
cout << "Yes" << endl;
else
cout << "No" << endl;
/*
while(1){
cin>>n>>m;
if(n==0&&m==0) return 0;
}
*/
return 0;
} | replace | 134 | 135 | 134 | 136 | MLE | |
p01811 | C++ | Runtime Error | // テ・ツ淞コテヲツ慊ャテ」ツδ?」ツδウテ」ツδ療」ツδャテ」ツδシテ」ツδ?(テァツクツョテ・ツーツ湘ァツ可?
#include <bits/stdc++.h>
using namespace std;
#define rep(i, a, n) for (int(i) = (a); (i) < (n); (i)++)
#define repq(i, a, n) for (int(i) = (a); (i) <= (n); (i)++)
#define repr(i, a, n) for (int(i) = (a); (i) >= (n); (i)--)
#define int long long
template <typename T> void chmax(T &a, T b) { a = max(a, b); }
template <typename T> void chmin(T &a, T b) { a = min(a, b); }
template <typename T> void chadd(T &a, T b) { a = a + b; }
typedef pair<int, int> pii;
typedef long long ll;
constexpr ll INF = 1001001001001001LL;
constexpr ll MOD = 1000000007LL;
// s テ」ツ?ォテ・ツ青ォテ」ツ?セテ」ツつ古」ツ?ヲテ」ツ??」ツつ?ABC
// テ」ツつ津・ツ?ィテ」ツ?ヲ u テ」ツ?ォテ・ツ、ツ嘉」ツ?暗」ツつ?
string replace_user(string s, string u) {
string t = "CBA", orig = s;
int N = s.length(), M = t.length(), P = u.length();
if (N < M)
return s;
string ret = "", temp = "";
// cout << "reversed: " << t << endl;
rep(i, 0, N) {
if (temp.length() < M) {
temp = s[i] + temp;
if (temp == t) {
ret += u;
temp = "";
}
} else {
char c = temp[M - 1];
ret += c;
temp.pop_back();
temp = s[i] + temp;
if (temp == t) {
ret += u;
temp = "";
}
}
// cout << "ret = " << ret << ", temp = " << temp << endl;
}
reverse(temp.begin(), temp.end());
// cout << "ret = " << ret << ", temp = " << temp << endl;
s = ret + temp;
return s;
}
map<string, int> m;
void solve(string s) {
if (m.count(s))
return;
m[s]++;
s = replace_user(s, "X");
int cnt[3] = {};
rep(i, 0, s.length()) cnt[s[i] - 'A']++;
rep(i, 0, 3) {
if (cnt[i])
continue;
replace(s.begin(), s.end(), 'X', (char)('A' + i));
if (!m.count(s))
solve(s);
}
}
signed main() {
string s;
cin >> s;
solve(s);
if (m.count("ABC"))
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
} | // テ・ツ淞コテヲツ慊ャテ」ツδ?」ツδウテ」ツδ療」ツδャテ」ツδシテ」ツδ?(テァツクツョテ・ツーツ湘ァツ可?
#include <bits/stdc++.h>
using namespace std;
#define rep(i, a, n) for (int(i) = (a); (i) < (n); (i)++)
#define repq(i, a, n) for (int(i) = (a); (i) <= (n); (i)++)
#define repr(i, a, n) for (int(i) = (a); (i) >= (n); (i)--)
#define int long long
template <typename T> void chmax(T &a, T b) { a = max(a, b); }
template <typename T> void chmin(T &a, T b) { a = min(a, b); }
template <typename T> void chadd(T &a, T b) { a = a + b; }
typedef pair<int, int> pii;
typedef long long ll;
constexpr ll INF = 1001001001001001LL;
constexpr ll MOD = 1000000007LL;
// s テ」ツ?ォテ・ツ青ォテ」ツ?セテ」ツつ古」ツ?ヲテ」ツ??」ツつ?ABC
// テ」ツつ津・ツ?ィテ」ツ?ヲ u テ」ツ?ォテ・ツ、ツ嘉」ツ?暗」ツつ?
string replace_user(string s, string u) {
string t = "CBA", orig = s;
int N = s.length(), M = t.length(), P = u.length();
if (N < M)
return s;
string ret = "", temp = "";
// cout << "reversed: " << t << endl;
rep(i, 0, N) {
if (temp.length() < M) {
temp = s[i] + temp;
if (temp == t) {
ret += u;
temp = "";
}
} else {
char c = temp[M - 1];
ret += c;
temp.pop_back();
temp = s[i] + temp;
if (temp == t) {
ret += u;
temp = "";
}
}
// cout << "ret = " << ret << ", temp = " << temp << endl;
}
reverse(temp.begin(), temp.end());
// cout << "ret = " << ret << ", temp = " << temp << endl;
s = ret + temp;
return s;
}
map<string, int> m;
void solve(string s) {
if (m.count(s))
return;
m[s]++;
s = replace_user(s, "X");
int cnt[3] = {};
rep(i, 0, s.length()) if (s[i] != 'X') cnt[s[i] - 'A']++;
rep(i, 0, 3) {
if (cnt[i])
continue;
replace(s.begin(), s.end(), 'X', (char)('A' + i));
if (!m.count(s))
solve(s);
}
}
signed main() {
string s;
cin >> s;
solve(s);
if (m.count("ABC"))
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
} | replace | 59 | 60 | 59 | 60 | 0 | |
p01811 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int main() {
string s;
cin >> s;
while (1) {
if (s == "ABC") {
cout << "Yes" << endl;
return 0;
}
int n = s.size();
vector<bool> v(n);
for (int i = 1; i < n - 1; i++) {
if (s[i - 1] == 'A' && s[i] == 'B' && s[i + 1] == 'C') {
v[i - 1] = 1;
v[i] = 1;
v[i + 1] = 1;
}
}
int a = 0, b = 0, c = 0;
for (int i = 0; i < n; i++) {
if (!v[i]) {
if (s[i] == 'A') {
a++;
} else if (s[i] == 'B') {
b++;
} else {
c++;
}
}
}
string t;
if (a == 0) {
if (b != 0 && c != 0) {
int p = 0;
while (1) {
if (p == n)
break;
if (v[p] == 1) {
t.push_back('A');
p += 3;
} else {
t.push_back(s[p]);
p++;
}
}
} else {
cout << "No" << endl;
return 0;
}
}
if (b == 0) {
if (a != 0 && c != 0) {
int p = 0;
while (1) {
if (p == n)
break;
if (v[p] == 1) {
t.push_back('B');
p += 3;
} else {
t.push_back(s[p]);
p++;
}
}
} else {
cout << "No" << endl;
return 0;
}
}
if (c == 0) {
if (b != 0 && a != 0) {
int p = 0;
while (1) {
if (p == n)
break;
if (v[p] == 1) {
t.push_back('C');
p += 3;
} else {
t.push_back(s[p]);
p++;
}
}
} else {
cout << "No" << endl;
return 0;
}
}
s = t;
}
return 0;
}
| #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int main() {
string s;
cin >> s;
while (1) {
if (s == "ABC") {
cout << "Yes" << endl;
return 0;
}
if (s.size() <= 3) {
cout << "No" << endl;
return 0;
}
int n = s.size();
vector<bool> v(n);
for (int i = 1; i < n - 1; i++) {
if (s[i - 1] == 'A' && s[i] == 'B' && s[i + 1] == 'C') {
v[i - 1] = 1;
v[i] = 1;
v[i + 1] = 1;
}
}
int a = 0, b = 0, c = 0;
for (int i = 0; i < n; i++) {
if (!v[i]) {
if (s[i] == 'A') {
a++;
} else if (s[i] == 'B') {
b++;
} else {
c++;
}
}
}
string t;
if (a == 0) {
if (b != 0 && c != 0) {
int p = 0;
while (1) {
if (p == n)
break;
if (v[p] == 1) {
t.push_back('A');
p += 3;
} else {
t.push_back(s[p]);
p++;
}
}
} else {
cout << "No" << endl;
return 0;
}
}
if (b == 0) {
if (a != 0 && c != 0) {
int p = 0;
while (1) {
if (p == n)
break;
if (v[p] == 1) {
t.push_back('B');
p += 3;
} else {
t.push_back(s[p]);
p++;
}
}
} else {
cout << "No" << endl;
return 0;
}
}
if (c == 0) {
if (b != 0 && a != 0) {
int p = 0;
while (1) {
if (p == n)
break;
if (v[p] == 1) {
t.push_back('C');
p += 3;
} else {
t.push_back(s[p]);
p++;
}
}
} else {
cout << "No" << endl;
return 0;
}
}
s = t;
}
return 0;
}
| insert | 18 | 18 | 18 | 22 | TLE | |
p01811 | C++ | Memory Limit Exceeded | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
bool f(const string &s) {
// cout<< s<< endl;
if (s == "ABC")
return true;
if (s.size() <= 3)
return false;
int n = s.size();
char c;
if (s.substr(0, 3) == "ABC")
c = 'A';
else if (s.substr(n - 3, 3) == "ABC")
c = 'C';
else
c = 'B';
string t = "";
rep(i, n) {
if (s.substr(i, 3) == "ABC") {
t += c;
i += 2;
} else {
t += s[i];
}
}
string u = "";
int m = t.size();
rep(i, m) {
if (t[i] == c) {
u += "ABC";
} else {
u += t[i];
}
}
if (s == u)
return f(t);
else
return false;
}
int main() {
string s;
cin >> s;
bool ok = f(s);
if (ok)
cout << "Yes" << endl;
else
cout << "No" << endl;
// cout<< ret<< endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
bool f(const string &s) {
// cout<< s<< endl;
if (s == "ABC")
return true;
if (s.size() <= 3)
return false;
int n = s.size();
char c;
if (s.substr(0, 3) == "ABC")
c = 'A';
else if (s.substr(n - 3, 3) == "ABC")
c = 'C';
else
c = 'B';
string t = "";
rep(i, n) {
if (s.substr(i, 3) == "ABC") {
t += c;
i += 2;
} else {
t += s[i];
}
}
if (s.size() == t.size())
return false;
string u = "";
int m = t.size();
rep(i, m) {
if (t[i] == c) {
u += "ABC";
} else {
u += t[i];
}
}
if (s == u)
return f(t);
else
return false;
}
int main() {
string s;
cin >> s;
bool ok = f(s);
if (ok)
cout << "Yes" << endl;
else
cout << "No" << endl;
// cout<< ret<< endl;
return 0;
}
| insert | 30 | 30 | 30 | 32 | MLE | |
p01811 | C++ | Runtime Error | #include <iostream>
#include <string>
using namespace std;
int main() {
string s;
cin >> s;
while (s != "ABC") {
string t = "";
for (int i = 0; i < s.length() - 2; i++) {
if (s.substr(i, 3) == "ABC") {
for (int j = 0; j < 3; j++)
s[i + j] = ' ';
}
}
bool a = false, b = false, c = false;
for (int i = 0; i < s.length(); i++) {
if (s[i] == 'A')
a = true;
else if (s[i] == 'B')
b = true;
else if (s[i] == 'C')
c = true;
}
char cha = ' ';
if (a && b)
cha = 'C';
if (b && c)
cha = 'A';
if (c && a)
cha = 'B';
if (cha == ' ' || (a && b && c)) {
cout << "No" << endl;
return 0;
}
for (int i = 0; i < s.length(); i++) {
if (s[i] == ' ') {
t = t + cha;
i += 2;
} else
t = t + s[i];
}
if (t == s) {
cout << "No" << endl;
return 0;
}
s = t;
}
cout << "Yes" << endl;
return 0;
} | #include <iostream>
#include <string>
using namespace std;
int main() {
string s;
cin >> s;
if (s.length() < 3) {
cout << "No" << endl;
return 0;
}
while (s != "ABC") {
string t = "";
for (int i = 0; i < s.length() - 2; i++) {
if (s.substr(i, 3) == "ABC") {
for (int j = 0; j < 3; j++)
s[i + j] = ' ';
}
}
bool a = false, b = false, c = false;
for (int i = 0; i < s.length(); i++) {
if (s[i] == 'A')
a = true;
else if (s[i] == 'B')
b = true;
else if (s[i] == 'C')
c = true;
}
char cha = ' ';
if (a && b)
cha = 'C';
if (b && c)
cha = 'A';
if (c && a)
cha = 'B';
if (cha == ' ' || (a && b && c)) {
cout << "No" << endl;
return 0;
}
for (int i = 0; i < s.length(); i++) {
if (s[i] == ' ') {
t = t + cha;
i += 2;
} else
t = t + s[i];
}
if (t == s) {
cout << "No" << endl;
return 0;
}
s = t;
}
cout << "Yes" << endl;
return 0;
} | insert | 7 | 7 | 7 | 11 | 0 | |
p01811 | C++ | Time Limit Exceeded | #include <iostream>
#include <map>
#include <string>
using namespace std;
int main() {
string S;
cin >> S;
map<char, int> M;
while (S.size() > 3) {
for (char c = 'A'; c < 'D'; ++c)
M[c] = 0;
int abc = 0;
int l = S.size();
for (int i = 0; i < l; ++i) {
M[S[i]] += 1;
if (S[i] == 'A' && i < l - 2 && S[i + 1] == 'B' && S[i + 2] == 'C')
abc += 1;
}
char s = 'A';
bool f = true;
for (; s < 'D'; ++s) {
if (!(M[s] - abc)) {
f = false;
break;
}
}
if (f) {
cout << "No" << endl;
return 0;
}
string T = S;
S = "";
for (int i = 0; i < l; ++i) {
if (i < l - 2 && T[i] == 'A' && T[i + 1] == 'B' && T[i + 2] == 'C') {
S += s;
i += 2;
} else
S += T[i];
}
}
if (S == "ABC")
cout << "Yes" << endl;
else
cout << "No" << endl;
;
return 0;
} | #include <iostream>
#include <map>
#include <string>
using namespace std;
int main() {
string S;
cin >> S;
map<char, int> M;
while (S.size() > 3) {
if (!(S.size() % 2)) {
cout << "No" << endl;
return 0;
}
for (char c = 'A'; c < 'D'; ++c)
M[c] = 0;
int abc = 0;
int l = S.size();
for (int i = 0; i < l; ++i) {
M[S[i]] += 1;
if (S[i] == 'A' && i < l - 2 && S[i + 1] == 'B' && S[i + 2] == 'C')
abc += 1;
}
char s = 'A';
bool f = true;
for (; s < 'D'; ++s) {
if (!(M[s] - abc)) {
f = false;
break;
}
}
if (f) {
cout << "No" << endl;
return 0;
}
string T = S;
S = "";
for (int i = 0; i < l; ++i) {
if (i < l - 2 && T[i] == 'A' && T[i + 1] == 'B' && T[i + 2] == 'C') {
S += s;
i += 2;
} else
S += T[i];
}
}
if (S == "ABC")
cout << "Yes" << endl;
else
cout << "No" << endl;
;
return 0;
} | insert | 10 | 10 | 10 | 14 | TLE | |
p01811 | C++ | Runtime Error | #include <iostream>
#include <queue>
#include <string>
#include <vector>
using namespace std;
bool check_encode(string str, char c, string sn) {
string ss = "";
for (int i = 0; i < str.length(); ++i) {
if (str[i] == c) {
ss += "ABC";
} else {
ss += str[i];
}
}
cout << str << " " << ss << " " << sn << endl;
if (ss == sn) {
return false;
} else {
return true;
}
}
int main(void) {
string str;
cin >> str;
string sn = str;
queue<string> gene;
gene.push(str);
bool find = false;
while (!gene.empty()) {
sn = gene.front();
gene.pop();
if (sn == "ABC") {
find = true;
break;
}
vector<bool> seq(sn.length(), false);
bool cs = false;
// ABC??????
for (int i = 0; i < sn.length() - 2; ++i) {
if (sn[i] == 'A' && sn[i + 1] == 'B' && sn[i + 2] == 'C') {
seq[i] = true;
cs = true;
}
}
bool fa, fb, fc;
fa = fb = fc = false;
//???????????????
if (cs) {
string astr, bstr, cstr;
astr = bstr = cstr = "";
for (int i = 0; i < sn.length(); ++i) {
if (seq[i]) {
astr += "A";
bstr += "B";
cstr += "C";
i += 2;
} else {
astr += sn[i];
bstr += sn[i];
cstr += sn[i];
if (sn[i] == 'A') {
fa = true;
} else if (sn[i] == 'B') {
fb = true;
} else if (sn[i] == 'C') {
fc = true;
}
}
}
if (!fa) {
gene.push(astr);
}
if (!fb) {
gene.push(bstr);
}
if (!fc) {
gene.push(cstr);
}
// cout << astr << " " << bstr << " " << cstr << endl;
}
}
if (find) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
} | #include <iostream>
#include <queue>
#include <string>
#include <vector>
using namespace std;
bool check_encode(string str, char c, string sn) {
string ss = "";
for (int i = 0; i < str.length(); ++i) {
if (str[i] == c) {
ss += "ABC";
} else {
ss += str[i];
}
}
cout << str << " " << ss << " " << sn << endl;
if (ss == sn) {
return false;
} else {
return true;
}
}
int main(void) {
string str;
cin >> str;
string sn = str;
queue<string> gene;
gene.push(str);
bool find = false;
while (sn.length() > 2 && !gene.empty()) {
sn = gene.front();
gene.pop();
if (sn == "ABC") {
find = true;
break;
}
vector<bool> seq(sn.length(), false);
bool cs = false;
// ABC??????
for (int i = 0; i < sn.length() - 2; ++i) {
if (sn[i] == 'A' && sn[i + 1] == 'B' && sn[i + 2] == 'C') {
seq[i] = true;
cs = true;
}
}
bool fa, fb, fc;
fa = fb = fc = false;
//???????????????
if (cs) {
string astr, bstr, cstr;
astr = bstr = cstr = "";
for (int i = 0; i < sn.length(); ++i) {
if (seq[i]) {
astr += "A";
bstr += "B";
cstr += "C";
i += 2;
} else {
astr += sn[i];
bstr += sn[i];
cstr += sn[i];
if (sn[i] == 'A') {
fa = true;
} else if (sn[i] == 'B') {
fb = true;
} else if (sn[i] == 'C') {
fc = true;
}
}
}
if (!fa) {
gene.push(astr);
}
if (!fb) {
gene.push(bstr);
}
if (!fc) {
gene.push(cstr);
}
// cout << astr << " " << bstr << " " << cstr << endl;
}
}
if (find) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
} | replace | 33 | 34 | 33 | 34 | 0 | |
p01812 | C++ | Time Limit Exceeded | #include <algorithm>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
int x[101][101];
vector<int> D;
int n, m, p, dp[100000];
queue<int> Q;
int main() {
cin >> n >> m >> p;
for (int i = 0; i < m; i++) {
int r;
cin >> r;
D.push_back(r);
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < p; j++)
cin >> x[i][j];
}
for (int i = 1; i < 100000; i++)
dp[i] = 998244353;
Q.push(0);
while (!Q.empty()) {
int i = Q.front();
int bit[16];
for (int j = 0; j < m; j++)
bit[j] = (i / (1 << j)) % 2;
for (int o = 0; o < p; o++) {
int bit2[16];
for (int k = 0; k < m; k++)
bit2[k] = 1;
for (int j = 0; j < m; j++) {
if (bit[j] == 0) {
int to = x[D[j]][o];
for (int l = 0; l < m; l++) {
if (D[l] == to)
bit2[l] = 0;
}
}
}
int cnt = 0;
for (int j = 0; j < m; j++)
cnt += (1 << j) * bit2[j];
if (dp[cnt] == 998244353) {
dp[cnt] = min(dp[cnt], dp[i] + 1);
Q.push(cnt);
}
}
}
cout << dp[(1 << m) - 1] << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
int x[101][101];
vector<int> D;
int n, m, p, dp[100000];
queue<int> Q;
int main() {
cin >> n >> m >> p;
for (int i = 0; i < m; i++) {
int r;
cin >> r;
D.push_back(r);
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < p; j++)
cin >> x[i][j];
}
for (int i = 1; i < 100000; i++)
dp[i] = 998244353;
Q.push(0);
while (!Q.empty()) {
int i = Q.front();
Q.pop();
int bit[16];
for (int j = 0; j < m; j++)
bit[j] = (i / (1 << j)) % 2;
for (int o = 0; o < p; o++) {
int bit2[16];
for (int k = 0; k < m; k++)
bit2[k] = 1;
for (int j = 0; j < m; j++) {
if (bit[j] == 0) {
int to = x[D[j]][o];
for (int l = 0; l < m; l++) {
if (D[l] == to)
bit2[l] = 0;
}
}
}
int cnt = 0;
for (int j = 0; j < m; j++)
cnt += (1 << j) * bit2[j];
if (dp[cnt] == 998244353) {
dp[cnt] = min(dp[cnt], dp[i] + 1);
Q.push(cnt);
}
}
}
cout << dp[(1 << m) - 1] << endl;
return 0;
} | insert | 25 | 25 | 25 | 26 | TLE | |
p01812 | C++ | Runtime Error | #include <iostream>
#include <map>
#include <queue>
#include <vector>
using namespace std;
int main() {
int n, m, k;
cin >> n >> m >> k;
vector<int> d(m);
map<int, int> mp;
int v[101][101] = {};
for (int i = 0; i < m; i++) {
cin >> d[i];
d[i]--;
mp[d[i]] = i;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < k; j++) {
cin >> v[i][j];
v[i][j]--;
}
}
int bits = (1 << m) - 1;
vector<bool> flag((1 << m) + 1);
vector<int> dst((1 << m) + 1);
queue<int> q;
q.push(bits);
flag[bits] = 1;
dst[bits] = 0;
while (!q.empty()) {
auto x = q.front();
q.pop();
for (int i = 0; i < k; i++) {
int sa = 0;
for (int j = 0; j < m; j++) {
if (x & (1 << j)) {
if (mp.find(v[d[j]][i]) != mp.end()) {
int y = mp[v[d[j]][i]];
sa += 1 << y;
}
}
}
if (!flag[sa]) {
flag[sa] = 1;
dst[sa] = dst[x] + 1;
q.push(sa);
}
}
}
cout << dst[0] << endl;
return 0;
}
| #include <iostream>
#include <map>
#include <queue>
#include <vector>
using namespace std;
int main() {
int n, m, k;
cin >> n >> m >> k;
vector<int> d(m);
map<int, int> mp;
int v[101][101] = {};
for (int i = 0; i < m; i++) {
cin >> d[i];
d[i]--;
mp[d[i]] = i;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < k; j++) {
cin >> v[i][j];
v[i][j]--;
}
}
int bits = (1 << m) - 1;
vector<bool> flag((1 << m) + 1);
vector<int> dst((1 << m) + 1);
queue<int> q;
q.push(bits);
flag[bits] = 1;
dst[bits] = 0;
while (!q.empty()) {
auto x = q.front();
q.pop();
for (int i = 0; i < k; i++) {
int sa = 0;
for (int j = 0; j < m; j++) {
if (x & (1 << j)) {
if (mp.find(v[d[j]][i]) != mp.end()) {
int y = mp[v[d[j]][i]];
if (!(sa & 1 << y))
sa += 1 << y;
}
}
}
if (!flag[sa]) {
flag[sa] = 1;
dst[sa] = dst[x] + 1;
q.push(sa);
}
}
}
cout << dst[0] << endl;
return 0;
}
| replace | 40 | 41 | 40 | 42 | 0 | |
p01812 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define loop(i, a, b) for (int i = a; i < b; i++)
#define rep(i, a) loop(i, 0, a)
#define pb push_back
#define mp make_pair
#define all(in) in.begin(), in.end()
#define shosu(x) fixed << setprecision(x)
using namespace std;
// kaewasuretyuui
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<pii> vp;
typedef vector<vp> vvp;
typedef pair<int, pii> pip;
typedef vector<pip> vip;
const double PI = acos(-1);
const double EPS = 1e-8;
const double inf = 1e8;
int main() {
int n, m, r;
cin >> n >> m >> r;
vi a(m);
rep(i, m) cin >> a[i];
map<int, int> ma;
rep(i, m) ma[a[i]] = i + 1;
vvi in(n, vi(r));
rep(i, n) rep(j, r) cin >> in[i][j];
int N = 1 << m;
vi dp(N, inf);
dp[N - 1] = 0;
queue<int> q;
q.push(N - 1);
while (!q.empty()) {
int b = q.front();
q.pop();
rep(k, r) {
int w = 0;
rep(i, m) if (b & 1 << i) w |= 1 << (ma[in[a[i] - 1][k]] - 1);
if (dp[w] > dp[b] + 1) {
dp[w] = dp[b] + 1;
q.push(w);
}
}
}
/* for(int i=N-1;i>0;i--)if(dp[i]!=inf)rep(k,r){
vi t;
rep(j,m)if(i&1<<j)t.pb(a[j]);
rep(j,t.size())if(t[j])t[j]=in[t[j]-1][k];
int w=0;
rep(j,t.size())if(ma[t[j]])w|=1<<(ma[t[j]]-1);
dp[w]=min(dp[w],dp[i]+1);
}
*/
cout << dp[0] << endl;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define loop(i, a, b) for (int i = a; i < b; i++)
#define rep(i, a) loop(i, 0, a)
#define pb push_back
#define mp make_pair
#define all(in) in.begin(), in.end()
#define shosu(x) fixed << setprecision(x)
using namespace std;
// kaewasuretyuui
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<pii> vp;
typedef vector<vp> vvp;
typedef pair<int, pii> pip;
typedef vector<pip> vip;
const double PI = acos(-1);
const double EPS = 1e-8;
const double inf = 1e8;
int main() {
int n, m, r;
cin >> n >> m >> r;
vi a(m);
rep(i, m) cin >> a[i];
map<int, int> ma;
rep(i, m) ma[a[i]] = i + 1;
vvi in(n, vi(r));
rep(i, n) rep(j, r) cin >> in[i][j];
int N = 1 << m;
vi dp(N, inf);
dp[N - 1] = 0;
queue<int> q;
q.push(N - 1);
while (!q.empty()) {
int b = q.front();
q.pop();
rep(k, r) {
int w = 0;
rep(i, m) if (b & 1 << i && ma[in[a[i] - 1][k]]) w |=
1 << (ma[in[a[i] - 1][k]] - 1);
if (dp[w] > dp[b] + 1) {
dp[w] = dp[b] + 1;
q.push(w);
}
}
}
/* for(int i=N-1;i>0;i--)if(dp[i]!=inf)rep(k,r){
vi t;
rep(j,m)if(i&1<<j)t.pb(a[j]);
rep(j,t.size())if(t[j])t[j]=in[t[j]-1][k];
int w=0;
rep(j,t.size())if(ma[t[j]])w|=1<<(ma[t[j]]-1);
dp[w]=min(dp[w],dp[i]+1);
}
*/
cout << dp[0] << endl;
} | replace | 52 | 53 | 52 | 54 | -11 | |
p01812 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
cin >> n >> m >> k;
vector<int> d(m);
map<int, int> dark_map;
for (int i = 0; i < m; i++) {
cin >> d[i];
d[i]--;
dark_map[d[i]] = i;
}
vector<vector<int>> v(n, vector<int>(k));
for (int i = 0; i < n; i++)
for (int j = 0; j < k; j++) {
cin >> v[i][j];
v[i][j]--;
}
vector<vector<int>> v2(m);
for (int i = 0; i < m; i++) {
v2[i] = v[d[i]];
}
const int INF = 1e9;
vector<int> dp(1 << m, INF);
int first_p = (1 << m) - 1;
dp[first_p] = 0;
pair<int, int> state = make_pair(0, first_p);
priority_queue<pair<int, int>> que;
que.push(state);
while (!que.empty()) {
state = que.top();
que.pop();
int p = state.second;
int sc = state.first;
if (dp[p] < sc)
continue;
for (int i = 0; i < k; i++) {
int top = 0;
for (int j = 0; j < m; j++) {
if (p & (1 << j)) {
if (dark_map.count(v2[j][i])) {
top |= (1 << (dark_map[v2[j][i]]));
}
}
}
if (dp[top] > sc + 1) {
dp[top] = sc + 1;
que.push(make_pair(sc + 1, top));
}
}
}
cout << dp[0] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
cin >> n >> m >> k;
vector<int> d(m);
map<int, int> dark_map;
for (int i = 0; i < m; i++) {
cin >> d[i];
d[i]--;
dark_map[d[i]] = i;
}
vector<vector<int>> v(n, vector<int>(k));
for (int i = 0; i < n; i++)
for (int j = 0; j < k; j++) {
cin >> v[i][j];
v[i][j]--;
}
vector<vector<int>> v2(m);
for (int i = 0; i < m; i++) {
v2[i] = v[d[i]];
}
const int INF = 1e9;
vector<int> dp(1 << m, INF);
int first_p = (1 << m) - 1;
dp[first_p] = 0;
pair<int, int> state = make_pair(0, first_p);
priority_queue<pair<int, int>, vector<pair<int, int>>,
greater<pair<int, int>>>
que;
que.push(state);
while (!que.empty()) {
state = que.top();
que.pop();
int p = state.second;
int sc = state.first;
if (dp[p] < sc)
continue;
for (int i = 0; i < k; i++) {
int top = 0;
for (int j = 0; j < m; j++) {
if (p & (1 << j)) {
if (dark_map.count(v2[j][i])) {
top |= (1 << (dark_map[v2[j][i]]));
}
}
}
if (dp[top] > sc + 1) {
dp[top] = sc + 1;
que.push(make_pair(sc + 1, top));
}
}
}
cout << dp[0] << endl;
return 0;
} | replace | 28 | 29 | 28 | 31 | TLE | |
p01820 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
const string D = "^>v<";
const int dx[] = {0, 1, 0, -1};
const int dy[] = {-1, 0, 1, 0};
const int inf = 1 << 25;
int fld[3000][3000], w, h;
int ans;
void compress(vector<int> &vec) {
vector<int> temp = vec;
sort(temp.begin(), temp.end());
temp.erase(unique(temp.begin(), temp.end()), temp.end());
for (int i = 0; i < vec.size(); i++) {
vec[i] = find(temp.begin(), temp.end(), vec[i]) - temp.begin();
}
}
int solve(int x, int y, int d) {
if (x < 0 || w < x || y < 0 || h < y)
return 0;
int nx = x + dx[d], ny = y + dy[d], nd = d;
if (0 <= nx && nx <= w && 0 <= ny && ny <= h && fld[ny][nx] != -1)
nd = fld[ny][nx];
int hoge = fld[y][x];
fld[y][x] = -1;
int ret = solve(nx, ny, nd) + (hoge != -1);
return ret;
}
int main() {
int n;
cin >> n;
vector<int> ix, iy, id;
for (int i = 0; i < n; i++) {
int x, y;
char d;
cin >> x >> y >> d;
ix.push_back(x);
iy.push_back(y);
id.push_back(D.find(d));
}
compress(ix);
compress(iy);
w = *max_element(ix.begin(), ix.end()),
h = *max_element(iy.begin(), iy.end());
ans = 0;
memset(fld, -1, sizeof(fld));
/*
for(int j = 0; j < n; j++) fld[iy[j]][ix[j]] = id[j];
for(int i = 0; i <= h; i++){
for(int j = 0; j <= w; j++) printf("%2d", fld[i][j]);
cout << endl;
}
*/
for (int i = 0; i < n; i++) {
memset(fld, -1, sizeof(fld));
for (int j = 0; j < n; j++)
fld[iy[j]][ix[j]] = id[j];
ans = max(ans, solve(ix[i], iy[i], id[i]));
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
const string D = "^>v<";
const int dx[] = {0, 1, 0, -1};
const int dy[] = {-1, 0, 1, 0};
const int inf = 1 << 25;
int fld[3000][3000], w, h;
int ans;
void compress(vector<int> &vec) {
vector<int> temp = vec;
sort(temp.begin(), temp.end());
temp.erase(unique(temp.begin(), temp.end()), temp.end());
for (int i = 0; i < vec.size(); i++) {
vec[i] = find(temp.begin(), temp.end(), vec[i]) - temp.begin();
}
}
int solve(int x, int y, int d) {
if (x < 0 || w < x || y < 0 || h < y)
return 0;
int nx = x + dx[d], ny = y + dy[d], nd = d;
if (0 <= nx && nx <= w && 0 <= ny && ny <= h && fld[ny][nx] != -1)
nd = fld[ny][nx];
int hoge = fld[y][x];
fld[y][x] = -1;
int ret = solve(nx, ny, nd) + (hoge != -1);
return ret;
}
int main() {
int n;
cin >> n;
vector<int> ix, iy, id;
for (int i = 0; i < n; i++) {
int x, y;
char d;
cin >> x >> y >> d;
ix.push_back(x);
iy.push_back(y);
id.push_back(D.find(d));
}
compress(ix);
compress(iy);
w = *max_element(ix.begin(), ix.end()),
h = *max_element(iy.begin(), iy.end());
ans = 0;
memset(fld, -1, sizeof(fld));
/*
for(int j = 0; j < n; j++) fld[iy[j]][ix[j]] = id[j];
for(int i = 0; i <= h; i++){
for(int j = 0; j <= w; j++) printf("%2d", fld[i][j]);
cout << endl;
}
*/
for (int i = 0; i < n; i++) {
// memset(fld, -1, sizeof(fld));
for (int j = 0; j < n; j++)
fld[iy[j]][ix[j]] = id[j];
ans = max(ans, solve(ix[i], iy[i], id[i]));
}
cout << ans << endl;
return 0;
} | replace | 58 | 59 | 58 | 59 | TLE | |
p01820 | C++ | Runtime Error | #include <bits/stdc++.h>
#define MAX 2048
#define inf 1 << 29
#define linf 1e16
#define eps (1e-8)
#define mod 1000000007
#define pi acos(-1)
#define phi (1.0 + sqrt(5)) / 2.0
#define f first
#define s second
#define mp make_pair
#define pb push_back
#define all(a) (a).begin(), (a).end()
#define pd(a) printf("%.10f\n", (double)(a))
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define RFOR(i, a, b) for (int i = (a)-1; (b) <= i; i--)
#define equals(a, b) (fabs((a) - (b)) < eps)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<int, double> pid;
typedef pair<double, int> pdi;
typedef vector<int> vi;
typedef vector<pii> vpi;
const int dx[8] = {1, 0, -1, 0, 1, 1, -1, -1};
const int dy[8] = {0, 1, 0, -1, 1, -1, 1, -1};
int n;
vector<pii> e[MAX];
int a[MAX], b[MAX];
string c[MAX];
bool used[MAX];
int dfs(int v) {
int res = 1;
used[v] = true;
FOR(i, 0, e[v].size()) {
int next = e[v][i].s;
if (!used[next]) {
res += dfs(next);
break;
}
}
return res;
}
int solve() {
int res = 0;
FOR(i, 0, n) {
FOR(j, 0, n) {
if (i == j)
continue;
if (c[i] == ">" && b[i] == b[j] && a[i] < a[j])
e[i].pb(mp(a[j] - a[i], j));
if (c[i] == "<" && b[i] == b[j] && a[j] < a[i])
e[i].pb(mp(a[i] - a[j], j));
if (c[i] == "v" && a[i] == a[j] && b[i] < b[j])
e[i].pb(mp(b[j] - b[i], j));
if (c[i] == "^" && a[i] == a[j] && b[j] < b[i])
e[i].pb(mp(b[i] - b[j], j));
}
sort(all(e[i]));
}
FOR(i, 0, n) {
fill(used, used + MAX, false);
res = max(res, dfs(i));
}
return res;
}
int main() {
cin >> n;
FOR(i, 0, n) cin >> a[i] >> b[i] >> c[i];
cout << solve() << endl;
return 0;
} | #include <bits/stdc++.h>
#define MAX 3003
#define inf 1 << 29
#define linf 1e16
#define eps (1e-8)
#define mod 1000000007
#define pi acos(-1)
#define phi (1.0 + sqrt(5)) / 2.0
#define f first
#define s second
#define mp make_pair
#define pb push_back
#define all(a) (a).begin(), (a).end()
#define pd(a) printf("%.10f\n", (double)(a))
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define RFOR(i, a, b) for (int i = (a)-1; (b) <= i; i--)
#define equals(a, b) (fabs((a) - (b)) < eps)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<int, double> pid;
typedef pair<double, int> pdi;
typedef vector<int> vi;
typedef vector<pii> vpi;
const int dx[8] = {1, 0, -1, 0, 1, 1, -1, -1};
const int dy[8] = {0, 1, 0, -1, 1, -1, 1, -1};
int n;
vector<pii> e[MAX];
int a[MAX], b[MAX];
string c[MAX];
bool used[MAX];
int dfs(int v) {
int res = 1;
used[v] = true;
FOR(i, 0, e[v].size()) {
int next = e[v][i].s;
if (!used[next]) {
res += dfs(next);
break;
}
}
return res;
}
int solve() {
int res = 0;
FOR(i, 0, n) {
FOR(j, 0, n) {
if (i == j)
continue;
if (c[i] == ">" && b[i] == b[j] && a[i] < a[j])
e[i].pb(mp(a[j] - a[i], j));
if (c[i] == "<" && b[i] == b[j] && a[j] < a[i])
e[i].pb(mp(a[i] - a[j], j));
if (c[i] == "v" && a[i] == a[j] && b[i] < b[j])
e[i].pb(mp(b[j] - b[i], j));
if (c[i] == "^" && a[i] == a[j] && b[j] < b[i])
e[i].pb(mp(b[i] - b[j], j));
}
sort(all(e[i]));
}
FOR(i, 0, n) {
fill(used, used + MAX, false);
res = max(res, dfs(i));
}
return res;
}
int main() {
cin >> n;
FOR(i, 0, n) cin >> a[i] >> b[i] >> c[i];
cout << solve() << endl;
return 0;
} | replace | 1 | 2 | 1 | 2 | 0 | |
p01825 | C++ | Time Limit Exceeded | #include "bits/stdc++.h"
using namespace std;
using ld = long double;
const ld eps = 1e-9;
typedef ld Weight;
struct Edge {
int src, dest;
int cap, rev;
Weight weight;
bool operator<(const Edge &rhs) const { return weight > rhs.weight; }
};
/* ??????????????¬ */
#include <complex>
typedef complex<ld> Point;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(), (x).end()
const ld pi = acos(-1.0);
const ld dtop = pi / 180.;
const ld ptod = 1. / dtop;
namespace std {
bool operator<(const Point &lhs, const Point &rhs) {
if (lhs.real() < rhs.real() - eps)
return true;
if (lhs.real() > rhs.real() + eps)
return false;
return lhs.imag() < rhs.imag();
}
} // namespace std
// ????????\???
Point input_Point() {
ld x, y;
cin >> x >> y;
return Point(x, y);
}
// ????????????????????????
bool eq(const ld a, const ld b) { return (abs(a - b) < eps); }
// ??????
ld dot(const Point &a, const Point &b) { return real(conj(a) * b); }
// ??????
ld cross(const Point &a, const Point &b) { return imag(conj(a) * b); }
// ??´????????????
class Line {
public:
Point a, b;
Line() : a(Point(0, 0)), b(Point(0, 0)) {}
Line(Point a, Point b) : a(a), b(b) {}
Point operator[](const int _num) const {
if (_num == 0)
return a;
else if (_num == 1)
return b;
else {
assert(false);
return Point();
}
}
};
// ????????????
class Circle {
public:
Point p;
ld r;
Circle() : p(Point(0, 0)), r(0) {}
Circle(Point p, ld r) : p(p), r(r) {}
};
// ccw
// 1: a,b,c??????????¨???¨?????????????????¶
//-1: a,b,c???????¨???¨?????????????????¶
// 2: c,a,b???????????´???????????¶
//-2: a,b,c???????????´???????????¶
// 0: a,c,b???????????´???????????¶
int ccw(const Point &a, const Point &b, const Point &c) {
const Point nb(b - a);
const Point nc(c - a);
if (cross(nb, nc) > eps)
return 1; // a,b,c??????????¨???¨?????????????????¶
if (cross(nb, nc) < -eps)
return -1; // a,b,c???????¨???¨?????????????????¶
if (dot(nb, nc) < 0)
return 2; // c,a,b???????????´???????????¶
if (norm(nb) < norm(nc))
return -2; // a,b,c???????????´???????????¶
return 0; // a,c,b???????????´???????????¶
}
/* ???????????? */
// ??´?????¨??´??????????????????
bool isis_ll(const Line &l, const Line &m) {
return !eq(cross(l.b - l.a, m.b - m.a), 0);
}
// ??´?????¨?????????????????????
bool isis_ls(const Line &l, const Line &s) {
return isis_ll(l, s) &&
(cross(l.b - l.a, s.a - l.a) * cross(l.b - l.a, s.b - l.a) < eps);
}
// ????????¨?????????????????????
bool isis_ss(const Line &s, const Line &t) {
return ccw(s.a, s.b, t.a) * ccw(s.a, s.b, t.b) <= 0 &&
ccw(t.a, t.b, s.a) * ccw(t.a, t.b, s.b) <= 0;
}
// ????????´????????????
bool isis_lp(const Line &l, const Point &p) {
return (abs(cross(l.b - p, l.a - p)) < eps);
}
// ?????????????????????
bool isis_sp(const Line &s, const Point &p) {
return (abs(s.a - p) + abs(s.b - p) - abs(s.b - s.a) < eps);
}
// ??????????¶?
Point proj(const Line &l, const Point &p) {
ld t = dot(p - l.a, l.b - l.a) / norm(l.a - l.b);
return l.a + t * (l.b - l.a);
}
//???????±??????????????????????
Point reflect(const Line &l, const Point &p) {
Point pr = proj(l, p);
return pr * 2.l - p;
}
// ??´?????¨??´????????????
Point is_ll(const Line &s, const Line &t) {
Point sv = s.b - s.a, tv = t.b - t.a;
assert(cross(sv, tv) != 0);
return s.a + sv * cross(tv, t.a - s.a) / cross(tv, sv);
}
// ??´?????¨??´????????????
vector<Point> is_ll2(const Line &s, const Line &t) {
Point sv = s.b - s.a, tv = t.b - t.a;
if (cross(sv, tv) != 0)
return vector<Point>(1, is_ll(s, t));
else {
vector<Point> ans;
for (int k = 0; k < 2; ++k) {
if (isis_sp(s, t[k]) && find(ans.begin(), ans.end(), t[k]) == ans.end())
ans.push_back(t[k]);
if (isis_sp(t, s[k]) && find(ans.begin(), ans.end(), s[k]) == ans.end())
ans.push_back(s[k]);
}
return ans;
}
}
// ????????¨???????????????
//???????????£????????¨???????????¨assert(false)
Point is_ss(const Line &s, const Line &t) {
if (isis_ss(s, t)) {
for (int k = 0; k < 2; ++k) {
for (int l = 0; l < 2; ++l) {
if (s[k] == t[l])
return s[k];
}
}
return is_ll(s, t);
} else {
//??????isis_ss?????????
assert(false);
return Point(0, 0);
}
}
// ????????¨???????????????
vector<Point> is_ss2(const Line &s, const Line &t) {
vector<Point> kouho(is_ll2(s, t));
vector<Point> ans;
for (auto p : kouho) {
if (isis_sp(s, p) && isis_sp(t, p))
ans.emplace_back(p);
}
return ans;
}
// ??´?????¨???????????¢
ld dist_lp(const Line &l, const Point &p) { return abs(p - proj(l, p)); }
//??´?????¨??´???????????¢
ld dist_ll(const Line &l, const Line &m) {
return isis_ll(l, m) ? 0 : dist_lp(l, m.a);
}
// ??´?????¨??????????????¢
ld dist_ls(const Line &l, const Line &s) {
return isis_ls(l, s) ? 0 : min(dist_lp(l, s.a), dist_lp(l, s.b));
}
// ????????¨???????????¢
ld dist_sp(const Line &s, const Point &p) {
Point r = proj(s, p);
return isis_sp(s, r) ? abs(r - p) : min(abs(s.a - p), abs(s.b - p));
}
// ????????¨??????????????¢
ld dist_ss(const Line &s, const Line &t) {
if (isis_ss(s, t))
return 0;
return min(
{dist_sp(s, t.a), dist_sp(s, t.b), dist_sp(t, s.a), dist_sp(t, s.b)});
}
//??´?????¨??´?????????????????????????????????
Line bisection(const Line &s, const Line &t) {
const Point laglanju(is_ll(s, t));
const Point avec =
!(abs(laglanju - s[0]) < eps) ? s[0] - laglanju : s[1] - laglanju;
const Point bvec =
!(abs(laglanju - t[0]) < eps) ? t[0] - laglanju : t[1] - laglanju;
return Line(laglanju, laglanju + (abs(bvec) * avec + abs(avec) * bvec) /
(abs(avec) + abs(bvec)));
}
//???????????´?????????????????????
//???????????´??????????????§???????????¨????¢?????????¨?????????
Point inner_center(const vector<Line> &ls) {
vector<Point> vertics;
for (int i = 0; i < static_cast<int>(ls.size()); ++i) {
vertics.push_back(is_ll(ls[i], ls[(i + 1) % 3]));
}
if (vertics[0] == vertics[1] || vertics[1] == vertics[2] ||
vertics[2] == vertics[0])
return vertics[0];
Line bi1(
bisection(Line(vertics[0], vertics[1]), Line(vertics[0], vertics[2])));
Line bi2(
bisection(Line(vertics[1], vertics[2]), Line(vertics[1], vertics[0])));
if (bi1[0] == bi2[0])
return bi1[0];
else {
return is_ll(bi1, bi2);
}
}
//???????????´?????????????????????
//???????????´??????????????§???????????¨????¢?????????¨?????????
vector<Point> ex_center(const vector<Line> &ls) {
vector<Point> vertics;
for (int i = 0; i < static_cast<int>(ls.size()); ++i) {
vertics.push_back(is_ll(ls[i], ls[(i + 1) % 3]));
}
if (abs(vertics[0] - vertics[1]) < eps ||
abs(vertics[1] - vertics[2]) < eps ||
(abs(vertics[2] - vertics[0]) < eps))
return vector<Point>();
vector<Point> ecs;
for (int i = 0; i < 3; ++i) {
Line bi1(
bisection(Line(vertics[i], vertics[i] * 2.0l - vertics[(i + 2) % 3]),
Line(vertics[i], vertics[(i + 1) % 3])));
Line bi2(bisection(Line(vertics[(i + 1) % 3],
vertics[(i + 1) % 3] * 2.0l - vertics[(i + 2) % 3]),
Line(vertics[(i + 1) % 3], vertics[i])));
ecs.push_back(is_ll(bi1, bi2));
}
return ecs;
}
// a,b:??????
// c:????????§??????
//???????????´?????????????????¢?????????????±??????????
vector<Point> same_dis(const vector<Line> &ls) {
vector<Point> vertics;
vertics.push_back(is_ll(ls[0], ls[2]));
vertics.push_back(is_ll(ls[1], ls[2]));
if (abs(vertics[0] - vertics[1]) < eps)
return vector<Point>{vertics[0]};
Line bis(bisection(ls[0], ls[1]));
vector<Point> ecs;
Line abi(bisection(Line(vertics[0], vertics[1]), ls[0]));
ecs.push_back(is_ll(bis, abi));
Line bbi(bisection(Line(vertics[0], 2.l * vertics[0] - vertics[1]), ls[0]));
ecs.push_back(is_ll(bis, bbi));
return ecs;
}
/* ??? */
// ?????¨????????????
vector<Point> is_cc(const Circle &c1, const Circle &c2) {
vector<Point> res;
ld d = abs(c1.p - c2.p);
ld rc = (d * d + c1.r * c1.r - c2.r * c2.r) / (2 * d);
ld dfr = c1.r * c1.r - rc * rc;
if (abs(dfr) < eps)
dfr = 0.0;
else if (dfr < 0.0)
return res; // no intersection
ld rs = sqrt(dfr);
Point diff = (c2.p - c1.p) / d;
res.push_back(c1.p + diff * Point(rc, rs));
if (dfr != 0.0)
res.push_back(c1.p + diff * Point(rc, -rs));
return res;
}
//???????????????????????????
/* 0 => out
1 => on
2 => in*/
int is_in_Circle(const Circle &cir, const Point &p) {
ld dis = abs(cir.p - p);
if (dis > cir.r + eps)
return 0;
else if (dis < cir.r - eps)
return 2;
else
return 1;
}
//???lc??????rc??????????????????
/*0 => out
1 => on
2 => in*/
int Circle_in_Circle(const Circle &lc, const Circle &rc) {
ld dis = abs(lc.p - rc.p);
if (dis < rc.r - lc.r - eps)
return 2;
else if (dis > rc.r - lc.r + eps)
return 0;
else
return 1;
}
// ?????¨??´????????????
vector<Point> is_lc(const Circle &c, const Line &l) {
vector<Point> res;
ld d = dist_lp(l, c.p);
if (d < c.r + eps) {
ld len = (d > c.r) ? 0.0 : sqrt(c.r * c.r - d * d); // safety;
Point nor = (l.a - l.b) / abs(l.a - l.b);
res.push_back(proj(l, c.p) + len * nor);
res.push_back(proj(l, c.p) - len * nor);
}
return res;
}
// ?????¨??????????????¢
vector<Point> is_sc(const Circle &c, const Line &l) {
vector<Point> v = is_lc(c, l), res;
for (Point p : v)
if (isis_sp(l, p))
res.push_back(p);
return res;
}
// ?????¨????????\???
vector<Line> tangent_cp(const Circle &c, const Point &p) {
vector<Line> ret;
Point v = c.p - p;
ld d = abs(v);
ld l = sqrt(norm(v) - c.r * c.r);
if (isnan(l)) {
return ret;
}
Point v1 = v * Point(l / d, c.r / d);
Point v2 = v * Point(l / d, -c.r / d);
ret.push_back(Line(p, p + v1));
if (l < eps)
return ret;
ret.push_back(Line(p, p + v2));
return ret;
}
// ?????¨????????\???
vector<Line> tangent_cc(const Circle &c1, const Circle &c2) {
vector<Line> ret;
if (abs(c1.p - c2.p) - (c1.r + c2.r) > -eps) {
Point center = (c1.p * c2.r + c2.p * c1.r) / (c1.r + c2.r);
ret = tangent_cp(c1, center);
}
if (abs(c1.r - c2.r) > eps) {
Point out = (-c1.p * c2.r + c2.p * c1.r) / (c1.r - c2.r);
vector<Line> nret = tangent_cp(c1, out);
ret.insert(ret.end(), all(nret));
} else {
Point v = c2.p - c1.p;
v /= abs(v);
Point q1 = c1.p + v * Point(0, 1) * c1.r;
Point q2 = c1.p + v * Point(0, -1) * c1.r;
ret.push_back(Line(q1, q1 + v));
ret.push_back(Line(q2, q2 + v));
}
return ret;
}
//??????????????????????????¢???
ld two_Circle_area(const Circle &l, const Circle &r) {
ld dis = abs(l.p - r.p);
if (dis > l.r + r.r)
return 0;
else if (dis + r.r < l.r) {
return r.r * r.r * pi;
} else if (dis + l.r < r.r) {
return l.r * l.r * pi;
} else {
ld ans = (l.r) * (l.r) *
acos((dis * dis + l.r * l.r - r.r * r.r) / (2 * dis * l.r)) +
(r.r) * (r.r) *
acos((dis * dis + r.r * r.r - l.r * l.r) / (2 * dis * r.r)) -
sqrt(4 * dis * dis * l.r * l.r -
(dis * dis + l.r * l.r - r.r * r.r) *
(dis * dis + l.r * l.r - r.r * r.r)) /
2;
return ans;
}
}
/* ????§???¢ */
typedef vector<Point> Polygon;
// ??¢???
ld area(const Polygon &p) {
ld res = 0;
int n = p.size();
rep(j, n) res += cross(p[j], p[(j + 1) % n]);
return res / 2;
}
//????§???¢????????¢??????
bool is_counter_clockwise(const Polygon &poly) {
ld angle = 0;
int n = poly.size();
rep(i, n) {
Point a = poly[i], b = poly[(i + 1) % n], c = poly[(i + 2) % n];
angle += arg((c - b) / (b - a));
}
return angle > eps;
}
// ??????????????????
/*0 => out
1 => on
2 => in*/
int is_in_Polygon(const Polygon &poly, const Point &p) {
ld angle = 0;
int n = poly.size();
rep(i, n) {
Point a = poly[i], b = poly[(i + 1) % n];
if (isis_sp(Line(a, b), p))
return 1;
angle += arg((b - p) / (a - p));
}
return eq(angle, 0) ? 0 : 2;
}
//??????????????????2?????????
enum { out, on, in };
int convex_contains(const Polygon &P, const Point &p) {
const int n = P.size();
Point g = (P[0] + P[n / 3] + P[2 * n / 3]) / 3.0l; // inner-point
int a = 0, b = n;
while (a + 1 < b) { // invariant: c is in fan g-P[a]-P[b]
int c = (a + b) / 2;
if (cross(P[a] - g, P[c] - g) > 0) { // angle < 180 deg
if (cross(P[a] - g, p - g) > 0 && cross(P[c] - g, p - g) < 0)
b = c;
else
a = c;
} else {
if (cross(P[a] - g, p - g) < 0 && cross(P[c] - g, p - g) > 0)
a = c;
else
b = c;
}
}
b %= n;
if (cross(P[a] - p, P[b] - p) < 0)
return 0;
if (cross(P[a] - p, P[b] - p) > 0)
return 2;
return 1;
}
// ??????
//???????????????????????¨????????????????????§??¨???
Polygon convex_hull(vector<Point> ps) {
int n = ps.size();
int k = 0;
sort(ps.begin(), ps.end());
Polygon ch(2 * n);
for (int i = 0; i < n; ch[k++] = ps[i++])
while (k >= 2 && ccw(ch[k - 2], ch[k - 1], ps[i]) <= 0)
--k;
for (int i = n - 2, t = k + 1; i >= 0; ch[k++] = ps[i--])
while (k >= t && ccw(ch[k - 2], ch[k - 1], ps[i]) <= 0)
--k;
ch.resize(k - 1);
return ch;
}
//????????????
vector<Polygon> convex_cut(const Polygon &ps, const Line &l) {
int n = ps.size();
Polygon q;
Polygon r;
rep(i, n) {
Point a = ps[i], b = ps[(i + 1) % n];
Line m = Line(a, b);
if (ccw(l.a, l.b, a) != -1)
q.push_back(a);
if (ccw(l.a, l.b, a) != 1)
r.push_back(a);
if (ccw(l.a, l.b, a) * ccw(l.a, l.b, b) < 0 && isis_ll(l, m)) {
q.push_back(is_ll(l, m));
r.push_back(is_ll(l, m));
}
}
const vector<Polygon> polys{q, r};
return polys;
}
/* ??¢??¬??????????????? */
void add_Point(vector<Point> &ps, const Point p) {
for (Point q : ps)
if (abs(q - p) < eps)
return;
ps.push_back(p);
}
typedef vector<Edge> Edges;
typedef vector<Edges> Graph;
typedef vector<Weight> Array;
typedef vector<Array> Matrix;
void add_edge(Graph &g, int src, int dest, int cap, Weight weight) {
g[src].push_back(Edge{src, dest, cap, (int)g[dest].size(), weight});
g[dest].push_back(Edge{dest, src, 0, (int)g[src].size() - 1, -weight});
}
Graph segment_arrangement(const vector<Line> &s, const vector<Point> &p) {
int n = p.size(), m = s.size();
Graph g(n);
rep(i, m) {
vector<pair<ld, int>> vec;
rep(j, n) {
if (isis_sp(s[i], p[j]))
vec.emplace_back(abs(s[i].a - p[j]), j);
}
sort(all(vec));
rep(j, vec.size() - 1) {
int from = vec[j].second, to = vec[j + 1].second;
add_edge(g, from, to, 1, static_cast<Weight>(abs(p[from] - p[to])));
}
}
return g;
}
pair<vector<Point>, Graph> sennbunn_arrangement(const vector<Line> &s) {
vector<Point> crss;
for (int i = 0; i < static_cast<int>(s.size()); ++i) {
for (int j = i + 1; j < static_cast<int>(s.size()); ++j) {
if (isis_ss(s[i], s[j])) {
crss.push_back(is_ll2(s[i], s[j])[0]);
}
}
}
for (int i = 0; i < static_cast<int>(s.size()); ++i) {
crss.push_back(s[i][0]);
crss.push_back(s[i][1]);
}
sort(crss.begin(), crss.end());
crss.erase(unique(crss.begin(), crss.end()), crss.end());
return make_pair(crss, segment_arrangement(s, crss));
}
Graph Circle_arrangement(const vector<Circle> &c, const vector<Point> &p) {
const int n = p.size(), m = c.size();
Graph g(n);
rep(i, m) {
vector<pair<ld, int>> vec;
rep(j, n) if (abs(abs(c[i].p - p[j]) - c[i].r) < eps)
vec.emplace_back(arg(c[i].p - p[j]), j);
sort(all(vec));
rep(j, vec.size() - 1) {
int from = vec[j].second, to = vec[j + 1].second;
ld angle = vec[j + 1].first - vec[j].first;
add_edge(g, from, to, 1, static_cast<Weight>(angle * c[i].r));
}
if (vec.size() >= 2) {
int from = vec.back().second, to = vec.front().first;
ld angle = vec.front().first - vec.back().first;
add_edge(g, from, to, 1, static_cast<Weight>(angle * c[i].r));
}
}
return g;
}
const int V = 1500;
Weight h[V]; //??????????????£???
Weight dist[V]; //???????????¢
int prevv[V], preve[V]; //??´???????????¨??????
#define REP(i, n) for (int i = 0; i < (int)n; ++i)
#define FOR(i, c) for (auto i = (c).begin(); i != (c).end(); ++i)
#define ALL(c) (c).begin(), (c).end()
const Weight INF = 1e18;
Weight min_cost_flow(Graph &g, int s, int t, int f) {
Weight res = 0;
memset(h, 0, sizeof(h));
typedef pair<Weight, int> P;
while (f > 0) {
priority_queue<P, vector<P>, greater<P>> que;
fill(dist, dist + V, INF);
dist[s] = 0;
que.push(P(0, s));
while (!que.empty()) {
P p = que.top();
que.pop();
int v = p.second;
if (dist[v] < p.first)
continue;
REP(i, g[v].size()) {
Edge &e = g[v][i];
if (e.cap > 0 && dist[e.dest] > dist[v] + e.weight + h[v] - h[e.dest]) {
dist[e.dest] = dist[v] + e.weight + h[v] - h[e.dest];
prevv[e.dest] = v;
preve[e.dest] = i;
que.push(P(dist[e.dest], e.dest));
}
}
}
if (dist[t] == INF)
return -1;
REP(v, V) h[v] = h[v] + dist[v];
int d = f;
for (int v = t; v != s; v = prevv[v])
d = min(d, g[prevv[v]][preve[v]].cap);
f -= d;
res = res + d * h[t];
for (int v = t; v != s; v = prevv[v]) {
Edge &e = g[prevv[v]][preve[v]];
e.cap -= d;
g[v][e.rev].cap += d;
}
}
return res;
}
int main() {
int N;
cin >> N;
ld sx, sy;
cin >> sx >> sy;
Point sp;
sp = Point(sx, sy);
vector<Line> segs(N);
ld aans = 0;
for (int i = 0; i < N; ++i) {
ld ax, ay, bx, by;
cin >> ax >> ay >> bx >> by;
segs[i] = Line(Point(ax, ay), Point(bx, by));
aans += abs(segs[i].b - segs[i].a);
}
vector<pair<Point, Point>> pairs(N);
for (int i = 0; i < N; ++i) {
pairs[i] = make_pair(segs[i].a, segs[i].b);
}
const int start = 0;
const int in = start + 1;
const int out = in + pairs.size();
const int goal = out + pairs.size();
Graph aft(goal + 1);
for (int i = 0; i < pairs.size(); ++i) {
for (int j = 0; j < pairs.size(); ++j) {
ld dis = abs(pairs[i].second - pairs[j].first);
add_edge(aft, in + i, out + j, 1, dis);
}
}
for (int i = 0; i < pairs.size(); ++i) {
add_edge(aft, start, in + i, 1, 0);
add_edge(aft, out + i, goal, 1, 0);
}
aans = aans + min_cost_flow(aft, start, goal, pairs.size());
cout << fixed << setprecision(22) << aans << endl;
return 0;
} | #include "bits/stdc++.h"
using namespace std;
using ld = long double;
const ld eps = 1e-9;
typedef ld Weight;
struct Edge {
int src, dest;
int cap, rev;
Weight weight;
bool operator<(const Edge &rhs) const { return weight > rhs.weight; }
};
/* ??????????????¬ */
#include <complex>
typedef complex<ld> Point;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(), (x).end()
const ld pi = acos(-1.0);
const ld dtop = pi / 180.;
const ld ptod = 1. / dtop;
namespace std {
bool operator<(const Point &lhs, const Point &rhs) {
if (lhs.real() < rhs.real() - eps)
return true;
if (lhs.real() > rhs.real() + eps)
return false;
return lhs.imag() < rhs.imag();
}
} // namespace std
// ????????\???
Point input_Point() {
ld x, y;
cin >> x >> y;
return Point(x, y);
}
// ????????????????????????
bool eq(const ld a, const ld b) { return (abs(a - b) < eps); }
// ??????
ld dot(const Point &a, const Point &b) { return real(conj(a) * b); }
// ??????
ld cross(const Point &a, const Point &b) { return imag(conj(a) * b); }
// ??´????????????
class Line {
public:
Point a, b;
Line() : a(Point(0, 0)), b(Point(0, 0)) {}
Line(Point a, Point b) : a(a), b(b) {}
Point operator[](const int _num) const {
if (_num == 0)
return a;
else if (_num == 1)
return b;
else {
assert(false);
return Point();
}
}
};
// ????????????
class Circle {
public:
Point p;
ld r;
Circle() : p(Point(0, 0)), r(0) {}
Circle(Point p, ld r) : p(p), r(r) {}
};
// ccw
// 1: a,b,c??????????¨???¨?????????????????¶
//-1: a,b,c???????¨???¨?????????????????¶
// 2: c,a,b???????????´???????????¶
//-2: a,b,c???????????´???????????¶
// 0: a,c,b???????????´???????????¶
int ccw(const Point &a, const Point &b, const Point &c) {
const Point nb(b - a);
const Point nc(c - a);
if (cross(nb, nc) > eps)
return 1; // a,b,c??????????¨???¨?????????????????¶
if (cross(nb, nc) < -eps)
return -1; // a,b,c???????¨???¨?????????????????¶
if (dot(nb, nc) < 0)
return 2; // c,a,b???????????´???????????¶
if (norm(nb) < norm(nc))
return -2; // a,b,c???????????´???????????¶
return 0; // a,c,b???????????´???????????¶
}
/* ???????????? */
// ??´?????¨??´??????????????????
bool isis_ll(const Line &l, const Line &m) {
return !eq(cross(l.b - l.a, m.b - m.a), 0);
}
// ??´?????¨?????????????????????
bool isis_ls(const Line &l, const Line &s) {
return isis_ll(l, s) &&
(cross(l.b - l.a, s.a - l.a) * cross(l.b - l.a, s.b - l.a) < eps);
}
// ????????¨?????????????????????
bool isis_ss(const Line &s, const Line &t) {
return ccw(s.a, s.b, t.a) * ccw(s.a, s.b, t.b) <= 0 &&
ccw(t.a, t.b, s.a) * ccw(t.a, t.b, s.b) <= 0;
}
// ????????´????????????
bool isis_lp(const Line &l, const Point &p) {
return (abs(cross(l.b - p, l.a - p)) < eps);
}
// ?????????????????????
bool isis_sp(const Line &s, const Point &p) {
return (abs(s.a - p) + abs(s.b - p) - abs(s.b - s.a) < eps);
}
// ??????????¶?
Point proj(const Line &l, const Point &p) {
ld t = dot(p - l.a, l.b - l.a) / norm(l.a - l.b);
return l.a + t * (l.b - l.a);
}
//???????±??????????????????????
Point reflect(const Line &l, const Point &p) {
Point pr = proj(l, p);
return pr * 2.l - p;
}
// ??´?????¨??´????????????
Point is_ll(const Line &s, const Line &t) {
Point sv = s.b - s.a, tv = t.b - t.a;
assert(cross(sv, tv) != 0);
return s.a + sv * cross(tv, t.a - s.a) / cross(tv, sv);
}
// ??´?????¨??´????????????
vector<Point> is_ll2(const Line &s, const Line &t) {
Point sv = s.b - s.a, tv = t.b - t.a;
if (cross(sv, tv) != 0)
return vector<Point>(1, is_ll(s, t));
else {
vector<Point> ans;
for (int k = 0; k < 2; ++k) {
if (isis_sp(s, t[k]) && find(ans.begin(), ans.end(), t[k]) == ans.end())
ans.push_back(t[k]);
if (isis_sp(t, s[k]) && find(ans.begin(), ans.end(), s[k]) == ans.end())
ans.push_back(s[k]);
}
return ans;
}
}
// ????????¨???????????????
//???????????£????????¨???????????¨assert(false)
Point is_ss(const Line &s, const Line &t) {
if (isis_ss(s, t)) {
for (int k = 0; k < 2; ++k) {
for (int l = 0; l < 2; ++l) {
if (s[k] == t[l])
return s[k];
}
}
return is_ll(s, t);
} else {
//??????isis_ss?????????
assert(false);
return Point(0, 0);
}
}
// ????????¨???????????????
vector<Point> is_ss2(const Line &s, const Line &t) {
vector<Point> kouho(is_ll2(s, t));
vector<Point> ans;
for (auto p : kouho) {
if (isis_sp(s, p) && isis_sp(t, p))
ans.emplace_back(p);
}
return ans;
}
// ??´?????¨???????????¢
ld dist_lp(const Line &l, const Point &p) { return abs(p - proj(l, p)); }
//??´?????¨??´???????????¢
ld dist_ll(const Line &l, const Line &m) {
return isis_ll(l, m) ? 0 : dist_lp(l, m.a);
}
// ??´?????¨??????????????¢
ld dist_ls(const Line &l, const Line &s) {
return isis_ls(l, s) ? 0 : min(dist_lp(l, s.a), dist_lp(l, s.b));
}
// ????????¨???????????¢
ld dist_sp(const Line &s, const Point &p) {
Point r = proj(s, p);
return isis_sp(s, r) ? abs(r - p) : min(abs(s.a - p), abs(s.b - p));
}
// ????????¨??????????????¢
ld dist_ss(const Line &s, const Line &t) {
if (isis_ss(s, t))
return 0;
return min(
{dist_sp(s, t.a), dist_sp(s, t.b), dist_sp(t, s.a), dist_sp(t, s.b)});
}
//??´?????¨??´?????????????????????????????????
Line bisection(const Line &s, const Line &t) {
const Point laglanju(is_ll(s, t));
const Point avec =
!(abs(laglanju - s[0]) < eps) ? s[0] - laglanju : s[1] - laglanju;
const Point bvec =
!(abs(laglanju - t[0]) < eps) ? t[0] - laglanju : t[1] - laglanju;
return Line(laglanju, laglanju + (abs(bvec) * avec + abs(avec) * bvec) /
(abs(avec) + abs(bvec)));
}
//???????????´?????????????????????
//???????????´??????????????§???????????¨????¢?????????¨?????????
Point inner_center(const vector<Line> &ls) {
vector<Point> vertics;
for (int i = 0; i < static_cast<int>(ls.size()); ++i) {
vertics.push_back(is_ll(ls[i], ls[(i + 1) % 3]));
}
if (vertics[0] == vertics[1] || vertics[1] == vertics[2] ||
vertics[2] == vertics[0])
return vertics[0];
Line bi1(
bisection(Line(vertics[0], vertics[1]), Line(vertics[0], vertics[2])));
Line bi2(
bisection(Line(vertics[1], vertics[2]), Line(vertics[1], vertics[0])));
if (bi1[0] == bi2[0])
return bi1[0];
else {
return is_ll(bi1, bi2);
}
}
//???????????´?????????????????????
//???????????´??????????????§???????????¨????¢?????????¨?????????
vector<Point> ex_center(const vector<Line> &ls) {
vector<Point> vertics;
for (int i = 0; i < static_cast<int>(ls.size()); ++i) {
vertics.push_back(is_ll(ls[i], ls[(i + 1) % 3]));
}
if (abs(vertics[0] - vertics[1]) < eps ||
abs(vertics[1] - vertics[2]) < eps ||
(abs(vertics[2] - vertics[0]) < eps))
return vector<Point>();
vector<Point> ecs;
for (int i = 0; i < 3; ++i) {
Line bi1(
bisection(Line(vertics[i], vertics[i] * 2.0l - vertics[(i + 2) % 3]),
Line(vertics[i], vertics[(i + 1) % 3])));
Line bi2(bisection(Line(vertics[(i + 1) % 3],
vertics[(i + 1) % 3] * 2.0l - vertics[(i + 2) % 3]),
Line(vertics[(i + 1) % 3], vertics[i])));
ecs.push_back(is_ll(bi1, bi2));
}
return ecs;
}
// a,b:??????
// c:????????§??????
//???????????´?????????????????¢?????????????±??????????
vector<Point> same_dis(const vector<Line> &ls) {
vector<Point> vertics;
vertics.push_back(is_ll(ls[0], ls[2]));
vertics.push_back(is_ll(ls[1], ls[2]));
if (abs(vertics[0] - vertics[1]) < eps)
return vector<Point>{vertics[0]};
Line bis(bisection(ls[0], ls[1]));
vector<Point> ecs;
Line abi(bisection(Line(vertics[0], vertics[1]), ls[0]));
ecs.push_back(is_ll(bis, abi));
Line bbi(bisection(Line(vertics[0], 2.l * vertics[0] - vertics[1]), ls[0]));
ecs.push_back(is_ll(bis, bbi));
return ecs;
}
/* ??? */
// ?????¨????????????
vector<Point> is_cc(const Circle &c1, const Circle &c2) {
vector<Point> res;
ld d = abs(c1.p - c2.p);
ld rc = (d * d + c1.r * c1.r - c2.r * c2.r) / (2 * d);
ld dfr = c1.r * c1.r - rc * rc;
if (abs(dfr) < eps)
dfr = 0.0;
else if (dfr < 0.0)
return res; // no intersection
ld rs = sqrt(dfr);
Point diff = (c2.p - c1.p) / d;
res.push_back(c1.p + diff * Point(rc, rs));
if (dfr != 0.0)
res.push_back(c1.p + diff * Point(rc, -rs));
return res;
}
//???????????????????????????
/* 0 => out
1 => on
2 => in*/
int is_in_Circle(const Circle &cir, const Point &p) {
ld dis = abs(cir.p - p);
if (dis > cir.r + eps)
return 0;
else if (dis < cir.r - eps)
return 2;
else
return 1;
}
//???lc??????rc??????????????????
/*0 => out
1 => on
2 => in*/
int Circle_in_Circle(const Circle &lc, const Circle &rc) {
ld dis = abs(lc.p - rc.p);
if (dis < rc.r - lc.r - eps)
return 2;
else if (dis > rc.r - lc.r + eps)
return 0;
else
return 1;
}
// ?????¨??´????????????
vector<Point> is_lc(const Circle &c, const Line &l) {
vector<Point> res;
ld d = dist_lp(l, c.p);
if (d < c.r + eps) {
ld len = (d > c.r) ? 0.0 : sqrt(c.r * c.r - d * d); // safety;
Point nor = (l.a - l.b) / abs(l.a - l.b);
res.push_back(proj(l, c.p) + len * nor);
res.push_back(proj(l, c.p) - len * nor);
}
return res;
}
// ?????¨??????????????¢
vector<Point> is_sc(const Circle &c, const Line &l) {
vector<Point> v = is_lc(c, l), res;
for (Point p : v)
if (isis_sp(l, p))
res.push_back(p);
return res;
}
// ?????¨????????\???
vector<Line> tangent_cp(const Circle &c, const Point &p) {
vector<Line> ret;
Point v = c.p - p;
ld d = abs(v);
ld l = sqrt(norm(v) - c.r * c.r);
if (isnan(l)) {
return ret;
}
Point v1 = v * Point(l / d, c.r / d);
Point v2 = v * Point(l / d, -c.r / d);
ret.push_back(Line(p, p + v1));
if (l < eps)
return ret;
ret.push_back(Line(p, p + v2));
return ret;
}
// ?????¨????????\???
vector<Line> tangent_cc(const Circle &c1, const Circle &c2) {
vector<Line> ret;
if (abs(c1.p - c2.p) - (c1.r + c2.r) > -eps) {
Point center = (c1.p * c2.r + c2.p * c1.r) / (c1.r + c2.r);
ret = tangent_cp(c1, center);
}
if (abs(c1.r - c2.r) > eps) {
Point out = (-c1.p * c2.r + c2.p * c1.r) / (c1.r - c2.r);
vector<Line> nret = tangent_cp(c1, out);
ret.insert(ret.end(), all(nret));
} else {
Point v = c2.p - c1.p;
v /= abs(v);
Point q1 = c1.p + v * Point(0, 1) * c1.r;
Point q2 = c1.p + v * Point(0, -1) * c1.r;
ret.push_back(Line(q1, q1 + v));
ret.push_back(Line(q2, q2 + v));
}
return ret;
}
//??????????????????????????¢???
ld two_Circle_area(const Circle &l, const Circle &r) {
ld dis = abs(l.p - r.p);
if (dis > l.r + r.r)
return 0;
else if (dis + r.r < l.r) {
return r.r * r.r * pi;
} else if (dis + l.r < r.r) {
return l.r * l.r * pi;
} else {
ld ans = (l.r) * (l.r) *
acos((dis * dis + l.r * l.r - r.r * r.r) / (2 * dis * l.r)) +
(r.r) * (r.r) *
acos((dis * dis + r.r * r.r - l.r * l.r) / (2 * dis * r.r)) -
sqrt(4 * dis * dis * l.r * l.r -
(dis * dis + l.r * l.r - r.r * r.r) *
(dis * dis + l.r * l.r - r.r * r.r)) /
2;
return ans;
}
}
/* ????§???¢ */
typedef vector<Point> Polygon;
// ??¢???
ld area(const Polygon &p) {
ld res = 0;
int n = p.size();
rep(j, n) res += cross(p[j], p[(j + 1) % n]);
return res / 2;
}
//????§???¢????????¢??????
bool is_counter_clockwise(const Polygon &poly) {
ld angle = 0;
int n = poly.size();
rep(i, n) {
Point a = poly[i], b = poly[(i + 1) % n], c = poly[(i + 2) % n];
angle += arg((c - b) / (b - a));
}
return angle > eps;
}
// ??????????????????
/*0 => out
1 => on
2 => in*/
int is_in_Polygon(const Polygon &poly, const Point &p) {
ld angle = 0;
int n = poly.size();
rep(i, n) {
Point a = poly[i], b = poly[(i + 1) % n];
if (isis_sp(Line(a, b), p))
return 1;
angle += arg((b - p) / (a - p));
}
return eq(angle, 0) ? 0 : 2;
}
//??????????????????2?????????
enum { out, on, in };
int convex_contains(const Polygon &P, const Point &p) {
const int n = P.size();
Point g = (P[0] + P[n / 3] + P[2 * n / 3]) / 3.0l; // inner-point
int a = 0, b = n;
while (a + 1 < b) { // invariant: c is in fan g-P[a]-P[b]
int c = (a + b) / 2;
if (cross(P[a] - g, P[c] - g) > 0) { // angle < 180 deg
if (cross(P[a] - g, p - g) > 0 && cross(P[c] - g, p - g) < 0)
b = c;
else
a = c;
} else {
if (cross(P[a] - g, p - g) < 0 && cross(P[c] - g, p - g) > 0)
a = c;
else
b = c;
}
}
b %= n;
if (cross(P[a] - p, P[b] - p) < 0)
return 0;
if (cross(P[a] - p, P[b] - p) > 0)
return 2;
return 1;
}
// ??????
//???????????????????????¨????????????????????§??¨???
Polygon convex_hull(vector<Point> ps) {
int n = ps.size();
int k = 0;
sort(ps.begin(), ps.end());
Polygon ch(2 * n);
for (int i = 0; i < n; ch[k++] = ps[i++])
while (k >= 2 && ccw(ch[k - 2], ch[k - 1], ps[i]) <= 0)
--k;
for (int i = n - 2, t = k + 1; i >= 0; ch[k++] = ps[i--])
while (k >= t && ccw(ch[k - 2], ch[k - 1], ps[i]) <= 0)
--k;
ch.resize(k - 1);
return ch;
}
//????????????
vector<Polygon> convex_cut(const Polygon &ps, const Line &l) {
int n = ps.size();
Polygon q;
Polygon r;
rep(i, n) {
Point a = ps[i], b = ps[(i + 1) % n];
Line m = Line(a, b);
if (ccw(l.a, l.b, a) != -1)
q.push_back(a);
if (ccw(l.a, l.b, a) != 1)
r.push_back(a);
if (ccw(l.a, l.b, a) * ccw(l.a, l.b, b) < 0 && isis_ll(l, m)) {
q.push_back(is_ll(l, m));
r.push_back(is_ll(l, m));
}
}
const vector<Polygon> polys{q, r};
return polys;
}
/* ??¢??¬??????????????? */
void add_Point(vector<Point> &ps, const Point p) {
for (Point q : ps)
if (abs(q - p) < eps)
return;
ps.push_back(p);
}
typedef vector<Edge> Edges;
typedef vector<Edges> Graph;
typedef vector<Weight> Array;
typedef vector<Array> Matrix;
void add_edge(Graph &g, int src, int dest, int cap, Weight weight) {
g[src].push_back(Edge{src, dest, cap, (int)g[dest].size(), weight});
g[dest].push_back(Edge{dest, src, 0, (int)g[src].size() - 1, -weight});
}
Graph segment_arrangement(const vector<Line> &s, const vector<Point> &p) {
int n = p.size(), m = s.size();
Graph g(n);
rep(i, m) {
vector<pair<ld, int>> vec;
rep(j, n) {
if (isis_sp(s[i], p[j]))
vec.emplace_back(abs(s[i].a - p[j]), j);
}
sort(all(vec));
rep(j, vec.size() - 1) {
int from = vec[j].second, to = vec[j + 1].second;
add_edge(g, from, to, 1, static_cast<Weight>(abs(p[from] - p[to])));
}
}
return g;
}
pair<vector<Point>, Graph> sennbunn_arrangement(const vector<Line> &s) {
vector<Point> crss;
for (int i = 0; i < static_cast<int>(s.size()); ++i) {
for (int j = i + 1; j < static_cast<int>(s.size()); ++j) {
if (isis_ss(s[i], s[j])) {
crss.push_back(is_ll2(s[i], s[j])[0]);
}
}
}
for (int i = 0; i < static_cast<int>(s.size()); ++i) {
crss.push_back(s[i][0]);
crss.push_back(s[i][1]);
}
sort(crss.begin(), crss.end());
crss.erase(unique(crss.begin(), crss.end()), crss.end());
return make_pair(crss, segment_arrangement(s, crss));
}
Graph Circle_arrangement(const vector<Circle> &c, const vector<Point> &p) {
const int n = p.size(), m = c.size();
Graph g(n);
rep(i, m) {
vector<pair<ld, int>> vec;
rep(j, n) if (abs(abs(c[i].p - p[j]) - c[i].r) < eps)
vec.emplace_back(arg(c[i].p - p[j]), j);
sort(all(vec));
rep(j, vec.size() - 1) {
int from = vec[j].second, to = vec[j + 1].second;
ld angle = vec[j + 1].first - vec[j].first;
add_edge(g, from, to, 1, static_cast<Weight>(angle * c[i].r));
}
if (vec.size() >= 2) {
int from = vec.back().second, to = vec.front().first;
ld angle = vec.front().first - vec.back().first;
add_edge(g, from, to, 1, static_cast<Weight>(angle * c[i].r));
}
}
return g;
}
const int V = 1500;
Weight h[V]; //??????????????£???
Weight dist[V]; //???????????¢
int prevv[V], preve[V]; //??´???????????¨??????
#define REP(i, n) for (int i = 0; i < (int)n; ++i)
#define FOR(i, c) for (auto i = (c).begin(); i != (c).end(); ++i)
#define ALL(c) (c).begin(), (c).end()
const Weight INF = 1e18;
Weight min_cost_flow(Graph &g, int s, int t, int f) {
Weight res = 0;
memset(h, 0, sizeof(h));
typedef pair<Weight, int> P;
while (f > 0) {
priority_queue<P, vector<P>, greater<P>> que;
fill(dist, dist + V, INF);
dist[s] = 0;
que.push(P(0, s));
while (!que.empty()) {
P p = que.top();
que.pop();
int v = p.second;
if (dist[v] < p.first)
continue;
REP(i, g[v].size()) {
Edge &e = g[v][i];
if (e.cap > 0 &&
dist[e.dest] > dist[v] + e.weight + h[v] - h[e.dest] + eps) {
dist[e.dest] = dist[v] + e.weight + h[v] - h[e.dest];
prevv[e.dest] = v;
preve[e.dest] = i;
que.push(P(dist[e.dest], e.dest));
}
}
}
if (dist[t] == INF)
return -1;
REP(v, V) h[v] = h[v] + dist[v];
int d = f;
for (int v = t; v != s; v = prevv[v])
d = min(d, g[prevv[v]][preve[v]].cap);
f -= d;
res = res + d * h[t];
for (int v = t; v != s; v = prevv[v]) {
Edge &e = g[prevv[v]][preve[v]];
e.cap -= d;
g[v][e.rev].cap += d;
}
}
return res;
}
int main() {
int N;
cin >> N;
ld sx, sy;
cin >> sx >> sy;
Point sp;
sp = Point(sx, sy);
vector<Line> segs(N);
ld aans = 0;
for (int i = 0; i < N; ++i) {
ld ax, ay, bx, by;
cin >> ax >> ay >> bx >> by;
segs[i] = Line(Point(ax, ay), Point(bx, by));
aans += abs(segs[i].b - segs[i].a);
}
vector<pair<Point, Point>> pairs(N);
for (int i = 0; i < N; ++i) {
pairs[i] = make_pair(segs[i].a, segs[i].b);
}
const int start = 0;
const int in = start + 1;
const int out = in + pairs.size();
const int goal = out + pairs.size();
Graph aft(goal + 1);
for (int i = 0; i < pairs.size(); ++i) {
for (int j = 0; j < pairs.size(); ++j) {
ld dis = abs(pairs[i].second - pairs[j].first);
add_edge(aft, in + i, out + j, 1, dis);
}
}
for (int i = 0; i < pairs.size(); ++i) {
add_edge(aft, start, in + i, 1, 0);
add_edge(aft, out + i, goal, 1, 0);
}
aans = aans + min_cost_flow(aft, start, goal, pairs.size());
cout << fixed << setprecision(22) << aans << endl;
return 0;
} | replace | 629 | 630 | 629 | 631 | TLE | |
p01825 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<ll, ll> P;
#define EACH(i, a) for (auto &i : a)
#define FOR(i, a, b) for (ll i = (a); i < (b); i++)
#define RFOR(i, a, b) for (ll i = (b)-1; i >= (a); i--)
#define REP(i, n) for (ll i = 0; i < (n); i++)
#define RREP(i, n) for (ll i = (n)-1; i >= 0; i--)
#define debug(x) cout << #x << ": " << x << endl
#define pb push_back
#define ALL(a) (a).begin(), (a).end()
const ll linf = 1e18;
const int inf = 1e9;
const double eps = 1e-12;
const double pi = acos(-1);
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
EACH(x, vec) is >> x;
return is;
}
template <typename T> ostream &operator<<(ostream &os, vector<T> &vec) {
REP(i, vec.size()) {
if (i)
os << " ";
os << vec[i];
}
return os;
}
template <typename T> ostream &operator<<(ostream &os, vector<vector<T>> &vec) {
REP(i, vec.size()) {
if (i)
os << endl;
os << vec[i];
}
return os;
}
typedef double Weight;
struct Edge {
ll to, cap;
Weight cost;
ll rev;
};
vector<vector<Edge>> G;
void add_edge(ll from, ll to, ll cap, Weight cost) {
if (from < 0 || to < 0)
return;
G[from].push_back({to, cap, cost, (ll)G[to].size()});
G[to].push_back({from, 0, -cost, (ll)G[from].size() - 1});
}
Weight dist[21000], h[21000] = {0};
ll prevV[21000], prevE[21000];
double min_cost_flow(ll s, ll t, ll f) {
typedef pair<Weight, ll> _P;
Weight res = 0;
while (f > 0) {
fill_n(dist, 21000, inf);
dist[s] = 0;
priority_queue<_P, vector<_P>, greater<_P>> Q;
Q.push({0, s});
while (!Q.empty()) {
_P p = Q.top();
Q.pop();
ll v = p.second;
if (p.first > dist[v])
continue;
REP(i, G[v].size()) {
Edge &e = G[v][i];
if (e.cap > 0 && dist[v] + e.cost + h[v] - h[e.to] < dist[e.to]) {
dist[e.to] = dist[v] + e.cost + h[v] - h[e.to];
prevV[e.to] = v;
prevE[e.to] = i;
Q.push({dist[e.to], e.to});
}
}
}
REP(i, G.size()) h[i] += dist[i];
if (abs(dist[t] - inf) < eps) {
cout << "ERROR" << endl;
exit(1);
}
ll d = f;
for (ll v = t; v != s; v = prevV[v]) {
d = min(d, G[prevV[v]][prevE[v]].cap);
}
f -= d;
res += d * h[t];
for (ll v = t; v != s; v = prevV[v]) {
Edge &e = G[prevV[v]][prevE[v]];
e.cap -= d;
G[e.to][e.rev].cap += d;
}
}
return res;
}
typedef complex<double> Point;
template <typename T> istream &operator>>(istream &is, complex<T> &p) {
T x, y;
is >> x >> y;
p = {x, y};
return is;
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
int n;
cin >> n;
Point sp;
cin >> sp;
vector<pair<Point, Point>> v(n);
REP(i, n) cin >> v[i].first >> v[i].second;
double ans = 0;
REP(i, n) ans += abs(v[i].second - v[i].first);
int lid = 0;
vector<int> fid(n), tid(n);
REP(i, n) fid[i] = lid++;
REP(i, n) tid[i] = lid++;
int s = lid++, t = lid++;
G.clear();
G.resize(lid);
REP(i, n) REP(j, n) {
double cost = abs(v[i].second - v[j].first);
add_edge(fid[i], tid[j], 1, cost);
}
REP(i, n) add_edge(s, fid[i], 1, 0);
REP(i, n) add_edge(tid[i], t, 1, 0);
ans += min_cost_flow(s, t, n);
cout << fixed << setprecision(10) << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<ll, ll> P;
#define EACH(i, a) for (auto &i : a)
#define FOR(i, a, b) for (ll i = (a); i < (b); i++)
#define RFOR(i, a, b) for (ll i = (b)-1; i >= (a); i--)
#define REP(i, n) for (ll i = 0; i < (n); i++)
#define RREP(i, n) for (ll i = (n)-1; i >= 0; i--)
#define debug(x) cout << #x << ": " << x << endl
#define pb push_back
#define ALL(a) (a).begin(), (a).end()
const ll linf = 1e18;
const int inf = 1e9;
const double eps = 1e-12;
const double pi = acos(-1);
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
EACH(x, vec) is >> x;
return is;
}
template <typename T> ostream &operator<<(ostream &os, vector<T> &vec) {
REP(i, vec.size()) {
if (i)
os << " ";
os << vec[i];
}
return os;
}
template <typename T> ostream &operator<<(ostream &os, vector<vector<T>> &vec) {
REP(i, vec.size()) {
if (i)
os << endl;
os << vec[i];
}
return os;
}
typedef double Weight;
struct Edge {
ll to, cap;
Weight cost;
ll rev;
};
vector<vector<Edge>> G;
void add_edge(ll from, ll to, ll cap, Weight cost) {
if (from < 0 || to < 0)
return;
G[from].push_back({to, cap, cost, (ll)G[to].size()});
G[to].push_back({from, 0, -cost, (ll)G[from].size() - 1});
}
Weight dist[21000], h[21000] = {0};
ll prevV[21000], prevE[21000];
double min_cost_flow(ll s, ll t, ll f) {
typedef pair<Weight, ll> _P;
Weight res = 0;
while (f > 0) {
fill_n(dist, 21000, inf);
dist[s] = 0;
priority_queue<_P, vector<_P>, greater<_P>> Q;
Q.push({0, s});
while (!Q.empty()) {
_P p = Q.top();
Q.pop();
ll v = p.second;
if (p.first > dist[v])
continue;
REP(i, G[v].size()) {
Edge &e = G[v][i];
if (e.cap > eps &&
dist[v] + e.cost + h[v] - h[e.to] + eps < dist[e.to]) {
dist[e.to] = dist[v] + e.cost + h[v] - h[e.to];
prevV[e.to] = v;
prevE[e.to] = i;
Q.push({dist[e.to], e.to});
}
}
}
REP(i, G.size()) h[i] += dist[i];
if (abs(dist[t] - inf) < eps) {
cout << "ERROR" << endl;
exit(1);
}
ll d = f;
for (ll v = t; v != s; v = prevV[v]) {
d = min(d, G[prevV[v]][prevE[v]].cap);
}
f -= d;
res += d * h[t];
for (ll v = t; v != s; v = prevV[v]) {
Edge &e = G[prevV[v]][prevE[v]];
e.cap -= d;
G[e.to][e.rev].cap += d;
}
}
return res;
}
typedef complex<double> Point;
template <typename T> istream &operator>>(istream &is, complex<T> &p) {
T x, y;
is >> x >> y;
p = {x, y};
return is;
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
int n;
cin >> n;
Point sp;
cin >> sp;
vector<pair<Point, Point>> v(n);
REP(i, n) cin >> v[i].first >> v[i].second;
double ans = 0;
REP(i, n) ans += abs(v[i].second - v[i].first);
int lid = 0;
vector<int> fid(n), tid(n);
REP(i, n) fid[i] = lid++;
REP(i, n) tid[i] = lid++;
int s = lid++, t = lid++;
G.clear();
G.resize(lid);
REP(i, n) REP(j, n) {
double cost = abs(v[i].second - v[j].first);
add_edge(fid[i], tid[j], 1, cost);
}
REP(i, n) add_edge(s, fid[i], 1, 0);
REP(i, n) add_edge(tid[i], t, 1, 0);
ans += min_cost_flow(s, t, n);
cout << fixed << setprecision(10) << ans << endl;
} | replace | 79 | 80 | 79 | 81 | TLE | |
p01829 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
string S, res;
cin >> S;
ll n = S.size(), md = -1, MAX = 1, s = stoi(S);
vector<int> digit = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
for (int i = 0; i < n; i++) {
MAX *= 10;
}
do {
ll val = 0;
string v;
for (int i = 0; i < n; i++) {
val = val * 10 + digit[i];
v.push_back('0' + digit[i]);
}
ll d = min(MAX - abs(s - val), abs(s - val));
if (d > md) {
md = d;
res = v;
}
} while (next_permutation(digit.begin(), digit.end()));
cout << res << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
string S, res;
cin >> S;
ll n = S.size(), md = -1, MAX = 1, s = stoll(S);
vector<int> digit = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
for (int i = 0; i < n; i++) {
MAX *= 10;
}
do {
ll val = 0;
string v;
for (int i = 0; i < n; i++) {
val = val * 10 + digit[i];
v.push_back('0' + digit[i]);
}
ll d = min(MAX - abs(s - val), abs(s - val));
if (d > md) {
md = d;
res = v;
}
} while (next_permutation(digit.begin(), digit.end()));
cout << res << endl;
return 0;
} | replace | 7 | 8 | 7 | 8 | 0 | |
p01829 | C++ | Runtime Error | #include <cmath>
#include <iomanip>
#include <iostream>
#include <string>
using namespace std;
using lint = long long;
lint ten = 1;
lint M;
lint maxdiff = 0, ans = 0;
void dfs(int N, int used, lint num) {
if (N == 0) {
lint diff = min(abs(num - M), ten - abs(num - M));
if (diff > maxdiff || (diff == maxdiff && num < ans)) {
ans = num;
maxdiff = diff;
}
} else {
for (int d = 0; d < 10; ++d) {
if ((used >> d) & 1)
continue;
dfs(N - 1, used | (1 << d), num * 10 + d);
}
}
}
int main() {
string S;
cin >> S;
int N = S.size();
for (int i = 0; i < N; ++i)
ten *= 10;
M = stoi(S);
dfs(N, 0, 0);
cout << right << setw(N) << setfill('0') << ans << endl;
return 0;
}
| #include <cmath>
#include <iomanip>
#include <iostream>
#include <string>
using namespace std;
using lint = long long;
lint ten = 1;
lint M;
lint maxdiff = 0, ans = 0;
void dfs(int N, int used, lint num) {
if (N == 0) {
lint diff = min(abs(num - M), ten - abs(num - M));
if (diff > maxdiff || (diff == maxdiff && num < ans)) {
ans = num;
maxdiff = diff;
}
} else {
for (int d = 0; d < 10; ++d) {
if ((used >> d) & 1)
continue;
dfs(N - 1, used | (1 << d), num * 10 + d);
}
}
}
int main() {
string S;
cin >> S;
int N = S.size();
for (int i = 0; i < N; ++i)
ten *= 10;
M = stoll(S);
dfs(N, 0, 0);
cout << right << setw(N) << setfill('0') << ans << endl;
return 0;
}
| replace | 34 | 35 | 34 | 35 | 0 | |
p01840 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<ll> VL;
typedef vector<VL> VVL;
typedef pair<int, int> PII;
#define FOR(i, a, n) for (ll i = (ll)a; i < (ll)n; ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(x) x.begin(), x.end()
#define MP make_pair
#define PB push_back
#define MOD 1000000007
#define INF (1LL << 30)
#define LLINF (1LL << 60)
#define PI 3.14159265359
#define EPS 1e-12
#define int ll
signed main(void) {
int n, m, t, a[105], b[10010];
cin >> n >> m >> t;
REP(i, n) {
cin >> a[i];
b[a[i] - m]++;
b[a[i] + m]--;
}
FOR(i, 1, t) b[i] += b[i - 1];
int ret = 0;
REP(i, t) if (b[i] == 0) ret++;
cout << ret << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<ll> VL;
typedef vector<VL> VVL;
typedef pair<int, int> PII;
#define FOR(i, a, n) for (ll i = (ll)a; i < (ll)n; ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(x) x.begin(), x.end()
#define MP make_pair
#define PB push_back
#define MOD 1000000007
#define INF (1LL << 30)
#define LLINF (1LL << 60)
#define PI 3.14159265359
#define EPS 1e-12
#define int ll
signed main(void) {
int n, m, t, a[105], b[10010];
cin >> n >> m >> t;
REP(i, n) {
cin >> a[i];
b[max((ll)0, a[i] - m)]++;
b[min(t, a[i] + m)]--;
}
FOR(i, 1, t) b[i] += b[i - 1];
int ret = 0;
REP(i, t) if (b[i] == 0) ret++;
cout << ret << endl;
return 0;
} | replace | 27 | 29 | 27 | 29 | 0 | |
p01840 | C++ | Runtime Error | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (n); i++)
#define PB push_back
#define MP make_pair
#define ALL(a) (a).begin(), (a).end()
#define ll long long
using namespace std;
int main() {
int n, m, t, a;
int time[10100];
memset(time, 0, sizeof(time));
cin >> n >> m >> t;
REP(i, n) {
cin >> a;
time[a - m]++;
time[a + m]--;
}
REP(i, t) time[i + 1] += time[i];
int ans = 0;
REP(i, t) if (time[i] == 0) ans++;
cout << ans << endl;
} | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (n); i++)
#define PB push_back
#define MP make_pair
#define ALL(a) (a).begin(), (a).end()
#define ll long long
using namespace std;
int main() {
int n, m, t, a;
int time[10100];
memset(time, 0, sizeof(time));
cin >> n >> m >> t;
REP(i, n) {
cin >> a;
time[a - m]++;
time[min(a + m, 10010)]--;
}
REP(i, t) time[i + 1] += time[i];
int ans = 0;
REP(i, t) if (time[i] == 0) ans++;
cout << ans << endl;
} | replace | 15 | 16 | 15 | 16 | 0 | |
p01840 | C++ | Runtime Error | #include <iostream>
using namespace std;
int main() {
int N, M, T, t[100];
int imos[10001] = {0};
cin >> N >> M >> T;
for (int i = 0; i < N; i++) {
int t;
cin >> t;
imos[t - M]++, imos[t + M]--;
}
for (int i = 1; i <= T; i++) {
imos[i] += imos[i - 1];
}
int cnt = 0;
for (int i = 0; i < T; i++) {
if (!imos[i])
cnt++;
}
cout << cnt << endl;
} | #include <iostream>
using namespace std;
int main() {
int N, M, T, t[100];
int imos[30000] = {0};
cin >> N >> M >> T;
for (int i = 0; i < N; i++) {
int t;
cin >> t;
imos[t - M]++, imos[t + M]--;
}
for (int i = 1; i <= T; i++) {
imos[i] += imos[i - 1];
}
int cnt = 0;
for (int i = 0; i < T; i++) {
if (!imos[i])
cnt++;
}
cout << cnt << endl;
} | replace | 6 | 7 | 6 | 7 | 0 | |
p01840 | C++ | Runtime Error | /* template.cpp {{{ */
#include <bits/stdc++.h>
using namespace std;
#define get_macro(a, b, c, d, name, ...) name
#define rep(...) get_macro(__VA_ARGS__, rep4, rep3, rep2, rep1)(__VA_ARGS__)
#define rrep(...) \
get_macro(__VA_ARGS__, rrep4, rrep3, rrep2, rrep1)(__VA_ARGS__)
#define rep1(n) rep2(i_, n)
#define rep2(i, n) rep3(i, 0, n)
#define rep3(i, a, b) rep4(i, a, b, 1)
#define rep4(i, a, b, s) for (ll i = (a); i < (ll)(b); i += (ll)(s))
#define rrep1(n) rrep2(i_, n)
#define rrep2(i, n) rrep3(i, 0, n)
#define rrep3(i, a, b) rrep4(i, a, b, 1)
#define rrep4(i, a, b, s) for (ll i = (ll)(b)-1; i >= (ll)(a); i -= (ll)(s))
#define each(x, c) for (auto &&x : c)
#define fs first
#define sc second
#define all(c) begin(c), end(c)
using ui = unsigned;
using ll = long long;
using ul = unsigned long long;
using ld = long double;
const int inf = 1e9 + 10;
const ll inf_ll = 1e18 + 10;
const ll mod = 1e9 + 7;
const ll mod9 = 1e9 + 9;
const int dx[]{-1, 0, 1, 0, -1, 1, 1, -1};
const int dy[]{0, -1, 0, 1, -1, -1, 1, 1};
template <class T, class U> void chmin(T &x, const U &y) { x = min<T>(x, y); }
template <class T, class U> void chmax(T &x, const U &y) { x = max<T>(x, y); }
struct prepare_ {
prepare_() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(12);
}
} prepare__;
/* }}} */
int n, m, t;
int a[100];
int b[10000];
int main() {
cin >> n >> m >> t;
rep(i, n) {
cin >> a[i];
rep(j, a[i] - m, a[i] + m) b[j] = 1;
}
int res = t;
rep(i, t) res -= b[i];
cout << res << endl;
} | /* template.cpp {{{ */
#include <bits/stdc++.h>
using namespace std;
#define get_macro(a, b, c, d, name, ...) name
#define rep(...) get_macro(__VA_ARGS__, rep4, rep3, rep2, rep1)(__VA_ARGS__)
#define rrep(...) \
get_macro(__VA_ARGS__, rrep4, rrep3, rrep2, rrep1)(__VA_ARGS__)
#define rep1(n) rep2(i_, n)
#define rep2(i, n) rep3(i, 0, n)
#define rep3(i, a, b) rep4(i, a, b, 1)
#define rep4(i, a, b, s) for (ll i = (a); i < (ll)(b); i += (ll)(s))
#define rrep1(n) rrep2(i_, n)
#define rrep2(i, n) rrep3(i, 0, n)
#define rrep3(i, a, b) rrep4(i, a, b, 1)
#define rrep4(i, a, b, s) for (ll i = (ll)(b)-1; i >= (ll)(a); i -= (ll)(s))
#define each(x, c) for (auto &&x : c)
#define fs first
#define sc second
#define all(c) begin(c), end(c)
using ui = unsigned;
using ll = long long;
using ul = unsigned long long;
using ld = long double;
const int inf = 1e9 + 10;
const ll inf_ll = 1e18 + 10;
const ll mod = 1e9 + 7;
const ll mod9 = 1e9 + 9;
const int dx[]{-1, 0, 1, 0, -1, 1, 1, -1};
const int dy[]{0, -1, 0, 1, -1, -1, 1, 1};
template <class T, class U> void chmin(T &x, const U &y) { x = min<T>(x, y); }
template <class T, class U> void chmax(T &x, const U &y) { x = max<T>(x, y); }
struct prepare_ {
prepare_() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(12);
}
} prepare__;
/* }}} */
int n, m, t;
int a[100];
int b[40000];
int main() {
cin >> n >> m >> t;
rep(i, n) {
cin >> a[i];
rep(j, a[i] - m, a[i] + m) b[j] = 1;
}
int res = t;
rep(i, t) res -= b[i];
cout << res << endl;
} | replace | 42 | 43 | 42 | 43 | 0 | |
p01840 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstdio>
#include <fstream>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <time.h>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
typedef vector<ll> V;
typedef complex<double> Point;
#define PI acos(-1.0)
#define EPS 1e-10
const ll INF = (1LL << 31) - 1;
const ll MOD = 1e9 + 7;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define rep(i, N) for (int i = 0; i < (N); i++)
#define ALL(s) (s).begin(), (s).end()
#define EQ(a, b) (abs((a) - (b)) < EPS)
#define EQV(a, b) (EQ((a).real(), (b).real()) && EQ((a).imag(), (b).imag()))
#define fi first
#define se second
#define N_SIZE (1LL << 20)
#define NIL -1
#define MAX_N 100100 * 3
int T[10100];
int n, m, t;
int main() {
cin >> n >> m >> t;
rep(i, n) {
int tt;
cin >> tt;
T[tt - m]++;
T[tt + m]--;
}
rep(i, t) { T[i + 1] += T[i]; }
int ans = 0;
rep(i, t) {
// cout << i << " " << T[i] << endl;
ans += (T[i] == 0);
}
cout << ans << endl;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstdio>
#include <fstream>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <time.h>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
typedef vector<ll> V;
typedef complex<double> Point;
#define PI acos(-1.0)
#define EPS 1e-10
const ll INF = (1LL << 31) - 1;
const ll MOD = 1e9 + 7;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define rep(i, N) for (int i = 0; i < (N); i++)
#define ALL(s) (s).begin(), (s).end()
#define EQ(a, b) (abs((a) - (b)) < EPS)
#define EQV(a, b) (EQ((a).real(), (b).real()) && EQ((a).imag(), (b).imag()))
#define fi first
#define se second
#define N_SIZE (1LL << 20)
#define NIL -1
#define MAX_N 100100 * 3
int T[20100];
int n, m, t;
int main() {
cin >> n >> m >> t;
rep(i, n) {
int tt;
cin >> tt;
T[tt - m]++;
T[tt + m]--;
}
rep(i, t) { T[i + 1] += T[i]; }
int ans = 0;
rep(i, t) {
// cout << i << " " << T[i] << endl;
ans += (T[i] == 0);
}
cout << ans << endl;
} | replace | 42 | 43 | 42 | 43 | 0 | |
p01840 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define INF 999999999
#define mod 1000000007
#define rep(i, n) for (int i = 0; i < int(n); i++)
#define rrep(i, n) for (int i = (n); i >= 0; i--)
#define REP(i, a, b) for (int i = (a); i < int(b); i++)
#define all(x) (x).begin(), x.end()
#define pb push_back
#define MOD(x) (x % (mod))
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef pair<int, int> pi;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
bool debug = false;
/*---------------------------------------------------*/
int main() {
int n, m, t;
int a;
int time[10005];
rep(i, 10005) time[i] = 0;
cin >> n >> m >> t;
rep(i, n) {
cin >> a;
time[a - m] += 1;
time[a + m] -= 1;
}
for (int i = 1; i <= t; i++)
time[i] += time[i - 1];
int ans = 0;
for (int i = 0; i < t; i++)
if (time[i] == 0)
ans++;
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define INF 999999999
#define mod 1000000007
#define rep(i, n) for (int i = 0; i < int(n); i++)
#define rrep(i, n) for (int i = (n); i >= 0; i--)
#define REP(i, a, b) for (int i = (a); i < int(b); i++)
#define all(x) (x).begin(), x.end()
#define pb push_back
#define MOD(x) (x % (mod))
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef pair<int, int> pi;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
bool debug = false;
/*---------------------------------------------------*/
int main() {
int n, m, t;
int a;
int time[20005];
rep(i, 20005) time[i] = 0;
cin >> n >> m >> t;
rep(i, n) {
cin >> a;
time[a - m] += 1;
time[a + m] -= 1;
}
for (int i = 1; i <= t; i++)
time[i] += time[i - 1];
int ans = 0;
for (int i = 0; i < t; i++)
if (time[i] == 0)
ans++;
cout << ans << endl;
return 0;
} | replace | 37 | 39 | 37 | 39 | 0 | |
p01840 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
signed main() {
bool a[10001]{};
int b, c, d;
cin >> b >> c >> d;
for (int e = 0; e < b; e++) {
int f;
cin >> f;
for (int g = f - c; g < f + c; g++) {
a[g] = true;
}
}
int s = 0;
for (int h = 0; h < d; h++) {
if (!a[h])
s++;
}
cout << s << endl;
} | #include <bits/stdc++.h>
using namespace std;
signed main() {
bool a[30000]{};
int b, c, d;
cin >> b >> c >> d;
for (int e = 0; e < b; e++) {
int f;
cin >> f;
for (int g = f - c; g < f + c; g++) {
a[g] = true;
}
}
int s = 0;
for (int h = 0; h < d; h++) {
if (!a[h])
s++;
}
cout << s << endl;
} | replace | 4 | 5 | 4 | 5 | 0 | |
p01840 | C++ | Runtime Error | #include <iostream>
using namespace std;
int a[10000], n, m, t, p;
int main() {
cin >> n >> m >> t;
for (int i = 0; i < n; i++) {
cin >> p;
a[p - m]++;
a[p + m]--;
}
for (int i = 1; i < t; i++)
a[i] += a[i - 1];
int cnt = 0;
for (int i = 0; i < t; i++) {
if (a[i] == 0)
cnt++;
}
cout << cnt << endl;
return 0;
} | #include <iostream>
using namespace std;
int a[100000], n, m, t, p;
int main() {
cin >> n >> m >> t;
for (int i = 0; i < n; i++) {
cin >> p;
a[p - m]++;
a[p + m]--;
}
for (int i = 1; i < t; i++)
a[i] += a[i - 1];
int cnt = 0;
for (int i = 0; i < t; i++) {
if (a[i] == 0)
cnt++;
}
cout << cnt << endl;
return 0;
} | replace | 2 | 3 | 2 | 3 | 0 | |
p01840 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, t;
cin >> n >> m >> t;
int s[11451] = {};
for (int i = 0; i < n; i++) {
int a;
cin >> a;
s[a - m + 1]++;
s[a + m + 1]--;
}
for (int i = 1; i < 11450; i++) {
s[i] += s[i - 1];
}
int ans = 0;
for (int i = 1; i <= t; i++) {
if (!s[i])
ans++;
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, t;
cin >> n >> m >> t;
int s[114514] = {};
for (int i = 0; i < n; i++) {
int a;
cin >> a;
s[a - m + 1]++;
s[a + m + 1]--;
}
for (int i = 1; i < 11450; i++) {
s[i] += s[i - 1];
}
int ans = 0;
for (int i = 1; i <= t; i++) {
if (!s[i])
ans++;
}
cout << ans << endl;
return 0;
} | replace | 6 | 7 | 6 | 7 | 0 | |
p01840 | C++ | Runtime Error | #include <iostream>
using namespace std;
int main(void) {
int n, m, t;
int x;
cin >> n >> m >> t;
int b[10101] = {};
for (int i = 0; i < n; i++) {
cin >> x;
b[x - m]--;
b[x + m]++;
}
int ans = 0;
if (b[0] == 0)
ans++;
for (int i = 1; i < t; i++) {
b[i] += b[i - 1];
if (b[i] == 0)
ans++;
}
cout << ans << endl;
} | #include <iostream>
using namespace std;
int main(void) {
int n, m, t;
int x;
cin >> n >> m >> t;
int b[10101] = {};
for (int i = 0; i < n; i++) {
cin >> x;
b[x - m]--;
if (x + m <= t)
b[x + m]++;
}
int ans = 0;
if (b[0] == 0)
ans++;
for (int i = 1; i < t; i++) {
b[i] += b[i - 1];
if (b[i] == 0)
ans++;
}
cout << ans << endl;
} | replace | 11 | 12 | 11 | 13 | 0 | |
p01840 | C++ | Runtime Error | #include <bits/stdc++.h>
#define REP(i, n, N) for (int i = n; i < N; i++)
#define p(S) cout << S << endl
using namespace std;
int main() {
int N, M, T;
cin >> N >> M >> T;
int t[10001];
fill(t, t + 10001, 1);
int let;
int ans = 0;
REP(i, 0, N) {
cin >> let;
REP(j, let - M + 1, let + M + 1) { t[j] = 0; }
}
REP(i, 1, T + 1) { ans += t[i]; }
p(ans);
return 0;
} | #include <bits/stdc++.h>
#define REP(i, n, N) for (int i = n; i < N; i++)
#define p(S) cout << S << endl
using namespace std;
int main() {
int N, M, T;
cin >> N >> M >> T;
int t[10001];
fill(t, t + 10001, 1);
int let;
int ans = 0;
REP(i, 0, N) {
cin >> let;
REP(j, let - M + 1, let + M + 1) {
if (j > 10000)
break;
t[j] = 0;
}
}
REP(i, 1, T + 1) { ans += t[i]; }
p(ans);
return 0;
} | replace | 14 | 15 | 14 | 19 | 0 | |
p01840 | C++ | Runtime Error | //
// main.cpp
// Delivery to a Luxurious House
//
// Created by x15071xx on 2017/06/19.
// Copyright ?? 2017??´ AIT. All rights reserved.
//
#include <iostream>
#include <vector>
using namespace std;
int main(int argc, const char *argv[]) {
int n, m, t, taroSc[10000] = {0}, time = 0;
vector<int> cometime;
cin >> n >> m >> t;
for (int i = 0; i < n; i++) {
int tmp;
cin >> tmp;
cometime.push_back(tmp);
}
for (int i = 0; i < n; i++) {
for (int j = cometime[i] - m; j < cometime[i] + m; j++) {
taroSc[j] = 1;
}
}
for (int i = 0; i < t; i++) {
if (taroSc[i] == 0) {
time++;
}
}
cout << time << endl;
return 0;
} | //
// main.cpp
// Delivery to a Luxurious House
//
// Created by x15071xx on 2017/06/19.
// Copyright ?? 2017??´ AIT. All rights reserved.
//
#include <iostream>
#include <vector>
using namespace std;
int main(int argc, const char *argv[]) {
int n, m, t, taroSc[100000] = {0}, time = 0;
vector<int> cometime;
cin >> n >> m >> t;
for (int i = 0; i < n; i++) {
int tmp;
cin >> tmp;
cometime.push_back(tmp);
}
for (int i = 0; i < n; i++) {
for (int j = cometime[i] - m; j < cometime[i] + m; j++) {
taroSc[j] = 1;
}
}
for (int i = 0; i < t; i++) {
if (taroSc[i] == 0) {
time++;
}
}
cout << time << endl;
return 0;
} | replace | 14 | 15 | 14 | 15 | 0 | |
p01840 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < (n); i++)
#define REAP(i, a, n) for (int i = (a); i < (n); i++)
#define YES cout << "Yes" << endl
#define NO cout << "No" << endl
#define fr first
#define sc second
#define pb push_back
#define All(v) v.begin(), v.end()
typedef long long ll;
int main() {
int n, m, t;
cin >> n >> m >> t;
int a;
vector<int> tim(t, 1);
REP(i, n) {
cin >> a;
a--;
for (int j = a - m + 1; j <= a + m; j++) {
tim[j] = 0;
}
}
int sum = 0;
REP(i, t) { sum += tim[i]; }
cout << sum << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < (n); i++)
#define REAP(i, a, n) for (int i = (a); i < (n); i++)
#define YES cout << "Yes" << endl
#define NO cout << "No" << endl
#define fr first
#define sc second
#define pb push_back
#define All(v) v.begin(), v.end()
typedef long long ll;
int main() {
int n, m, t;
cin >> n >> m >> t;
int a;
vector<int> tim(t, 1);
REP(i, n) {
cin >> a;
a--;
for (int j = a - m + 1; j <= a + m && j < t; j++) {
tim[j] = 0;
}
}
int sum = 0;
REP(i, t) { sum += tim[i]; }
cout << sum << endl;
}
| replace | 21 | 22 | 21 | 22 | 0 | |
p01840 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <string>
#include <vector>
using namespace std;
long long int mod = 1000000007;
int main(void) {
int n, m, t;
cin >> n >> m >> t;
vector<bool> a(10000 + 5, false);
for (int i = 1; i < n + 1; i++) {
int tmp;
cin >> tmp;
for (int j = tmp - m; j < tmp + m; j++)
a[j] = true;
}
int cnt = 0;
for (int i = 0; i < t; i++) {
cnt += a[i];
}
cout << t - cnt << endl;
return 0;
}
// | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <string>
#include <vector>
using namespace std;
long long int mod = 1000000007;
int main(void) {
int n, m, t;
cin >> n >> m >> t;
vector<bool> a(10000 + 5, false);
for (int i = 1; i < n + 1; i++) {
int tmp;
cin >> tmp;
for (int j = max(0, tmp - m); j < min(10005, tmp + m); j++)
a[j] = true;
}
int cnt = 0;
for (int i = 0; i < t; i++) {
cnt += a[i];
}
cout << t - cnt << endl;
return 0;
}
// | replace | 22 | 23 | 22 | 23 | 0 | |
p01840 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <time.h>
#include <tuple>
#include <vector>
#define all(c) ((c).begin(), (c).end())
#define rall(c) ((c).rbegin(), (c).rend())
#define ll long long
#define fi first
#define se second
#define inf (999999999)
using namespace std;
const ll MOD = 1e9 + 7;
const double PI = acos(-1.0);
//---------------------------------------------------------------------------------------------//
int n, m, t;
int a[110];
int main() {
cin >> n >> m >> t;
bool b[10000];
for (int i = 0; i < t; i++)
b[i] = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
for (int j = a[i] - m; j <= a[i] + m - 1; j++) {
b[j] = 1;
}
}
int ans = 0;
for (int i = 0; i < t; i++) {
if (b[i] == 0)
ans++;
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <time.h>
#include <tuple>
#include <vector>
#define all(c) ((c).begin(), (c).end())
#define rall(c) ((c).rbegin(), (c).rend())
#define ll long long
#define fi first
#define se second
#define inf (999999999)
using namespace std;
const ll MOD = 1e9 + 7;
const double PI = acos(-1.0);
//---------------------------------------------------------------------------------------------//
int n, m, t;
int a[110];
int main() {
cin >> n >> m >> t;
bool b[20100];
for (int i = 0; i < t; i++)
b[i] = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
for (int j = a[i] - m; j <= a[i] + m - 1; j++) {
b[j] = 1;
}
}
int ans = 0;
for (int i = 0; i < t; i++) {
if (b[i] == 0)
ans++;
}
cout << ans << endl;
return 0;
} | replace | 33 | 34 | 33 | 34 | 0 | |
p01841 | C++ | Runtime Error | #include <bits/stdc++.h>
#define range(i, a, b) for (int i = (a); i < (b); i++)
#define rep(i, b) for (int i = 0; i < (b); i++)
#define all(a) (a).begin(), (a).end()
#define show(x) cerr << #x << " = " << (x) << endl;
using namespace std;
struct Node {
int l, r;
int num;
Node() { l = r = -1; }
};
int number(string &s, int &i) {
int res = 0;
while (isdigit(s[i])) {
res *= 10;
res += s[i] - '0';
i++;
}
return res;
}
int dfs(vector<Node> &node, string &s, int l, int r, int &idx) {
if (r - l == 0)
return -1;
int cur = idx;
int cnt = 0, i = l;
while (true) {
if (s[i] == '(')
cnt++;
else if (s[i] == ')')
cnt--;
else if (cnt == 0) {
idx++;
node[cur].l = dfs(node, s, l + 1, i - 1, idx);
i++;
node[cur].num = number(s, i);
i++;
idx++;
node[cur].r = dfs(node, s, i + 1, r - 1, idx);
break;
}
i++;
}
return cur;
}
string merge(vector<Node> &x, int xi, vector<Node> &y, int yi) {
if (xi == -1 or yi == -1)
return "";
string left = merge(x, x[xi].l, y, y[yi].l);
string num = to_string(x[xi].num + y[yi].num);
string right = merge(x, x[xi].r, y, y[yi].r);
return "(" + left + ")" + "[" + num + "]" + "(" + right + ")";
}
int main() {
string a, b;
cin >> a >> b;
vector<Node> x(200), y(200);
int idx = 0;
dfs(x, a, 0, a.size(), idx);
idx = 0;
dfs(y, b, 0, b.size(), idx);
string ans = merge(x, 0, y, 0);
cout << merge(x, 0, y, 0) << endl;
}
| #include <bits/stdc++.h>
#define range(i, a, b) for (int i = (a); i < (b); i++)
#define rep(i, b) for (int i = 0; i < (b); i++)
#define all(a) (a).begin(), (a).end()
#define show(x) cerr << #x << " = " << (x) << endl;
using namespace std;
struct Node {
int l, r;
int num;
Node() { l = r = -1; }
};
int number(string &s, int &i) {
int res = 0;
while (isdigit(s[i])) {
res *= 10;
res += s[i] - '0';
i++;
}
return res;
}
int dfs(vector<Node> &node, string &s, int l, int r, int &idx) {
if (r - l == 0)
return -1;
int cur = idx;
int cnt = 0, i = l;
while (true) {
if (s[i] == '(')
cnt++;
else if (s[i] == ')')
cnt--;
else if (cnt == 0) {
idx++;
node[cur].l = dfs(node, s, l + 1, i - 1, idx);
i++;
node[cur].num = number(s, i);
i++;
idx++;
node[cur].r = dfs(node, s, i + 1, r - 1, idx);
break;
}
i++;
}
return cur;
}
string merge(vector<Node> &x, int xi, vector<Node> &y, int yi) {
if (xi == -1 or yi == -1)
return "";
string left = merge(x, x[xi].l, y, y[yi].l);
string num = to_string(x[xi].num + y[yi].num);
string right = merge(x, x[xi].r, y, y[yi].r);
return "(" + left + ")" + "[" + num + "]" + "(" + right + ")";
}
int main() {
string a, b;
cin >> a >> b;
vector<Node> x(10000), y(10000);
int idx = 0;
dfs(x, a, 0, a.size(), idx);
idx = 0;
dfs(y, b, 0, b.size(), idx);
string ans = merge(x, 0, y, 0);
cout << merge(x, 0, y, 0) << endl;
}
| replace | 65 | 66 | 65 | 66 | 0 | |
p01841 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define int long long // <-----!!!!!!!!!!!!!!!!!!!
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep2(i, a, b) for (int i = (a); i < (b); i++)
#define rrep(i, n) for (int i = (n)-1; i >= 0; i--)
#define rrep2(i, a, b) for (int i = (a)-1; i >= b; i--)
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define printV(_v) \
for (auto _x : _v) { \
cout << _x << " "; \
} \
cout << endl
#define printVS(vs) \
for (auto x : vs) { \
cout << x << endl; \
}
#define printVV(_vv) \
for (auto _v : _vv) { \
for (auto _x : _v) { \
cout << _x << " "; \
} \
cout << endl; \
}
#define printP(p) cout << p.first << " " << p.second << endl
#define printVP(vp) \
for (auto p : vp) \
printP(p);
#define readV(_v) rep(j, _v.size()) cin >> _v[j];
#define readVV(_vv) rep(i, _vv.size()) readV(_vv[i]);
#define output(_x) cout << _x << endl;
typedef long long ll;
typedef pair<int, int> Pii;
typedef tuple<int, int, int> TUPLE;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<vvi> vvvi;
typedef vector<Pii> vp;
const int inf = 1e9;
const int mod = 1e9 + 7;
typedef string::const_iterator State;
void assume(State &begin1, State &begin2, char expected, string &s) {
// cerr << "assume: " << *begin1 << ", " << *begin2 << ", " << expected << ",
// " << s << endl;
assert(*begin1 == expected && *begin2 == expected);
s += *begin1;
begin1++;
begin2++;
}
string number(State &begin1, State &begin2) {
// cerr << "number: " << *begin1 << ", " << *begin2 << endl;
int val1 = 0;
while (isdigit(*begin1)) {
val1 *= 10;
val1 += *begin1 - '0';
begin1++;
}
int val2 = 0;
while (isdigit(*begin2)) {
val2 *= 10;
val2 += *begin2 - '0';
begin2++;
}
return to_string(val1 + val2);
}
string node(State &begin1, State &begin2) {
// cerr << "node: " << *begin1 << ", " << *begin2 << endl;
if (*begin1 == ')') {
int depth = 1;
for (;;) {
if (*begin2 == '(') {
depth++;
} else if (*begin2 == ')') {
depth--;
}
if (depth == 0) {
return "";
}
begin2++;
}
}
if (*begin2 == ')') {
int depth = 1;
for (;;) {
if (*begin1 == '(') {
depth++;
} else if (*begin1 == ')') {
depth--;
}
if (depth == 0) {
return "";
}
begin1++;
}
}
string ret = "";
assume(begin1, begin2, '(', ret);
ret += node(begin1, begin2);
assume(begin1, begin2, ')', ret);
assume(begin1, begin2, '[', ret);
ret += number(begin1, begin2);
assume(begin1, begin2, ']', ret);
assume(begin1, begin2, '(', ret);
ret += node(begin1, begin2);
assume(begin1, begin2, ')', ret);
return ret;
}
signed main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
string s1, s2;
while (cin >> s1 >> s2, s1 != "#") {
State begin1 = s1.begin();
State begin2 = s2.begin();
cout << node(begin1, begin2) << endl;
assert(begin1 == s1.end() && begin2 == s2.end());
}
} | #include <bits/stdc++.h>
using namespace std;
#define int long long // <-----!!!!!!!!!!!!!!!!!!!
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep2(i, a, b) for (int i = (a); i < (b); i++)
#define rrep(i, n) for (int i = (n)-1; i >= 0; i--)
#define rrep2(i, a, b) for (int i = (a)-1; i >= b; i--)
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define printV(_v) \
for (auto _x : _v) { \
cout << _x << " "; \
} \
cout << endl
#define printVS(vs) \
for (auto x : vs) { \
cout << x << endl; \
}
#define printVV(_vv) \
for (auto _v : _vv) { \
for (auto _x : _v) { \
cout << _x << " "; \
} \
cout << endl; \
}
#define printP(p) cout << p.first << " " << p.second << endl
#define printVP(vp) \
for (auto p : vp) \
printP(p);
#define readV(_v) rep(j, _v.size()) cin >> _v[j];
#define readVV(_vv) rep(i, _vv.size()) readV(_vv[i]);
#define output(_x) cout << _x << endl;
typedef long long ll;
typedef pair<int, int> Pii;
typedef tuple<int, int, int> TUPLE;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<vvi> vvvi;
typedef vector<Pii> vp;
const int inf = 1e9;
const int mod = 1e9 + 7;
typedef string::const_iterator State;
void assume(State &begin1, State &begin2, char expected, string &s) {
// cerr << "assume: " << *begin1 << ", " << *begin2 << ", " << expected << ",
// " << s << endl;
assert(*begin1 == expected && *begin2 == expected);
s += *begin1;
begin1++;
begin2++;
}
string number(State &begin1, State &begin2) {
// cerr << "number: " << *begin1 << ", " << *begin2 << endl;
int val1 = 0;
while (isdigit(*begin1)) {
val1 *= 10;
val1 += *begin1 - '0';
begin1++;
}
int val2 = 0;
while (isdigit(*begin2)) {
val2 *= 10;
val2 += *begin2 - '0';
begin2++;
}
return to_string(val1 + val2);
}
string node(State &begin1, State &begin2) {
// cerr << "node: " << *begin1 << ", " << *begin2 << endl;
if (*begin1 == ')') {
int depth = 1;
for (;;) {
if (*begin2 == '(') {
depth++;
} else if (*begin2 == ')') {
depth--;
}
if (depth == 0) {
return "";
}
begin2++;
}
}
if (*begin2 == ')') {
int depth = 1;
for (;;) {
if (*begin1 == '(') {
depth++;
} else if (*begin1 == ')') {
depth--;
}
if (depth == 0) {
return "";
}
begin1++;
}
}
string ret = "";
assume(begin1, begin2, '(', ret);
ret += node(begin1, begin2);
assume(begin1, begin2, ')', ret);
assume(begin1, begin2, '[', ret);
ret += number(begin1, begin2);
assume(begin1, begin2, ']', ret);
assume(begin1, begin2, '(', ret);
ret += node(begin1, begin2);
assume(begin1, begin2, ')', ret);
return ret;
}
signed main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
string s1, s2;
cin >> s1 >> s2;
State begin1 = s1.begin();
State begin2 = s2.begin();
cout << node(begin1, begin2) << endl;
assert(begin1 == s1.end() && begin2 == s2.end());
} | replace | 126 | 132 | 126 | 131 | TLE | |
p01842 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#ifdef DEBUG_MODE
#define DBG(n) n;
#else
#define DBG(n) ;
#endif
#define REP(i, n) for (ll(i) = (0); (i) < (n); ++i)
#define rep(i, s, g) for (ll(i) = (s); (i) < (g); ++i)
#define rrep(i, s, g) for (ll(i) = (s); i >= (g); --(i))
#define PB push_back
#define MP make_pair
#define FI first
#define SE second
#define SHOW1d(v, n) \
{ \
for (int WWW = 0; WWW < (n); WWW++) \
cerr << v[WWW] << ' '; \
cerr << endl << endl; \
}
#define SHOW2d(v, i, j) \
{ \
for (int aaa = 0; aaa < i; aaa++) { \
for (int bbb = 0; bbb < j; bbb++) \
cerr << v[aaa][bbb] << ' '; \
cerr << endl; \
} \
cerr << endl; \
}
#define ALL(v) v.begin(), v.end()
#define Decimal fixed << setprecision(20)
#define INF 1000000000
#define LLINF 1000000000000000000LL
#define MOD 1000000007
typedef long long ll;
typedef pair<ll, ll> P;
ll dp[4][55][55][55][55];
ll n, m;
vector<ll> a;
vector<ll> b;
ll check(ll hoge, ll x1, ll y1, ll x2, ll y2) {
ll ret = 0;
for (ll i = x1 - 1; i >= x2; i--) {
if (a[i] != -1)
ret += a[i];
}
for (ll i = y1 - 1; i >= y2; i--) {
if (b[i] != -1)
ret -= b[i];
}
DBG(cout << "check " << hoge << ' ' << x1 << ' ' << y1 << ' ' << x2 << ' '
<< y2 << endl;
cout << ret << endl;)
return ret;
}
ll dfs(ll type, ll x1, ll y1, ll x2, ll y2) {
DBG(cout << "IN " << type << ' ' << x1 << ' ' << y1 << ' ' << x2 << ' ' << y2
<< endl;)
ll ret;
// A
if (type % 2 == 0) {
ret = -LLINF;
// 置く
if (x1 < n) {
if (a[x1] == -1) {
ret = max(ret, dfs(1, x1 + 1, y1, x2, y1));
} else {
ret = max(ret, dfs(1, x1 + 1, y1, x2, y2));
}
}
// 置かない
if (type == 2)
ret = max(ret, 0LL);
else if (x1 == x2 && y1 == y2) {
ret = max(ret, dfs(3, x1, y1, x2, y2));
} else {
ll tmp = check(type, x1, y1, x2, y2);
ret = max(ret, dfs(1, x1, y1, x1, y1) + tmp);
}
}
// B
else {
ret = LLINF;
// 置く
if (y1 < m) {
if (b[y1] == -1) {
ret = min(ret, dfs(0, x1, y1 + 1, x1, y2));
} else {
ret = min(ret, dfs(0, x1, y1 + 1, x2, y2));
}
}
// 置かない
if (type == 3)
ret = min(ret, 0LL);
else if (x1 == x2 && y1 == y2) {
ret = min(ret, dfs(2, x1, y1, x2, y2));
} else {
ll tmp = check(type, x1, y1, x2, y2);
ret = min(ret, dfs(0, x1, y1, x1, y1) + tmp);
}
}
DBG(cout << "OUT " << type << ' ' << x1 << ' ' << y1 << ' ' << x2 << ' ' << y2
<< ' ' << ret << endl;)
return dp[type][x1][y1][x2][y2] = ret;
}
int main() {
cin >> n >> m;
REP(i, n) {
ll tmp;
cin >> tmp;
a.PB(tmp);
}
REP(i, m) {
ll tmp;
cin >> tmp;
b.PB(tmp);
}
REP(i, 55) REP(j, 55) REP(k, 55) REP(l, 55) {
dp[0][i][j][k][l] = LLINF;
dp[2][i][j][k][l] = LLINF;
dp[1][i][j][k][l] = LLINF;
dp[3][i][j][k][l] = LLINF;
}
cout << dfs(0, 0, 0, 0, 0) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#ifdef DEBUG_MODE
#define DBG(n) n;
#else
#define DBG(n) ;
#endif
#define REP(i, n) for (ll(i) = (0); (i) < (n); ++i)
#define rep(i, s, g) for (ll(i) = (s); (i) < (g); ++i)
#define rrep(i, s, g) for (ll(i) = (s); i >= (g); --(i))
#define PB push_back
#define MP make_pair
#define FI first
#define SE second
#define SHOW1d(v, n) \
{ \
for (int WWW = 0; WWW < (n); WWW++) \
cerr << v[WWW] << ' '; \
cerr << endl << endl; \
}
#define SHOW2d(v, i, j) \
{ \
for (int aaa = 0; aaa < i; aaa++) { \
for (int bbb = 0; bbb < j; bbb++) \
cerr << v[aaa][bbb] << ' '; \
cerr << endl; \
} \
cerr << endl; \
}
#define ALL(v) v.begin(), v.end()
#define Decimal fixed << setprecision(20)
#define INF 1000000000
#define LLINF 1000000000000000000LL
#define MOD 1000000007
typedef long long ll;
typedef pair<ll, ll> P;
ll dp[4][55][55][55][55];
ll n, m;
vector<ll> a;
vector<ll> b;
ll check(ll hoge, ll x1, ll y1, ll x2, ll y2) {
ll ret = 0;
for (ll i = x1 - 1; i >= x2; i--) {
if (a[i] != -1)
ret += a[i];
}
for (ll i = y1 - 1; i >= y2; i--) {
if (b[i] != -1)
ret -= b[i];
}
DBG(cout << "check " << hoge << ' ' << x1 << ' ' << y1 << ' ' << x2 << ' '
<< y2 << endl;
cout << ret << endl;)
return ret;
}
ll dfs(ll type, ll x1, ll y1, ll x2, ll y2) {
DBG(cout << "IN " << type << ' ' << x1 << ' ' << y1 << ' ' << x2 << ' ' << y2
<< endl;)
if (dp[type][x1][y1][x2][y2] != LLINF)
return dp[type][x1][y1][x2][y2];
ll ret;
// A
if (type % 2 == 0) {
ret = -LLINF;
// 置く
if (x1 < n) {
if (a[x1] == -1) {
ret = max(ret, dfs(1, x1 + 1, y1, x2, y1));
} else {
ret = max(ret, dfs(1, x1 + 1, y1, x2, y2));
}
}
// 置かない
if (type == 2)
ret = max(ret, 0LL);
else if (x1 == x2 && y1 == y2) {
ret = max(ret, dfs(3, x1, y1, x2, y2));
} else {
ll tmp = check(type, x1, y1, x2, y2);
ret = max(ret, dfs(1, x1, y1, x1, y1) + tmp);
}
}
// B
else {
ret = LLINF;
// 置く
if (y1 < m) {
if (b[y1] == -1) {
ret = min(ret, dfs(0, x1, y1 + 1, x1, y2));
} else {
ret = min(ret, dfs(0, x1, y1 + 1, x2, y2));
}
}
// 置かない
if (type == 3)
ret = min(ret, 0LL);
else if (x1 == x2 && y1 == y2) {
ret = min(ret, dfs(2, x1, y1, x2, y2));
} else {
ll tmp = check(type, x1, y1, x2, y2);
ret = min(ret, dfs(0, x1, y1, x1, y1) + tmp);
}
}
DBG(cout << "OUT " << type << ' ' << x1 << ' ' << y1 << ' ' << x2 << ' ' << y2
<< ' ' << ret << endl;)
return dp[type][x1][y1][x2][y2] = ret;
}
int main() {
cin >> n >> m;
REP(i, n) {
ll tmp;
cin >> tmp;
a.PB(tmp);
}
REP(i, m) {
ll tmp;
cin >> tmp;
b.PB(tmp);
}
REP(i, 55) REP(j, 55) REP(k, 55) REP(l, 55) {
dp[0][i][j][k][l] = LLINF;
dp[2][i][j][k][l] = LLINF;
dp[1][i][j][k][l] = LLINF;
dp[3][i][j][k][l] = LLINF;
}
cout << dfs(0, 0, 0, 0, 0) << endl;
return 0;
}
| insert | 64 | 64 | 64 | 66 | TLE | |
p01842 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using ll = int64_t;
using PLL = pair<ll, ll>;
template <typename T> using V = vector<T>;
template <typename T> using VV = V<V<T>>;
ll memo[2][50][50][50][50][2];
bool calced[2][50][50][50][50][2];
V<ll> decka, deckb;
ll pass_turn(ll player, ll rest_a, ll rest_b, ll stack_a, ll stack_b) {
assert(abs(stack_a - stack_b) <= 1);
if (stack_a + stack_b == 0)
return 0;
ll aidx = decka.size() - rest_a - 1;
ll bidx = deckb.size() - rest_b - 1;
bool which;
if (stack_a != stack_b)
which = stack_a < stack_b;
else
which = (player == 0);
V<pair<ll, bool>> st;
for (ll i = 0; i < stack_a + stack_b; i++) {
auto &idx = (!which ? aidx : bidx);
const auto &deck = (!which ? decka : deckb);
st.emplace_back(deck[idx], which);
// cerr << deck[idx] << ", ";
idx--;
which = !which;
}
// cerr << endl;
ll scorea = 0, scoreb = 0;
for (const auto &e : st) {
ll n;
bool w;
tie(n, w) = e;
if (n == -1 && w == true)
break;
if (n != -1)
scorea += (w == false ? n : 0);
}
for (const auto &e : st) {
ll n;
bool w;
tie(n, w) = e;
if (n == -1 && w == false)
break;
if (n != -1)
scoreb += (w == true ? n : 0);
}
return scorea - scoreb;
}
ll calc(ll player, ll rest_a, ll rest_b, ll stack_a, ll stack_b, bool passed) {
if (calced[player][rest_a][rest_b][stack_a][stack_b][(ll)passed])
return memo[player][rest_a][rest_b][stack_a][stack_b][(ll)passed];
ll ret;
bool npassed = (stack_a + stack_b == 0);
if (rest_a == 0 && rest_b == 0) {
ret = pass_turn(player, rest_a, rest_b, stack_a, stack_b);
} else if (player == 0 && rest_a == 0) {
ret = pass_turn(player, rest_a, rest_b, stack_a, stack_b);
if (!(passed && (stack_a + stack_b == 0)))
ret += calc(1, rest_a, rest_b, 0, 0, npassed);
} else if (player == 1 && rest_b == 0) {
ret = pass_turn(!player, rest_a, rest_b, stack_a, stack_b);
if (!(passed && (stack_a + stack_b == 0)))
ret += calc(0, rest_a, rest_b, 0, 0, npassed);
} else {
ll r1 = pass_turn(player, rest_a, rest_b, stack_a, stack_b);
if (!(passed && (stack_a + stack_b == 0)))
r1 += calc(!player, rest_a, rest_b, 0, 0, npassed);
ll r2;
if ((player == 0 && rest_a > 0) || (player == 1 && rest_b > 0)) {
ll nrest_a = rest_a - (player == 0);
ll nrest_b = rest_b - (player == 1);
ll nstack_a = stack_a + (player == 0);
ll nstack_b = stack_b + (player == 1);
r2 = calc(!player, nrest_a, nrest_b, nstack_a, nstack_b, false);
} else {
r2 = r1;
}
if (player == 0)
ret = max(r1, r2);
else
ret = min(r1, r2);
// cerr << r1 << ", " << r2 << endl;
}
calced[player][rest_a][rest_b][stack_a][stack_b][(ll)passed] = true;
// cerr << player << ", " << rest_a << ", " << rest_b << ", " << stack_a << ",
// " << stack_b << ", " << ret << endl;
return memo[player][rest_a][rest_b][stack_a][stack_b][(ll)passed] = ret;
}
int main() {
ll N, M;
cin >> N >> M;
decka.resize(N);
deckb.resize(M);
for (ll &e : decka)
cin >> e;
for (ll &e : deckb)
cin >> e;
calc(0, N, M, 0, 0, false);
ll ans = memo[0][N][M][0][0][0];
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = int64_t;
using PLL = pair<ll, ll>;
template <typename T> using V = vector<T>;
template <typename T> using VV = V<V<T>>;
ll memo[2][55][55][55][55][2];
bool calced[2][55][55][55][55][2];
V<ll> decka, deckb;
ll pass_turn(ll player, ll rest_a, ll rest_b, ll stack_a, ll stack_b) {
assert(abs(stack_a - stack_b) <= 1);
if (stack_a + stack_b == 0)
return 0;
ll aidx = decka.size() - rest_a - 1;
ll bidx = deckb.size() - rest_b - 1;
bool which;
if (stack_a != stack_b)
which = stack_a < stack_b;
else
which = (player == 0);
V<pair<ll, bool>> st;
for (ll i = 0; i < stack_a + stack_b; i++) {
auto &idx = (!which ? aidx : bidx);
const auto &deck = (!which ? decka : deckb);
st.emplace_back(deck[idx], which);
// cerr << deck[idx] << ", ";
idx--;
which = !which;
}
// cerr << endl;
ll scorea = 0, scoreb = 0;
for (const auto &e : st) {
ll n;
bool w;
tie(n, w) = e;
if (n == -1 && w == true)
break;
if (n != -1)
scorea += (w == false ? n : 0);
}
for (const auto &e : st) {
ll n;
bool w;
tie(n, w) = e;
if (n == -1 && w == false)
break;
if (n != -1)
scoreb += (w == true ? n : 0);
}
return scorea - scoreb;
}
ll calc(ll player, ll rest_a, ll rest_b, ll stack_a, ll stack_b, bool passed) {
if (calced[player][rest_a][rest_b][stack_a][stack_b][(ll)passed])
return memo[player][rest_a][rest_b][stack_a][stack_b][(ll)passed];
ll ret;
bool npassed = (stack_a + stack_b == 0);
if (rest_a == 0 && rest_b == 0) {
ret = pass_turn(player, rest_a, rest_b, stack_a, stack_b);
} else if (player == 0 && rest_a == 0) {
ret = pass_turn(player, rest_a, rest_b, stack_a, stack_b);
if (!(passed && (stack_a + stack_b == 0)))
ret += calc(1, rest_a, rest_b, 0, 0, npassed);
} else if (player == 1 && rest_b == 0) {
ret = pass_turn(!player, rest_a, rest_b, stack_a, stack_b);
if (!(passed && (stack_a + stack_b == 0)))
ret += calc(0, rest_a, rest_b, 0, 0, npassed);
} else {
ll r1 = pass_turn(player, rest_a, rest_b, stack_a, stack_b);
if (!(passed && (stack_a + stack_b == 0)))
r1 += calc(!player, rest_a, rest_b, 0, 0, npassed);
ll r2;
if ((player == 0 && rest_a > 0) || (player == 1 && rest_b > 0)) {
ll nrest_a = rest_a - (player == 0);
ll nrest_b = rest_b - (player == 1);
ll nstack_a = stack_a + (player == 0);
ll nstack_b = stack_b + (player == 1);
r2 = calc(!player, nrest_a, nrest_b, nstack_a, nstack_b, false);
} else {
r2 = r1;
}
if (player == 0)
ret = max(r1, r2);
else
ret = min(r1, r2);
// cerr << r1 << ", " << r2 << endl;
}
calced[player][rest_a][rest_b][stack_a][stack_b][(ll)passed] = true;
// cerr << player << ", " << rest_a << ", " << rest_b << ", " << stack_a << ",
// " << stack_b << ", " << ret << endl;
return memo[player][rest_a][rest_b][stack_a][stack_b][(ll)passed] = ret;
}
int main() {
ll N, M;
cin >> N >> M;
decka.resize(N);
deckb.resize(M);
for (ll &e : decka)
cin >> e;
for (ll &e : deckb)
cin >> e;
calc(0, N, M, 0, 0, false);
ll ans = memo[0][N][M][0][0][0];
cout << ans << endl;
return 0;
}
| replace | 7 | 9 | 7 | 9 | -11 | |
p01845 | C++ | Time Limit Exceeded | #include <iostream>
using namespace std;
int main() {
int r, w, c, R;
while (1) {
int count = 0;
cin >> r >> w >> c >> R;
if (r == 0)
break;
while (1) {
if ((double)(r + count * R) / w == c) {
break;
} else if ((double)(r + count * R) / w < c) {
count++;
} else if ((double)(r + count * R) / w > c) {
w++;
}
}
cout << count << endl;
}
return 0;
} | #include <iostream>
using namespace std;
int main() {
int r, w, c, R;
while (1) {
int count = 0;
cin >> r >> w >> c >> R;
if (r == 0)
break;
if (w * c <= r) {
} else if ((w * c - r) % R == 0) {
count = (w * c - r) / R;
} else
count = (w * c - r) / R + 1;
cout << count << endl;
}
return 0;
} | replace | 10 | 19 | 10 | 15 | TLE | |
p01845 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
int r, w, c, R;
while (cin >> r >> w >> c >> R) {
int ans = (w * c - r) / R;
if ((w * c - r) % R)
++ans;
if (w * c <= r)
ans = 0;
cout << ans << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int r, w, c, R;
while (cin >> r >> w >> c >> R, r) {
int ans = (w * c - r) / R;
if ((w * c - r) % R)
++ans;
if (w * c <= r)
ans = 0;
cout << ans << endl;
}
return 0;
} | replace | 6 | 7 | 6 | 7 | -8 | |
p01845 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
int main() {
double R0, W0, C, R;
while (cin >> R0 >> W0 >> C >> R, R0 + W0 + C + R != 0) {
int ans = 0;
while (!(R0 / W0 == C)) {
if (R0 / W0 > C) {
W0 += 1.0;
} else if (R0 / W0 < C) {
R0 += R;
ans++;
}
}
cout << ans << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
double R0, W0, C, R;
while (cin >> R0 >> W0 >> C >> R, R0 + W0 + C + R != 0) {
int ans = 0;
while (R0 / W0 < C) {
R0 += R;
ans++;
}
cout << ans << endl;
}
return 0;
} | replace | 6 | 13 | 6 | 9 | TLE | |
p01846 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
inline std::vector<std::string> split(const std::string &str, char sep) {
std::vector<std::string> v;
std::stringstream ss(str);
std::string buffer;
while (std::getline(ss, buffer, sep)) {
v.push_back(buffer);
}
return v;
}
int w = 0, h = 0;
inline string make_jfen(bool *ball) {
string ret = "";
int counter = 0;
for (int j = 0; j < w; j++) {
if (ball[j]) {
if (counter != 0) {
stringstream ss;
ss << counter;
char num_c;
ss >> num_c;
ret += num_c;
counter = 0;
}
ret += 'b';
} else if (!ball[j]) {
counter++;
}
}
if (counter != 0) {
stringstream ss;
ss << counter;
char num_c;
ss >> num_c;
ret += num_c;
counter = 0;
}
return ret;
}
/*
inline string make_jfen(bool *ball){
string ret = "";
bool flag =false;
for(int j=0; j<w; j++){
if(ball[j]){
flag = true;
break;
}
}
if(!flag){
stringstream ss;
ss << w;
char num_c;
ss >> num_c;
ret += num_c;
}
else if(flag){
int counter = 0;
for(int j=0; j<w; j++){
if(ball[j]){
if(counter != 0){
stringstream ss;
ss << counter;
char num_c;
ss >> num_c;
ret += num_c;
counter = 0;
}
ret += 'b';
}
else if(!ball[j]){
counter++;
}
}
if(counter != 0){
stringstream ss;
ss << counter;
char num_c;
ss >> num_c;
ret += num_c;
counter = 0;
}
}
return ret;
}
//*/
bool avoid_ball[10], insert_ball[10];
int main() {
while (true) {
string s;
cin >> s;
if (s == "#") {
break;
}
vector<string> vec = split(s, '/');
w = 0;
h = vec.size();
for (char c : vec[0]) {
if (c == 'b') {
w++;
continue;
}
stringstream ss;
ss << c;
int tmp;
ss >> tmp;
w += tmp;
}
int a, b, c, d;
cin >> a >> b >> c >> d;
a--;
b--;
c--;
d--;
if (a != c) {
int index = 0;
memset(avoid_ball, false, sizeof(avoid_ball));
for (char cc : vec[a]) {
if (cc == 'b') {
avoid_ball[index] = true;
index++;
continue;
}
stringstream ss;
ss << cc;
int tmp;
ss >> tmp;
index += tmp;
}
avoid_ball[b] = false;
vec[a] = make_jfen(avoid_ball);
memset(insert_ball, false, sizeof(insert_ball));
index = 0;
for (char cc : vec[c]) {
if (cc == 'b') {
insert_ball[index] = true;
index++;
continue;
}
stringstream ss;
ss << cc;
int tmp;
ss >> tmp;
index += tmp;
}
insert_ball[d] = true;
vec[c] = make_jfen(insert_ball);
} else if (a == c) {
memset(avoid_ball, false, sizeof(avoid_ball));
int index = 0;
for (char cc : vec[a]) {
if (cc == 'b') {
avoid_ball[index] = true;
index++;
continue;
}
stringstream ss;
ss << cc;
int tmp;
ss >> tmp;
index += tmp;
}
avoid_ball[b] = false;
avoid_ball[d] = true;
vec[a] = make_jfen(avoid_ball);
}
string ans = "";
for (int i = 0; i < h; i++) {
ans += vec[i];
if (i + 1 != h) {
ans += '/';
}
}
cout << ans << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
inline std::vector<std::string> split(const std::string &str, char sep) {
std::vector<std::string> v;
std::stringstream ss(str);
std::string buffer;
while (std::getline(ss, buffer, sep)) {
v.push_back(buffer);
}
return v;
}
int w = 0, h = 0;
inline string make_jfen(bool *ball) {
string ret = "";
int counter = 0;
for (int j = 0; j < w; j++) {
if (ball[j]) {
if (counter != 0) {
stringstream ss;
ss << counter;
char num_c;
ss >> num_c;
ret += num_c;
counter = 0;
}
ret += 'b';
} else if (!ball[j]) {
counter++;
}
}
if (counter != 0) {
stringstream ss;
ss << counter;
char num_c;
ss >> num_c;
ret += num_c;
counter = 0;
}
return ret;
}
/*
inline string make_jfen(bool *ball){
string ret = "";
bool flag =false;
for(int j=0; j<w; j++){
if(ball[j]){
flag = true;
break;
}
}
if(!flag){
stringstream ss;
ss << w;
char num_c;
ss >> num_c;
ret += num_c;
}
else if(flag){
int counter = 0;
for(int j=0; j<w; j++){
if(ball[j]){
if(counter != 0){
stringstream ss;
ss << counter;
char num_c;
ss >> num_c;
ret += num_c;
counter = 0;
}
ret += 'b';
}
else if(!ball[j]){
counter++;
}
}
if(counter != 0){
stringstream ss;
ss << counter;
char num_c;
ss >> num_c;
ret += num_c;
counter = 0;
}
}
return ret;
}
//*/
bool avoid_ball[10], insert_ball[10];
int main() {
while (true) {
string s;
cin >> s;
if (s == "#") {
break;
}
vector<string> vec = split(s, '/');
w = 0;
h = vec.size();
for (char c : vec[0]) {
if (c == 'b') {
w++;
continue;
}
stringstream ss;
ss << c;
int tmp;
ss >> tmp;
w += tmp;
}
int a, b, c, d;
cin >> a >> b >> c >> d;
a--;
b--;
c--;
d--;
if (a != c) {
int index = 0;
memset(avoid_ball, false, sizeof(avoid_ball));
for (char cc : vec[a]) {
if (cc == 'b') {
avoid_ball[index] = true;
index++;
continue;
}
stringstream ss;
ss << cc;
int tmp;
ss >> tmp;
index += tmp;
}
avoid_ball[b] = false;
vec[a] = make_jfen(avoid_ball);
memset(insert_ball, false, sizeof(insert_ball));
index = 0;
for (char cc : vec[c]) {
if (cc == 'b') {
insert_ball[index] = true;
index++;
continue;
}
stringstream ss;
ss << cc;
int tmp;
ss >> tmp;
index += tmp;
}
insert_ball[d] = true;
vec[c] = make_jfen(insert_ball);
} else if (a == c) {
memset(avoid_ball, false, sizeof(avoid_ball));
int index = 0;
for (char cc : vec[a]) {
if (cc == 'b') {
avoid_ball[index] = true;
index++;
continue;
}
stringstream ss;
ss << cc;
int tmp;
ss >> tmp;
index += tmp;
}
avoid_ball[b] = false;
avoid_ball[d] = true;
vec[a] = make_jfen(avoid_ball);
}
string ans = "";
for (int i = 0; i < h; i++) {
ans += vec[i];
if (i + 1 != h) {
ans += '/';
}
}
cout << ans << endl;
}
cin >> w;
return 0;
}
| replace | 203 | 204 | 203 | 204 | TLE | |
p01849 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<int, P> P1;
typedef pair<P, P> P2;
#define pu push
#define pb push_back
#define mp make_pair
#define eps 1e-7
#define INF 1000000000
#define fi first
#define sc second
#define rep(i, x) for (int i = 0; i < x; i++)
#define SORT(x) sort(x.begin(), x.end())
#define ERASE(x) x.erase(unique(x.begin(), x.end()), x.end())
#define POSL(x, v) (lower_bound(x.begin(), x.end(), v) - x.begin())
#define POSU(x, v) (upper_bound(x.begin(), x.end(), v) - x.begin())
int dp[(1 << 15) + 5], n, m, s[20], d[20];
int main() {
while (1) {
cin >> n >> m;
if (!n)
return 0;
int all = 0, ret = 0;
for (int i = 0; i < n; i++) {
cin >> s[i];
all += s[i];
}
for (int i = 0; i < m; i++) {
cin >> d[i];
if (d[i] > all)
ret += d[i] - all;
}
sort(d, d + m);
for (int i = 0; i < (1 << n); i++)
dp[i] = INF;
dp[0] = 0;
for (int i = 0; i < (1 << n); i++) {
int sum = 0;
for (int j = 0; j < n; j++) {
if (((i >> j) & 1))
sum += s[j];
}
for (int j = 0; j < n; j++) {
if (((i >> j) & 1))
continue;
int x = upper_bound(d, d + m, sum) - d;
int y = upper_bound(d, d + m, sum + s[j]) - d;
int z = dp[i];
for (int k = x; k < y; k++) {
z += min(d[k] - sum, sum + s[j] - d[k]);
}
dp[i + (1 << j)] = min(dp[i + (1 << j)], z);
}
}
cout << dp[(1 << n) - 1] + ret << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<int, P> P1;
typedef pair<P, P> P2;
#define pu push
#define pb push_back
#define mp make_pair
#define eps 1e-7
#define INF 1000000000
#define fi first
#define sc second
#define rep(i, x) for (int i = 0; i < x; i++)
#define SORT(x) sort(x.begin(), x.end())
#define ERASE(x) x.erase(unique(x.begin(), x.end()), x.end())
#define POSL(x, v) (lower_bound(x.begin(), x.end(), v) - x.begin())
#define POSU(x, v) (upper_bound(x.begin(), x.end(), v) - x.begin())
int dp[(1 << 15) + 5], n, m, s[20], d[120];
int main() {
while (1) {
cin >> n >> m;
if (!n)
return 0;
int all = 0, ret = 0;
for (int i = 0; i < n; i++) {
cin >> s[i];
all += s[i];
}
for (int i = 0; i < m; i++) {
cin >> d[i];
if (d[i] > all)
ret += d[i] - all;
}
sort(d, d + m);
for (int i = 0; i < (1 << n); i++)
dp[i] = INF;
dp[0] = 0;
for (int i = 0; i < (1 << n); i++) {
int sum = 0;
for (int j = 0; j < n; j++) {
if (((i >> j) & 1))
sum += s[j];
}
for (int j = 0; j < n; j++) {
if (((i >> j) & 1))
continue;
int x = upper_bound(d, d + m, sum) - d;
int y = upper_bound(d, d + m, sum + s[j]) - d;
int z = dp[i];
for (int k = x; k < y; k++) {
z += min(d[k] - sum, sum + s[j] - d[k]);
}
dp[i + (1 << j)] = min(dp[i + (1 << j)], z);
}
}
cout << dp[(1 << n) - 1] + ret << endl;
}
} | replace | 18 | 19 | 18 | 19 | 0 | |
p01849 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
const int INF = 1001001;
int n, m;
int s[15];
int d[101];
int dp[1 << 15][101];
int calc(int bit) {
// cout << bit << endl;
// 探索済みなら値return
if (dp[bit][m] != INF)
return dp[bit][m];
// 全部使った時のぬくもり
int warm = 0;
for (int i = 0; i < n; i++) {
if (bit & (1 << i))
warm += s[i];
}
// bitを1本折るときと、現在のbitを組み合わせる
for (int i = 0; i < n; i++) {
if (bit & (1 << i)) {
// もしbitが立っていたら
// bitを折る
int next_bit = bit & (~(1 << i));
// dpが最新バージョンに更新
int dummy = calc(next_bit);
// これはいい感じですか？
int temp_sum = 0;
vector<int> temp_dp(m + 1);
for (int j = 0; j < m; j++) {
temp_dp[j] = min(dp[next_bit][j], abs(warm - d[j]));
temp_sum += temp_dp[j];
}
temp_dp[m] = temp_sum;
if (temp_sum < dp[bit][m]) {
// もしいいなら入れ替える
for (int j = 0; j <= m; j++)
dp[bit][j] = temp_dp[j];
}
}
}
// cout << bit << " " << dp[bit][m] << endl;
return dp[bit][m];
}
int main() {
while (1) {
cin >> n >> m;
if (!n)
break;
for (int i = 0; i < (1 << n); i++) {
for (int j = 0; j <= m; j++) {
dp[i][j] = INF;
}
}
for (int i = 0; i < n; i++)
cin >> s[i];
for (int i = 0; i < m; i++)
cin >> d[i];
// dp初期化
int sum = 0;
for (int i = 0; i < m; i++) {
dp[0][i] = d[i];
sum += d[i];
}
dp[0][m] = sum;
cout << calc((1 << n) - 1) << endl;
/*for(int i = 0; i < (1 << n); i++){
for(int j = 0; j <= m; j++){
cout << dp[i][j] << " ";
}
cout << endl;
}*/
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const int INF = 100100000001;
int n, m;
int s[15];
int d[101];
int dp[1 << 15][101];
int calc(int bit) {
// cout << bit << endl;
// 探索済みなら値return
if (dp[bit][m] != INF)
return dp[bit][m];
// 全部使った時のぬくもり
int warm = 0;
for (int i = 0; i < n; i++) {
if (bit & (1 << i))
warm += s[i];
}
// bitを1本折るときと、現在のbitを組み合わせる
for (int i = 0; i < n; i++) {
if (bit & (1 << i)) {
// もしbitが立っていたら
// bitを折る
int next_bit = bit & (~(1 << i));
// dpが最新バージョンに更新
int dummy = calc(next_bit);
// これはいい感じですか？
int temp_sum = 0;
vector<int> temp_dp(m + 1);
for (int j = 0; j < m; j++) {
temp_dp[j] = min(dp[next_bit][j], abs(warm - d[j]));
temp_sum += temp_dp[j];
}
temp_dp[m] = temp_sum;
if (temp_sum < dp[bit][m]) {
// もしいいなら入れ替える
for (int j = 0; j <= m; j++)
dp[bit][j] = temp_dp[j];
}
}
}
// cout << bit << " " << dp[bit][m] << endl;
return dp[bit][m];
}
int main() {
while (1) {
cin >> n >> m;
if (!n)
break;
for (int i = 0; i < (1 << n); i++) {
for (int j = 0; j <= m; j++) {
dp[i][j] = INF;
}
}
for (int i = 0; i < n; i++)
cin >> s[i];
for (int i = 0; i < m; i++)
cin >> d[i];
// dp初期化
int sum = 0;
for (int i = 0; i < m; i++) {
dp[0][i] = d[i];
sum += d[i];
}
dp[0][m] = sum;
cout << calc((1 << n) - 1) << endl;
/*for(int i = 0; i < (1 << n); i++){
for(int j = 0; j <= m; j++){
cout << dp[i][j] << " ";
}
cout << endl;
}*/
}
return 0;
}
| replace | 2 | 3 | 2 | 3 | TLE | |
p01849 | C++ | Runtime Error | #include <algorithm>
#include <cfloat>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;
struct Info {
int array[16];
int state, sum_cost, used_num;
};
int N, M;
int POW[17];
int dp[32768];
int futon[16], demand[101];
void func() {
futon[0] = 0;
for (int i = 1; i <= N; i++)
scanf("%d", &futon[i]);
demand[0] = 0;
for (int i = 1; i <= M; i++)
scanf("%d", &demand[i]);
sort(demand, demand + (M + 1));
N++;
for (int i = 0; i < POW[N]; i++)
dp[i] = BIG_NUM;
Info first;
first.state = 0;
first.used_num = 0;
first.sum_cost = 0;
queue<Info> Q;
Q.push(first);
int tmp_sum, next_state;
while (!Q.empty()) {
if (Q.front().used_num == N) {
Q.pop();
} else if (Q.front().sum_cost > dp[Q.front().state]) {
Q.pop();
} else {
for (int loop = 0; loop < N; loop++) {
if (Q.front().state & (1 << loop)) {
// Do noghint
} else {
Info next_info;
for (int i = 0; i < Q.front().used_num; i++)
next_info.array[i] = Q.front().array[i];
next_info.array[Q.front().used_num] = futon[loop];
if (Q.front().used_num > 0) {
next_info.array[Q.front().used_num] +=
next_info.array[Q.front().used_num - 1];
}
int index = 0;
tmp_sum = 0;
for (int i = 1; i <= M; i++) {
while (index < Q.front().used_num &&
abs(demand[i] - next_info.array[index]) >
abs(demand[i] - next_info.array[index + 1]))
index++;
tmp_sum += abs(demand[i] - next_info.array[index]);
}
next_state = Q.front().state + POW[loop];
if (dp[next_state] > tmp_sum) {
dp[next_state] = tmp_sum;
next_info.state = next_state;
next_info.sum_cost = tmp_sum;
next_info.used_num = Q.front().used_num + 1;
Q.push(next_info);
}
}
}
Q.pop();
}
}
printf("%d\n", dp[POW[N] - 1]);
}
int main() {
for (int i = 0; i < 17; i++)
POW[i] = pow(2, i);
while (true) {
scanf("%d %d", &N, &M);
if (N == 0 && M == 0)
break;
func();
}
return 0;
} | #include <algorithm>
#include <cfloat>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;
struct Info {
int array[16];
int state, sum_cost, used_num;
};
int N, M;
int POW[17];
int dp[65536];
int futon[16], demand[101];
void func() {
futon[0] = 0;
for (int i = 1; i <= N; i++)
scanf("%d", &futon[i]);
demand[0] = 0;
for (int i = 1; i <= M; i++)
scanf("%d", &demand[i]);
sort(demand, demand + (M + 1));
N++;
for (int i = 0; i < POW[N]; i++)
dp[i] = BIG_NUM;
Info first;
first.state = 0;
first.used_num = 0;
first.sum_cost = 0;
queue<Info> Q;
Q.push(first);
int tmp_sum, next_state;
while (!Q.empty()) {
if (Q.front().used_num == N) {
Q.pop();
} else if (Q.front().sum_cost > dp[Q.front().state]) {
Q.pop();
} else {
for (int loop = 0; loop < N; loop++) {
if (Q.front().state & (1 << loop)) {
// Do noghint
} else {
Info next_info;
for (int i = 0; i < Q.front().used_num; i++)
next_info.array[i] = Q.front().array[i];
next_info.array[Q.front().used_num] = futon[loop];
if (Q.front().used_num > 0) {
next_info.array[Q.front().used_num] +=
next_info.array[Q.front().used_num - 1];
}
int index = 0;
tmp_sum = 0;
for (int i = 1; i <= M; i++) {
while (index < Q.front().used_num &&
abs(demand[i] - next_info.array[index]) >
abs(demand[i] - next_info.array[index + 1]))
index++;
tmp_sum += abs(demand[i] - next_info.array[index]);
}
next_state = Q.front().state + POW[loop];
if (dp[next_state] > tmp_sum) {
dp[next_state] = tmp_sum;
next_info.state = next_state;
next_info.sum_cost = tmp_sum;
next_info.used_num = Q.front().used_num + 1;
Q.push(next_info);
}
}
}
Q.pop();
}
}
printf("%d\n", dp[POW[N] - 1]);
}
int main() {
for (int i = 0; i < 17; i++)
POW[i] = pow(2, i);
while (true) {
scanf("%d %d", &N, &M);
if (N == 0 && M == 0)
break;
func();
}
return 0;
} | replace | 25 | 26 | 25 | 26 | 0 | |
p01854 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, k, n) for (int i = (k); i < (n); i++)
#define REP(i, n) FOR(i, 0, n)
#define ALL(a) begin(a), end(a)
#define MS(m, v) memset(m, v, sizeof(m))
#define D10 fixed << setprecision(10)
typedef vector<int> vi;
typedef vector<string> vs;
typedef pair<int, char> P;
typedef long long ll;
const int INF = 114514810;
const ll MOD = 1000000007;
const double EPS = 1e-8;
const double PI = acos(-1.0);
struct edge {
int to, cost;
bool operator<(const edge &e) const { return cost < e.cost; }
bool operator>(const edge &e) const { return cost > e.cost; }
};
vector<vi> s, h;
int n, m;
double dp[222][222];
double solve(int i, int w) {
if (i == n)
return 0;
double res = -1;
int tmp = 0, full = s[i][0] * h[i][0];
double tmph = 0;
res = max(res, solve(i + 1, w));
FOR(j, 1, w + 1) {
if (j > full) {
tmp++;
if (tmp == s[i].size())
break;
full += s[i][tmp] * h[i][tmp];
}
tmph += 1.0 / s[i][tmp];
res = max(res, solve(i + 1, w - j) + tmph);
}
return dp[i][w] = res;
}
int main() {
MS(dp, -1);
cin >> n >> m;
s.resize(n), h.resize(n);
REP(i, n) {
int k;
cin >> k;
s[i].resize(k), h[i].resize(k);
REP(j, k) cin >> s[i][j] >> h[i][j];
}
cout << D10 << solve(0, m) << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, k, n) for (int i = (k); i < (n); i++)
#define REP(i, n) FOR(i, 0, n)
#define ALL(a) begin(a), end(a)
#define MS(m, v) memset(m, v, sizeof(m))
#define D10 fixed << setprecision(10)
typedef vector<int> vi;
typedef vector<string> vs;
typedef pair<int, char> P;
typedef long long ll;
const int INF = 114514810;
const ll MOD = 1000000007;
const double EPS = 1e-8;
const double PI = acos(-1.0);
struct edge {
int to, cost;
bool operator<(const edge &e) const { return cost < e.cost; }
bool operator>(const edge &e) const { return cost > e.cost; }
};
vector<vi> s, h;
int n, m;
double dp[222][222];
double solve(int i, int w) {
if (i == n)
return 0;
if (dp[i][w] >= 0)
return dp[i][w];
double res = -1;
int tmp = 0, full = s[i][0] * h[i][0];
double tmph = 0;
res = max(res, solve(i + 1, w));
FOR(j, 1, w + 1) {
if (j > full) {
tmp++;
if (tmp == s[i].size())
break;
full += s[i][tmp] * h[i][tmp];
}
tmph += 1.0 / s[i][tmp];
res = max(res, solve(i + 1, w - j) + tmph);
}
return dp[i][w] = res;
}
int main() {
MS(dp, -1);
cin >> n >> m;
s.resize(n), h.resize(n);
REP(i, n) {
int k;
cin >> k;
s[i].resize(k), h[i].resize(k);
REP(j, k) cin >> s[i][j] >> h[i][j];
}
cout << D10 << solve(0, m) << endl;
return 0;
} | insert | 28 | 28 | 28 | 30 | TLE | |
p01856 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <utility>
#include <vector>
using namespace std;
int D[523][523];
int g[523][523];
int cnt, fx, fy;
void find(int y, int x) {
if (D[y][x]) {
fy = y + 1;
fx = x + 1;
cnt += D[y][x];
int p = D[y][x];
g[fy][fx] = p;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
D[y + i][x + j] -= p;
}
}
}
}
int main() {
int H, W;
cin >> H >> W;
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
cin >> D[i][j];
}
}
for (int i = 0; i < W; i++) {
int y = 0, x = i;
for (; x >= 0; y++, x--) {
find(y, x);
}
}
for (int i = 1; i < H; i++) {
int y = i, x = W - 1;
for (; y < H; y++, x--) {
find(y, x);
}
}
vector<pair<int, int>> ans;
if (cnt == 1) {
ans.emplace_back(fy, fx);
} else {
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
if (g[i][j]) {
int d = g[i][j] - 1;
for (int k = -1; k <= 1; k++) {
int ny = i + k;
if (ny < 0 || H <= ny)
continue;
for (int l = -1; l <= 1; l++) {
int nx = j + l;
if (nx < 0 || W <= nx || k == 0 && l == 0)
continue;
d += g[ny][nx];
}
}
if (d % 2) {
ans.emplace_back(i, j);
}
}
}
}
}
cout << ans.back().first << ' ' << ans.back().second << ' ' << ans[0].first
<< ' ' << ans[0].second << endl;
} | #include <algorithm>
#include <iostream>
#include <utility>
#include <vector>
using namespace std;
int D[523][523];
int g[523][523];
int cnt, fx, fy;
void find(int y, int x) {
if (D[y][x]) {
fy = y + 1;
fx = x + 1;
cnt++;
int p = D[y][x];
g[fy][fx] = p;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
D[y + i][x + j] -= p;
}
}
}
}
int main() {
int H, W;
cin >> H >> W;
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
cin >> D[i][j];
}
}
for (int i = 0; i < W; i++) {
int y = 0, x = i;
for (; x >= 0; y++, x--) {
find(y, x);
}
}
for (int i = 1; i < H; i++) {
int y = i, x = W - 1;
for (; y < H; y++, x--) {
find(y, x);
}
}
vector<pair<int, int>> ans;
if (cnt == 1) {
ans.emplace_back(fy, fx);
} else {
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
if (g[i][j]) {
int d = g[i][j] - 1;
for (int k = -1; k <= 1; k++) {
int ny = i + k;
if (ny < 0 || H <= ny)
continue;
for (int l = -1; l <= 1; l++) {
int nx = j + l;
if (nx < 0 || W <= nx || k == 0 && l == 0)
continue;
d += g[ny][nx];
}
}
if (d % 2) {
ans.emplace_back(i, j);
}
}
}
}
}
cout << ans.back().first << ' ' << ans.back().second << ' ' << ans[0].first
<< ' ' << ans[0].second << endl;
} | replace | 15 | 16 | 15 | 16 | 0 | |
p01858 | C++ | Runtime Error | #include <algorithm>
#include <array>
#include <cmath>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define vi vector<int>
#define vvi vector<vector<int>>
#define ll long long int
#define vl vector<ll>
#define vvl vector<vector<ll>>
#define vb vector<bool>
#define vc vector<char>
#define vs vector<string>
#define ld long double
#define INF 1e9
#define EPS 0.0000000001
#define rep(i, n) for (int i = 0; i < n; i++)
#define loop(i, s, n) for (int i = s; i < n; i++)
#define all(in) in.begin(), in.end()
template <class T, class S> void cmin(T &a, const S &b) {
if (a > b)
a = b;
}
template <class T, class S> void cmax(T &a, const S &b) {
if (a < b)
a = b;
}
#define MAX 9999999
using namespace std;
typedef pair<int, int> pii;
typedef pair<double, double> pdd;
typedef pair<ll, ll> pll;
int main() {
int n;
cin >> n;
string a = "kougekida";
string d = "mamoru";
string c = "tameru";
vector<string> v, u;
rep(i, n) {
string temp;
cin >> temp;
v.push_back(temp);
}
rep(i, n) {
string temp;
cin >> temp;
u.push_back(temp);
}
int vat = 0, uat = 0;
for (int i = 0; i < n; i++) {
string _u = u[i];
string _v = v[i];
if (_u == "kougekida" && _v == "kougekida") {
if (uat != 0 && vat == 0)
return puts("Nakajima-kun") * 0;
else if (uat == 0 && vat != 0)
return puts("Isono-kun") * 0;
else if (uat == vat) {
uat = 0;
vat = 0;
continue;
} else {
cout << (vat > uat ? "Isono-kun" : "Nakajima-kun") << endl;
return 0;
}
}
// one player atk and other player def
if ((_u == d && _v == a) || (_v == d && _u == a)) {
if (_u == d && _v == a) {
if (vat == 5) {
return puts("Isono-kun") * 0;
}
if (vat == 0)
return puts("Nakajima-kun") * 0;
else
vat = 0;
} else {
if (uat == 5)
return puts("Nakajima-kun") * 0;
if (uat == 0)
return puts("Isono-kun") + 0;
else
uat = 0;
}
}
// both player deffence or charge
if ((_u == d && _v == c) || (_u == c && _v == d) || (_u == d && _v == d) ||
(_u == c && _v == c)) {
if (_u == c)
cmin(++uat, 5);
if (_v == c)
cmin(++vat, 5);
}
if ((_v == a && _u == c) || (_v == c && _u == a)) {
if (_v == a && vat == 0)
return puts("Nakajima-kun") * 0;
else if (_u == a && uat == 0)
return puts("Isono-kun") * 0;
if (_v == a)
return puts("Isono-kun") * 0;
else
return puts("Nakajima-kun") * 0;
}
}
cout << "Hikiwake-kun" << endl;
} | #include <algorithm>
#include <array>
#include <cmath>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define vi vector<int>
#define vvi vector<vector<int>>
#define ll long long int
#define vl vector<ll>
#define vvl vector<vector<ll>>
#define vb vector<bool>
#define vc vector<char>
#define vs vector<string>
#define ld long double
#define INF 1e9
#define EPS 0.0000000001
#define rep(i, n) for (int i = 0; i < n; i++)
#define loop(i, s, n) for (int i = s; i < n; i++)
#define all(in) in.begin(), in.end()
template <class T, class S> void cmin(T &a, const S &b) {
if (a > b)
a = b;
}
template <class T, class S> void cmax(T &a, const S &b) {
if (a < b)
a = b;
}
#define MAX 9999999
using namespace std;
typedef pair<int, int> pii;
typedef pair<double, double> pdd;
typedef pair<ll, ll> pll;
int main() {
int n;
cin >> n;
string a = "kougekida";
string d = "mamoru";
string c = "tameru";
vector<string> v, u;
rep(i, n) {
string temp;
cin >> temp;
v.push_back(temp);
}
rep(i, n) {
string temp;
cin >> temp;
u.push_back(temp);
}
int vat = 0, uat = 0;
for (int i = 0; i < n; i++) {
string _u = u[i];
string _v = v[i];
if (_u == "kougekida" && _v == "kougekida") {
if (uat != 0 && vat == 0)
return puts("Nakajima-kun") * 0;
else if (uat == 0 && vat != 0)
return puts("Isono-kun") * 0;
else if (uat == vat) {
uat = 0;
vat = 0;
continue;
} else {
cout << (vat > uat ? "Isono-kun" : "Nakajima-kun") << endl;
return 0;
}
}
// one player atk and other player def
if ((_u == d && _v == a) || (_v == d && _u == a)) {
if (_u == d && _v == a) {
if (vat == 5) {
return puts("Isono-kun") * 0;
}
if (vat == 0)
return puts("Nakajima-kun") * 0;
else
vat = 0;
} else {
if (uat == 5)
return puts("Nakajima-kun") * 0;
if (uat == 0)
return puts("Isono-kun") * 0;
else
uat = 0;
}
}
// both player deffence or charge
if ((_u == d && _v == c) || (_u == c && _v == d) || (_u == d && _v == d) ||
(_u == c && _v == c)) {
if (_u == c)
cmin(++uat, 5);
if (_v == c)
cmin(++vat, 5);
}
if ((_v == a && _u == c) || (_v == c && _u == a)) {
if (_v == a && vat == 0)
return puts("Nakajima-kun") * 0;
else if (_u == a && uat == 0)
return puts("Isono-kun") * 0;
if (_v == a)
return puts("Isono-kun") * 0;
else
return puts("Nakajima-kun") * 0;
}
}
cout << "Hikiwake-kun" << endl;
} | replace | 97 | 98 | 97 | 98 | 0 | |
p01861 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define dump(...) cout << "# " << #__VA_ARGS__ << '=' << (__VA_ARGS__) << endl
#define repi(i, a, b) for (int i = int(a); i < int(b); i++)
#define peri(i, a, b) for (int i = int(b); i-- > int(a);)
#define rep(i, n) repi(i, 0, n)
#define per(i, n) peri(i, 0, n)
#define all(c) begin(c), end(c)
#define mp make_pair
#define mt make_tuple
typedef unsigned int uint;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef vector<string> vs;
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
return os << '(' << p.first << ',' << p.second << ')';
}
template <typename Tuple> void print_tuple(ostream &, const Tuple &) {}
template <typename Car, typename... Cdr, typename Tuple>
void print_tuple(ostream &os, const Tuple &t) {
print_tuple<Cdr...>(os, t);
os << (sizeof...(Cdr) ? "," : "") << get<sizeof...(Cdr)>(t);
}
template <typename... Args>
ostream &operator<<(ostream &os, const tuple<Args...> &t) {
print_tuple<Args...>(os << '(', t);
return os << ')';
}
template <typename Ch, typename Tr, typename C>
basic_ostream<Ch, Tr> &operator<<(basic_ostream<Ch, Tr> &os, const C &c) {
os << '[';
for (auto i = begin(c); i != end(c); ++i)
os << (i == begin(c) ? "" : " ") << *i;
return os << ']';
}
constexpr int INF = 1e9;
constexpr int MOD = 1e9 + 7;
constexpr double EPS = 1e-9;
int solve(int i, int l, int r, const vi &xs, const vi &as, const vi &bs,
const vi &cs, vector<vvi> &memo) {
if (memo[i][l][r] != -1)
return memo[i][l][r];
if (r - l == 1)
return memo[i][l][r] = (as[i] == xs[l]);
repi(p, l + 1, r) if (solve(bs[i], l, p, xs, as, bs, cs, memo) &&
solve(cs[i], p, r, xs, as, bs, cs,
memo)) return memo[i][l][r] = true;
return false;
}
int main() {
for (int n; cin >> n && n;) {
vi xs(n);
rep(i, n) cin >> xs[i];
int m;
cin >> m;
vi as(m), bs(m), cs(m);
rep(i, m) cin >> as[i] >> bs[i] >> cs[i], bs[i]--, cs[i]--;
vector<vvi> memo(m, vvi(n + 1, vi(n + 1, -1)));
cout << (solve(0, 0, n, xs, as, bs, cs, memo) ? "Yes" : "No") << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
#define dump(...) cout << "# " << #__VA_ARGS__ << '=' << (__VA_ARGS__) << endl
#define repi(i, a, b) for (int i = int(a); i < int(b); i++)
#define peri(i, a, b) for (int i = int(b); i-- > int(a);)
#define rep(i, n) repi(i, 0, n)
#define per(i, n) peri(i, 0, n)
#define all(c) begin(c), end(c)
#define mp make_pair
#define mt make_tuple
typedef unsigned int uint;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef vector<string> vs;
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
return os << '(' << p.first << ',' << p.second << ')';
}
template <typename Tuple> void print_tuple(ostream &, const Tuple &) {}
template <typename Car, typename... Cdr, typename Tuple>
void print_tuple(ostream &os, const Tuple &t) {
print_tuple<Cdr...>(os, t);
os << (sizeof...(Cdr) ? "," : "") << get<sizeof...(Cdr)>(t);
}
template <typename... Args>
ostream &operator<<(ostream &os, const tuple<Args...> &t) {
print_tuple<Args...>(os << '(', t);
return os << ')';
}
template <typename Ch, typename Tr, typename C>
basic_ostream<Ch, Tr> &operator<<(basic_ostream<Ch, Tr> &os, const C &c) {
os << '[';
for (auto i = begin(c); i != end(c); ++i)
os << (i == begin(c) ? "" : " ") << *i;
return os << ']';
}
constexpr int INF = 1e9;
constexpr int MOD = 1e9 + 7;
constexpr double EPS = 1e-9;
int solve(int i, int l, int r, const vi &xs, const vi &as, const vi &bs,
const vi &cs, vector<vvi> &memo) {
if (memo[i][l][r] != -1)
return memo[i][l][r];
if (r - l == 1)
return memo[i][l][r] = (as[i] == xs[l]);
repi(p, l + 1, r) if (solve(bs[i], l, p, xs, as, bs, cs, memo) &&
solve(cs[i], p, r, xs, as, bs, cs,
memo)) return memo[i][l][r] = true;
return memo[i][l][r] = false;
}
int main() {
for (int n; cin >> n && n;) {
vi xs(n);
rep(i, n) cin >> xs[i];
int m;
cin >> m;
vi as(m), bs(m), cs(m);
rep(i, m) cin >> as[i] >> bs[i] >> cs[i], bs[i]--, cs[i]--;
vector<vvi> memo(m, vvi(n + 1, vi(n + 1, -1)));
cout << (solve(0, 0, n, xs, as, bs, cs, memo) ? "Yes" : "No") << endl;
}
} | replace | 62 | 63 | 62 | 63 | TLE | |
p01863 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 30;
struct SuffixArray {
vector<int> SA;
string s;
void Build_SA(const string &str) {
s = str;
SA.resize(s.size());
iota(begin(SA), end(SA), 0);
sort(begin(SA), end(SA), [&](const int &a, const int &b) {
if (s[a] == s[b])
return (a > b);
return (s[a] < s[b]);
});
vector<int> classes(s.size()), c(s.size()), cnt(s.size());
for (int i = 0; i < s.size(); i++) {
c[i] = s[i];
}
for (int len = 1; len < s.size(); len <<= 1) {
for (int i = 0; i < s.size(); i++) {
if (i > 0 && c[SA[i - 1]] == c[SA[i]] && SA[i - 1] + len < s.size() &&
c[SA[i - 1] + len / 2] == c[SA[i] + len / 2]) {
classes[SA[i]] = classes[SA[i - 1]];
} else {
classes[SA[i]] = i;
}
}
iota(begin(cnt), end(cnt), 0);
copy(begin(SA), end(SA), begin(c));
for (int i = 0; i < s.size(); i++) {
int s1 = c[i] - len;
if (s1 >= 0)
SA[cnt[classes[s1]]++] = s1;
}
classes.swap(c);
}
}
int operator[](int k) const { return (SA[k]); }
int size() const { return (s.size()); }
bool lt_substr(string &t, int si = 0, int ti = 0) {
int sn = s.size(), tn = t.size();
while (si < sn && ti < tn) {
if (s[si] < t[ti])
return (true);
if (s[si] > t[ti])
return (false);
++si, ++ti;
}
return (si >= sn && ti < tn);
}
int lower_bound(string &t) {
int low = -1, high = SA.size();
while (high - low > 1) {
int mid = (low + high) >> 1;
if (lt_substr(t, SA[mid]))
low = mid;
else
high = mid;
}
return (high);
}
pair<int, int> lower_upper_bound(string &t) {
int idx = lower_bound(t);
int low = idx - 1, high = SA.size();
t.back()++;
while (high - low > 1) {
int mid = (low + high) >> 1;
if (lt_substr(t, SA[mid]))
low = mid;
else
high = mid;
}
t.back()--;
return (make_pair(idx, high));
}
};
struct LongestCommonPrefixArray {
vector<int> LCP;
vector<int> rank;
void Build_LCP(SuffixArray &SA) {
string &s = SA.s;
rank.resize(s.size());
for (int i = 0; i < s.size(); i++) {
rank[SA[i]] = i;
}
LCP.resize(s.size() - 1);
for (int i = 0, h = 0; i < s.size(); i++) {
if (rank[i] + 1 < s.size()) {
for (int j = SA[rank[i] + 1];
max(i, j) + h < s.length() && s[i + h] == s[j + h]; ++h)
;
LCP[rank[i]] = h;
if (h > 0)
--h;
}
}
}
int operator[](int k) const {
if (k < 0)
return (0);
return (LCP[k]);
}
int size() const { return (LCP.size() + 1); }
};
struct StaticSegmentTree {
vector<int> seg;
int sz;
StaticSegmentTree(int n) {
sz = 1;
while (sz < n)
sz <<= 1;
seg.assign(2 * sz - 1, INF);
}
void set(int k, int x) { seg[k + sz - 1] = x; }
void build() {
for (int k = sz - 2; k >= 0; k--) {
seg[k] = min(seg[2 * k + 1], seg[2 * k + 2]);
};
}
int rmq(int a, int b, int k, int l, int r) {
if (a >= r || b <= l)
return (INF);
if (a <= l && r <= b)
return (seg[k]);
return (min(rmq(a, b, 2 * k + 1, l, (l + r) >> 1),
rmq(a, b, 2 * k + 2, (l + r) >> 1, r)));
}
int rmq(int a, int b) { return (rmq(min(a, b), max(a, b), 0, 0, sz)); }
};
int main() {
string S;
cin >> S;
SuffixArray sa;
sa.Build_SA(S);
LongestCommonPrefixArray lcp;
lcp.Build_LCP(sa);
StaticSegmentTree tree(lcp.size());
for (int i = 0; i < S.size(); i++) {
tree.set(i, lcp[i]);
}
tree.build();
int ret = INF;
for (int A = 1; A < S.size(); A++) {
int B = (int)S.size() - A * 3;
if (B <= 0)
break;
if (B & 1)
continue;
B /= 2;
if (tree.rmq(lcp.rank[0], lcp.rank[A + B]) >= A &&
tree.rmq(lcp.rank[0], lcp.rank[A + B + A + B]) >= A &&
tree.rmq(lcp.rank[A], lcp.rank[A + B + A]) >= B) {
ret = min(ret, A + B);
}
}
if (ret >= INF) {
cout << "mitomerarenaiWA" << endl;
} else {
cout << "Love " << S.substr(0, ret) << "!" << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 30;
struct SuffixArray {
vector<int> SA;
string s;
void Build_SA(const string &str) {
s = str;
SA.resize(s.size());
iota(begin(SA), end(SA), 0);
sort(begin(SA), end(SA), [&](const int &a, const int &b) {
if (s[a] == s[b])
return (a > b);
return (s[a] < s[b]);
});
vector<int> classes(s.size()), c(s.size()), cnt(s.size());
for (int i = 0; i < s.size(); i++) {
c[i] = s[i];
}
for (int len = 1; len < s.size(); len <<= 1) {
for (int i = 0; i < s.size(); i++) {
if (i > 0 && c[SA[i - 1]] == c[SA[i]] && SA[i - 1] + len < s.size() &&
c[SA[i - 1] + len / 2] == c[SA[i] + len / 2]) {
classes[SA[i]] = classes[SA[i - 1]];
} else {
classes[SA[i]] = i;
}
}
iota(begin(cnt), end(cnt), 0);
copy(begin(SA), end(SA), begin(c));
for (int i = 0; i < s.size(); i++) {
int s1 = c[i] - len;
if (s1 >= 0)
SA[cnt[classes[s1]]++] = s1;
}
classes.swap(c);
}
}
int operator[](int k) const { return (SA[k]); }
int size() const { return (s.size()); }
bool lt_substr(string &t, int si = 0, int ti = 0) {
int sn = s.size(), tn = t.size();
while (si < sn && ti < tn) {
if (s[si] < t[ti])
return (true);
if (s[si] > t[ti])
return (false);
++si, ++ti;
}
return (si >= sn && ti < tn);
}
int lower_bound(string &t) {
int low = -1, high = SA.size();
while (high - low > 1) {
int mid = (low + high) >> 1;
if (lt_substr(t, SA[mid]))
low = mid;
else
high = mid;
}
return (high);
}
pair<int, int> lower_upper_bound(string &t) {
int idx = lower_bound(t);
int low = idx - 1, high = SA.size();
t.back()++;
while (high - low > 1) {
int mid = (low + high) >> 1;
if (lt_substr(t, SA[mid]))
low = mid;
else
high = mid;
}
t.back()--;
return (make_pair(idx, high));
}
};
struct LongestCommonPrefixArray {
vector<int> LCP;
vector<int> rank;
void Build_LCP(SuffixArray &SA) {
string &s = SA.s;
rank.resize(s.size());
for (int i = 0; i < s.size(); i++) {
rank[SA[i]] = i;
}
LCP.resize(s.size() - 1);
for (int i = 0, h = 0; i < s.size(); i++) {
if (rank[i] + 1 < s.size()) {
for (int j = SA[rank[i] + 1];
max(i, j) + h < s.length() && s[i + h] == s[j + h]; ++h)
;
LCP[rank[i]] = h;
if (h > 0)
--h;
}
}
}
int operator[](int k) const {
if (k < 0)
return (0);
return (LCP[k]);
}
int size() const { return (LCP.size() + 1); }
};
struct StaticSegmentTree {
vector<int> seg;
int sz;
StaticSegmentTree(int n) {
sz = 1;
while (sz < n)
sz <<= 1;
seg.assign(2 * sz - 1, INF);
}
void set(int k, int x) { seg[k + sz - 1] = x; }
void build() {
for (int k = sz - 2; k >= 0; k--) {
seg[k] = min(seg[2 * k + 1], seg[2 * k + 2]);
};
}
int rmq(int a, int b, int k, int l, int r) {
if (a >= r || b <= l)
return (INF);
if (a <= l && r <= b)
return (seg[k]);
return (min(rmq(a, b, 2 * k + 1, l, (l + r) >> 1),
rmq(a, b, 2 * k + 2, (l + r) >> 1, r)));
}
int rmq(int a, int b) { return (rmq(min(a, b), max(a, b), 0, 0, sz)); }
};
int main() {
string S;
cin >> S;
SuffixArray sa;
sa.Build_SA(S);
LongestCommonPrefixArray lcp;
lcp.Build_LCP(sa);
StaticSegmentTree tree(lcp.size());
for (int i = 0; i < lcp.size() - 1; i++) {
tree.set(i, lcp[i]);
}
tree.build();
int ret = INF;
for (int A = 1; A < S.size(); A++) {
int B = (int)S.size() - A * 3;
if (B <= 0)
break;
if (B & 1)
continue;
B /= 2;
if (tree.rmq(lcp.rank[0], lcp.rank[A + B]) >= A &&
tree.rmq(lcp.rank[0], lcp.rank[A + B + A + B]) >= A &&
tree.rmq(lcp.rank[A], lcp.rank[A + B + A]) >= B) {
ret = min(ret, A + B);
}
}
if (ret >= INF) {
cout << "mitomerarenaiWA" << endl;
} else {
cout << "Love " << S.substr(0, ret) << "!" << endl;
}
} | replace | 158 | 159 | 158 | 159 | 0 | |
p01863 | C++ | Runtime Error | #include "bits/stdc++.h"
#include <unordered_map>
#include <unordered_set>
#pragma warning(disable : 4996)
using namespace std;
using ld = long double;
const ld eps = 1e-9;
using ll = long long int;
using ha = pair<ll, ll>;
struct RollingHash {
static const ll mul0 = 10009, mul1 = 10007;
static const ll add0 = 1000010007, add1 = 1003333331;
size_t len;
// vector<ll> hash_, hash2_;
vector<ha> hash_;
// static vector<ll> pmo_, pmo2_;
static vector<ha> pmo_;
void init(const vector<ll> &s) {
len = s.size();
hash_.resize(len + 1);
hash_[0] = make_pair(0, 0);
if (pmo_.empty()) {
pmo_.push_back(make_pair(1, 1));
}
while (pmo_.size() <= len) {
pmo_.push_back(
make_pair(pmo_.back().first * mul0, pmo_.back().second * mul1));
}
for (unsigned int i = 0; i < len; ++i) {
hash_[i + 1] = make_pair((hash_[i].first * mul0 + s[i]),
(hash_[i].second * mul1 + s[i]));
}
return;
}
void init(const string &s) {
vector<ll> v;
for (char c : s) {
v.push_back(c);
}
init(v);
}
ha hash(const int l, const int r) const { // s[l..r]
return make_pair(
hash_[r + 1].first - hash_[l].first * pmo_[r + 1 - l].first,
hash_[r + 1].second - hash_[l].second * pmo_[r + 1 - l].second);
}
ha hash() const { // s[all]
return hash(0, len - 1);
}
// hash????????????
static ha concat(const ha L, const ha R, const int RLength) { // hash(L+R)
return make_pair((R.first + L.first * pmo_[RLength].first),
(R.second + L.second * pmo_[RLength].second));
}
// index????????????from??????to????????????????????????????????\????????????
ha get_changed_hash(const int index, const ll from, const ll to) const {
const ha p(hash());
return make_pair(p.first + (to - from) * pmo_[len - index - 1].first,
p.second + (to - from) * pmo_[len - index - 1].second);
}
};
vector<ha> RollingHash::pmo_;
int main() {
string st;
cin >> st;
RollingHash rh;
rh.init(st);
pair<int, int> ans = make_pair(0, 0);
for (int a = st.size() / 3; a > 0; --a) {
if ((st.size() - a * 3) % 2)
continue;
else {
int b = (st.size() - a * 3) / 2;
ha h0 = rh.hash(0, a - 1);
ha h1 = rh.hash(a, a + b - 1);
ha h2 = rh.hash(a + b, 2 * a + b - 1);
ha h3 = rh.hash(2 * a + b, 2 * a + 2 * b - 1);
ha h4 = rh.hash(2 * a + 2 * b, 3 * a + 2 * b - 1);
if (h0 == h2 && h2 == h4 && h1 == h3) {
ans = make_pair(a, b);
break;
}
}
}
if (ans.first) {
assert(ans.second);
cout << "Love " << st.substr(0, ans.first)
<< st.substr(ans.first, ans.second) << "!" << endl;
} else {
cout << "mitomerarenaiWA" << endl;
}
return 0;
} | #include "bits/stdc++.h"
#include <unordered_map>
#include <unordered_set>
#pragma warning(disable : 4996)
using namespace std;
using ld = long double;
const ld eps = 1e-9;
using ll = long long int;
using ha = pair<ll, ll>;
struct RollingHash {
static const ll mul0 = 10009, mul1 = 10007;
static const ll add0 = 1000010007, add1 = 1003333331;
size_t len;
// vector<ll> hash_, hash2_;
vector<ha> hash_;
// static vector<ll> pmo_, pmo2_;
static vector<ha> pmo_;
void init(const vector<ll> &s) {
len = s.size();
hash_.resize(len + 1);
hash_[0] = make_pair(0, 0);
if (pmo_.empty()) {
pmo_.push_back(make_pair(1, 1));
}
while (pmo_.size() <= len) {
pmo_.push_back(
make_pair(pmo_.back().first * mul0, pmo_.back().second * mul1));
}
for (unsigned int i = 0; i < len; ++i) {
hash_[i + 1] = make_pair((hash_[i].first * mul0 + s[i]),
(hash_[i].second * mul1 + s[i]));
}
return;
}
void init(const string &s) {
vector<ll> v;
for (char c : s) {
v.push_back(c);
}
init(v);
}
ha hash(const int l, const int r) const { // s[l..r]
return make_pair(
hash_[r + 1].first - hash_[l].first * pmo_[r + 1 - l].first,
hash_[r + 1].second - hash_[l].second * pmo_[r + 1 - l].second);
}
ha hash() const { // s[all]
return hash(0, len - 1);
}
// hash????????????
static ha concat(const ha L, const ha R, const int RLength) { // hash(L+R)
return make_pair((R.first + L.first * pmo_[RLength].first),
(R.second + L.second * pmo_[RLength].second));
}
// index????????????from??????to????????????????????????????????\????????????
ha get_changed_hash(const int index, const ll from, const ll to) const {
const ha p(hash());
return make_pair(p.first + (to - from) * pmo_[len - index - 1].first,
p.second + (to - from) * pmo_[len - index - 1].second);
}
};
vector<ha> RollingHash::pmo_;
int main() {
string st;
cin >> st;
RollingHash rh;
rh.init(st);
pair<int, int> ans = make_pair(0, 0);
for (int a = st.size() / 3; a > 0; --a) {
if ((st.size() - a * 3) % 2)
continue;
else {
int b = (st.size() - a * 3) / 2;
if (b) {
ha h0 = rh.hash(0, a - 1);
ha h1 = rh.hash(a, a + b - 1);
ha h2 = rh.hash(a + b, 2 * a + b - 1);
ha h3 = rh.hash(2 * a + b, 2 * a + 2 * b - 1);
ha h4 = rh.hash(2 * a + 2 * b, 3 * a + 2 * b - 1);
if (h0 == h2 && h2 == h4 && h1 == h3) {
ans = make_pair(a, b);
break;
}
}
}
}
if (ans.first) {
assert(ans.second);
cout << "Love " << st.substr(0, ans.first)
<< st.substr(ans.first, ans.second) << "!" << endl;
} else {
cout << "mitomerarenaiWA" << endl;
}
return 0;
} | replace | 78 | 86 | 78 | 88 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.