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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
p01426 | C++ | Memory Limit Exceeded | #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;
// < "d:\d_download\visual studio
// 2015\projects\programing_contest_c++\debug\a.txt" > "d:\d_download\visual
// studio 2015\projects\programing_contest_c++\debug\b.txt"
typedef ld Weight;
const Weight INF = 1e18;
const Weight ZERO = 0;
struct Edge {
int src, dst;
Weight weight;
int id;
Edge(int src_, int dst_, Weight weight_, const int id_)
: src(src_), dst(dst_), weight(weight_), id(id_) {}
Edge(int src, int dst, Weight weight) : src(src), dst(dst), weight(weight) {}
Edge() : src(0), dst(0), weight(0) {}
};
typedef vector<Edge> Edges;
typedef vector<Edges> Graph;
namespace getcycle {
vector<Edge> get_cycle(const Graph &g, const int start) {
vector<Edge> prev_es(g.size());
for (auto es : g) {
for (auto e : es) {
prev_es[e.dst] = e;
}
}
for (int i = 0; i < int(g.size()); ++i) {
if (i == start)
continue;
int now = i;
vector<Edge> cycles;
vector<int> comes(g.size(), -1);
comes[now] = 0;
int num = 1;
while (1) {
cycles.emplace_back(prev_es[now]);
now = prev_es[now].src;
if (comes[now] != -1) {
cycles = vector<Edge>(cycles.begin() + comes[now], cycles.end());
reverse(cycles.begin(), cycles.end());
return cycles;
} else if (now == start) {
break;
}
comes[now] = num++;
}
}
return vector<Edge>(0);
}
} // namespace getcycle
// aoj2309???varify??????????????£??????????????§????????????????????????
pair<Weight, Graph> chu_liu(const Graph &g, const int start, const int e_size) {
vector<Edge> cycle_edges;
Weight total_len = 0;
{
Graph tree(g.size());
{
Graph revg(g.size());
for (auto es : g) {
for (auto e : es) {
revg[e.dst].emplace_back(e.dst, e.src, e.weight, e.id);
}
}
for (int node = 0; node < int(g.size()); ++node) {
if (node == start)
continue;
else {
Weight amin = INF;
Edge min_edge;
for (auto reve : revg[node]) {
if (amin > reve.weight) {
amin = reve.weight;
min_edge = Edge(reve.dst, reve.src, reve.weight, reve.id);
}
}
if (amin < INF) {
total_len += min_edge.weight;
tree[min_edge.src].emplace_back(min_edge);
}
}
}
}
cycle_edges = getcycle::get_cycle(tree, start);
if (cycle_edges.empty()) {
return make_pair(total_len, tree);
}
}
vector<bool> node_is_cycle(g.size());
/*????´???°???Edge?????°????????§??????*/
vector<int> edge_is_cycle(e_size);
vector<Weight> prev_lens(g.size(), ZERO);
for (auto ce : cycle_edges) {
node_is_cycle[ce.src] = true;
prev_lens[ce.dst] = ce.weight;
}
Graph newg(g.size());
const int compress = cycle_edges[0].src;
/*????´???°???Edge?????°????????§??????*/
vector<Edge> memo(e_size);
for (int s = 0; s < int(g.size()); ++s) {
bool src_is_cycle = node_is_cycle[s];
for (auto e : g[s]) {
memo[e.id] = e;
bool dst_is_cycle = node_is_cycle[e.dst];
if (src_is_cycle && dst_is_cycle) {
continue;
} else if (src_is_cycle) {
e.src = compress;
} else if (dst_is_cycle) {
e.weight -= prev_lens[e.dst];
e.dst = compress;
}
newg[e.src].push_back(e);
}
}
auto p = chu_liu(newg, start, e_size);
Graph compress_tree(p.second);
Graph ans_tree(g.size());
for (auto es : compress_tree) {
for (auto e : es) {
const Edge prev_edge(memo[e.id]);
if (node_is_cycle[prev_edge.dst]) {
for (auto cycle_edge : cycle_edges) {
if (cycle_edge.dst != prev_edge.dst) {
ans_tree[cycle_edge.src].emplace_back(cycle_edge);
}
}
}
ans_tree[prev_edge.src].emplace_back(prev_edge);
}
}
Weight cycle_len = 0;
for (auto e : cycle_edges) {
cycle_len += e.weight;
}
return make_pair(p.first + cycle_len, ans_tree);
}
ld getlen(const vector<ld> &a, const vector<ld> &b, const ld n) {
ld sum = 0;
for (int k = 0; k < a.size(); ++k) {
sum += pow(a[k] * n - b[k], 2);
}
return sum;
}
ld getdis(const vector<ld> &a, const vector<ld> &b) {
ld amin = -1e8;
ld amax = 1e8;
int num = 100;
while (num--) {
ld amid1 = (amin * 2 + amax) / 3;
ld amid2 = (amin + amax * 2) / 3;
ld ans1 = getlen(a, b, amid1);
ld ans2 = getlen(a, b, amid2);
if (ans1 < ans2) {
amax = amid2;
} else {
amin = amid1;
}
}
return getlen(a, b, amin);
}
int main() {
int N, M;
cin >> N >> M;
vector<vector<ld>> vecs(M);
for (int i = 0; i < M; ++i) {
for (int j = 0; j < N; ++j) {
ld v;
cin >> v;
vecs[i].emplace_back(v);
}
}
Graph g(M);
int aid = 0;
for (int i = 0; i < M; ++i) {
for (int j = 0; j < M; ++j) {
if (i == j)
continue;
else {
ld len = getdis(vecs[i], vecs[j]);
g[i].push_back(Edge(i, j, len, aid++));
}
}
}
ld ans = 1e18;
for (int i = 0; i < M; ++i) {
vector<ld> v(N);
auto p = chu_liu(g, i, M * (M - 1));
ld plus = getlen(v, vecs[i], 0);
ans = min(ans, p.first + plus);
}
cout << setprecision(12) << fixed << ans << 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;
// < "d:\d_download\visual studio
// 2015\projects\programing_contest_c++\debug\a.txt" > "d:\d_download\visual
// studio 2015\projects\programing_contest_c++\debug\b.txt"
typedef double Weight;
const Weight INF = 1e18;
const Weight ZERO = 0;
struct Edge {
int src, dst;
Weight weight;
int id;
Edge(int src_, int dst_, Weight weight_, const int id_)
: src(src_), dst(dst_), weight(weight_), id(id_) {}
Edge(int src, int dst, Weight weight) : src(src), dst(dst), weight(weight) {}
Edge() : src(0), dst(0), weight(0) {}
};
typedef vector<Edge> Edges;
typedef vector<Edges> Graph;
namespace getcycle {
vector<Edge> get_cycle(const Graph &g, const int start) {
vector<Edge> prev_es(g.size());
for (auto es : g) {
for (auto e : es) {
prev_es[e.dst] = e;
}
}
for (int i = 0; i < int(g.size()); ++i) {
if (i == start)
continue;
int now = i;
vector<Edge> cycles;
vector<int> comes(g.size(), -1);
comes[now] = 0;
int num = 1;
while (1) {
cycles.emplace_back(prev_es[now]);
now = prev_es[now].src;
if (comes[now] != -1) {
cycles = vector<Edge>(cycles.begin() + comes[now], cycles.end());
reverse(cycles.begin(), cycles.end());
return cycles;
} else if (now == start) {
break;
}
comes[now] = num++;
}
}
return vector<Edge>(0);
}
} // namespace getcycle
// aoj2309???varify??????????????£??????????????§????????????????????????
pair<Weight, Graph> chu_liu(const Graph &g, const int start, const int e_size) {
vector<Edge> cycle_edges;
Weight total_len = 0;
{
Graph tree(g.size());
{
Graph revg(g.size());
for (auto es : g) {
for (auto e : es) {
revg[e.dst].emplace_back(e.dst, e.src, e.weight, e.id);
}
}
for (int node = 0; node < int(g.size()); ++node) {
if (node == start)
continue;
else {
Weight amin = INF;
Edge min_edge;
for (auto reve : revg[node]) {
if (amin > reve.weight) {
amin = reve.weight;
min_edge = Edge(reve.dst, reve.src, reve.weight, reve.id);
}
}
if (amin < INF) {
total_len += min_edge.weight;
tree[min_edge.src].emplace_back(min_edge);
}
}
}
}
cycle_edges = getcycle::get_cycle(tree, start);
if (cycle_edges.empty()) {
return make_pair(total_len, tree);
}
}
vector<bool> node_is_cycle(g.size());
/*????´???°???Edge?????°????????§??????*/
vector<int> edge_is_cycle(e_size);
vector<Weight> prev_lens(g.size(), ZERO);
for (auto ce : cycle_edges) {
node_is_cycle[ce.src] = true;
prev_lens[ce.dst] = ce.weight;
}
Graph newg(g.size());
const int compress = cycle_edges[0].src;
/*????´???°???Edge?????°????????§??????*/
vector<Edge> memo(e_size);
for (int s = 0; s < int(g.size()); ++s) {
bool src_is_cycle = node_is_cycle[s];
for (auto e : g[s]) {
memo[e.id] = e;
bool dst_is_cycle = node_is_cycle[e.dst];
if (src_is_cycle && dst_is_cycle) {
continue;
} else if (src_is_cycle) {
e.src = compress;
} else if (dst_is_cycle) {
e.weight -= prev_lens[e.dst];
e.dst = compress;
}
newg[e.src].push_back(e);
}
}
auto p = chu_liu(newg, start, e_size);
Graph compress_tree(p.second);
Graph ans_tree(g.size());
for (auto es : compress_tree) {
for (auto e : es) {
const Edge prev_edge(memo[e.id]);
if (node_is_cycle[prev_edge.dst]) {
for (auto cycle_edge : cycle_edges) {
if (cycle_edge.dst != prev_edge.dst) {
ans_tree[cycle_edge.src].emplace_back(cycle_edge);
}
}
}
ans_tree[prev_edge.src].emplace_back(prev_edge);
}
}
Weight cycle_len = 0;
for (auto e : cycle_edges) {
cycle_len += e.weight;
}
return make_pair(p.first + cycle_len, ans_tree);
}
ld getlen(const vector<ld> &a, const vector<ld> &b, const ld n) {
ld sum = 0;
for (int k = 0; k < a.size(); ++k) {
sum += pow(a[k] * n - b[k], 2);
}
return sum;
}
ld getdis(const vector<ld> &a, const vector<ld> &b) {
ld amin = -1e8;
ld amax = 1e8;
int num = 100;
while (num--) {
ld amid1 = (amin * 2 + amax) / 3;
ld amid2 = (amin + amax * 2) / 3;
ld ans1 = getlen(a, b, amid1);
ld ans2 = getlen(a, b, amid2);
if (ans1 < ans2) {
amax = amid2;
} else {
amin = amid1;
}
}
return getlen(a, b, amin);
}
int main() {
int N, M;
cin >> N >> M;
vector<vector<ld>> vecs(M);
for (int i = 0; i < M; ++i) {
for (int j = 0; j < N; ++j) {
ld v;
cin >> v;
vecs[i].emplace_back(v);
}
}
Graph g(M);
int aid = 0;
for (int i = 0; i < M; ++i) {
for (int j = 0; j < M; ++j) {
if (i == j)
continue;
else {
ld len = getdis(vecs[i], vecs[j]);
g[i].push_back(Edge(i, j, len, aid++));
}
}
}
ld ans = 1e18;
for (int i = 0; i < M; ++i) {
vector<ld> v(N);
auto p = chu_liu(g, i, M * (M - 1));
ld plus = getlen(v, vecs[i], 0);
ans = min(ans, p.first + plus);
}
cout << setprecision(12) << fixed << ans << endl;
return 0;
} | replace | 11 | 12 | 11 | 12 | MLE | |
p01426 | C++ | Memory Limit Exceeded | #include "bits/stdc++.h"
#include <unordered_map>
#include <unordered_set>
#pragma warning(disable : 4996)
using namespace std;
using ld = long double;
template <class T> using Table = vector<vector<T>>;
const ld eps = 1e-9;
//// < "D:\D_Download\Visual Studio
///2015\Projects\programing_contest_c++\Debug\a.txt" > "D:\D_Download\Visual
///Studio 2015\Projects\programing_contest_c++\Debug\b.answer"
typedef ld Weight;
struct Edge {
int src, dst;
Weight weight;
int id;
Edge(int src_, int dst_, Weight weight_, const int id_)
: src(src_), dst(dst_), weight(weight_), id(id_) {}
Edge(int src, int dst, Weight weight) : src(src), dst(dst), weight(weight) {}
Edge() : src(0), dst(0), weight(0) {}
};
const Weight INF = 1e18;
const Weight ZERO = 0;
bool operator<(const Edge &e, const Edge &f) {
return e.weight != f.weight ? e.weight > f.weight : // !!INVERSE!!
e.src != f.src ? e.src < f.src
: e.dst < f.dst;
}
typedef vector<Edge> Edges;
typedef vector<Edges> Graph;
ld getdis(const vector<ld> &f, const vector<ld> &t) {
ld amin = -1e9;
ld amax = 1e9;
int n = 100;
while (n--) {
ld amid0 = (amin * 2 + amax) / 3;
ld amid1 = (amin + amax * 2) / 3;
ld len0 = 0;
ld len1 = 0;
{
for (int i = 0; i < f.size(); ++i) {
len0 += (t[i] - amid0 * f[i]) * (t[i] - amid0 * f[i]);
}
for (int i = 0; i < f.size(); ++i) {
len1 += (t[i] - amid1 * f[i]) * (t[i] - amid1 * f[i]);
}
}
if (len0 < len1) {
amax = amid1;
} else {
amin = amid0;
}
if (!n)
return len0;
}
}
struct Dscc {
public:
// belongs,newedges
pair<vector<vector<int>>, vector<vector<int>>>
get(const vector<vector<int>> &edges) {
nums.resize(edges.size());
fill(nums.begin(), nums.end(), -1);
vector<vector<int>> revedges(edges.size());
for (int i = 0; i < edges.size(); ++i) {
for (auto j : edges[i]) {
revedges[j].push_back(i);
}
}
int num = 0;
for (int i = 0; i < edges.size(); ++i) {
dfs(i, num, edges);
}
vector<int> big(nums.size());
for (int i = 0; i < nums.size(); ++i) {
big[nums[i]] = i;
}
reverse(big.begin(), big.end());
unis.resize(edges.size());
fill(unis.begin(), unis.end(), -1);
num = 0;
for (int i = 0; i < big.size(); ++i) {
dfs2(big[i], num, revedges);
num++;
}
vector<int> nums;
for (int i = 0; i < unis.size(); ++i) {
nums.push_back(unis[i]);
}
sort(nums.begin(), nums.end());
nums.erase(unique(nums.begin(), nums.end()), nums.end());
map<int, int> mp;
for (int i = 0; i < nums.size(); ++i) {
mp[nums[i]] = i;
}
for (int i = 0; i < unis.size(); ++i) {
unis[i] = mp[unis[i]];
}
vector<vector<int>> belongs(nums.size());
for (int i = 0; i < unis.size(); ++i) {
belongs[unis[i]].push_back(i);
}
vector<vector<int>> newedges(nums.size());
for (int i = 0; i < edges.size(); ++i) {
for (auto j : edges[i]) {
if (unis[i] != unis[j]) {
newedges[unis[i]].push_back(unis[j]);
}
}
}
return make_pair(belongs, newedges);
}
// belongs,newedges
pair<vector<vector<int>>, vector<vector<Edge>>>
get(const vector<vector<Edge>> &edges) {
const int old_node_size = edges.size();
nums.resize(old_node_size);
fill(nums.begin(), nums.end(), -1);
vector<vector<Edge>> revedges(old_node_size);
for (const auto &e : edges) {
for (const auto &j : e) {
revedges[j.dst].push_back(Edge(j.dst, j.src, j.weight));
}
}
int num = 0;
for (int i = 0; i < old_node_size; ++i) {
dfs(i, num, edges);
}
vector<int> big(old_node_size);
for (int i = 0; i < old_node_size; ++i) {
big[nums[i]] = i;
}
reverse(big.begin(), big.end());
unis.resize(old_node_size);
fill(unis.begin(), unis.end(), -1);
num = 0;
for (int i = 0; i < old_node_size; ++i) {
dfs2(big[i], num, revedges);
num++;
}
vector<int> nums;
for (int i = 0; i < old_node_size; ++i) {
nums.push_back(unis[i]);
}
sort(nums.begin(), nums.end());
nums.erase(unique(nums.begin(), nums.end()), nums.end());
const int new_node_size = nums.size();
map<int, int> mp;
for (int i = 0; i < new_node_size; ++i) {
mp[nums[i]] = i;
}
for (int i = 0; i < old_node_size; ++i) {
unis[i] = mp[unis[i]];
}
vector<vector<int>> belongs(new_node_size);
for (int i = 0; i < old_node_size; ++i) {
belongs[unis[i]].push_back(i);
}
vector<vector<Edge>> newedges(new_node_size);
for (const auto &e : edges) {
for (const auto &j : e) {
if (unis[j.src] != unis[j.dst]) {
newedges[unis[j.src]].push_back(
Edge(unis[j.src], unis[j.dst], j.weight));
}
}
}
return make_pair(belongs, newedges);
}
private:
vector<int> nums;
vector<int> unis;
void dfs(const int id, int &num, const vector<vector<int>> &edges) {
if (nums[id] != -1)
return;
else {
nums[id] = -2;
for (auto i : edges[id]) {
dfs(i, num, edges);
}
}
nums[id] = num++;
return;
}
void dfs2(const int id, const int &num, const vector<vector<int>> &edges) {
if (unis[id] != -1)
return;
else {
unis[id] = -2;
for (auto i : edges[id])
dfs2(i, num, edges);
}
unis[id] = num;
return;
}
void dfs(const int id, int &num, const vector<vector<Edge>> &edges) {
if (nums[id] != -1)
return;
else {
nums[id] = -2;
for (auto i : edges[id]) {
dfs(i.dst, num, edges);
}
}
nums[id] = num++;
return;
}
void dfs2(const int id, const int &num, const vector<vector<Edge>> &edges) {
if (unis[id] != -1)
return;
else {
unis[id] = -2;
for (auto i : edges[id]) {
dfs2(i.dst, num, edges);
}
}
unis[id] = num;
return;
}
} dscc;
namespace getcycle {
pair<int, vector<Edge>> dfs(const Graph &g, vector<int> &used, const int now,
const int id) {
if (used[now] == -1) {
used[now] = id;
for (auto e : g[now]) {
if (used[e.dst] == id) {
return make_pair(e.dst, vector<Edge>(1, e));
} else if (used[e.dst] != -1) {
continue;
} else {
assert(used[e.dst] == -1);
auto p(dfs(g, used, e.dst, id));
if (p.first == -1) {
return p;
} else if (p.first == -2) {
continue;
} else {
p.second.push_back(e);
if (p.first == now) {
return make_pair(-1, p.second);
} else {
return p;
}
}
}
}
return make_pair(-2, vector<Edge>(0));
} else {
assert(false);
return make_pair(0, vector<Edge>(0));
}
}
vector<Edge> get_cycle(const Graph &g, const int start) {
vector<int> used(g.size(), -1);
int id = 0;
for (int i = 0; i < g.size(); ++i) {
if (used[i] == -1) {
vector<Edge> cycles = dfs(g, used, i, id).second;
id++;
if (!cycles.empty()) {
reverse(cycles.begin(), cycles.end());
return cycles;
}
}
}
return vector<Edge>(0);
}
} // namespace getcycle
pair<Weight, Graph> chu_liu(const Graph &g, const int start) {
Graph revg(g.size());
/*????´???°???Edge?????°????????§??????*/
// vector<Edge>memo(g.size()*g.size());
for (auto es : g) {
for (auto e : es) {
// memo[e.id] = e;
revg[e.dst].emplace_back(e.dst, e.src, e.weight);
}
}
Graph tree(g.size());
ld total_len = 0;
for (int node = 0; node < g.size(); ++node) {
if (node == start)
continue;
else {
Weight amin = INF;
Edge min_edge;
for (auto reve : revg[node]) {
if (amin > reve.weight) {
amin = reve.weight;
min_edge = Edge(reve.dst, reve.src, reve.weight);
}
}
if (amin < INF) {
total_len += min_edge.weight;
tree[min_edge.src].emplace_back(min_edge);
}
}
}
Weight cycle_len = 0;
vector<Edge> cycle_edges(getcycle::get_cycle(tree, start));
for (auto e : cycle_edges) {
cycle_len += e.weight;
}
if (cycle_edges.empty()) {
return make_pair(total_len, g);
} else {
vector<bool> node_is_cycle(g.size());
/*????´???°???Edge?????°????????§??????*/
vector<int> edge_is_cycle(g.size() * g.size());
vector<pair<int, Weight>> prevs(g.size(), make_pair(-1, ZERO));
for (auto ce : cycle_edges) {
node_is_cycle[ce.src] = true;
node_is_cycle[ce.dst] = true;
prevs[ce.dst] = make_pair(ce.src, ce.weight);
}
Graph newg(g.size());
const int compress = cycle_edges[0].src;
int ne_size = 0;
for (int s = 0; s < g.size(); ++s) {
bool src_is_cycle = node_is_cycle[s];
for (auto e : g[s]) {
bool dst_is_cycle = node_is_cycle[e.dst];
if (src_is_cycle && dst_is_cycle) {
} else if (src_is_cycle) {
newg[compress].push_back(Edge(compress, e.dst, e.weight, e.id));
ne_size++;
} else if (dst_is_cycle) {
newg[s].push_back(
Edge(s, compress, e.weight - prevs[e.dst].second, e.id));
ne_size++;
} else {
newg[s].push_back(Edge(s, e.dst, e.weight, e.id));
ne_size++;
}
}
}
auto p = chu_liu(newg, start);
Graph compress_tree(g.size());
Graph ans_tree(g.size());
for (auto es : compress_tree) {
for (auto e : es) {
Edge prev_edge(e);
ans_tree[prev_edge.src].emplace_back(prev_edge);
}
}
ld fin_len = p.first + cycle_len;
return make_pair(fin_len, ans_tree);
}
}
int main() {
int N, M;
cin >> N >> M;
vector<vector<ld>> vecs(M, vector<ld>(N));
vector<vector<ld>> edges(M, vector<ld>(M));
for (int i = 0; i < M; ++i) {
for (int j = 0; j < N; ++j) {
cin >> vecs[i][j];
}
}
const int start = 0;
const int node = 1;
Graph g(M + 1);
int id = 0;
for (int i = 0; i < M; ++i) {
ld inidis = 0;
for (int j = 0; j < N; ++j) {
inidis += vecs[i][j] * vecs[i][j];
}
g[start].emplace_back(start, node + i, inidis, id++);
for (int j = 0; j < M; ++j) {
if (i != j) {
ld dis = getdis(vecs[i], vecs[j]);
g[node + i].emplace_back(node + i, node + j, dis, id++);
}
}
}
auto p = chu_liu(g, start);
cout << fixed << setprecision(22) << p.first << endl;
return 0;
} | #include "bits/stdc++.h"
#include <unordered_map>
#include <unordered_set>
#pragma warning(disable : 4996)
using namespace std;
using ld = long double;
template <class T> using Table = vector<vector<T>>;
const ld eps = 1e-9;
//// < "D:\D_Download\Visual Studio
///2015\Projects\programing_contest_c++\Debug\a.txt" > "D:\D_Download\Visual
///Studio 2015\Projects\programing_contest_c++\Debug\b.answer"
typedef double Weight;
struct Edge {
int src, dst;
Weight weight;
int id;
Edge(int src_, int dst_, Weight weight_, const int id_)
: src(src_), dst(dst_), weight(weight_), id(id_) {}
Edge(int src, int dst, Weight weight) : src(src), dst(dst), weight(weight) {}
Edge() : src(0), dst(0), weight(0) {}
};
const Weight INF = 1e18;
const Weight ZERO = 0;
bool operator<(const Edge &e, const Edge &f) {
return e.weight != f.weight ? e.weight > f.weight : // !!INVERSE!!
e.src != f.src ? e.src < f.src
: e.dst < f.dst;
}
typedef vector<Edge> Edges;
typedef vector<Edges> Graph;
ld getdis(const vector<ld> &f, const vector<ld> &t) {
ld amin = -1e9;
ld amax = 1e9;
int n = 100;
while (n--) {
ld amid0 = (amin * 2 + amax) / 3;
ld amid1 = (amin + amax * 2) / 3;
ld len0 = 0;
ld len1 = 0;
{
for (int i = 0; i < f.size(); ++i) {
len0 += (t[i] - amid0 * f[i]) * (t[i] - amid0 * f[i]);
}
for (int i = 0; i < f.size(); ++i) {
len1 += (t[i] - amid1 * f[i]) * (t[i] - amid1 * f[i]);
}
}
if (len0 < len1) {
amax = amid1;
} else {
amin = amid0;
}
if (!n)
return len0;
}
}
struct Dscc {
public:
// belongs,newedges
pair<vector<vector<int>>, vector<vector<int>>>
get(const vector<vector<int>> &edges) {
nums.resize(edges.size());
fill(nums.begin(), nums.end(), -1);
vector<vector<int>> revedges(edges.size());
for (int i = 0; i < edges.size(); ++i) {
for (auto j : edges[i]) {
revedges[j].push_back(i);
}
}
int num = 0;
for (int i = 0; i < edges.size(); ++i) {
dfs(i, num, edges);
}
vector<int> big(nums.size());
for (int i = 0; i < nums.size(); ++i) {
big[nums[i]] = i;
}
reverse(big.begin(), big.end());
unis.resize(edges.size());
fill(unis.begin(), unis.end(), -1);
num = 0;
for (int i = 0; i < big.size(); ++i) {
dfs2(big[i], num, revedges);
num++;
}
vector<int> nums;
for (int i = 0; i < unis.size(); ++i) {
nums.push_back(unis[i]);
}
sort(nums.begin(), nums.end());
nums.erase(unique(nums.begin(), nums.end()), nums.end());
map<int, int> mp;
for (int i = 0; i < nums.size(); ++i) {
mp[nums[i]] = i;
}
for (int i = 0; i < unis.size(); ++i) {
unis[i] = mp[unis[i]];
}
vector<vector<int>> belongs(nums.size());
for (int i = 0; i < unis.size(); ++i) {
belongs[unis[i]].push_back(i);
}
vector<vector<int>> newedges(nums.size());
for (int i = 0; i < edges.size(); ++i) {
for (auto j : edges[i]) {
if (unis[i] != unis[j]) {
newedges[unis[i]].push_back(unis[j]);
}
}
}
return make_pair(belongs, newedges);
}
// belongs,newedges
pair<vector<vector<int>>, vector<vector<Edge>>>
get(const vector<vector<Edge>> &edges) {
const int old_node_size = edges.size();
nums.resize(old_node_size);
fill(nums.begin(), nums.end(), -1);
vector<vector<Edge>> revedges(old_node_size);
for (const auto &e : edges) {
for (const auto &j : e) {
revedges[j.dst].push_back(Edge(j.dst, j.src, j.weight));
}
}
int num = 0;
for (int i = 0; i < old_node_size; ++i) {
dfs(i, num, edges);
}
vector<int> big(old_node_size);
for (int i = 0; i < old_node_size; ++i) {
big[nums[i]] = i;
}
reverse(big.begin(), big.end());
unis.resize(old_node_size);
fill(unis.begin(), unis.end(), -1);
num = 0;
for (int i = 0; i < old_node_size; ++i) {
dfs2(big[i], num, revedges);
num++;
}
vector<int> nums;
for (int i = 0; i < old_node_size; ++i) {
nums.push_back(unis[i]);
}
sort(nums.begin(), nums.end());
nums.erase(unique(nums.begin(), nums.end()), nums.end());
const int new_node_size = nums.size();
map<int, int> mp;
for (int i = 0; i < new_node_size; ++i) {
mp[nums[i]] = i;
}
for (int i = 0; i < old_node_size; ++i) {
unis[i] = mp[unis[i]];
}
vector<vector<int>> belongs(new_node_size);
for (int i = 0; i < old_node_size; ++i) {
belongs[unis[i]].push_back(i);
}
vector<vector<Edge>> newedges(new_node_size);
for (const auto &e : edges) {
for (const auto &j : e) {
if (unis[j.src] != unis[j.dst]) {
newedges[unis[j.src]].push_back(
Edge(unis[j.src], unis[j.dst], j.weight));
}
}
}
return make_pair(belongs, newedges);
}
private:
vector<int> nums;
vector<int> unis;
void dfs(const int id, int &num, const vector<vector<int>> &edges) {
if (nums[id] != -1)
return;
else {
nums[id] = -2;
for (auto i : edges[id]) {
dfs(i, num, edges);
}
}
nums[id] = num++;
return;
}
void dfs2(const int id, const int &num, const vector<vector<int>> &edges) {
if (unis[id] != -1)
return;
else {
unis[id] = -2;
for (auto i : edges[id])
dfs2(i, num, edges);
}
unis[id] = num;
return;
}
void dfs(const int id, int &num, const vector<vector<Edge>> &edges) {
if (nums[id] != -1)
return;
else {
nums[id] = -2;
for (auto i : edges[id]) {
dfs(i.dst, num, edges);
}
}
nums[id] = num++;
return;
}
void dfs2(const int id, const int &num, const vector<vector<Edge>> &edges) {
if (unis[id] != -1)
return;
else {
unis[id] = -2;
for (auto i : edges[id]) {
dfs2(i.dst, num, edges);
}
}
unis[id] = num;
return;
}
} dscc;
namespace getcycle {
pair<int, vector<Edge>> dfs(const Graph &g, vector<int> &used, const int now,
const int id) {
if (used[now] == -1) {
used[now] = id;
for (auto e : g[now]) {
if (used[e.dst] == id) {
return make_pair(e.dst, vector<Edge>(1, e));
} else if (used[e.dst] != -1) {
continue;
} else {
assert(used[e.dst] == -1);
auto p(dfs(g, used, e.dst, id));
if (p.first == -1) {
return p;
} else if (p.first == -2) {
continue;
} else {
p.second.push_back(e);
if (p.first == now) {
return make_pair(-1, p.second);
} else {
return p;
}
}
}
}
return make_pair(-2, vector<Edge>(0));
} else {
assert(false);
return make_pair(0, vector<Edge>(0));
}
}
vector<Edge> get_cycle(const Graph &g, const int start) {
vector<int> used(g.size(), -1);
int id = 0;
for (int i = 0; i < g.size(); ++i) {
if (used[i] == -1) {
vector<Edge> cycles = dfs(g, used, i, id).second;
id++;
if (!cycles.empty()) {
reverse(cycles.begin(), cycles.end());
return cycles;
}
}
}
return vector<Edge>(0);
}
} // namespace getcycle
pair<Weight, Graph> chu_liu(const Graph &g, const int start) {
Graph revg(g.size());
/*????´???°???Edge?????°????????§??????*/
// vector<Edge>memo(g.size()*g.size());
for (auto es : g) {
for (auto e : es) {
// memo[e.id] = e;
revg[e.dst].emplace_back(e.dst, e.src, e.weight);
}
}
Graph tree(g.size());
ld total_len = 0;
for (int node = 0; node < g.size(); ++node) {
if (node == start)
continue;
else {
Weight amin = INF;
Edge min_edge;
for (auto reve : revg[node]) {
if (amin > reve.weight) {
amin = reve.weight;
min_edge = Edge(reve.dst, reve.src, reve.weight);
}
}
if (amin < INF) {
total_len += min_edge.weight;
tree[min_edge.src].emplace_back(min_edge);
}
}
}
Weight cycle_len = 0;
vector<Edge> cycle_edges(getcycle::get_cycle(tree, start));
for (auto e : cycle_edges) {
cycle_len += e.weight;
}
if (cycle_edges.empty()) {
return make_pair(total_len, g);
} else {
vector<bool> node_is_cycle(g.size());
/*????´???°???Edge?????°????????§??????*/
vector<int> edge_is_cycle(g.size() * g.size());
vector<pair<int, Weight>> prevs(g.size(), make_pair(-1, ZERO));
for (auto ce : cycle_edges) {
node_is_cycle[ce.src] = true;
node_is_cycle[ce.dst] = true;
prevs[ce.dst] = make_pair(ce.src, ce.weight);
}
Graph newg(g.size());
const int compress = cycle_edges[0].src;
int ne_size = 0;
for (int s = 0; s < g.size(); ++s) {
bool src_is_cycle = node_is_cycle[s];
for (auto e : g[s]) {
bool dst_is_cycle = node_is_cycle[e.dst];
if (src_is_cycle && dst_is_cycle) {
} else if (src_is_cycle) {
newg[compress].push_back(Edge(compress, e.dst, e.weight, e.id));
ne_size++;
} else if (dst_is_cycle) {
newg[s].push_back(
Edge(s, compress, e.weight - prevs[e.dst].second, e.id));
ne_size++;
} else {
newg[s].push_back(Edge(s, e.dst, e.weight, e.id));
ne_size++;
}
}
}
auto p = chu_liu(newg, start);
Graph compress_tree(g.size());
Graph ans_tree(g.size());
for (auto es : compress_tree) {
for (auto e : es) {
Edge prev_edge(e);
ans_tree[prev_edge.src].emplace_back(prev_edge);
}
}
ld fin_len = p.first + cycle_len;
return make_pair(fin_len, ans_tree);
}
}
int main() {
int N, M;
cin >> N >> M;
vector<vector<ld>> vecs(M, vector<ld>(N));
vector<vector<ld>> edges(M, vector<ld>(M));
for (int i = 0; i < M; ++i) {
for (int j = 0; j < N; ++j) {
cin >> vecs[i][j];
}
}
const int start = 0;
const int node = 1;
Graph g(M + 1);
int id = 0;
for (int i = 0; i < M; ++i) {
ld inidis = 0;
for (int j = 0; j < N; ++j) {
inidis += vecs[i][j] * vecs[i][j];
}
g[start].emplace_back(start, node + i, inidis, id++);
for (int j = 0; j < M; ++j) {
if (i != j) {
ld dis = getdis(vecs[i], vecs[j]);
g[node + i].emplace_back(node + i, node + j, dis, id++);
}
}
}
auto p = chu_liu(g, start);
cout << fixed << setprecision(22) << p.first << endl;
return 0;
} | replace | 13 | 14 | 13 | 14 | MLE | |
p01428 | C++ | Time Limit Exceeded | #include "bits/stdc++.h"
#define REP(i, n) for (ll i = 0; i < n; ++i)
#define RREP(i, n) for (ll i = n - 1; i >= 0; --i)
#define FOR(i, m, n) for (ll i = m; i < n; ++i)
#define RFOR(i, m, n) for (ll i = n - 1; i >= m; --i)
#define ALL(v) (v).begin(), (v).end()
#define PB(a) push_back(a)
#define UNIQUE(v) v.erase(unique(ALL(v)), v.end());
#define DUMP(v) \
REP(i, (v).size()) { \
cout << v[i]; \
if (i != v.size() - 1) \
cout << " "; \
else \
cout << endl; \
}
#define INF 1000000001ll
#define MOD 1000000007ll
#define EPS 1e-9
const int dx[8] = {1, 1, 0, -1, -1, -1, 0, 1};
const int dy[8] = {0, 1, 1, 1, 0, -1, -1, -1};
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<vi> vvi;
typedef vector<vl> vvl;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
ll max(ll a, int b) { return max(a, ll(b)); }
ll max(int a, ll b) { return max(ll(a), b); }
ll min(ll a, int b) { return min(a, ll(b)); }
ll min(int a, ll b) { return min(ll(a), b); }
///(?´????????`)(?´????????`)(?´????????`)(?´????????`)(?´????????`)(?´????????`)///
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
vector<string> v(8);
REP(i, 8) cin >> v[i];
REP(t, INF) {
int cnt = 0;
REP(i, 8) REP(j, 8) if (v[i][j] == '.') cnt++;
if (cnt == 0)
break;
int p = -1, q = -1, cmax = -1;
if (t % 2 == 0) {
vi m;
REP(i, 8) {
REP(j, 8) {
if (v[i][j] == '.') {
int c = 0;
vi s;
REP(k, 8) {
int ni = i, nj = j;
int tmp = 0;
REP(l, INF) {
ni += dx[k], nj += dy[k];
if (ni < 0 || nj < 0 || ni >= 8 || nj >= 8)
break;
if (v[ni][nj] == 'x')
tmp++;
else if (v[ni][nj] == 'o') {
if (tmp != 0)
s.push_back(k);
c += tmp;
break;
} else
break;
}
}
if (cmax < c) {
cmax = c, p = i, q = j;
m = s;
}
}
}
}
if (cmax <= 0)
continue;
else {
v[p][q] = 'o';
REP(j, m.size()) {
int ni = p, nj = q;
REP(i, INF) {
ni += dx[m[j]], nj += dy[m[j]];
if (ni >= 0 && nj >= 0 && ni < 8 && nj < 8 && v[ni][nj] == 'x')
v[ni][nj] = 'o';
else
break;
}
}
}
}
else {
vi m;
REP(i, 8) {
REP(j, 8) {
if (v[i][j] == '.') {
int c = 0;
vi s;
REP(k, 8) {
int ni = i, nj = j;
int tmp = 0;
REP(l, INF) {
ni += dx[k], nj += dy[k];
if (ni < 0 || nj < 0 || ni >= 8 || nj >= 8)
break;
if (v[ni][nj] == 'o')
tmp++;
else if (v[ni][nj] == 'x') {
if (tmp != 0)
s.push_back(k);
c += tmp;
break;
} else
break;
}
}
if (cmax <= c) {
cmax = c, p = i, q = j;
m = s;
}
}
}
}
if (cmax <= 0)
continue;
else {
v[p][q] = 'x';
REP(j, m.size()) {
int ni = p, nj = q;
REP(i, INF) {
ni += dx[m[j]], nj += dy[m[j]];
if (ni >= 0 && nj >= 0 && ni < 8 && nj < 8 && v[ni][nj] == 'o')
v[ni][nj] = 'x';
else
break;
}
}
}
}
}
REP(i, 8) {
REP(j, 8) { cout << v[i][j]; }
cout << endl;
}
return 0;
} | #include "bits/stdc++.h"
#define REP(i, n) for (ll i = 0; i < n; ++i)
#define RREP(i, n) for (ll i = n - 1; i >= 0; --i)
#define FOR(i, m, n) for (ll i = m; i < n; ++i)
#define RFOR(i, m, n) for (ll i = n - 1; i >= m; --i)
#define ALL(v) (v).begin(), (v).end()
#define PB(a) push_back(a)
#define UNIQUE(v) v.erase(unique(ALL(v)), v.end());
#define DUMP(v) \
REP(i, (v).size()) { \
cout << v[i]; \
if (i != v.size() - 1) \
cout << " "; \
else \
cout << endl; \
}
#define INF 1000000001ll
#define MOD 1000000007ll
#define EPS 1e-9
const int dx[8] = {1, 1, 0, -1, -1, -1, 0, 1};
const int dy[8] = {0, 1, 1, 1, 0, -1, -1, -1};
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<vi> vvi;
typedef vector<vl> vvl;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
ll max(ll a, int b) { return max(a, ll(b)); }
ll max(int a, ll b) { return max(ll(a), b); }
ll min(ll a, int b) { return min(a, ll(b)); }
ll min(int a, ll b) { return min(ll(a), b); }
///(?´????????`)(?´????????`)(?´????????`)(?´????????`)(?´????????`)(?´????????`)///
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
vector<string> v(8);
REP(i, 8) cin >> v[i];
REP(t, 10000) {
int p = -1, q = -1, cmax = -1;
if (t % 2 == 0) {
vi m;
REP(i, 8) {
REP(j, 8) {
if (v[i][j] == '.') {
int c = 0;
vi s;
REP(k, 8) {
int ni = i, nj = j;
int tmp = 0;
REP(l, INF) {
ni += dx[k], nj += dy[k];
if (ni < 0 || nj < 0 || ni >= 8 || nj >= 8)
break;
if (v[ni][nj] == 'x')
tmp++;
else if (v[ni][nj] == 'o') {
if (tmp != 0)
s.push_back(k);
c += tmp;
break;
} else
break;
}
}
if (cmax < c) {
cmax = c, p = i, q = j;
m = s;
}
}
}
}
if (cmax <= 0)
continue;
else {
v[p][q] = 'o';
REP(j, m.size()) {
int ni = p, nj = q;
REP(i, INF) {
ni += dx[m[j]], nj += dy[m[j]];
if (ni >= 0 && nj >= 0 && ni < 8 && nj < 8 && v[ni][nj] == 'x')
v[ni][nj] = 'o';
else
break;
}
}
}
}
else {
vi m;
REP(i, 8) {
REP(j, 8) {
if (v[i][j] == '.') {
int c = 0;
vi s;
REP(k, 8) {
int ni = i, nj = j;
int tmp = 0;
REP(l, INF) {
ni += dx[k], nj += dy[k];
if (ni < 0 || nj < 0 || ni >= 8 || nj >= 8)
break;
if (v[ni][nj] == 'o')
tmp++;
else if (v[ni][nj] == 'x') {
if (tmp != 0)
s.push_back(k);
c += tmp;
break;
} else
break;
}
}
if (cmax <= c) {
cmax = c, p = i, q = j;
m = s;
}
}
}
}
if (cmax <= 0)
continue;
else {
v[p][q] = 'x';
REP(j, m.size()) {
int ni = p, nj = q;
REP(i, INF) {
ni += dx[m[j]], nj += dy[m[j]];
if (ni >= 0 && nj >= 0 && ni < 8 && nj < 8 && v[ni][nj] == 'o')
v[ni][nj] = 'x';
else
break;
}
}
}
}
}
REP(i, 8) {
REP(j, 8) { cout << v[i][j]; }
cout << endl;
}
return 0;
} | replace | 43 | 48 | 43 | 44 | TLE | |
p01429 | C++ | Runtime Error | #include <algorithm>
#include <cstring>
#include <iostream>
#include <vector>
using namespace std;
using ll = long long;
constexpr int MAX = 1011;
int N, M, L;
ll memo[MAX][MAX];
vector<ll> K, sum;
ll calc(int l, int r) { return (sum[K[r] + 1] - sum[K[l]]) / L; }
ll solve(int l, int r) {
ll &res = memo[l][r];
if (res != -1)
return res;
int n = max(l, r) + 1;
if (n == N - 1) {
return calc(l, n) + calc(r, n);
}
res = min(solve(n, r) + calc(l, n), solve(l, n) + calc(r, n));
return res;
}
int main() {
cin >> N >> M >> L;
K.resize(N);
for (int i = 0; i < N; i++) {
cin >> K[i];
K[i]--;
}
sort(K.begin(), K.end());
vector<int> S(M);
for (int i = 0; i < M; i++) {
cin >> S[i];
}
sum.resize(M + 1);
for (int i = 0; i < M; i++) {
sum[i + 1] = sum[i] + S[i];
}
memset(memo, -1, sizeof(memo));
cout << solve(0, 0) << endl;
return 0;
} | #include <algorithm>
#include <cstring>
#include <iostream>
#include <vector>
using namespace std;
using ll = long long;
constexpr int MAX = 2010;
int N, M, L;
ll memo[MAX][MAX];
vector<ll> K, sum;
ll calc(int l, int r) { return (sum[K[r] + 1] - sum[K[l]]) / L; }
ll solve(int l, int r) {
ll &res = memo[l][r];
if (res != -1)
return res;
int n = max(l, r) + 1;
if (n == N - 1) {
return calc(l, n) + calc(r, n);
}
res = min(solve(n, r) + calc(l, n), solve(l, n) + calc(r, n));
return res;
}
int main() {
cin >> N >> M >> L;
K.resize(N);
for (int i = 0; i < N; i++) {
cin >> K[i];
K[i]--;
}
sort(K.begin(), K.end());
vector<int> S(M);
for (int i = 0; i < M; i++) {
cin >> S[i];
}
sum.resize(M + 1);
for (int i = 0; i < M; i++) {
sum[i + 1] = sum[i] + S[i];
}
memset(memo, -1, sizeof(memo));
cout << solve(0, 0) << endl;
return 0;
} | replace | 8 | 9 | 8 | 9 | 0 | |
p01430 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define ll long long
#define INF 1000000005
#define MOD 1000000007
#define EPS 1e-10
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define rrep(i, n) for (int i = (int)(n)-1; i >= 0; --i)
#define srep(i, s, t) for (int i = (int)(s); i < (int)(t); ++i)
#define each(a, b) for (auto(a) : (b))
#define all(v) (v).begin(), (v).end()
#define len(v) (int)(v).size()
#define zip(v) sort(all(v)), v.erase(unique(all(v)), v.end())
#define cmx(x, y) x = max(x, y)
#define cmn(x, y) x = min(x, y)
#define fi first
#define se second
#define pb push_back
#define show(x) cout << #x << " = " << (x) << endl
#define spair(p) cout << #p << ": " << p.fi << " " << p.se << endl
#define svec(v) \
cout << #v << ":"; \
rep(kbrni, v.size()) cout << " " << v[kbrni]; \
cout << endl
#define sset(s) \
cout << #s << ":"; \
each(kbrni, s) cout << " " << kbrni; \
cout << endl
#define smap(m) \
cout << #m << ":"; \
each(kbrni, m) cout << " {" << kbrni.first << ":" << kbrni.second << "}"; \
cout << endl
using namespace std;
typedef pair<int, int> P;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<double> vd;
typedef vector<P> vp;
typedef vector<string> vs;
const int MAX_N = 502;
map<int, int> G[MAX_N];
bool used[MAX_N];
int n;
void add_edge(int from, int to, int cap) {
G[from][to] = cap;
G[to][from] = cap;
}
void erase_edge(int from, int to) {
G[from][to] = 0;
G[to][from] = 0;
}
int dfs(int v, int t, int f) {
if (v == t)
return f;
used[v] = true;
each(it, G[v]) {
int nx = it.fi;
int &cap = it.se;
if (!used[nx] && cap > 0) {
int d = dfs(nx, t, min(f, cap));
if (d > 0) {
cap -= d;
G[nx][v] += d;
return d;
}
}
}
return 0;
}
int max_flow(int s, int t) {
int flow = 0;
while (true) {
memset(used, 0, sizeof(used));
int f = dfs(s, t, INF);
if (f == 0)
return flow;
flow += f;
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int E, q;
cin >> n >> E >> q;
rep(i, E) {
int a, b;
cin >> a >> b;
add_edge(a - 1, b - 1, 1);
}
int res = max_flow(0, n - 1);
rep(i, q) {
int a, b, c;
cin >> a >> b >> c;
--b, --c;
if (a == 1) {
add_edge(b, c, 1);
res += max_flow(0, n - 1);
} else {
int cap = G[b][c];
erase_edge(b, c);
// 逆向きに1流れてたら
if (cap == 2) {
swap(b, c);
}
if (cap != 1) {
memset(used, 0, sizeof(used));
int f = dfs(b, c, 1);
// aからbにフローを1流せない(枝(a,b)を削除した分をまかなえない)
if (f == 0) {
memset(used, 0, sizeof(used));
dfs(b, 0, 1);
memset(used, 0, sizeof(used));
dfs(n - 1, c, 1);
--res;
}
}
}
cout << res << "\n";
}
}
| #include <bits/stdc++.h>
#define ll long long
#define INF 1000000005
#define MOD 1000000007
#define EPS 1e-10
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define rrep(i, n) for (int i = (int)(n)-1; i >= 0; --i)
#define srep(i, s, t) for (int i = (int)(s); i < (int)(t); ++i)
#define each(a, b) for (auto &(a) : (b))
#define all(v) (v).begin(), (v).end()
#define len(v) (int)(v).size()
#define zip(v) sort(all(v)), v.erase(unique(all(v)), v.end())
#define cmx(x, y) x = max(x, y)
#define cmn(x, y) x = min(x, y)
#define fi first
#define se second
#define pb push_back
#define show(x) cout << #x << " = " << (x) << endl
#define spair(p) cout << #p << ": " << p.fi << " " << p.se << endl
#define svec(v) \
cout << #v << ":"; \
rep(kbrni, v.size()) cout << " " << v[kbrni]; \
cout << endl
#define sset(s) \
cout << #s << ":"; \
each(kbrni, s) cout << " " << kbrni; \
cout << endl
#define smap(m) \
cout << #m << ":"; \
each(kbrni, m) cout << " {" << kbrni.first << ":" << kbrni.second << "}"; \
cout << endl
using namespace std;
typedef pair<int, int> P;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<double> vd;
typedef vector<P> vp;
typedef vector<string> vs;
const int MAX_N = 502;
map<int, int> G[MAX_N];
bool used[MAX_N];
int n;
void add_edge(int from, int to, int cap) {
G[from][to] = cap;
G[to][from] = cap;
}
void erase_edge(int from, int to) {
G[from][to] = 0;
G[to][from] = 0;
}
int dfs(int v, int t, int f) {
if (v == t)
return f;
used[v] = true;
each(it, G[v]) {
int nx = it.fi;
int &cap = it.se;
if (!used[nx] && cap > 0) {
int d = dfs(nx, t, min(f, cap));
if (d > 0) {
cap -= d;
G[nx][v] += d;
return d;
}
}
}
return 0;
}
int max_flow(int s, int t) {
int flow = 0;
while (true) {
memset(used, 0, sizeof(used));
int f = dfs(s, t, INF);
if (f == 0)
return flow;
flow += f;
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int E, q;
cin >> n >> E >> q;
rep(i, E) {
int a, b;
cin >> a >> b;
add_edge(a - 1, b - 1, 1);
}
int res = max_flow(0, n - 1);
rep(i, q) {
int a, b, c;
cin >> a >> b >> c;
--b, --c;
if (a == 1) {
add_edge(b, c, 1);
res += max_flow(0, n - 1);
} else {
int cap = G[b][c];
erase_edge(b, c);
// 逆向きに1流れてたら
if (cap == 2) {
swap(b, c);
}
if (cap != 1) {
memset(used, 0, sizeof(used));
int f = dfs(b, c, 1);
// aからbにフローを1流せない(枝(a,b)を削除した分をまかなえない)
if (f == 0) {
memset(used, 0, sizeof(used));
dfs(b, 0, 1);
memset(used, 0, sizeof(used));
dfs(n - 1, c, 1);
--res;
}
}
}
cout << res << "\n";
}
}
| replace | 8 | 9 | 8 | 9 | TLE | |
p01431 | C++ | Memory Limit Exceeded | #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
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
using namespace std;
typedef vector<int> vi;
typedef vector<vi> vv;
typedef pair<int, int> P;
vi con[279]; // 6th Bell number
map<vi, int> inv; // inv of con
int mx_[279];
int bits[234]; // 11th Fibonacci number
vector<P> bitcon[234]; // 11010 -> {(0,2),(3,4)}
int nxt[279][234][234];
int C; // con
int B; // bits
int H, W;
string s[11];
int dp[12][279][234];
vi tmp;
void dfs(int x, int mx) {
con[C] = tmp;
mx_[C] = mx;
inv[tmp] = C++;
// printf("c=%d: ",C-1);
// for(int a:tmp) cout<<a<<" ";
// puts("");
if (x == 6)
return;
rep(i, mx + 1) {
tmp.pb(i);
dfs(x + 1, max(mx, i + 1));
tmp.pop_back();
}
}
inline int cntbit(int x) {
if (x == 0)
return 0;
return __builtin_popcount(x);
}
int par[12];
void init(int N) { rep(i, N) par[i] = i; }
int find(int x) {
if (par[x] == x)
return x;
return par[x] = find(par[x]);
}
bool same(int x, int y) { return find(x) == find(y); }
void unite(int x, int y) {
x = find(x), y = find(y);
if (x < y)
swap(x, y);
par[x] = y;
}
inline bool _b(int x, int y) { return ((x >> y) & 1) == 1; }
bool is(P x, P y) { return x.fs < y.sc && y.fs < x.sc; }
int main() {
dfs(0, 0);
cin >> H >> W;
rep(i, H) cin >> s[i];
if (W == 1) {
if (H == 1) {
if (s[0][0] == '.')
puts("0");
else
puts("1");
return 0;
}
rep1(i, H - 1) s[0] += s[i][0];
swap(H, W);
}
rep(i, 1 << W) {
bool ok = 1;
rep(j, W - 1) if (!_b(i, j) && !_b(i, j + 1)) ok = 0;
if (ok || i == 0) {
bits[B] = i;
// printf("bits[%d]=%d\n",B,i);
int p = -1;
vector<P> vp;
rep(j, W + 1) {
if (_b(i, j)) {
if (p < 0)
p = j;
} else {
if (p >= 0) {
vp.pb(P(p, j));
p = -1;
}
}
}
bitcon[B++] = vp;
// show(vp.size());
}
}
// show(B);
rep(i, C) rep(j, B) rep(k, B) nxt[i][j][k] = -1;
rep(i, C) {
vi &vc = con[i];
int sz = vc.size();
rep(j, B) {
int &b = bits[j];
vector<P> &bc = bitcon[j];
if (bc.size() != sz)
continue;
rep(k, B) {
int &nb = bits[k];
vector<P> &nbc = bitcon[k];
int nsz = nbc.size();
if ((b | nb) != (1 << W) - 1 && j > 0)
continue;
bool ok = 1;
rep(d, W - 1) if (_b(b, d) && _b(b, d + 1) && _b(nb, d) &&
_b(nb, d + 1)) ok = 0;
if (j > 0 && !ok)
continue;
// if(i==4&&j==6&&k==10) puts("---!!---");
// if(i==4&&j==6&&k==10) show(sz);
// if(i==4&&j==6&&k==10) show(nsz);
init(sz + nsz);
rep(d, sz) rep(e, sz) {
if (vc[d] == vc[e]) {
unite(d + nsz, e + nsz);
// if(i==4&&j==6&&k==10)
//printf("%d-%d\n",d+nsz,e+nsz);
}
}
bool used[6] = {};
rep(d, sz) rep(e, nsz) {
if (is(bc[d], nbc[e])) {
if (same(d + nsz, e)) {
ok = 0;
goto done;
}
unite(d + nsz, e);
// if(i==4&&j==6&&k==10)
//printf("%d-%d\n",d+nsz,e);
used[vc[d]] = 1;
}
}
done:
if (ok) {
// printf("'nxt[%d][%d][%d]=ok\n",i,j,k);
rep(d, mx_[i]) if (!used[d]) ok = 0;
if (!ok)
continue;
vi nvc;
map<int, int> mp;
int Z = 0;
rep(d, nsz) if (mp.count(find(d)) == 0) mp[find(d)] = Z++;
rep(d, nsz) nvc.pb(mp[find(d)]);
if (inv.count(nvc) == 0) {
show(nsz);
for (int a : nvc)
cout << a << " ";
assert(false);
}
nxt[i][j][k] = inv[nvc];
// printf("nxt[%d][%d][%d]=%d\n",i,j,k,nxt[i][j][k]);
// for(int a:nvc) cout<<a<<" ";
// puts("");
}
}
}
}
if (W == 1)
nxt[1][1][0] = 0;
rep(i, H + 1) rep(j, C) rep(k, B) dp[i][j][k] = -1;
dp[0][0][0] = 0;
rep(i, H) {
bool canuse[234] = {};
rep(k, B) {
bool ok = 1;
rep(x, W) {
if (s[i][x] == '#' && !_b(bits[k], x))
ok = 0;
if (s[i][x] == '.' && _b(bits[k], x))
ok = 0;
}
canuse[k] = ok;
// if(ok) printf("canuse[%d]=%d\n",k,ok);
}
rep(j, C) rep(k, B) {
if (dp[i][j][k] < 0)
continue;
// printf("i,j,k=(%d,%d,%d)\n",i,j,k);
if (i > 0 && k == 0 && W > 1)
continue;
rep(l, B) {
if (!canuse[l])
continue;
if (W > 1 && l == 0)
continue;
// printf(" i,j,k=(%d,%d,%d)\n",i,j,k);
// show(l);
// show(nxt[j][k][l]);
if (nxt[j][k][l] >= 0) {
chmax(dp[i + 1][nxt[j][k][l]][l], dp[i][j][k] + cntbit(bits[l]));
// printf("dp[%d][%d][%d],dp[%d][%d][%d]+%d\n",i+1,nxt[j][k][l],l,i,j,k,cntbit(bits[l]));
}
}
}
}
int ans = -1;
rep(j, C) {
bool ok = 1;
rep(k, con[j].size()) if (con[j][k] > 0) ok = 0;
if (!ok)
continue;
// show(j);
rep(k, B) {
chmax(ans, dp[H][j][k]);
// printf("dp[%d][%d][%d]=%d\n",H,j,k,dp[H][j][k]);
}
}
cout << ans << endl;
} | #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
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
using namespace std;
typedef vector<int> vi;
typedef vector<vi> vv;
typedef pair<int, int> P;
vi con[279]; // 6th Bell number
map<vi, int> inv; // inv of con
int mx_[279];
int bits[234]; // 11th Fibonacci number
vector<P> bitcon[234]; // 11010 -> {(0,2),(3,4)}
short int nxt[279][234][234];
int C; // con
int B; // bits
int H, W;
string s[11];
int dp[12][279][234];
vi tmp;
void dfs(int x, int mx) {
con[C] = tmp;
mx_[C] = mx;
inv[tmp] = C++;
// printf("c=%d: ",C-1);
// for(int a:tmp) cout<<a<<" ";
// puts("");
if (x == 6)
return;
rep(i, mx + 1) {
tmp.pb(i);
dfs(x + 1, max(mx, i + 1));
tmp.pop_back();
}
}
inline int cntbit(int x) {
if (x == 0)
return 0;
return __builtin_popcount(x);
}
int par[12];
void init(int N) { rep(i, N) par[i] = i; }
int find(int x) {
if (par[x] == x)
return x;
return par[x] = find(par[x]);
}
bool same(int x, int y) { return find(x) == find(y); }
void unite(int x, int y) {
x = find(x), y = find(y);
if (x < y)
swap(x, y);
par[x] = y;
}
inline bool _b(int x, int y) { return ((x >> y) & 1) == 1; }
bool is(P x, P y) { return x.fs < y.sc && y.fs < x.sc; }
int main() {
dfs(0, 0);
cin >> H >> W;
rep(i, H) cin >> s[i];
if (W == 1) {
if (H == 1) {
if (s[0][0] == '.')
puts("0");
else
puts("1");
return 0;
}
rep1(i, H - 1) s[0] += s[i][0];
swap(H, W);
}
rep(i, 1 << W) {
bool ok = 1;
rep(j, W - 1) if (!_b(i, j) && !_b(i, j + 1)) ok = 0;
if (ok || i == 0) {
bits[B] = i;
// printf("bits[%d]=%d\n",B,i);
int p = -1;
vector<P> vp;
rep(j, W + 1) {
if (_b(i, j)) {
if (p < 0)
p = j;
} else {
if (p >= 0) {
vp.pb(P(p, j));
p = -1;
}
}
}
bitcon[B++] = vp;
// show(vp.size());
}
}
// show(B);
rep(i, C) rep(j, B) rep(k, B) nxt[i][j][k] = -1;
rep(i, C) {
vi &vc = con[i];
int sz = vc.size();
rep(j, B) {
int &b = bits[j];
vector<P> &bc = bitcon[j];
if (bc.size() != sz)
continue;
rep(k, B) {
int &nb = bits[k];
vector<P> &nbc = bitcon[k];
int nsz = nbc.size();
if ((b | nb) != (1 << W) - 1 && j > 0)
continue;
bool ok = 1;
rep(d, W - 1) if (_b(b, d) && _b(b, d + 1) && _b(nb, d) &&
_b(nb, d + 1)) ok = 0;
if (j > 0 && !ok)
continue;
// if(i==4&&j==6&&k==10) puts("---!!---");
// if(i==4&&j==6&&k==10) show(sz);
// if(i==4&&j==6&&k==10) show(nsz);
init(sz + nsz);
rep(d, sz) rep(e, sz) {
if (vc[d] == vc[e]) {
unite(d + nsz, e + nsz);
// if(i==4&&j==6&&k==10)
//printf("%d-%d\n",d+nsz,e+nsz);
}
}
bool used[6] = {};
rep(d, sz) rep(e, nsz) {
if (is(bc[d], nbc[e])) {
if (same(d + nsz, e)) {
ok = 0;
goto done;
}
unite(d + nsz, e);
// if(i==4&&j==6&&k==10)
//printf("%d-%d\n",d+nsz,e);
used[vc[d]] = 1;
}
}
done:
if (ok) {
// printf("'nxt[%d][%d][%d]=ok\n",i,j,k);
rep(d, mx_[i]) if (!used[d]) ok = 0;
if (!ok)
continue;
vi nvc;
map<int, int> mp;
int Z = 0;
rep(d, nsz) if (mp.count(find(d)) == 0) mp[find(d)] = Z++;
rep(d, nsz) nvc.pb(mp[find(d)]);
if (inv.count(nvc) == 0) {
show(nsz);
for (int a : nvc)
cout << a << " ";
assert(false);
}
nxt[i][j][k] = inv[nvc];
// printf("nxt[%d][%d][%d]=%d\n",i,j,k,nxt[i][j][k]);
// for(int a:nvc) cout<<a<<" ";
// puts("");
}
}
}
}
if (W == 1)
nxt[1][1][0] = 0;
rep(i, H + 1) rep(j, C) rep(k, B) dp[i][j][k] = -1;
dp[0][0][0] = 0;
rep(i, H) {
bool canuse[234] = {};
rep(k, B) {
bool ok = 1;
rep(x, W) {
if (s[i][x] == '#' && !_b(bits[k], x))
ok = 0;
if (s[i][x] == '.' && _b(bits[k], x))
ok = 0;
}
canuse[k] = ok;
// if(ok) printf("canuse[%d]=%d\n",k,ok);
}
rep(j, C) rep(k, B) {
if (dp[i][j][k] < 0)
continue;
// printf("i,j,k=(%d,%d,%d)\n",i,j,k);
if (i > 0 && k == 0 && W > 1)
continue;
rep(l, B) {
if (!canuse[l])
continue;
if (W > 1 && l == 0)
continue;
// printf(" i,j,k=(%d,%d,%d)\n",i,j,k);
// show(l);
// show(nxt[j][k][l]);
if (nxt[j][k][l] >= 0) {
chmax(dp[i + 1][nxt[j][k][l]][l], dp[i][j][k] + cntbit(bits[l]));
// printf("dp[%d][%d][%d],dp[%d][%d][%d]+%d\n",i+1,nxt[j][k][l],l,i,j,k,cntbit(bits[l]));
}
}
}
}
int ans = -1;
rep(j, C) {
bool ok = 1;
rep(k, con[j].size()) if (con[j][k] > 0) ok = 0;
if (!ok)
continue;
// show(j);
rep(k, B) {
chmax(ans, dp[H][j][k]);
// printf("dp[%d][%d][%d]=%d\n",H,j,k,dp[H][j][k]);
}
}
cout << ans << endl;
} | replace | 19 | 20 | 19 | 20 | MLE | |
p01432 | C++ | Runtime Error | #include <algorithm>
#include <stdio.h>
#include <vector>
using namespace std;
const double EPS = 1e-8;
typedef vector<double> vec;
typedef vector<vec> mat;
inline double ABS(double a) { return max(a, -a); }
vec gauss_jordan(const mat &A, const vec &b) {
int n = A.size();
mat B(n, vec(n + 1));
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
B[i][j] = A[i][j];
for (int i = 0; i < n; i++)
B[i][n] = b[i];
for (int i = 0; i < n; i++) {
int pivot = i;
for (int j = i; j < n; j++) {
if (ABS(B[j][i]) > ABS(B[pivot][i]))
pivot = j;
}
swap(B[i], B[pivot]);
if (ABS(B[i][i]) < EPS)
return vec();
for (int j = i + 1; j <= n; j++)
B[i][j] /= B[i][i];
for (int j = 0; j < n; j++) {
if (i != j) {
for (int k = i + 1; k <= n; k++)
B[j][k] -= B[j][i] * B[i][k];
}
}
}
vec x(n);
for (int i = 0; i < n; i++)
x[i] = B[i][n];
return x;
}
double p[12][120];
double dp[110000];
int main() {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
if (a < 0)
a = -a;
if (b == 1) {
if (a % c != 0) {
printf("-1\n");
} else {
a /= c;
c = 1;
}
}
p[0][0] = 1;
for (int i = 0; i < c; i++) {
for (int j = 0; j < 100; j++) {
for (int k = 1; k <= b; k++) {
p[i + 1][j + k] += p[i][j] / b;
}
}
}
int n = b * c;
mat A(n, vec(n));
vec B(n);
for (int i = 0; i < n; i++) {
A[i][i] = 1;
if (i == 0)
continue;
B[i] = 1;
for (int j = c; j <= b * c; j++) {
int to = i - j;
if (to < 0)
to = -to;
A[i][to] -= p[c][j];
}
}
vec x = gauss_jordan(A, B);
for (int i = 0; i < n; i++)
dp[i] = x[i];
for (int i = n; i <= 100000; i++) {
dp[i] = 1;
for (int j = c; j <= b * c; j++) {
dp[i] += dp[i - j] * p[c][j];
}
}
if (a <= 100000)
printf("%.12f\n", dp[a]);
else {
double M = (c + b * c) * 0.5;
printf("%.12f\n", dp[100000] + (a - 100000) / M);
}
} | #include <algorithm>
#include <stdio.h>
#include <vector>
using namespace std;
const double EPS = 1e-8;
typedef vector<double> vec;
typedef vector<vec> mat;
inline double ABS(double a) { return max(a, -a); }
vec gauss_jordan(const mat &A, const vec &b) {
int n = A.size();
mat B(n, vec(n + 1));
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
B[i][j] = A[i][j];
for (int i = 0; i < n; i++)
B[i][n] = b[i];
for (int i = 0; i < n; i++) {
int pivot = i;
for (int j = i; j < n; j++) {
if (ABS(B[j][i]) > ABS(B[pivot][i]))
pivot = j;
}
swap(B[i], B[pivot]);
if (ABS(B[i][i]) < EPS)
return vec();
for (int j = i + 1; j <= n; j++)
B[i][j] /= B[i][i];
for (int j = 0; j < n; j++) {
if (i != j) {
for (int k = i + 1; k <= n; k++)
B[j][k] -= B[j][i] * B[i][k];
}
}
}
vec x(n);
for (int i = 0; i < n; i++)
x[i] = B[i][n];
return x;
}
double p[12][120];
double dp[110000];
int main() {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
if (a < 0)
a = -a;
if (b == 1) {
if (a % c != 0) {
printf("-1\n");
return 0;
} else {
a /= c;
c = 1;
}
}
p[0][0] = 1;
for (int i = 0; i < c; i++) {
for (int j = 0; j < 100; j++) {
for (int k = 1; k <= b; k++) {
p[i + 1][j + k] += p[i][j] / b;
}
}
}
int n = b * c;
mat A(n, vec(n));
vec B(n);
for (int i = 0; i < n; i++) {
A[i][i] = 1;
if (i == 0)
continue;
B[i] = 1;
for (int j = c; j <= b * c; j++) {
int to = i - j;
if (to < 0)
to = -to;
A[i][to] -= p[c][j];
}
}
vec x = gauss_jordan(A, B);
for (int i = 0; i < n; i++)
dp[i] = x[i];
for (int i = n; i <= 100000; i++) {
dp[i] = 1;
for (int j = c; j <= b * c; j++) {
dp[i] += dp[i - j] * p[c][j];
}
}
if (a <= 100000)
printf("%.12f\n", dp[a]);
else {
double M = (c + b * c) * 0.5;
printf("%.12f\n", dp[100000] + (a - 100000) / M);
}
} | insert | 50 | 50 | 50 | 51 | 0 | |
p01432 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, k, n) for (int i = (int)(k); i < (int)(n); i++)
#define REP(i, n) FOR(i, 0, n)
#define ALL(a) a.begin(), a.end()
#define MS(m, v) memset(m, v, sizeof(m))
typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef vector<string> vs;
typedef pair<int, int> pii;
const int MOD = 1000000007;
const int INF = MOD + 1;
const ld EPS = 1e-12;
template <class T> T &chmin(T &a, const T &b) { return a = min(a, b); }
template <class T> T &chmax(T &a, const T &b) { return a = max(a, b); }
/*--------------------template--------------------*/
typedef ld Data;
typedef vector<Data> Array;
typedef vector<Array> Matrix;
bool is_zero(Data dat) { return (abs(dat) < EPS); }
Matrix operator-(Matrix mat) {
REP(i, mat.size()) REP(j, mat[0].size()) mat[i][j] = -mat[i][j];
return mat;
}
Matrix operator+(Matrix lhs, const Matrix &rhs) {
REP(i, lhs.size()) REP(j, lhs[0].size()) lhs[i][j] = lhs[i][j] + rhs[i][j];
return lhs;
}
Matrix operator-(Matrix lhs, const Matrix &rhs) {
REP(i, lhs.size()) REP(j, lhs[0].size()) lhs[i][j] = lhs[i][j] - rhs[i][j];
return lhs;
}
Matrix operator*(const Matrix &lhs, const Matrix &rhs) {
Matrix res(lhs.size(), Array(rhs[0].size(), 0));
REP(i, lhs.size())
REP(j, rhs[0].size()) REP(k, rhs.size()) res[i][j] =
fma(lhs[i][k], rhs[k][j], res[i][j]);
return res;
}
Array operator+(const Array &lhs, const Array &rhs) {
Array res = lhs;
REP(i, rhs.size()) res[i] = res[i] + rhs[i];
return res;
}
Array operator*(const Matrix &lhs, const Array &rhs) {
Array res(lhs.size());
REP(i, lhs.size())
res[i] = inner_product(begin(lhs[i]), end(lhs[i]), begin(rhs), Data(0));
return res;
}
Array operator*(Data scalar, const Array &rhs) {
Array res(rhs.size());
REP(i, rhs.size())
res[i] = scalar * rhs[i];
return res;
}
Matrix transpose(const Matrix &A) {
const int n = A[0].size(), m = A.size();
Matrix res(n, Array(m, 0));
REP(i, n) REP(j, m) res[i][j] = A[j][i];
return res;
}
Data inner_product_ex(const Array &a, const Array &b, const Matrix &m) {
Array b_prime = m * b;
return inner_product(begin(a), end(a), begin(b_prime), Data(0));
}
Data norm(const Array &a) {
return inner_product(begin(a), end(a), begin(a), Data(0));
}
Data norm(const Array &a, const Matrix &M) { return inner_product_ex(a, a, M); }
int rankMat(Matrix A) {
const int n = A.size(), m = A[0].size();
int r = 0;
for (int i = 0; r < n && i < m; ++i) {
int pivot = r;
for (int j = r + 1; j < n; ++j)
if (abs(A[j][i]) > abs(A[pivot][i]))
pivot = j;
swap(A[pivot], A[r]);
if (is_zero(A[r][i]))
continue;
for (int k = m - 1; k >= i; --k)
A[r][k] = A[r][k] / A[r][i];
for (int j = r + 1; j < n; ++j)
for (int k = m - 1; k >= i; --k)
A[j][k] = fma(-A[r][k], A[j][i], A[j][k]);
++r;
}
return r;
}
Data det(Matrix A) {
const int n = A.size();
Data D = Data(1);
for (int i = 0; i < n; ++i) {
int pivot = i;
for (int j = i + 1; j < n; ++j)
if (abs(A[j][i]) > abs(A[pivot][i]))
pivot = j;
swap(A[pivot], A[i]);
D = D * A[i][i] * Data(i != pivot ? -1 : 1);
if (is_zero(A[i][i]))
break;
for (int j = i + 1; j < n; ++j)
for (int k = n - 1; k >= i; --k)
A[j][k] = A[j][k] - A[i][k] * A[j][i] / A[i][i];
}
return D;
}
Array gauss_jordan(const Matrix &A, const Array &b) {
int n = A.size();
Matrix B(n, Array(n + 1));
REP(i, n) REP(j, n) B[i][j] = A[i][j];
REP(i, n) B[i][n] = b[i];
REP(i, n) {
int pivot = i;
FOR(j, i, n) {
if (abs(B[j][i]) > abs(B[pivot][i]))
pivot = j;
}
swap(B[i], B[pivot]);
if (abs(B[i][i]) < EPS)
return Array();
FOR(j, i + 1, n + 1) B[i][j] /= B[i][i];
REP(j, n) {
if (i != j) {
FOR(k, i + 1, n + 1) B[j][k] -= B[j][i] * B[i][k];
}
}
}
Array x(n);
REP(i, n) x[i] = B[i][n];
return x;
}
int mx;
ld dp[111111];
ld solve(int s, vector<ld> &exp) {
if (s == 0)
return 0;
if (dp[s] >= 0)
return dp[s];
ld res = 1;
FOR(i, 1, mx + 1) { res += solve(abs(s - i), exp) * exp[i]; }
return dp[s] = res;
}
int main() {
cin.sync_with_stdio(false);
cout << fixed << setprecision(10);
REP(i, 111111) dp[i] = 0;
int s, n, k;
cin >> s >> n >> k;
s = abs(s);
ld adv[11][111];
MS(adv, 0);
adv[0][0] = 1.0;
REP(i, k) {
REP(j, 100) {
FOR(dice, 1, n + 1) { adv[i + 1][j + dice] += adv[i][j] / n; }
}
}
vector<ld> v;
REP(i, 101) v.push_back(adv[k][i]);
ld exp = 0;
REP(i, 111) exp += i * adv[k][i];
ld ans = 0;
if (s > 100000) {
ans += (s - 100000) / exp;
s = 100000;
}
mx = n * k;
Matrix A(mx, Array(mx));
Array b(mx);
A[0][0] = 1;
FOR(i, 1, mx) {
FOR(j, 1, mx + 1) { A[i][abs(i - j)] += v[j]; }
}
FOR(i, 1, mx) {
A[i][i] -= 1;
b[i] = -1;
}
Array x = gauss_jordan(A, b);
REP(i, mx) dp[i] = x[i];
FOR(i, mx, s + 1) {
REP(j, 101) {
if (i - j < 0)
break;
dp[i] += dp[i - j] * v[j];
}
dp[i] += 1;
}
cout << dp[s] + ans << endl;
// cout << solve(s, v) + ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, k, n) for (int i = (int)(k); i < (int)(n); i++)
#define REP(i, n) FOR(i, 0, n)
#define ALL(a) a.begin(), a.end()
#define MS(m, v) memset(m, v, sizeof(m))
typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef vector<string> vs;
typedef pair<int, int> pii;
const int MOD = 1000000007;
const int INF = MOD + 1;
const ld EPS = 1e-12;
template <class T> T &chmin(T &a, const T &b) { return a = min(a, b); }
template <class T> T &chmax(T &a, const T &b) { return a = max(a, b); }
/*--------------------template--------------------*/
typedef ld Data;
typedef vector<Data> Array;
typedef vector<Array> Matrix;
bool is_zero(Data dat) { return (abs(dat) < EPS); }
Matrix operator-(Matrix mat) {
REP(i, mat.size()) REP(j, mat[0].size()) mat[i][j] = -mat[i][j];
return mat;
}
Matrix operator+(Matrix lhs, const Matrix &rhs) {
REP(i, lhs.size()) REP(j, lhs[0].size()) lhs[i][j] = lhs[i][j] + rhs[i][j];
return lhs;
}
Matrix operator-(Matrix lhs, const Matrix &rhs) {
REP(i, lhs.size()) REP(j, lhs[0].size()) lhs[i][j] = lhs[i][j] - rhs[i][j];
return lhs;
}
Matrix operator*(const Matrix &lhs, const Matrix &rhs) {
Matrix res(lhs.size(), Array(rhs[0].size(), 0));
REP(i, lhs.size())
REP(j, rhs[0].size()) REP(k, rhs.size()) res[i][j] =
fma(lhs[i][k], rhs[k][j], res[i][j]);
return res;
}
Array operator+(const Array &lhs, const Array &rhs) {
Array res = lhs;
REP(i, rhs.size()) res[i] = res[i] + rhs[i];
return res;
}
Array operator*(const Matrix &lhs, const Array &rhs) {
Array res(lhs.size());
REP(i, lhs.size())
res[i] = inner_product(begin(lhs[i]), end(lhs[i]), begin(rhs), Data(0));
return res;
}
Array operator*(Data scalar, const Array &rhs) {
Array res(rhs.size());
REP(i, rhs.size())
res[i] = scalar * rhs[i];
return res;
}
Matrix transpose(const Matrix &A) {
const int n = A[0].size(), m = A.size();
Matrix res(n, Array(m, 0));
REP(i, n) REP(j, m) res[i][j] = A[j][i];
return res;
}
Data inner_product_ex(const Array &a, const Array &b, const Matrix &m) {
Array b_prime = m * b;
return inner_product(begin(a), end(a), begin(b_prime), Data(0));
}
Data norm(const Array &a) {
return inner_product(begin(a), end(a), begin(a), Data(0));
}
Data norm(const Array &a, const Matrix &M) { return inner_product_ex(a, a, M); }
int rankMat(Matrix A) {
const int n = A.size(), m = A[0].size();
int r = 0;
for (int i = 0; r < n && i < m; ++i) {
int pivot = r;
for (int j = r + 1; j < n; ++j)
if (abs(A[j][i]) > abs(A[pivot][i]))
pivot = j;
swap(A[pivot], A[r]);
if (is_zero(A[r][i]))
continue;
for (int k = m - 1; k >= i; --k)
A[r][k] = A[r][k] / A[r][i];
for (int j = r + 1; j < n; ++j)
for (int k = m - 1; k >= i; --k)
A[j][k] = fma(-A[r][k], A[j][i], A[j][k]);
++r;
}
return r;
}
Data det(Matrix A) {
const int n = A.size();
Data D = Data(1);
for (int i = 0; i < n; ++i) {
int pivot = i;
for (int j = i + 1; j < n; ++j)
if (abs(A[j][i]) > abs(A[pivot][i]))
pivot = j;
swap(A[pivot], A[i]);
D = D * A[i][i] * Data(i != pivot ? -1 : 1);
if (is_zero(A[i][i]))
break;
for (int j = i + 1; j < n; ++j)
for (int k = n - 1; k >= i; --k)
A[j][k] = A[j][k] - A[i][k] * A[j][i] / A[i][i];
}
return D;
}
Array gauss_jordan(const Matrix &A, const Array &b) {
int n = A.size();
Matrix B(n, Array(n + 1));
REP(i, n) REP(j, n) B[i][j] = A[i][j];
REP(i, n) B[i][n] = b[i];
REP(i, n) {
int pivot = i;
FOR(j, i, n) {
if (abs(B[j][i]) > abs(B[pivot][i]))
pivot = j;
}
swap(B[i], B[pivot]);
if (abs(B[i][i]) < EPS)
return Array();
FOR(j, i + 1, n + 1) B[i][j] /= B[i][i];
REP(j, n) {
if (i != j) {
FOR(k, i + 1, n + 1) B[j][k] -= B[j][i] * B[i][k];
}
}
}
Array x(n);
REP(i, n) x[i] = B[i][n];
return x;
}
int mx;
ld dp[111111];
ld solve(int s, vector<ld> &exp) {
if (s == 0)
return 0;
if (dp[s] >= 0)
return dp[s];
ld res = 1;
FOR(i, 1, mx + 1) { res += solve(abs(s - i), exp) * exp[i]; }
return dp[s] = res;
}
int main() {
cin.sync_with_stdio(false);
cout << fixed << setprecision(10);
REP(i, 111111) dp[i] = 0;
int s, n, k;
cin >> s >> n >> k;
s = abs(s);
if (n == 1) {
cout << s / k << endl;
return 0;
}
ld adv[11][111];
MS(adv, 0);
adv[0][0] = 1.0;
REP(i, k) {
REP(j, 100) {
FOR(dice, 1, n + 1) { adv[i + 1][j + dice] += adv[i][j] / n; }
}
}
vector<ld> v;
REP(i, 101) v.push_back(adv[k][i]);
ld exp = 0;
REP(i, 111) exp += i * adv[k][i];
ld ans = 0;
if (s > 100000) {
ans += (s - 100000) / exp;
s = 100000;
}
mx = n * k;
Matrix A(mx, Array(mx));
Array b(mx);
A[0][0] = 1;
FOR(i, 1, mx) {
FOR(j, 1, mx + 1) { A[i][abs(i - j)] += v[j]; }
}
FOR(i, 1, mx) {
A[i][i] -= 1;
b[i] = -1;
}
Array x = gauss_jordan(A, b);
REP(i, mx) dp[i] = x[i];
FOR(i, mx, s + 1) {
REP(j, 101) {
if (i - j < 0)
break;
dp[i] += dp[i - j] * v[j];
}
dp[i] += 1;
}
cout << dp[s] + ans << endl;
// cout << solve(s, v) + ans << endl;
return 0;
} | insert | 172 | 172 | 172 | 176 | 0 | |
p01434 | C++ | Runtime Error | #include <algorithm>
#include <cassert>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#define rep(i, n) for (int i = 0; i < (int)n; i++)
#define all(c) (c).begin(), (c).end()
#define mp make_pair
#define pb push_back
#define each(i, c) \
for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); i++)
#define dbg(x) cerr << __LINE__ << ": " << #x << " = " << (x) << endl
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef pair<int, int> pi;
const int inf = (int)1e9 + 10;
const double INF = 1e12, EPS = 1e-9;
const int MX = 100000;
int n, m, p[MX];
int s[MX], t[MX];
int main() {
vi v;
scanf("%d%d", &n, &m);
rep(i, n) scanf("%d%d", s + i, t + i), v.pb(s[i]), v.pb(t[i]);
rep(i, m) scanf("%d", p + i), v.pb(p[i]);
v.pb(p[m++] = -inf);
v.pb(p[m++] = inf);
sort(p, p + m);
sort(all(v));
v.erase(unique(all(v)), v.end());
vi d[2];
d[0].resize(v.size());
d[1].resize(v.size());
rep(i, n) {
int a = lower_bound(all(v), s[i]) - v.begin();
int b = lower_bound(all(v), t[i]) - v.begin();
int p1 = (upper_bound(p, p + m, s[i]) - 1 - p) % 2;
if (a < b)
d[p1][a]++, d[p1][b]--;
else
d[p1][b]++, d[p1][a]--;
}
ll ans = 0, parity = 1, s0 = 0, s1 = 0;
rep(i, v.size()) {
if (i) {
if (parity % 2 == 0)
ans += s0 * (v[i] - v[i - 1]);
else
ans += s1 * (v[i] - v[i - 1]);
}
s0 += d[0][i];
s1 += d[1][i];
if (binary_search(p, p + m, v[i]))
parity ^= 1;
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <cassert>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#define rep(i, n) for (int i = 0; i < (int)n; i++)
#define all(c) (c).begin(), (c).end()
#define mp make_pair
#define pb push_back
#define each(i, c) \
for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); i++)
#define dbg(x) cerr << __LINE__ << ": " << #x << " = " << (x) << endl
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef pair<int, int> pi;
const int inf = (int)1e9 + 10;
const double INF = 1e12, EPS = 1e-9;
const int MX = 100010;
int n, m, p[MX];
int s[MX], t[MX];
int main() {
vi v;
scanf("%d%d", &n, &m);
rep(i, n) scanf("%d%d", s + i, t + i), v.pb(s[i]), v.pb(t[i]);
rep(i, m) scanf("%d", p + i), v.pb(p[i]);
v.pb(p[m++] = -inf);
v.pb(p[m++] = inf);
sort(p, p + m);
sort(all(v));
v.erase(unique(all(v)), v.end());
vi d[2];
d[0].resize(v.size());
d[1].resize(v.size());
rep(i, n) {
int a = lower_bound(all(v), s[i]) - v.begin();
int b = lower_bound(all(v), t[i]) - v.begin();
int p1 = (upper_bound(p, p + m, s[i]) - 1 - p) % 2;
if (a < b)
d[p1][a]++, d[p1][b]--;
else
d[p1][b]++, d[p1][a]--;
}
ll ans = 0, parity = 1, s0 = 0, s1 = 0;
rep(i, v.size()) {
if (i) {
if (parity % 2 == 0)
ans += s0 * (v[i] - v[i - 1]);
else
ans += s1 * (v[i] - v[i - 1]);
}
s0 += d[0][i];
s1 += d[1][i];
if (binary_search(p, p + m, v[i]))
parity ^= 1;
}
cout << ans << endl;
return 0;
} | replace | 28 | 29 | 28 | 29 | 0 | |
p01434 | C++ | Runtime Error | #include <bits/stdc++.h>
#define N 10005
using namespace std;
long long n, m, s[N], t[N], p[N], d[N], ans;
int bynary_search(int x) {
int l = 0, r = m;
while (l < r) {
int mid = (l + r) / 2;
if (x <= p[mid])
r = mid;
else
l = mid + 1;
}
return l;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++)
cin >> s[i] >> t[i];
for (int i = 0; i < m; i++)
cin >> p[i];
sort(p, p + m);
d[0] = p[0], d[1] = p[1] - p[0];
ans = 0;
for (int i = 2; i < m; i++)
d[i] = d[i - 2] + p[i] - p[i - 1];
for (int i = 0; i < n; i++) {
int r1 = bynary_search(s[i]);
int r2 = bynary_search(t[i]);
if (r1 == r2)
ans += max(s[i], t[i]) - min(s[i], t[i]);
else if (abs(r1 - r2) == 1) {
if (s[i] < t[i])
ans += p[r1] - s[i];
else
ans += s[i] - p[r1 - 1];
} else if (s[i] < t[i]) {
if (r2 % 2 == r1 % 2)
ans += p[r1] - s[i] + d[r2 - 2] - d[r1] + t[i] - p[r2 - 1];
else
ans += p[r1] - s[i] + d[r2 - 1] - d[r1];
} else {
if (r2 % 2 == r1 % 2)
ans += s[i] - p[r1 - 1] + d[r1 - 2] - d[r2] + p[r2] - t[i];
else
ans += s[i] - p[r1 - 1] + d[r1 - 2] - d[r2 - 1];
}
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define N 100005
using namespace std;
long long n, m, s[N], t[N], p[N], d[N], ans;
int bynary_search(int x) {
int l = 0, r = m;
while (l < r) {
int mid = (l + r) / 2;
if (x <= p[mid])
r = mid;
else
l = mid + 1;
}
return l;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++)
cin >> s[i] >> t[i];
for (int i = 0; i < m; i++)
cin >> p[i];
sort(p, p + m);
d[0] = p[0], d[1] = p[1] - p[0];
ans = 0;
for (int i = 2; i < m; i++)
d[i] = d[i - 2] + p[i] - p[i - 1];
for (int i = 0; i < n; i++) {
int r1 = bynary_search(s[i]);
int r2 = bynary_search(t[i]);
if (r1 == r2)
ans += max(s[i], t[i]) - min(s[i], t[i]);
else if (abs(r1 - r2) == 1) {
if (s[i] < t[i])
ans += p[r1] - s[i];
else
ans += s[i] - p[r1 - 1];
} else if (s[i] < t[i]) {
if (r2 % 2 == r1 % 2)
ans += p[r1] - s[i] + d[r2 - 2] - d[r1] + t[i] - p[r2 - 1];
else
ans += p[r1] - s[i] + d[r2 - 1] - d[r1];
} else {
if (r2 % 2 == r1 % 2)
ans += s[i] - p[r1 - 1] + d[r1 - 2] - d[r2] + p[r2] - t[i];
else
ans += s[i] - p[r1 - 1] + d[r1 - 2] - d[r2 - 1];
}
}
cout << ans << endl;
return 0;
} | replace | 1 | 2 | 1 | 2 | 0 | |
p01434 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int n, m;
int s[10010], t[10010];
int p[10010];
int a[10010];
int main() {
cin >> n >> m, m++;
for (int i = 0; i < n; i++) {
cin >> s[i] >> t[i];
}
for (int i = 1; i < m; i++) {
cin >> p[i];
}
sort(p, p + m);
long long res = 0;
for (int i = 0; i < n; i++) {
if (lower_bound(p, p + m, s[i]) == lower_bound(p, p + m, t[i])) {
res += abs(s[i] - t[i]);
} else if (s[i] < t[i]) {
int l = lower_bound(p, p + m, s[i]) - p - 1;
int r = lower_bound(p, p + m, t[i]) - p;
if ((l ^ r) & 1) {
a[l]++;
a[r + 1]--;
res -= s[i] - p[l];
res -= p[r] - t[i];
} else {
a[l]++;
a[r]--;
res -= s[i] - p[l];
}
} else {
int l = lower_bound(p, p + m, t[i]) - p - 1;
int r = lower_bound(p, p + m, s[i]) - p;
if ((l ^ r) & 1) {
a[l]++;
a[r + 1]--;
res -= t[i] - p[l];
res -= p[r] - s[i];
} else {
a[l + 1]++;
a[r + 1]--;
res -= p[r] - s[i];
}
}
}
for (int i = 0; i < m; i++) {
a[i + 2] += a[i];
res += (long long)(p[i + 1] - p[i]) * a[i];
}
cout << res << endl;
} | #include <bits/stdc++.h>
using namespace std;
int n, m;
int s[100010], t[100010];
int p[100010];
int a[100010];
int main() {
cin >> n >> m, m++;
for (int i = 0; i < n; i++) {
cin >> s[i] >> t[i];
}
for (int i = 1; i < m; i++) {
cin >> p[i];
}
sort(p, p + m);
long long res = 0;
for (int i = 0; i < n; i++) {
if (lower_bound(p, p + m, s[i]) == lower_bound(p, p + m, t[i])) {
res += abs(s[i] - t[i]);
} else if (s[i] < t[i]) {
int l = lower_bound(p, p + m, s[i]) - p - 1;
int r = lower_bound(p, p + m, t[i]) - p;
if ((l ^ r) & 1) {
a[l]++;
a[r + 1]--;
res -= s[i] - p[l];
res -= p[r] - t[i];
} else {
a[l]++;
a[r]--;
res -= s[i] - p[l];
}
} else {
int l = lower_bound(p, p + m, t[i]) - p - 1;
int r = lower_bound(p, p + m, s[i]) - p;
if ((l ^ r) & 1) {
a[l]++;
a[r + 1]--;
res -= t[i] - p[l];
res -= p[r] - s[i];
} else {
a[l + 1]++;
a[r + 1]--;
res -= p[r] - s[i];
}
}
}
for (int i = 0; i < m; i++) {
a[i + 2] += a[i];
res += (long long)(p[i + 1] - p[i]) * a[i];
}
cout << res << endl;
} | replace | 4 | 7 | 4 | 7 | 0 | |
p01435 | C++ | Runtime Error | #pragma GCC optimize("Ofast")
#include <algorithm>
#include <bitset>
#include <cassert>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <unordered_map>
#include <unordered_set>
using namespace std;
using i64 = int_fast64_t;
using db = double;
using ldb = long double;
using pii = pair<int, int>;
using pli = pair<int_fast64_t, int>;
using pll = pair<int_fast64_t, int_fast64_t>;
using pdi = pair<double, int>;
using pdd = pair<double, double>;
template <class T> using vct = vector<T>;
template <class T> using heap = priority_queue<T>;
template <class T> using minheap = priority_queue<T, vector<T>, greater<T>>;
template <class T> constexpr T inf = numeric_limits<T>::max() / (T)1024;
constexpr int dx[9] = {1, 0, -1, 0, 1, -1, -1, 1, 0};
constexpr int dy[9] = {0, 1, 0, -1, 1, 1, -1, -1, 0};
constexpr long double Pi = 3.1415926535897932384626433832795028841971;
constexpr long double Golden = 1.61803398874989484820;
constexpr long double eps = 1e-15;
#define iostream_untie true
#define mod 1000000007LL
#define stdout_precision 10
#define stderr_precision 6
#define itrep(i, v) for (auto i = begin(v); i != end(v); ++i)
#define ritrep(i, v) for (auto i = rbegin(v); i != rend(v); ++i)
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = (n)-1; i >= 0; --i)
#define all(v) begin(v), end(v)
#define rall(v) rbegin(v), rend(v)
#define fir first
#define sec second
#define u_map unordered_map
#define u_set unordered_set
#define l_bnd lower_bound
#define u_bnd upper_bound
#define rsz resize
#define ers erase
#define emp emplace
#define emf emplace_front
#define emb emplace_back
#define pof pop_front
#define pob pop_back
#define mkp make_pair
#define mkt make_tuple
#define popcnt __builtin_popcount
namespace setup {
struct setupper {
setupper() {
if (iostream_untie) {
ios::sync_with_stdio(false);
std::cin.tie(nullptr);
std::cout.tie(nullptr);
std::cerr.tie(nullptr);
}
std::cout << fixed << setprecision(stdout_precision);
std::cerr << fixed << setprecision(stderr_precision);
#ifdef LOCAL
if (!freopen("input.txt", "rt", stdin)) {
cerr << "Failed to open the input file.\n";
exit(EXIT_FAILURE);
}
// if(!freopen("output.txt","wt",stdout)) {
// cerr << "Failed to open the output file.\n"; exit(EXIT_FAILURE);
// }
// std::cerr << "\n---stderr---\n";
// auto print_atexit = []() {
// std::cerr << "Exec time : " << clock() / (double)CLOCKS_PER_SEC *
// 1000.0 << "ms\n"; std::cerr << "------------\n";
// };
// atexit((void(*)())print_atexit);
// atexit((void(*)())fclose(stdin));
#endif
}
} __setupper;
} // namespace setup
namespace std {
template <class RAitr> void rsort(RAitr __first, RAitr __last) {
sort(__first, __last, greater<>());
}
template <class T> void hash_combine(size_t &seed, T const &key) {
seed ^= hash<T>()(key) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}
template <class T, class U> struct hash<pair<T, U>> {
size_t operator()(pair<T, U> const &pr) const {
size_t seed = 0;
hash_combine(seed, pr.first);
hash_combine(seed, pr.second);
return seed;
}
};
template <class Tup, size_t index = tuple_size<Tup>::value - 1>
struct hashval_calc {
static void apply(size_t &seed, Tup const &tup) {
hashval_calc<Tup, index - 1>::apply(seed, tup);
hash_combine(seed, get<index>(tup));
}
};
template <class Tup> struct hashval_calc<Tup, 0> {
static void apply(size_t &seed, Tup const &tup) {
hash_combine(seed, get<0>(tup));
}
};
template <class... T> struct hash<tuple<T...>> {
size_t operator()(tuple<T...> const &tup) const {
size_t seed = 0;
hashval_calc<tuple<T...>>::apply(seed, tup);
return seed;
}
};
} // namespace std
template <class T, class U> istream &operator>>(istream &s, pair<T, U> &p) {
return s >> p.first >> p.second;
}
template <class T, class U>
ostream &operator<<(ostream &s, const pair<T, U> p) {
return s << p.first << " " << p.second;
}
template <class T> ostream &operator<<(ostream &s, const vector<T> &v) {
for (size_t i = 0; i < v.size(); ++i)
s << (i ? " " : "") << v[i];
return s;
}
#define dump(...) \
cerr << " [ " << __LINE__ << " : " << __FUNCTION__ << " ] " << #__VA_ARGS__ \
<< " : "; \
dump_func(__VA_ARGS__)
template <class T> void dump_func(T x) { cerr << x << '\n'; }
template <class T, class... Rest> void dump_func(T x, Rest... rest) {
cerr << x << ",";
dump_func(rest...);
}
template <class T = i64> T read() {
T x;
return cin >> x, x;
}
template <class T> void write(T x) { cout << x << '\n'; }
template <class T, class... Rest> void write(T x, Rest... rest) {
cout << x << ' ';
write(rest...);
}
void writeln() {}
template <class T, class... Rest> void writeln(T x, Rest... rest) {
cout << x << '\n';
writeln(rest...);
}
#define esc(...) writeln(__VA_ARGS__), exit(0)
namespace updater {
template <class T> static void add(T &x, const T &y) { x += y; }
template <class T> static void ext_add(T &x, const T &y, size_t w) {
x += y * w;
}
template <class T> static void mul(T &x, const T &y) { x *= y; }
template <class T> static void ext_mul(T &x, const T &y, size_t w) {
x *= (T)pow(y, w);
}
template <class T> static bool chmax(T &x, const T &y) {
return x < y ? x = y, true : false;
}
template <class T> static bool chmin(T &x, const T &y) {
return x > y ? x = y, true : false;
}
}; // namespace updater
using updater::add;
using updater::chmax;
using updater::chmin;
template <class T> constexpr T minf(const T &x, const T &y) {
return min(x, y);
}
template <class T> constexpr T maxf(const T &x, const T &y) {
return max(x, y);
}
constexpr bool bit(i64 n, int e) { return (n >> e) & 1; }
constexpr int_fast64_t mask(int_fast64_t n, int e) {
return n & ((1 << e) - 1);
}
constexpr int ilog(int_fast64_t x, int_fast64_t b = 2) {
return x ? 1 + ilog(x / b, b) : -1;
}
template <class F>
int_fast64_t binry(int_fast64_t ok, int_fast64_t ng, const F &fn) {
while (abs(ok - ng) > 1) {
int_fast64_t mid = (ok + ng) / 2;
(fn(mid) ? ok : ng) = mid;
}
return ok;
}
template <class A, size_t N, class T> void init(A (&array)[N], const T &val) {
fill((T *)array, (T *)(array + N), val);
}
template <class T> vector<int> cmprs(const vector<T> &v) {
vector<T> tmp = v;
vector<int> ret;
sort(begin(tmp), end(tmp));
tmp.erase(unique(begin(tmp), end(tmp)), end(tmp));
for (T i : v)
ret.emplace_back(lower_bound(begin(tmp), end(tmp), i) - begin(tmp));
return ret;
}
template <class T> vector<int> cmprs(const T *__first, const T *__last) {
return cmprs(vector<T>(__first, __last));
}
template <class F> void for_subset(uint_fast64_t s, const F &fn) {
uint_fast64_t tmp = s;
do {
fn(tmp);
} while ((--tmp &= s) != s);
}
/* The main code follows. */
int N, E, T;
int sar[310];
pair<int, vector<int>> gen[310];
signed main() {
cin >> N >> E >> T;
minheap<pii> hp;
for (int i = 1; i <= N; ++i) {
int w;
cin >> w;
if (w)
sar[i] = 1;
else
sar[i] = inf<int>;
}
rep(i, E) {
int g, c;
cin >> g >> c;
gen[i].fir = g;
rep(j, c) {
int x;
cin >> x;
gen[i].sec.emplace_back(x);
}
}
for (int t = 1; t <= N; ++t) {
for (int i = 0; i < E; ++i) {
int tmp = 0;
int num = 0;
priority_queue<int> pq;
for (auto &x : gen[i].sec) {
pq.emplace(sar[x]);
}
while (!pq.empty()) {
tmp = max(tmp, pq.top() + num);
num++;
pq.pop();
}
chmin(sar[gen[i].fir], tmp);
}
}
if (sar[T] >= inf<int>)
esc(-1);
esc(sar[T]);
}
| #pragma GCC optimize("Ofast")
#include <algorithm>
#include <bitset>
#include <cassert>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <unordered_map>
#include <unordered_set>
using namespace std;
using i64 = int_fast64_t;
using db = double;
using ldb = long double;
using pii = pair<int, int>;
using pli = pair<int_fast64_t, int>;
using pll = pair<int_fast64_t, int_fast64_t>;
using pdi = pair<double, int>;
using pdd = pair<double, double>;
template <class T> using vct = vector<T>;
template <class T> using heap = priority_queue<T>;
template <class T> using minheap = priority_queue<T, vector<T>, greater<T>>;
template <class T> constexpr T inf = numeric_limits<T>::max() / (T)1024;
constexpr int dx[9] = {1, 0, -1, 0, 1, -1, -1, 1, 0};
constexpr int dy[9] = {0, 1, 0, -1, 1, 1, -1, -1, 0};
constexpr long double Pi = 3.1415926535897932384626433832795028841971;
constexpr long double Golden = 1.61803398874989484820;
constexpr long double eps = 1e-15;
#define iostream_untie true
#define mod 1000000007LL
#define stdout_precision 10
#define stderr_precision 6
#define itrep(i, v) for (auto i = begin(v); i != end(v); ++i)
#define ritrep(i, v) for (auto i = rbegin(v); i != rend(v); ++i)
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = (n)-1; i >= 0; --i)
#define all(v) begin(v), end(v)
#define rall(v) rbegin(v), rend(v)
#define fir first
#define sec second
#define u_map unordered_map
#define u_set unordered_set
#define l_bnd lower_bound
#define u_bnd upper_bound
#define rsz resize
#define ers erase
#define emp emplace
#define emf emplace_front
#define emb emplace_back
#define pof pop_front
#define pob pop_back
#define mkp make_pair
#define mkt make_tuple
#define popcnt __builtin_popcount
namespace setup {
struct setupper {
setupper() {
if (iostream_untie) {
ios::sync_with_stdio(false);
std::cin.tie(nullptr);
std::cout.tie(nullptr);
std::cerr.tie(nullptr);
}
std::cout << fixed << setprecision(stdout_precision);
std::cerr << fixed << setprecision(stderr_precision);
#ifdef LOCAL
if (!freopen("input.txt", "rt", stdin)) {
cerr << "Failed to open the input file.\n";
exit(EXIT_FAILURE);
}
// if(!freopen("output.txt","wt",stdout)) {
// cerr << "Failed to open the output file.\n"; exit(EXIT_FAILURE);
// }
// std::cerr << "\n---stderr---\n";
// auto print_atexit = []() {
// std::cerr << "Exec time : " << clock() / (double)CLOCKS_PER_SEC *
// 1000.0 << "ms\n"; std::cerr << "------------\n";
// };
// atexit((void(*)())print_atexit);
// atexit((void(*)())fclose(stdin));
#endif
}
} __setupper;
} // namespace setup
namespace std {
template <class RAitr> void rsort(RAitr __first, RAitr __last) {
sort(__first, __last, greater<>());
}
template <class T> void hash_combine(size_t &seed, T const &key) {
seed ^= hash<T>()(key) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}
template <class T, class U> struct hash<pair<T, U>> {
size_t operator()(pair<T, U> const &pr) const {
size_t seed = 0;
hash_combine(seed, pr.first);
hash_combine(seed, pr.second);
return seed;
}
};
template <class Tup, size_t index = tuple_size<Tup>::value - 1>
struct hashval_calc {
static void apply(size_t &seed, Tup const &tup) {
hashval_calc<Tup, index - 1>::apply(seed, tup);
hash_combine(seed, get<index>(tup));
}
};
template <class Tup> struct hashval_calc<Tup, 0> {
static void apply(size_t &seed, Tup const &tup) {
hash_combine(seed, get<0>(tup));
}
};
template <class... T> struct hash<tuple<T...>> {
size_t operator()(tuple<T...> const &tup) const {
size_t seed = 0;
hashval_calc<tuple<T...>>::apply(seed, tup);
return seed;
}
};
} // namespace std
template <class T, class U> istream &operator>>(istream &s, pair<T, U> &p) {
return s >> p.first >> p.second;
}
template <class T, class U>
ostream &operator<<(ostream &s, const pair<T, U> p) {
return s << p.first << " " << p.second;
}
template <class T> ostream &operator<<(ostream &s, const vector<T> &v) {
for (size_t i = 0; i < v.size(); ++i)
s << (i ? " " : "") << v[i];
return s;
}
#define dump(...) \
cerr << " [ " << __LINE__ << " : " << __FUNCTION__ << " ] " << #__VA_ARGS__ \
<< " : "; \
dump_func(__VA_ARGS__)
template <class T> void dump_func(T x) { cerr << x << '\n'; }
template <class T, class... Rest> void dump_func(T x, Rest... rest) {
cerr << x << ",";
dump_func(rest...);
}
template <class T = i64> T read() {
T x;
return cin >> x, x;
}
template <class T> void write(T x) { cout << x << '\n'; }
template <class T, class... Rest> void write(T x, Rest... rest) {
cout << x << ' ';
write(rest...);
}
void writeln() {}
template <class T, class... Rest> void writeln(T x, Rest... rest) {
cout << x << '\n';
writeln(rest...);
}
#define esc(...) writeln(__VA_ARGS__), exit(0)
namespace updater {
template <class T> static void add(T &x, const T &y) { x += y; }
template <class T> static void ext_add(T &x, const T &y, size_t w) {
x += y * w;
}
template <class T> static void mul(T &x, const T &y) { x *= y; }
template <class T> static void ext_mul(T &x, const T &y, size_t w) {
x *= (T)pow(y, w);
}
template <class T> static bool chmax(T &x, const T &y) {
return x < y ? x = y, true : false;
}
template <class T> static bool chmin(T &x, const T &y) {
return x > y ? x = y, true : false;
}
}; // namespace updater
using updater::add;
using updater::chmax;
using updater::chmin;
template <class T> constexpr T minf(const T &x, const T &y) {
return min(x, y);
}
template <class T> constexpr T maxf(const T &x, const T &y) {
return max(x, y);
}
constexpr bool bit(i64 n, int e) { return (n >> e) & 1; }
constexpr int_fast64_t mask(int_fast64_t n, int e) {
return n & ((1 << e) - 1);
}
constexpr int ilog(int_fast64_t x, int_fast64_t b = 2) {
return x ? 1 + ilog(x / b, b) : -1;
}
template <class F>
int_fast64_t binry(int_fast64_t ok, int_fast64_t ng, const F &fn) {
while (abs(ok - ng) > 1) {
int_fast64_t mid = (ok + ng) / 2;
(fn(mid) ? ok : ng) = mid;
}
return ok;
}
template <class A, size_t N, class T> void init(A (&array)[N], const T &val) {
fill((T *)array, (T *)(array + N), val);
}
template <class T> vector<int> cmprs(const vector<T> &v) {
vector<T> tmp = v;
vector<int> ret;
sort(begin(tmp), end(tmp));
tmp.erase(unique(begin(tmp), end(tmp)), end(tmp));
for (T i : v)
ret.emplace_back(lower_bound(begin(tmp), end(tmp), i) - begin(tmp));
return ret;
}
template <class T> vector<int> cmprs(const T *__first, const T *__last) {
return cmprs(vector<T>(__first, __last));
}
template <class F> void for_subset(uint_fast64_t s, const F &fn) {
uint_fast64_t tmp = s;
do {
fn(tmp);
} while ((--tmp &= s) != s);
}
/* The main code follows. */
int N, E, T;
int sar[310];
pair<int, vector<int>> gen[1010];
signed main() {
cin >> N >> E >> T;
minheap<pii> hp;
for (int i = 1; i <= N; ++i) {
int w;
cin >> w;
if (w)
sar[i] = 1;
else
sar[i] = inf<int>;
}
rep(i, E) {
int g, c;
cin >> g >> c;
gen[i].fir = g;
rep(j, c) {
int x;
cin >> x;
gen[i].sec.emplace_back(x);
}
}
for (int t = 1; t <= N; ++t) {
for (int i = 0; i < E; ++i) {
int tmp = 0;
int num = 0;
priority_queue<int> pq;
for (auto &x : gen[i].sec) {
pq.emplace(sar[x]);
}
while (!pq.empty()) {
tmp = max(tmp, pq.top() + num);
num++;
pq.pop();
}
chmin(sar[gen[i].fir], tmp);
}
}
if (sar[T] >= inf<int>)
esc(-1);
esc(sar[T]);
}
| replace | 235 | 236 | 235 | 236 | 0 | |
p01435 | 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<class... T>
ostream& operator<<(ostream& os, tuple<T...>& t) {
for (size_t i = 0; i < tuple_size< tuple<T...> >::value; ++i) {
if (i) os << " ";
os << get<0>(t);
}
return os;
}
*/
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;
}
struct Law {
int G;
vector<int> S;
};
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
int N, E, T;
cin >> N >> E >> T;
--T;
vector<int> W(N);
cin >> W;
vector<Law> law;
REP(i, E) {
int G, C;
cin >> G >> C;
--G;
vector<int> S(C);
cin >> S;
REP(i, C) S[i]--;
law.pb((Law){G, S});
}
vector<int> dp(N, inf);
REP(i, N) {
if (W[i] == 1) {
dp[i] = 1;
}
}
REP(t, 100) REP(i, N) REP(j, E) {
int M = 0, m = inf;
vector<int> a(law[j].S.size());
REP(k, law[j].S.size()) {
int id = law[j].S[k];
a[k] = dp[id];
}
sort(ALL(a), greater<int>());
int c = 1;
REP(i, a.size()) { c = max(c, a[i] + (int)i); }
if (c < dp[law[j].G]) {
dp[law[j].G] = c;
}
}
if (dp[T] == inf)
cout << -1 << endl;
else
cout << dp[T] << 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<class... T>
ostream& operator<<(ostream& os, tuple<T...>& t) {
for (size_t i = 0; i < tuple_size< tuple<T...> >::value; ++i) {
if (i) os << " ";
os << get<0>(t);
}
return os;
}
*/
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;
}
struct Law {
int G;
vector<int> S;
};
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
int N, E, T;
cin >> N >> E >> T;
--T;
vector<int> W(N);
cin >> W;
vector<Law> law;
REP(i, E) {
int G, C;
cin >> G >> C;
--G;
vector<int> S(C);
cin >> S;
REP(i, C) S[i]--;
law.pb((Law){G, S});
}
vector<int> dp(N, inf);
REP(i, N) {
if (W[i] == 1) {
dp[i] = 1;
}
}
REP(i, E) REP(j, E) {
int M = 0, m = inf;
vector<int> a(law[j].S.size());
REP(k, law[j].S.size()) {
int id = law[j].S[k];
a[k] = dp[id];
}
sort(ALL(a), greater<int>());
int c = 1;
REP(i, a.size()) { c = max(c, a[i] + (int)i); }
if (c < dp[law[j].G]) {
dp[law[j].G] = c;
}
}
if (dp[T] == inf)
cout << -1 << endl;
else
cout << dp[T] << endl;
} | replace | 83 | 84 | 83 | 84 | TLE | |
p01437 | C++ | Time Limit Exceeded | #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#define all(c) (c).begin(), (c).end()
#define rep(i, n) for (int i = 0; i < (n); i++)
#define pb(e) push_back(e)
#define mp(a, b) make_pair(a, b)
#define fr first
#define sc second
const int INF = 100000000;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
using namespace std;
typedef pair<int, int> P;
typedef long long ll;
template <class T> bool chmin(T &a, T b) {
if (b < a) {
a = b;
return true;
}
return false;
}
ll H, W, L;
string maze[110];
struct State {
int dir, y, x;
ll cnt;
State(int dir, int y, int x, ll cnt) : dir(dir), y(y), x(x), cnt(cnt) {}
};
void solve(P &ans_p, int &ans_dir) {
queue<State> que;
map<char, int> dir;
dir['E'] = 0;
dir['S'] = 1;
dir['W'] = 2;
dir['N'] = 3;
ll d[4][110][110];
rep(y, 110) rep(x, 110) d[0][y][x] = d[1][y][x] = d[2][y][x] = d[3][y][x] =
INF;
rep(y, H) rep(x, W) if (maze[y][x] != '.' && maze[y][x] != '#') {
d[dir[maze[y][x]]][y][x] = 0;
que.push(State(dir[maze[y][x]], y, x, 0));
}
while (que.size()) {
State s = que.front();
que.pop();
// printf("%d %d %d : %d\n",s.dir,s.y,s.x,s.cnt);
if (L == s.cnt) {
ans_p = P(s.y, s.x);
ans_dir = s.dir;
return;
}
if (d[s.dir][s.y][s.x] != s.cnt) {
// printf("%d %d %d : %d %d\n",s.dir,s.y,s.x,s.cnt,d[s.dir][s.y][s.x]);
int diff = abs(s.cnt - d[s.dir][s.y][s.x]);
int t = (L - s.cnt) / diff;
if (t > 0 && diff > 0) {
s.cnt += (t - 1) * diff;
}
// printf("\t%d\n",s.cnt);
}
int ny = s.y + dy[s.dir];
int nx = s.x + dx[s.dir];
if (!(0 <= ny && ny < H && 0 <= nx && nx < W)) {
que.push(State((s.dir + 1) % 4, s.y, s.x, s.cnt));
chmin(d[(s.dir + 1) % 4][s.y][s.x], s.cnt);
} else {
if (maze[ny][nx] == '#') {
que.push(State((s.dir + 1) % 4, s.y, s.x, s.cnt));
chmin(d[(s.dir + 1) % 4][s.y][s.x], s.cnt);
} else {
que.push(State(s.dir, ny, nx, s.cnt + 1));
chmin(d[s.dir][ny][nx], s.cnt + 1);
}
}
}
}
int main() {
while (cin >> H >> W >> L) {
if (H == 0)
break;
rep(y, H) cin >> maze[y];
P ans;
int dir = -1;
solve(ans, dir);
if (dir == -1)
int a = 1 / 0;
char d;
if (dir == 0)
d = 'E';
if (dir == 1)
d = 'S';
if (dir == 2)
d = 'W';
if (dir == 3)
d = 'N';
printf("%d %d %c\n", ans.fr + 1, ans.sc + 1, d);
}
return 0;
} | #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#define all(c) (c).begin(), (c).end()
#define rep(i, n) for (int i = 0; i < (n); i++)
#define pb(e) push_back(e)
#define mp(a, b) make_pair(a, b)
#define fr first
#define sc second
const int INF = 100000000;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
using namespace std;
typedef pair<int, int> P;
typedef long long ll;
template <class T> bool chmin(T &a, T b) {
if (b < a) {
a = b;
return true;
}
return false;
}
ll H, W, L;
string maze[110];
struct State {
int dir, y, x;
ll cnt;
State(int dir, int y, int x, ll cnt) : dir(dir), y(y), x(x), cnt(cnt) {}
};
void solve(P &ans_p, int &ans_dir) {
queue<State> que;
map<char, int> dir;
dir['E'] = 0;
dir['S'] = 1;
dir['W'] = 2;
dir['N'] = 3;
ll d[4][110][110];
rep(y, 110) rep(x, 110) d[0][y][x] = d[1][y][x] = d[2][y][x] = d[3][y][x] =
INF;
rep(y, H) rep(x, W) if (maze[y][x] != '.' && maze[y][x] != '#') {
d[dir[maze[y][x]]][y][x] = 0;
que.push(State(dir[maze[y][x]], y, x, 0));
}
while (que.size()) {
State s = que.front();
que.pop();
// printf("%d %d %d : %d\n",s.dir,s.y,s.x,s.cnt);
if (L == s.cnt) {
ans_p = P(s.y, s.x);
ans_dir = s.dir;
return;
}
if (d[s.dir][s.y][s.x] != s.cnt) {
// printf("%d %d %d : %d %d\n",s.dir,s.y,s.x,s.cnt,d[s.dir][s.y][s.x]);
ll diff = abs(s.cnt - d[s.dir][s.y][s.x]);
ll t = (L - s.cnt) / diff;
if (t > 0 && diff > 0) {
s.cnt += (t - 1) * diff;
}
// printf("\t%d\n",s.cnt);
}
int ny = s.y + dy[s.dir];
int nx = s.x + dx[s.dir];
if (!(0 <= ny && ny < H && 0 <= nx && nx < W)) {
que.push(State((s.dir + 1) % 4, s.y, s.x, s.cnt));
chmin(d[(s.dir + 1) % 4][s.y][s.x], s.cnt);
} else {
if (maze[ny][nx] == '#') {
que.push(State((s.dir + 1) % 4, s.y, s.x, s.cnt));
chmin(d[(s.dir + 1) % 4][s.y][s.x], s.cnt);
} else {
que.push(State(s.dir, ny, nx, s.cnt + 1));
chmin(d[s.dir][ny][nx], s.cnt + 1);
}
}
}
}
int main() {
while (cin >> H >> W >> L) {
if (H == 0)
break;
rep(y, H) cin >> maze[y];
P ans;
int dir = -1;
solve(ans, dir);
if (dir == -1)
int a = 1 / 0;
char d;
if (dir == 0)
d = 'E';
if (dir == 1)
d = 'S';
if (dir == 2)
d = 'W';
if (dir == 3)
d = 'N';
printf("%d %d %c\n", ans.fr + 1, ans.sc + 1, d);
}
return 0;
} | replace | 75 | 77 | 75 | 77 | TLE | |
p01437 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cassert>
#include <cctype>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
inline int toInt(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();
}
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef long long ll;
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define FOR(i, a, b) for (int i = (a); i <= (b); ++i)
#define REP(i, n) FOR(i, 0, (n)-1)
const double EPS = 1e-10;
const double PI = acos(-1.0);
const int INF = INT_MAX / 10;
int dy[] = {-1, 0, 1, 0};
int dx[] = {0, 1, 0, -1};
char dd[] = {'N', 'E', 'S', 'W'};
typedef vector<ll> vl;
typedef vector<vl> vvl;
int main() {
ll H, W, L;
while (cin >> H >> W >> L, H) {
vs field(H);
REP(i, H) { cin >> field[i]; }
int cx, cy, cd;
REP(i, H) {
REP(j, W) {
if (field[i][j] != '.' && field[i][j] != '#') {
cx = j;
cy = i;
switch (field[i][j]) {
case 'N':
cd = 0;
break;
case 'E':
cd = 1;
break;
case 'S':
cd = 2;
break;
case 'W':
cd = 3;
break;
}
break;
}
}
}
vector<vvl> turn(H, vvl(W, vl(4)));
bool looped = false;
for (ll t = 0; t < L; t++) {
if (!looped && turn[cy][cx][cd] != 0) {
looped = true;
ll cycle = (t - turn[cy][cx][cd] - 1);
t += (L - t) / cycle;
}
int nx = cx + dx[cd];
int ny = cy + dy[cd];
if (ny < 0 || H <= ny || nx < 0 || W <= nx || field[ny][nx] == '#') {
cd = (cd + 1) % 4;
t--;
continue;
}
turn[cy][cx][cd] = t;
cy = ny;
cx = nx;
}
cout << cy + 1 << " " << cx + 1 << " " << dd[cd] << endl;
}
return 0;
} | #include <algorithm>
#include <cassert>
#include <cctype>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
inline int toInt(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();
}
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef long long ll;
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define FOR(i, a, b) for (int i = (a); i <= (b); ++i)
#define REP(i, n) FOR(i, 0, (n)-1)
const double EPS = 1e-10;
const double PI = acos(-1.0);
const int INF = INT_MAX / 10;
int dy[] = {-1, 0, 1, 0};
int dx[] = {0, 1, 0, -1};
char dd[] = {'N', 'E', 'S', 'W'};
typedef vector<ll> vl;
typedef vector<vl> vvl;
int main() {
ll H, W, L;
while (cin >> H >> W >> L, H) {
vs field(H);
REP(i, H) { cin >> field[i]; }
int cx, cy, cd;
REP(i, H) {
REP(j, W) {
if (field[i][j] != '.' && field[i][j] != '#') {
cx = j;
cy = i;
switch (field[i][j]) {
case 'N':
cd = 0;
break;
case 'E':
cd = 1;
break;
case 'S':
cd = 2;
break;
case 'W':
cd = 3;
break;
}
break;
}
}
}
vector<vvl> turn(H, vvl(W, vl(4)));
bool looped = false;
for (ll t = 0; t < L; t++) {
if (!looped && turn[cy][cx][cd] != 0) {
looped = true;
ll cycle = (t - turn[cy][cx][cd]);
t += ((L - t) / cycle) * cycle;
if (t == L) {
t -= cycle;
}
}
int nx = cx + dx[cd];
int ny = cy + dy[cd];
if (ny < 0 || H <= ny || nx < 0 || W <= nx || field[ny][nx] == '#') {
cd = (cd + 1) % 4;
t--;
continue;
}
turn[cy][cx][cd] = t;
cy = ny;
cx = nx;
}
cout << cy + 1 << " " << cx + 1 << " " << dd[cd] << endl;
}
return 0;
} | replace | 89 | 91 | 89 | 94 | TLE | |
p01437 | C++ | Time Limit Exceeded | #include <algorithm>
#include <array>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
// BEGIN CUT HERE
#ifdef _MSC_VER
#include <agents.h>
#endif
// END CUT HERE
#define FOR(i, a, b) for (int i = (a); i < (int)(b); ++i)
#define rep(i, n) FOR(i, 0, n)
#define ALL(v) begin(v), end(v)
#define REV(v) rbegin(v), rend(v)
#define MEMSET(v, s) memset(v, s, sizeof(v))
#define MP make_pair
#define MT make_tuple
#define X first
#define Y second
using namespace std;
typedef pair<int, int> P;
typedef long long ll;
int dist[110][110][4];
char v[110][110];
const int dx[] = {0, 1, 0, -1};
const int dy[] = {-1, 0, 1, 0};
int main() {
int n, m, L;
while (cin >> n >> m >> L, n) {
MEMSET(v, 0);
FOR(i, 1, n + 1) FOR(j, 1, m + 1) cin >> v[i][j];
int r, c, d;
FOR(i, 1, n + 1) FOR(j, 1, m + 1) {
if (v[i][j] != '.' && v[i][j] != '#') {
rep(dir, 4) if (v[i][j] == "NESW"[dir]) tie(r, c, d) = MT(i, j, dir);
v[i][j] = '.';
}
}
MEMSET(dist, -1);
int x = 0;
dist[r][c][d] = x++;
bool loop = true;
while (L) {
while (v[r + dy[d]][c + dx[d]] != '.')
d = (d + 1) % 4;
r += dy[d], c += dx[d];
L--;
if (loop && dist[r][c][d] >= 0)
L %= (x - dist[r][c][d]), loop = false;
dist[r][c][d] = x++;
// for (int i = 1; i <= n; ++i){
// for (int j = 1; j <= m; ++j){
// cout << (MP(i, j) == MP(r, c) ? "NESW"[d] : v[i][j]);
// }cout << '\n';
// }cout << '\n';
}
cout << r << ' ' << c << ' ' << "NESW"[d] << '\n';
}
return 0;
} | #include <algorithm>
#include <array>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
// BEGIN CUT HERE
#ifdef _MSC_VER
#include <agents.h>
#endif
// END CUT HERE
#define FOR(i, a, b) for (int i = (a); i < (int)(b); ++i)
#define rep(i, n) FOR(i, 0, n)
#define ALL(v) begin(v), end(v)
#define REV(v) rbegin(v), rend(v)
#define MEMSET(v, s) memset(v, s, sizeof(v))
#define MP make_pair
#define MT make_tuple
#define X first
#define Y second
using namespace std;
typedef pair<int, int> P;
typedef long long ll;
int dist[110][110][4];
char v[110][110];
const int dx[] = {0, 1, 0, -1};
const int dy[] = {-1, 0, 1, 0};
int main() {
ll n, m, L;
while (cin >> n >> m >> L, n) {
MEMSET(v, 0);
FOR(i, 1, n + 1) FOR(j, 1, m + 1) cin >> v[i][j];
int r, c, d;
FOR(i, 1, n + 1) FOR(j, 1, m + 1) {
if (v[i][j] != '.' && v[i][j] != '#') {
rep(dir, 4) if (v[i][j] == "NESW"[dir]) tie(r, c, d) = MT(i, j, dir);
v[i][j] = '.';
}
}
MEMSET(dist, -1);
int x = 0;
dist[r][c][d] = x++;
bool loop = true;
while (L) {
while (v[r + dy[d]][c + dx[d]] != '.')
d = (d + 1) % 4;
r += dy[d], c += dx[d];
L--;
if (loop && dist[r][c][d] >= 0)
L %= (x - dist[r][c][d]), loop = false;
dist[r][c][d] = x++;
// for (int i = 1; i <= n; ++i){
// for (int j = 1; j <= m; ++j){
// cout << (MP(i, j) == MP(r, c) ? "NESW"[d] : v[i][j]);
// }cout << '\n';
// }cout << '\n';
}
cout << r << ' ' << c << ' ' << "NESW"[d] << '\n';
}
return 0;
} | replace | 46 | 47 | 46 | 47 | TLE | |
p01437 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cassert>
#include <cctype>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
inline int toInt(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();
}
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef long long ll;
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define EXIST(s, e) ((s).find(e) != (s).end())
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
const double EPS = 1e-9;
const double PI = acos(-1.0);
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<vvl> vvvl;
struct node {
int y, x, dir;
ll cost;
node(int y, int x, int dir, ll cost) : y(y), x(x), cost(cost), dir(dir) {}
};
int dx[] = {-1, 0, 1, 0}, dy[] = {0, -1, 0, 1};
char dirs[] = {'W', 'N', 'E', 'S'};
const ll MAX = LONG_MAX;
int main() {
int h, w, l;
while (cin >> h >> w >> l, h | w | l) {
vs c(h);
pii start;
int initdir;
REP(i, h) {
cin >> c[i];
REP(j, w) {
switch (c[i][j]) {
case 'W':
start = make_pair(i, j);
initdir = 0;
break;
case 'N':
start = make_pair(i, j);
initdir = 1;
break;
case 'E':
start = make_pair(i, j);
initdir = 2;
break;
case 'S':
start = make_pair(i, j);
initdir = 3;
break;
}
}
}
vvvl cost(h, vvl(w, vl(4, MAX)));
queue<node> q;
cost[start.first][start.second][initdir] = l;
q.push(node(start.first, start.second, initdir, l));
while (!q.empty()) {
node cnode = q.front();
q.pop();
if (cnode.cost == 0) {
cout << cnode.y + 1 << " " << cnode.x + 1 << " " << dirs[cnode.dir]
<< endl;
break;
}
int d = cnode.dir;
int y = cnode.y + dy[d];
int x = cnode.x + dx[d];
while (!(y >= 0 && x >= 0 && y < h && x < w && c[y][x] != '#')) {
d = (d + 1) % 4;
y = cnode.y + dy[d];
x = cnode.x + dx[d];
}
if (cost[y][x][d] != MAX) {
ll diff = cost[y][x][d] - (cnode.cost - 1);
cost[y][x][d] = (cnode.cost - 1) % diff;
q.push(node(y, x, d, (cnode.cost - 1) % diff));
} else {
cost[y][x][d] = cnode.cost - 1;
q.push(node(y, x, d, cnode.cost - 1));
}
}
}
} | #include <algorithm>
#include <cassert>
#include <cctype>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
inline int toInt(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();
}
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef long long ll;
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define EXIST(s, e) ((s).find(e) != (s).end())
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
const double EPS = 1e-9;
const double PI = acos(-1.0);
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<vvl> vvvl;
struct node {
int y, x, dir;
ll cost;
node(int y, int x, int dir, ll cost) : y(y), x(x), cost(cost), dir(dir) {}
};
int dx[] = {-1, 0, 1, 0}, dy[] = {0, -1, 0, 1};
char dirs[] = {'W', 'N', 'E', 'S'};
const ll MAX = LONG_MAX;
int main() {
int h, w;
ll l;
while (cin >> h >> w >> l, h | w | l) {
vs c(h);
pii start;
int initdir;
REP(i, h) {
cin >> c[i];
REP(j, w) {
switch (c[i][j]) {
case 'W':
start = make_pair(i, j);
initdir = 0;
break;
case 'N':
start = make_pair(i, j);
initdir = 1;
break;
case 'E':
start = make_pair(i, j);
initdir = 2;
break;
case 'S':
start = make_pair(i, j);
initdir = 3;
break;
}
}
}
vvvl cost(h, vvl(w, vl(4, MAX)));
queue<node> q;
cost[start.first][start.second][initdir] = l;
q.push(node(start.first, start.second, initdir, l));
while (!q.empty()) {
node cnode = q.front();
q.pop();
if (cnode.cost == 0) {
cout << cnode.y + 1 << " " << cnode.x + 1 << " " << dirs[cnode.dir]
<< endl;
break;
}
int d = cnode.dir;
int y = cnode.y + dy[d];
int x = cnode.x + dx[d];
while (!(y >= 0 && x >= 0 && y < h && x < w && c[y][x] != '#')) {
d = (d + 1) % 4;
y = cnode.y + dy[d];
x = cnode.x + dx[d];
}
if (cost[y][x][d] != MAX) {
ll diff = cost[y][x][d] - (cnode.cost - 1);
cost[y][x][d] = (cnode.cost - 1) % diff;
q.push(node(y, x, d, (cnode.cost - 1) % diff));
} else {
cost[y][x][d] = cnode.cost - 1;
q.push(node(y, x, d, cnode.cost - 1));
}
}
}
} | replace | 58 | 59 | 58 | 60 | TLE | |
p01437 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};
int todir[256];
char tochr[4];
int h, w;
long long l;
string c[110];
int vis[110][110][4];
int main() {
for (int i = 0; i < 4; i++) {
todir["NESW"[i]] = i;
tochr[i] = "NESW"[i];
}
while (cin >> h >> w >> l, h) {
memset(vis, -1, sizeof(vis));
c[0] = c[h + 1] = string(w + 2, '#');
for (int i = 1; i <= h; i++) {
cin >> c[i];
c[i] = "#" + c[i] + "#";
}
int x, y, dir;
for (int i = 1; i <= h; i++) {
for (int j = 1; j <= w; j++) {
if (c[i][j] != '.' && c[i][j] != '#') {
x = i;
y = j;
dir = todir[c[i][j]];
c[i][j] = '.';
}
}
}
for (long long t = 0; t < l; t++) {
while (true) {
int nx = x + dx[dir];
int ny = y + dy[dir];
if (c[nx][ny] == '.')
break;
dir = (dir + 1) % 4;
}
if (~vis[x][y][dir]) {
t += (l - t - 1) / (t - vis[x][y][dir]) * (t - vis[x][y][dir]);
}
x += dx[dir];
y += dy[dir];
}
cout << x << " " << y << " " << tochr[dir] << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};
int todir[256];
char tochr[4];
int h, w;
long long l;
string c[110];
int vis[110][110][4];
int main() {
for (int i = 0; i < 4; i++) {
todir["NESW"[i]] = i;
tochr[i] = "NESW"[i];
}
while (cin >> h >> w >> l, h) {
memset(vis, -1, sizeof(vis));
c[0] = c[h + 1] = string(w + 2, '#');
for (int i = 1; i <= h; i++) {
cin >> c[i];
c[i] = "#" + c[i] + "#";
}
int x, y, dir;
for (int i = 1; i <= h; i++) {
for (int j = 1; j <= w; j++) {
if (c[i][j] != '.' && c[i][j] != '#') {
x = i;
y = j;
dir = todir[c[i][j]];
c[i][j] = '.';
}
}
}
for (long long t = 0; t < l; t++) {
while (true) {
int nx = x + dx[dir];
int ny = y + dy[dir];
if (c[nx][ny] == '.')
break;
dir = (dir + 1) % 4;
}
if (~vis[x][y][dir]) {
t += (l - t - 1) / (t - vis[x][y][dir]) * (t - vis[x][y][dir]);
} else
vis[x][y][dir] = t;
x += dx[dir];
y += dy[dir];
}
cout << x << " " << y << " " << tochr[dir] << endl;
}
} | replace | 48 | 49 | 48 | 50 | TLE | |
p01437 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define ALL(c) c.begin(), c.end()
#define RALL(c) c.rbegin(), c.rend()
#define SORT(x) sort((x).begin(), (x).end())
#define REP(i, x, y) for (int i = (x); i < (y); ++i)
#define MP(a, b) make_pair((a), (b))
#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 INF_ = 1LL << 58;
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;
}
struct State {
int y, x, dir;
};
void Solve() {
while (true) {
ll h, w, l;
cin >> h >> w >> l;
if (h == 0 && w == 0 && l == 0)
break;
vector<string> cells(h);
REP(i, 0, h) cin >> cells[i];
const char empty = '.', wall = '#';
const int north = 0, east = 1, south = 2, west = 3;
int y, x, dir;
REP(i, 0, h) REP(j, 0, w) if (cells[i][j] != empty && cells[i][j] != wall) {
y = i;
x = j;
switch (cells[i][j]) {
case 'N':
dir = north;
break;
case 'E':
dir = east;
break;
case 'S':
dir = south;
break;
case 'W':
dir = west;
break;
default:
break;
}
cells[i][j] = empty;
break;
}
int rotate[4];
REP(i, 0, 4) rotate[i] = (i + 1) % 4;
// State memo[100][100][4];
// REP(i,0,h) REP(j,0,w) REP(k,0,4){
// int y_=i,x_=j;
// int ny=y_+dy[k],nx=x_+dx[k];
// while(0<=ny&&ny<h&&0<=nx&&nx<w&&cells[ny][nx]==empty){
// y_=ny; x_=nx;
// ny=y_+dy[k]; nx=x_+dx[k];
//}
// memo[i][j][k]={y_,x_,rotate[k]};
//}
const int dx[] = {0, 1, 0, -1}, dy[] = {-1, 0, 1, 0};
ll visited[100][100][4];
fill_n((ll *)visited, 100 * 100 * 4, -1);
ll cnt = 0;
while (cnt < l) {
dump(y);
dump(x);
if (visited[y][x][dir] == -1)
visited[y][x][dir] = cnt;
else {
ll tmp = 0;
while (cnt + tmp + cnt - visited[y][x][dir] <= l)
tmp += (cnt - visited[y][x][dir]);
cnt += tmp;
if (cnt == l)
break;
}
int ny = y + dy[dir], nx = x + dx[dir];
while (
!(0 <= ny && ny < h && 0 <= nx && nx < w && cells[ny][nx] == empty)) {
dir = rotate[dir];
ny = y + dy[dir];
nx = x + dx[dir];
}
y = ny;
x = nx;
++cnt;
}
cout << y + 1 << ' ' << x + 1 << ' ' << "NESW"[dir] << endl;
}
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
Solve();
return 0;
} | #include <algorithm>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define ALL(c) c.begin(), c.end()
#define RALL(c) c.rbegin(), c.rend()
#define SORT(x) sort((x).begin(), (x).end())
#define REP(i, x, y) for (int i = (x); i < (y); ++i)
#define MP(a, b) make_pair((a), (b))
#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 INF_ = 1LL << 58;
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;
}
struct State {
int y, x, dir;
};
void Solve() {
while (true) {
ll h, w, l;
cin >> h >> w >> l;
if (h == 0 && w == 0 && l == 0)
break;
vector<string> cells(h);
REP(i, 0, h) cin >> cells[i];
const char empty = '.', wall = '#';
const int north = 0, east = 1, south = 2, west = 3;
int y, x, dir;
REP(i, 0, h) REP(j, 0, w) if (cells[i][j] != empty && cells[i][j] != wall) {
y = i;
x = j;
switch (cells[i][j]) {
case 'N':
dir = north;
break;
case 'E':
dir = east;
break;
case 'S':
dir = south;
break;
case 'W':
dir = west;
break;
default:
break;
}
cells[i][j] = empty;
break;
}
int rotate[4];
REP(i, 0, 4) rotate[i] = (i + 1) % 4;
// State memo[100][100][4];
// REP(i,0,h) REP(j,0,w) REP(k,0,4){
// int y_=i,x_=j;
// int ny=y_+dy[k],nx=x_+dx[k];
// while(0<=ny&&ny<h&&0<=nx&&nx<w&&cells[ny][nx]==empty){
// y_=ny; x_=nx;
// ny=y_+dy[k]; nx=x_+dx[k];
//}
// memo[i][j][k]={y_,x_,rotate[k]};
//}
const int dx[] = {0, 1, 0, -1}, dy[] = {-1, 0, 1, 0};
ll visited[100][100][4];
fill_n((ll *)visited, 100 * 100 * 4, -1);
ll cnt = 0;
while (cnt < l) {
dump(y);
dump(x);
if (visited[y][x][dir] == -1)
visited[y][x][dir] = cnt;
else {
cnt += ((l - cnt) / (cnt - visited[y][x][dir])) *
(cnt - visited[y][x][dir]);
if (cnt == l)
break;
}
int ny = y + dy[dir], nx = x + dx[dir];
while (
!(0 <= ny && ny < h && 0 <= nx && nx < w && cells[ny][nx] == empty)) {
dir = rotate[dir];
ny = y + dy[dir];
nx = x + dx[dir];
}
y = ny;
x = nx;
++cnt;
}
cout << y + 1 << ' ' << x + 1 << ' ' << "NESW"[dir] << endl;
}
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
Solve();
return 0;
} | replace | 110 | 114 | 110 | 112 | TLE | |
p01437 | C++ | Time Limit Exceeded | // 11
#include <algorithm>
#include <iostream>
using namespace std;
int main() {
for (long long h, w, l; cin >> h >> w >> l, h | w | l;) {
bool s[102][102] = {};
int x, y, d;
string ds = "NESW";
for (int i = 1; i <= h; i++) {
for (int j = 1; j <= w; j++) {
char c;
cin >> c;
s[i][j] = c != '#';
if (c != '#' && c != '.') {
x = j;
y = i;
d = ds.find(c);
}
}
}
long long p[102][102][4];
fill(p[0][0], p[102][0], -1);
while (l) {
int dx[] = {0, 1, 0, -1};
int dy[] = {-1, 0, 1, 0};
for (;;) {
if (p[y][x][d] != -1) {
int m = p[y][x][d] - l;
if (l > m) {
l = l % m + m;
}
}
p[y][x][d] = l;
if (s[y + dy[d]][x + dx[d]])
break;
d = (d + 1) % 4;
}
y += dy[d];
x += dx[d];
l--;
}
end:
cout << y << ' ' << x << ' ' << ds[d] << endl;
}
return 0;
} | // 11
#include <algorithm>
#include <iostream>
using namespace std;
int main() {
for (long long h, w, l; cin >> h >> w >> l, h | w | l;) {
bool s[102][102] = {};
int x, y, d;
string ds = "NESW";
for (int i = 1; i <= h; i++) {
for (int j = 1; j <= w; j++) {
char c;
cin >> c;
s[i][j] = c != '#';
if (c != '#' && c != '.') {
x = j;
y = i;
d = ds.find(c);
}
}
}
long long p[102][102][4];
fill(p[0][0], p[102][0], -1);
while (l) {
int dx[] = {0, 1, 0, -1};
int dy[] = {-1, 0, 1, 0};
for (;;) {
if (p[y][x][d] != -1) {
long long m = p[y][x][d] - l;
if (l > m) {
l = l % m + m;
}
}
p[y][x][d] = l;
if (s[y + dy[d]][x + dx[d]])
break;
d = (d + 1) % 4;
}
y += dy[d];
x += dx[d];
l--;
}
end:
cout << y << ' ' << x << ' ' << ds[d] << endl;
}
return 0;
} | replace | 30 | 31 | 30 | 31 | TLE | |
p01438 | C++ | Memory Limit Exceeded | // #define __USE_MINGW_ANSI_STDIO 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 IN(a, b, x) (a <= x && x < b)
#define MP make_pair
#define PB push_back
#define INF (1LL << 30)
#define LLINF (1LL << 60)
#define PI 3.14159265359
#define EPS 1e-12
#define int ll
template <typename T> T &chmin(T &a, const T &b) { return a = min(a, b); }
template <typename T> T &chmax(T &a, const T &b) { return a = max(a, b); }
int dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0};
int t[105], val[105], dp[1 << 17][105];
signed main(void) {
while (true) {
int n;
cin >> n;
if (!n)
break;
REP(i, n) {
int m, l;
cin >> m >> l;
val[i] = l;
t[i] = 0;
REP(j, m) {
int s, e;
cin >> s >> e;
FOR(k, s, e) t[i] |= 1 << (k - 6);
}
}
memset(dp, -1, sizeof(dp));
dp[0][0] = 0;
REP(i, n) {
REP(j, 1 << 16) {
if (dp[j][i] < 0)
continue;
// cout << i << " " << bitset<16>(j) << endl;
dp[j][i + 1] = max(dp[j][i + 1], dp[j][i]);
// t[i] ??? j ???????????????????????????
bool flag = true;
REP(k, 16) {
if (((t[i] >> k) & 1) && ((j >> k) & 1)) {
flag = false;
// cout << "false" << k << endl;
}
}
// cout << flag << endl;
if (flag) {
// cout << bitset<16>(j|t[i]) << " " << dp[j|t[i]][i+1] << " " <<
// dp[j][i] + val[i] << endl;
dp[j | t[i]][i + 1] = max(dp[j | t[i]][i + 1], dp[j][i] + val[i]);
}
}
}
ll ret = 0;
REP(i, 1 << 16) chmax(ret, dp[i][n]);
cout << ret << endl;
}
return 0;
} | // #define __USE_MINGW_ANSI_STDIO 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 IN(a, b, x) (a <= x && x < b)
#define MP make_pair
#define PB push_back
#define INF (1LL << 30)
#define LLINF (1LL << 60)
#define PI 3.14159265359
#define EPS 1e-12
#define int ll
template <typename T> T &chmin(T &a, const T &b) { return a = min(a, b); }
template <typename T> T &chmax(T &a, const T &b) { return a = max(a, b); }
int dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0};
int t[105], val[105], dp[1 << 16][105];
signed main(void) {
while (true) {
int n;
cin >> n;
if (!n)
break;
REP(i, n) {
int m, l;
cin >> m >> l;
val[i] = l;
t[i] = 0;
REP(j, m) {
int s, e;
cin >> s >> e;
FOR(k, s, e) t[i] |= 1 << (k - 6);
}
}
memset(dp, -1, sizeof(dp));
dp[0][0] = 0;
REP(i, n) {
REP(j, 1 << 16) {
if (dp[j][i] < 0)
continue;
// cout << i << " " << bitset<16>(j) << endl;
dp[j][i + 1] = max(dp[j][i + 1], dp[j][i]);
// t[i] ??? j ???????????????????????????
bool flag = true;
REP(k, 16) {
if (((t[i] >> k) & 1) && ((j >> k) & 1)) {
flag = false;
// cout << "false" << k << endl;
}
}
// cout << flag << endl;
if (flag) {
// cout << bitset<16>(j|t[i]) << " " << dp[j|t[i]][i+1] << " " <<
// dp[j][i] + val[i] << endl;
dp[j | t[i]][i + 1] = max(dp[j | t[i]][i + 1], dp[j][i] + val[i]);
}
}
}
ll ret = 0;
REP(i, 1 << 16) chmax(ret, dp[i][n]);
cout << ret << endl;
}
return 0;
} | replace | 28 | 29 | 28 | 29 | MLE | |
p01438 | C++ | Runtime Error | // Header {{{
// includes {{{
#include <algorithm>
#include <cassert>
#include <cctype>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iostream>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <sys/time.h>
#include <unistd.h>
#include <vector>
// }}}
using namespace std;
// consts {{{
static const int INF = 1e9;
static const double PI = acos(-1.0);
static const double EPS = 1e-10;
// }}}
// typedefs {{{
typedef long long int LL;
typedef unsigned long long int ULL;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
typedef vector<ULL> VULL;
typedef vector<VULL> VVULL;
typedef vector<double> VD;
typedef vector<VD> VVD;
typedef vector<bool> VB;
typedef vector<VB> VVB;
typedef vector<char> VC;
typedef vector<VC> VVC;
typedef vector<string> VS;
typedef vector<VS> VVS;
typedef pair<int, int> PII;
typedef complex<int> P;
// }}}
// macros & inline functions {{{
// syntax sugars {{{
#define FOR(i, b, e) for (typeof(e) i = (b); i < (e); ++i)
#define FORI(i, b, e) for (typeof(e) i = (b); i <= (e); ++i)
#define REP(i, n) FOR(i, 0, n)
#define REPI(i, n) FORI(i, 0, n)
#define OPOVER(_op, _type) inline bool operator _op(const _type &t) const
// }}}
// conversion {{{
inline int toInt(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();
}
// }}}
// array and STL {{{
#define ARRSIZE(a) (sizeof(a) / sizeof(a[0]))
#define ZERO(a, v) (assert(v == 0 || v == -1), memset(a, v, sizeof(a)))
#define F first
#define S second
#define MP(a, b) make_pair(a, b)
#define SIZE(a) ((LL)a.size())
#define PB(e) push_back(e)
#define SORT(v) sort((v).begin(), (v).end())
#define RSORT(v) sort((v).rbegin(), (v).rend())
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define EACH(c, it) \
for (typeof((c).begin()) it = (c).begin(); it != (c).end(); ++it)
#define REACH(c, it) \
for (typeof((c).rbegin()) it = (c).rbegin(); it != (c).rend(); ++it)
#define EXIST(s, e) ((s).find(e) != (s).end())
// }}}
// bit manipulation {{{
// singed integers are not for bitwise operations, specifically arithmetic
// shifts ('>>', and maybe not good for '<<' too)
#define IS_UNSIGNED(n) (!numeric_limits<typeof(n)>::is_signed)
#define BIT(n) (assert(IS_UNSIGNED(n)), assert(n < 64), (1ULL << (n)))
#define BITOF(n, m) \
(assert(IS_UNSIGNED(n)), assert(m < 64), ((ULL)(n) >> (m)&1))
inline int BITS_COUNT(ULL b) {
int c = 0;
while (b != 0) {
c += (b & 1);
b >>= 1;
}
return c;
}
inline int MSB(ULL b) {
int c = 0;
while (b != 0) {
++c;
b >>= 1;
}
return c - 1;
}
inline int MAKE_MASK(ULL upper, ULL lower) {
assert(lower < 64 && upper < 64 && lower <= upper);
return (BIT(upper) - 1) ^ (BIT(lower) - 1);
}
// }}}
// for readable code {{{
#define EVEN(n) (n % 2 == 0)
#define ODD(n) (!EVEN(n))
// }}}
// debug {{{
#define arrsz(a) (sizeof(a) / sizeof(a[0]))
#define dprt(fmt, ...) \
if (opt_debug) { \
fprintf(stderr, fmt, ##__VA_ARGS__); \
}
#define darr(a) \
if (opt_debug) { \
copy((a), (a) + arrsz(a), ostream_iterator<int>(cerr, " ")); \
cerr << endl; \
}
#define darr_range(a, f, t) \
if (opt_debug) { \
copy((a) + (f), (a) + (t), ostream_iterator<int>(cerr, " ")); \
cerr << endl; \
}
#define dvec(v) \
if (opt_debug) { \
copy(ALL(v), ostream_iterator<int>(cerr, " ")); \
cerr << endl; \
}
#define darr2(a) \
if (opt_debug) { \
FOR(__i, 0, (arrsz(a))) { darr((a)[__i]); } \
}
#define WAIT() \
if (opt_debug) { \
string _wait_; \
cerr << "(hit return to continue)" << endl; \
getline(cin, _wait_); \
}
#define dump(x) \
if (opt_debug) { \
cerr << " [L" << __LINE__ << "] " << #x << " = " << (x) << endl; \
}
#define dumpl(x) \
if (opt_debug) { \
cerr << " [L" << __LINE__ << "] " << #x << endl << (x) << endl; \
}
#define dumpf() \
if (opt_debug) { \
cerr << __PRETTY_FUNCTION__ << endl; \
}
#define where() \
if (opt_debug) { \
cerr << __FILE__ << ": " << __PRETTY_FUNCTION__ << " [L: " << __LINE__ \
<< "]" << endl; \
}
#define show_bits(b, s) \
if (opt_debug) { \
REP(i, s) { \
cerr << BITOF(b, s - 1 - i); \
if (i % 4 == 3) \
cerr << ' '; \
} \
cerr << endl; \
}
// ostreams {{{
// complex
template <typename T> ostream &operator<<(ostream &s, const complex<T> &d) {
return s << "(" << d.real() << ", " << d.imag() << ")";
}
// pair
template <typename T1, typename T2>
ostream &operator<<(ostream &s, const pair<T1, T2> &d) {
return s << "(" << d.first << ", " << d.second << ")";
}
// vector
template <typename T> ostream &operator<<(ostream &s, const vector<T> &d) {
int len = d.size();
REP(i, len) {
s << d[i];
if (i < len - 1)
s << "\t";
}
return s;
}
// 2 dimentional vector
template <typename T>
ostream &operator<<(ostream &s, const vector<vector<T>> &d) {
int len = d.size();
REP(i, len) { s << d[i] << endl; }
return s;
}
// map
template <typename T1, typename T2>
ostream &operator<<(ostream &s, const map<T1, T2> &m) {
s << "{" << endl;
for (typeof(m.begin()) itr = m.begin(); itr != m.end(); ++itr) {
s << "\t" << (*itr).first << " : " << (*itr).second << endl;
}
s << "}" << endl;
return s;
}
// }}}
// }}}
// }}}
// time {{{
inline double now() {
struct timeval tv;
gettimeofday(&tv, NULL);
return (static_cast<double>(tv.tv_sec) +
static_cast<double>(tv.tv_usec) * 1e-6);
}
// }}}
// string manipulation {{{
inline VS split(string s, char delimiter) {
VS v;
string t;
REP(i, s.length()) {
if (s[i] == delimiter)
v.PB(t), t = "";
else
t += s[i];
}
v.PB(t);
return v;
}
inline string join(VS s, string j) {
string t;
REP(i, s.size()) { t += s[i] + j; }
return t;
}
// }}}
// geometry {{{
#define Y real()
#define X imag()
// }}}
// 2 dimentional array {{{
P dydx4[4] = {P(-1, 0), P(0, 1), P(1, 0), P(0, -1)};
P dydx8[8] = {P(-1, 0), P(0, 1), P(1, 0), P(0, -1),
P(-1, 1), P(1, 1), P(1, -1), P(-1, -1)};
int g_height, g_width;
bool in_field(P p) {
return (0 <= p.Y && p.Y < g_height) && (0 <= p.X && p.X < g_width);
}
// }}}
// input and output {{{
inline void input(string filename) { freopen(filename.c_str(), "r", stdin); }
inline void output(string filename) { freopen(filename.c_str(), "w", stdout); }
// }}}
// }}}
bool opt_debug = false;
int main(int argc, char **argv) {
std::ios_base::sync_with_stdio(false);
// set options {{{
int __c;
while ((__c = getopt(argc, argv, "d")) != -1) {
switch (__c) {
case 'd':
opt_debug = true;
break;
default:
abort();
}
}
// }}}
input("./inputs/0.txt");
// output("./outputs/0.txt");
int N;
while (cin >> N, N) {
VI satisfactions(N);
VULL guys(N, 0);
REP(i, N) {
int M;
cin >> M >> satisfactions[i];
REP(j, M) {
int S, E;
cin >> S >> E;
S -= 6;
E -= 6;
guys[i] |= (1 << E) - (1 << S);
}
}
VI dp(1 << 17, 0);
REP(i, N) {
for (ULL bit = 0; bit < 1 << 17; ++bit) {
if ((guys[i] & bit) == 0) {
dp[guys[i] | bit] =
max(dp[guys[i] | bit], dp[bit] + satisfactions[i]);
}
}
}
int ans = 0;
REP(bit, 1 << 17) { ans = max(ans, dp[bit]); }
cout << ans << endl;
}
return 0;
}
// vim: foldmethod=marker | // Header {{{
// includes {{{
#include <algorithm>
#include <cassert>
#include <cctype>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iostream>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <sys/time.h>
#include <unistd.h>
#include <vector>
// }}}
using namespace std;
// consts {{{
static const int INF = 1e9;
static const double PI = acos(-1.0);
static const double EPS = 1e-10;
// }}}
// typedefs {{{
typedef long long int LL;
typedef unsigned long long int ULL;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
typedef vector<ULL> VULL;
typedef vector<VULL> VVULL;
typedef vector<double> VD;
typedef vector<VD> VVD;
typedef vector<bool> VB;
typedef vector<VB> VVB;
typedef vector<char> VC;
typedef vector<VC> VVC;
typedef vector<string> VS;
typedef vector<VS> VVS;
typedef pair<int, int> PII;
typedef complex<int> P;
// }}}
// macros & inline functions {{{
// syntax sugars {{{
#define FOR(i, b, e) for (typeof(e) i = (b); i < (e); ++i)
#define FORI(i, b, e) for (typeof(e) i = (b); i <= (e); ++i)
#define REP(i, n) FOR(i, 0, n)
#define REPI(i, n) FORI(i, 0, n)
#define OPOVER(_op, _type) inline bool operator _op(const _type &t) const
// }}}
// conversion {{{
inline int toInt(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();
}
// }}}
// array and STL {{{
#define ARRSIZE(a) (sizeof(a) / sizeof(a[0]))
#define ZERO(a, v) (assert(v == 0 || v == -1), memset(a, v, sizeof(a)))
#define F first
#define S second
#define MP(a, b) make_pair(a, b)
#define SIZE(a) ((LL)a.size())
#define PB(e) push_back(e)
#define SORT(v) sort((v).begin(), (v).end())
#define RSORT(v) sort((v).rbegin(), (v).rend())
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define EACH(c, it) \
for (typeof((c).begin()) it = (c).begin(); it != (c).end(); ++it)
#define REACH(c, it) \
for (typeof((c).rbegin()) it = (c).rbegin(); it != (c).rend(); ++it)
#define EXIST(s, e) ((s).find(e) != (s).end())
// }}}
// bit manipulation {{{
// singed integers are not for bitwise operations, specifically arithmetic
// shifts ('>>', and maybe not good for '<<' too)
#define IS_UNSIGNED(n) (!numeric_limits<typeof(n)>::is_signed)
#define BIT(n) (assert(IS_UNSIGNED(n)), assert(n < 64), (1ULL << (n)))
#define BITOF(n, m) \
(assert(IS_UNSIGNED(n)), assert(m < 64), ((ULL)(n) >> (m)&1))
inline int BITS_COUNT(ULL b) {
int c = 0;
while (b != 0) {
c += (b & 1);
b >>= 1;
}
return c;
}
inline int MSB(ULL b) {
int c = 0;
while (b != 0) {
++c;
b >>= 1;
}
return c - 1;
}
inline int MAKE_MASK(ULL upper, ULL lower) {
assert(lower < 64 && upper < 64 && lower <= upper);
return (BIT(upper) - 1) ^ (BIT(lower) - 1);
}
// }}}
// for readable code {{{
#define EVEN(n) (n % 2 == 0)
#define ODD(n) (!EVEN(n))
// }}}
// debug {{{
#define arrsz(a) (sizeof(a) / sizeof(a[0]))
#define dprt(fmt, ...) \
if (opt_debug) { \
fprintf(stderr, fmt, ##__VA_ARGS__); \
}
#define darr(a) \
if (opt_debug) { \
copy((a), (a) + arrsz(a), ostream_iterator<int>(cerr, " ")); \
cerr << endl; \
}
#define darr_range(a, f, t) \
if (opt_debug) { \
copy((a) + (f), (a) + (t), ostream_iterator<int>(cerr, " ")); \
cerr << endl; \
}
#define dvec(v) \
if (opt_debug) { \
copy(ALL(v), ostream_iterator<int>(cerr, " ")); \
cerr << endl; \
}
#define darr2(a) \
if (opt_debug) { \
FOR(__i, 0, (arrsz(a))) { darr((a)[__i]); } \
}
#define WAIT() \
if (opt_debug) { \
string _wait_; \
cerr << "(hit return to continue)" << endl; \
getline(cin, _wait_); \
}
#define dump(x) \
if (opt_debug) { \
cerr << " [L" << __LINE__ << "] " << #x << " = " << (x) << endl; \
}
#define dumpl(x) \
if (opt_debug) { \
cerr << " [L" << __LINE__ << "] " << #x << endl << (x) << endl; \
}
#define dumpf() \
if (opt_debug) { \
cerr << __PRETTY_FUNCTION__ << endl; \
}
#define where() \
if (opt_debug) { \
cerr << __FILE__ << ": " << __PRETTY_FUNCTION__ << " [L: " << __LINE__ \
<< "]" << endl; \
}
#define show_bits(b, s) \
if (opt_debug) { \
REP(i, s) { \
cerr << BITOF(b, s - 1 - i); \
if (i % 4 == 3) \
cerr << ' '; \
} \
cerr << endl; \
}
// ostreams {{{
// complex
template <typename T> ostream &operator<<(ostream &s, const complex<T> &d) {
return s << "(" << d.real() << ", " << d.imag() << ")";
}
// pair
template <typename T1, typename T2>
ostream &operator<<(ostream &s, const pair<T1, T2> &d) {
return s << "(" << d.first << ", " << d.second << ")";
}
// vector
template <typename T> ostream &operator<<(ostream &s, const vector<T> &d) {
int len = d.size();
REP(i, len) {
s << d[i];
if (i < len - 1)
s << "\t";
}
return s;
}
// 2 dimentional vector
template <typename T>
ostream &operator<<(ostream &s, const vector<vector<T>> &d) {
int len = d.size();
REP(i, len) { s << d[i] << endl; }
return s;
}
// map
template <typename T1, typename T2>
ostream &operator<<(ostream &s, const map<T1, T2> &m) {
s << "{" << endl;
for (typeof(m.begin()) itr = m.begin(); itr != m.end(); ++itr) {
s << "\t" << (*itr).first << " : " << (*itr).second << endl;
}
s << "}" << endl;
return s;
}
// }}}
// }}}
// }}}
// time {{{
inline double now() {
struct timeval tv;
gettimeofday(&tv, NULL);
return (static_cast<double>(tv.tv_sec) +
static_cast<double>(tv.tv_usec) * 1e-6);
}
// }}}
// string manipulation {{{
inline VS split(string s, char delimiter) {
VS v;
string t;
REP(i, s.length()) {
if (s[i] == delimiter)
v.PB(t), t = "";
else
t += s[i];
}
v.PB(t);
return v;
}
inline string join(VS s, string j) {
string t;
REP(i, s.size()) { t += s[i] + j; }
return t;
}
// }}}
// geometry {{{
#define Y real()
#define X imag()
// }}}
// 2 dimentional array {{{
P dydx4[4] = {P(-1, 0), P(0, 1), P(1, 0), P(0, -1)};
P dydx8[8] = {P(-1, 0), P(0, 1), P(1, 0), P(0, -1),
P(-1, 1), P(1, 1), P(1, -1), P(-1, -1)};
int g_height, g_width;
bool in_field(P p) {
return (0 <= p.Y && p.Y < g_height) && (0 <= p.X && p.X < g_width);
}
// }}}
// input and output {{{
inline void input(string filename) { freopen(filename.c_str(), "r", stdin); }
inline void output(string filename) { freopen(filename.c_str(), "w", stdout); }
// }}}
// }}}
bool opt_debug = false;
int main(int argc, char **argv) {
std::ios_base::sync_with_stdio(false);
// set options {{{
int __c;
while ((__c = getopt(argc, argv, "d")) != -1) {
switch (__c) {
case 'd':
opt_debug = true;
break;
default:
abort();
}
}
// }}}
// input("./inputs/0.txt");
// output("./outputs/0.txt");
int N;
while (cin >> N, N) {
VI satisfactions(N);
VULL guys(N, 0);
REP(i, N) {
int M;
cin >> M >> satisfactions[i];
REP(j, M) {
int S, E;
cin >> S >> E;
S -= 6;
E -= 6;
guys[i] |= (1 << E) - (1 << S);
}
}
VI dp(1 << 17, 0);
REP(i, N) {
for (ULL bit = 0; bit < 1 << 17; ++bit) {
if ((guys[i] & bit) == 0) {
dp[guys[i] | bit] =
max(dp[guys[i] | bit], dp[bit] + satisfactions[i]);
}
}
}
int ans = 0;
REP(bit, 1 << 17) { ans = max(ans, dp[bit]); }
cout << ans << endl;
}
return 0;
}
// vim: foldmethod=marker | replace | 288 | 289 | 288 | 289 | -6 | terminate called after throwing an instance of 'std::bad_alloc'
what(): std::bad_alloc
|
p01438 | C++ | Runtime Error | #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 = (b)-1; i >= (a); i--)
#define all(a) (a).begin(), (a).end()
typedef long long ll;
typedef pair<int, int> P;
typedef tuple<int, int, int> TUPLE;
typedef vector<int> V;
typedef vector<V> VV;
typedef vector<VV> VVV;
signed main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
int N;
while (cin >> N, N) {
V L(N);
VV want(N, V(16, 0));
rep(i, N) {
int M;
cin >> M >> L[i];
rep(j, M) {
int s, t;
cin >> s >> t;
rep2(k, s, t) want[i][k] = 1;
}
}
V dp(1 << 16, 0);
rep(s, 1 << 16) {
rep(i, N) {
bool ok = true;
rep(j, 16) {
if (((s >> j) & 1) && want[i][j]) {
ok = false;
break;
}
}
if (ok) {
int ns = s;
rep(j, 16) { ns |= want[i][j] * (1 << j); }
dp[ns] = max(dp[ns], dp[s] + L[i]);
}
}
}
cout << *max_element(all(dp)) << endl;
}
} | #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 = (b)-1; i >= (a); i--)
#define all(a) (a).begin(), (a).end()
typedef long long ll;
typedef pair<int, int> P;
typedef tuple<int, int, int> TUPLE;
typedef vector<int> V;
typedef vector<V> VV;
typedef vector<VV> VVV;
signed main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
int N;
while (cin >> N, N) {
V L(N);
VV want(N, V(16, 0));
rep(i, N) {
int M;
cin >> M >> L[i];
rep(j, M) {
int s, t;
cin >> s >> t;
rep2(k, s, t) want[i][k - 6] = 1;
}
}
V dp(1 << 16, 0);
rep(s, 1 << 16) {
rep(i, N) {
bool ok = true;
rep(j, 16) {
if (((s >> j) & 1) && want[i][j]) {
ok = false;
break;
}
}
if (ok) {
int ns = s;
rep(j, 16) { ns |= want[i][j] * (1 << j); }
dp[ns] = max(dp[ns], dp[s] + L[i]);
}
}
}
cout << *max_element(all(dp)) << endl;
}
} | replace | 31 | 32 | 31 | 32 | -6 | Fatal glibc error: malloc assertion failure in sysmalloc: (old_top == initial_top (av) && old_size == 0) || ((unsigned long) (old_size) >= MINSIZE && prev_inuse (old_top) && ((unsigned long) old_end & (pagesize - 1)) == 0)
|
p01438 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define loop(n, i) for (int i = 0; i < n; i++)
#define all(v) v.begin(), v.end()
#define HERE cout << "HERE: " << __LINE__ << endl;
#define INSP(v) cout << v << " at " << __LINE__ << endl;
using namespace std;
typedef long long ll;
ll dp[101][65536];
int main() {
while (1) {
fill(dp[0], dp[100] + 65536, 0);
int n;
cin >> n;
vector<ll> L(n);
vector<vector<int>> S, E;
loop(n, i) {
int m;
cin >> m >> L[i];
vector<int> s(m), e(m);
loop(m, j) cin >> s[j] >> e[j];
S.push_back(s);
E.push_back(e);
}
loop(n, i) {
int mask = 0;
loop(S[i].size(), k) {
for (int l = S[i][k]; l < E[i][k]; l++) {
mask ^= (1 << (l - 6));
}
}
loop(1 << 16, j) {
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j]);
if ((j & mask) == 0) {
dp[i + 1][j ^ mask] = max(dp[i + 1][j ^ mask], dp[i][j] + L[i]);
}
}
}
ll ans = 0;
loop(1 << 16, i) ans = max(ans, dp[n][i]);
cout << ans << endl;
}
return 0;
} | #include <bits/stdc++.h>
#define loop(n, i) for (int i = 0; i < n; i++)
#define all(v) v.begin(), v.end()
#define HERE cout << "HERE: " << __LINE__ << endl;
#define INSP(v) cout << v << " at " << __LINE__ << endl;
using namespace std;
typedef long long ll;
ll dp[101][65536];
int main() {
while (1) {
fill(dp[0], dp[100] + 65536, 0);
int n;
cin >> n;
if (!n)
break;
vector<ll> L(n);
vector<vector<int>> S, E;
loop(n, i) {
int m;
cin >> m >> L[i];
vector<int> s(m), e(m);
loop(m, j) cin >> s[j] >> e[j];
S.push_back(s);
E.push_back(e);
}
loop(n, i) {
int mask = 0;
loop(S[i].size(), k) {
for (int l = S[i][k]; l < E[i][k]; l++) {
mask ^= (1 << (l - 6));
}
}
loop(1 << 16, j) {
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j]);
if ((j & mask) == 0) {
dp[i + 1][j ^ mask] = max(dp[i + 1][j ^ mask], dp[i][j] + L[i]);
}
}
}
ll ans = 0;
loop(1 << 16, i) ans = max(ans, dp[n][i]);
cout << ans << endl;
}
return 0;
} | insert | 17 | 17 | 17 | 19 | TLE | |
p01438 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cstring>
#include <iostream>
#include <vector>
using namespace std;
typedef pair<int, int> pii;
struct Guy {
int sc;
int L;
bool ok;
};
typedef long long ll;
int n;
Guy guys[101];
ll dp[2][1 << 17];
ll dfs(int pos, int s) {
if (pos == n)
return 0;
if (dp[pos][s] != -1)
return dp[pos][s];
ll res = 0;
// ツ債。ツ嘉アツ偲ヲツづゥツつゥツ氾崢つゥ
// no get
res = max(res, dfs(pos + 1, s));
// get
if (guys[pos].ok) {
bool ok = true;
for (int i = 0; i < 17; i++) {
if (((s >> i) & 1) && ((guys[pos].sc >> i) & 1)) {
ok = false;
break;
}
}
if (ok) {
res = max(res, dfs(pos + 1, s | guys[pos].sc) + guys[pos].L);
}
}
return dp[pos][s] = res;
}
int main() {
while (cin >> n && n != 0) {
for (int i = 0; i < n; i++) {
int m;
cin >> m >> guys[i].L;
guys[i].sc = 0;
guys[i].ok = true;
for (int j = 0; j < m; j++) {
int s, e;
cin >> s >> e;
s -= 6;
e -= 6;
for (int k = s; k < e; k++) {
if (!((guys[i].sc >> k) & 1)) {
guys[i].sc |= (1 << k);
} else {
guys[i].ok = false;
}
}
}
}
for (int i = 0; i < 2; i++)
for (int j = 0; j < (1 << 17); j++)
dp[i][j] = 0;
for (int i = n - 1; i >= 0; i--) {
int cur = (i + 1) % 2;
int nxt = (i) % 2;
for (int j = 0; j < (1 << 17); j++)
dp[nxt][j] = 0;
for (int j = 0; j < (1 << 17); j++) {
dp[nxt][j] = dp[cur][j];
if (guys[i].ok) {
bool ok = true;
for (int k = 0; k < 17; k++) {
if (((j >> k) & 1) && ((guys[i].sc >> k) & 1)) {
ok = false;
break;
}
}
if (ok) {
dp[nxt][j] = max(dp[nxt][j], dp[cur][j | guys[i].sc] + guys[i].L);
}
}
}
}
ll res = dp[0][0];
// ll res=dfs(0,0);
cout << res << endl;
}
return 0;
} | #include <algorithm>
#include <cstring>
#include <iostream>
#include <vector>
using namespace std;
typedef pair<int, int> pii;
struct Guy {
int sc;
int L;
bool ok;
};
typedef long long ll;
int n;
Guy guys[101];
ll dp[2][1 << 17];
ll dfs(int pos, int s) {
if (pos == n)
return 0;
if (dp[pos][s] != -1)
return dp[pos][s];
ll res = 0;
// ツ債。ツ嘉アツ偲ヲツづゥツつゥツ氾崢つゥ
// no get
res = max(res, dfs(pos + 1, s));
// get
if (guys[pos].ok) {
bool ok = true;
for (int i = 0; i < 17; i++) {
if (((s >> i) & 1) && ((guys[pos].sc >> i) & 1)) {
ok = false;
break;
}
}
if (ok) {
res = max(res, dfs(pos + 1, s | guys[pos].sc) + guys[pos].L);
}
}
return dp[pos][s] = res;
}
int main() {
while (cin >> n && n != 0) {
for (int i = 0; i < n; i++) {
int m;
cin >> m >> guys[i].L;
guys[i].sc = 0;
guys[i].ok = true;
for (int j = 0; j < m; j++) {
int s, e;
cin >> s >> e;
s -= 6;
e -= 6;
for (int k = s; k < e; k++) {
if (!((guys[i].sc >> k) & 1)) {
guys[i].sc |= (1 << k);
} else {
guys[i].ok = false;
}
}
}
}
for (int i = 0; i < 2; i++)
for (int j = 0; j < (1 << 17); j++)
dp[i][j] = 0;
for (int i = n - 1; i >= 0; i--) {
int cur = (i + 1) % 2;
int nxt = (i) % 2;
for (int j = 0; j < (1 << 17); j++)
dp[nxt][j] = 0;
for (int j = 0; j < (1 << 17); j++) {
dp[nxt][j] = dp[cur][j];
if (guys[i].ok) {
bool ok = (j & guys[i].sc) ? 0 : 1;
// for(int k=0;k<17;k++){
// if(((j>>k)&1)&&((guys[i].sc>>k)&1)){
// ok=false;
// break;
// }
// }
if (ok) {
dp[nxt][j] = max(dp[nxt][j], dp[cur][j | guys[i].sc] + guys[i].L);
}
}
}
}
ll res = dp[0][0];
// ll res=dfs(0,0);
cout << res << endl;
}
return 0;
} | replace | 78 | 85 | 78 | 85 | TLE | |
p01442 | C++ | Memory Limit Exceeded | #include "bits/stdc++.h"
#include <unordered_map>
#include <unordered_set>
#pragma warning(disable : 4996)
using namespace std;
using ld = long double;
template <class T> using Table = vector<vector<T>>;
ld eps = 1e-9;
struct aa {
int x;
int y;
int n;
int w;
};
const int dx[4] = {-1, 0, 1, 0};
const int dy[4] = {0, 1, 0, -1};
class Compare {
public:
// aa?????????????????¶
bool operator()(const aa &l, const aa &r) { return l.n > r.n; }
};
vector<vector<int>> wheres(4);
vector<vector<int>> anext;
int main() {
while (1) {
int H, W, N;
cin >> H >> W >> N;
anext.clear();
wheres.resize(4);
if (!H)
break;
string st;
cin >> st;
int way = 3;
vector<int> ways;
ways.push_back(way);
wheres[way].push_back(0);
for (int i = 0; i < N; ++i) {
if (st[i] == 'L') {
way = (way + 1) % 4;
} else {
way = (way + 3) % 4;
}
ways.push_back(way);
wheres[way].push_back(i + 1);
}
for (int i = 0; i < N; ++i) {
vector<int> v;
for (int j = 0; j < 4; ++j) {
auto it = upper_bound(wheres[j].begin(), wheres[j].end(), i);
if (it == wheres[j].end())
v.push_back(1e8);
else
v.push_back(*it);
}
for (int j = 0; j < ways[i]; ++j) {
rotate(v.begin(), v.end(), v.end());
}
anext.push_back(v);
}
wheres.clear();
vector<vector<int>> field(H + 2, vector<int>(W + 2, 0));
for (int x = 0; x <= W + 1; ++x) {
int y = 0;
field[y][x] = 1;
y = H + 1;
field[y][x] = 1;
}
for (int y = 0; y <= H + 1; ++y) {
int x = 0;
field[y][x] = 1;
x = W + 1;
field[y][x] = 1;
}
vector<vector<vector<int>>> memo(
H + 1, vector<vector<int>>(W + 1, vector<int>(4, 1e8)));
int gx, gy;
int sx, sy;
for (int i = 0; i < H; ++i) {
string ast;
cin >> ast;
for (int j = 0; j < W; ++j) {
if (ast[j] == 'G') {
gx = j + 1;
gy = i + 1;
} else if (ast[j] == 'S') {
sx = j + 1;
sy = i + 1;
} else if (ast[j] == '#') {
field[i + 1][j + 1] = true;
}
}
}
priority_queue<aa, vector<aa>, Compare> que;
que.push(aa{sx, sy, 0, 3});
memo[sy][sx][3] = 0;
string ans = "No";
while (!que.empty()) {
aa atop(que.top());
que.pop();
const int px = atop.x;
const int py = atop.y;
const int pn = atop.n;
const int pw = atop.w;
if (px == gx && py == gy) {
ans = "Yes";
break;
}
{
const int nx = px + dx[pw];
const int ny = py + dy[pw];
if (!field[ny][nx]) {
if (memo[ny][nx][pw] > pn) {
memo[ny][nx][pw] = pn;
que.push(aa{nx, ny, pn, pw});
}
}
}
if (pn != N) {
for (int i = 0; i < 4; ++i) {
if (anext[pn][i] < 1e8) {
if (memo[py][px][i] > anext[pn][i]) {
memo[py][px][i] = anext[pn][i];
que.push(aa{px, py, anext[pn][i], i});
}
}
}
}
}
cout << ans << endl;
}
return 0;
} | #include "bits/stdc++.h"
#include <unordered_map>
#include <unordered_set>
#pragma warning(disable : 4996)
using namespace std;
using ld = long double;
template <class T> using Table = vector<vector<T>>;
ld eps = 1e-9;
struct aa {
int x;
int y;
int n;
int w;
};
const int dx[4] = {-1, 0, 1, 0};
const int dy[4] = {0, 1, 0, -1};
class Compare {
public:
// aa?????????????????¶
bool operator()(const aa &l, const aa &r) { return l.n > r.n; }
};
vector<vector<int>> wheres(4);
vector<vector<int>> anext;
int main() {
while (1) {
int H, W, N;
cin >> H >> W >> N;
anext.clear();
wheres.resize(4);
if (!H)
break;
string st;
cin >> st;
int way = 3;
vector<int> ways;
ways.push_back(way);
wheres[way].push_back(0);
for (int i = 0; i < N; ++i) {
if (st[i] == 'L') {
way = (way + 1) % 4;
} else {
way = (way + 3) % 4;
}
ways.push_back(way);
wheres[way].push_back(i + 1);
}
for (int i = 0; i < N; ++i) {
vector<int> v;
for (int j = 0; j < 4; ++j) {
auto it = upper_bound(wheres[j].begin(), wheres[j].end(), i);
if (it == wheres[j].end())
v.push_back(1e8);
else
v.push_back(*it);
}
for (int j = 0; j < ways[i]; ++j) {
rotate(v.begin(), v.end(), v.end());
}
anext.push_back(v);
}
wheres.clear();
vector<vector<int>> field(H + 2, vector<int>(W + 2, 0));
for (int x = 0; x <= W + 1; ++x) {
int y = 0;
field[y][x] = 1;
y = H + 1;
field[y][x] = 1;
}
for (int y = 0; y <= H + 1; ++y) {
int x = 0;
field[y][x] = 1;
x = W + 1;
field[y][x] = 1;
}
int memo[1001][1001][4];
for (int i = 0; i < 1001; ++i) {
for (int j = 0; j < 1001; ++j) {
for (int k = 0; k < 4; ++k) {
memo[i][j][k] = 1e8;
}
}
}
int gx, gy;
int sx, sy;
for (int i = 0; i < H; ++i) {
string ast;
cin >> ast;
for (int j = 0; j < W; ++j) {
if (ast[j] == 'G') {
gx = j + 1;
gy = i + 1;
} else if (ast[j] == 'S') {
sx = j + 1;
sy = i + 1;
} else if (ast[j] == '#') {
field[i + 1][j + 1] = true;
}
}
}
priority_queue<aa, vector<aa>, Compare> que;
que.push(aa{sx, sy, 0, 3});
memo[sy][sx][3] = 0;
string ans = "No";
while (!que.empty()) {
aa atop(que.top());
que.pop();
const int px = atop.x;
const int py = atop.y;
const int pn = atop.n;
const int pw = atop.w;
if (px == gx && py == gy) {
ans = "Yes";
break;
}
{
const int nx = px + dx[pw];
const int ny = py + dy[pw];
if (!field[ny][nx]) {
if (memo[ny][nx][pw] > pn) {
memo[ny][nx][pw] = pn;
que.push(aa{nx, ny, pn, pw});
}
}
}
if (pn != N) {
for (int i = 0; i < 4; ++i) {
if (anext[pn][i] < 1e8) {
if (memo[py][px][i] > anext[pn][i]) {
memo[py][px][i] = anext[pn][i];
que.push(aa{px, py, anext[pn][i], i});
}
}
}
}
}
cout << ans << endl;
}
return 0;
} | replace | 76 | 78 | 76 | 84 | MLE | |
p01443 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int(i) = 0; (i) < (int)(n); ++(i))
#define all(x) (x).begin(), (x).end()
#define pb push_back
#define fi first
#define se second
#define dbg(x) cout << #x " = " << ((x)) << endl
template <class T, class U>
ostream &operator<<(ostream &o, const pair<T, U> &p) {
o << "(" << p.fi << "," << p.se << ")";
return o;
}
template <class T> ostream &operator<<(ostream &o, const vector<T> &v) {
o << "[";
for (T t : v) {
o << t << ",";
}
o << "]";
return o;
}
struct SegTree {
int n;
vector<ll> dat;
ll mod;
// 初期化
SegTree(int _n, ll _mod) {
n = 1;
while (n < _n)
n *= 2;
dat = vector<ll>(2 * n - 1, 0);
mod = _mod;
}
// k番目(0-indexed)の値をaに変更
void update(int k, ll a) {
k += n - 1;
dat[k] = a;
// 更新
while (k > 0) {
k = (k - 1) / 2;
dat[k] = (dat[2 * k + 1] + dat[2 * k + 2]) % mod;
}
}
// 内部的に投げられるクエリ
ll _query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return 0;
if (a <= l && r <= b)
return dat[k];
ll vl = _query(a, b, 2 * k + 1, l, (l + r) / 2);
ll vr = _query(a, b, 2 * k + 2, (l + r) / 2, r);
return (vl + vr) % mod;
}
//[a,b)
ll query(int a, int b) { return _query(a, b, 0, 0, n); }
};
using P = pair<string, int>;
int main() {
int a, b, p;
while (cin >> a >> b >> p, a) {
int n = b - a + 1;
SegTree st(n, p);
vector<P> v;
for (int i = 1; i <= b - a + 1; ++i) {
int val = a + i - 1;
v.pb({to_string(val), i});
}
sort(all(v));
st.update(0, 1);
rep(i, v.size()) {
int idx = v[i].se;
st.update(idx, st.query(0, idx));
}
cout << st.query(1, n + 1) << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int(i) = 0; (i) < (int)(n); ++(i))
#define all(x) (x).begin(), (x).end()
#define pb push_back
#define fi first
#define se second
#define dbg(x) cout << #x " = " << ((x)) << endl
template <class T, class U>
ostream &operator<<(ostream &o, const pair<T, U> &p) {
o << "(" << p.fi << "," << p.se << ")";
return o;
}
template <class T> ostream &operator<<(ostream &o, const vector<T> &v) {
o << "[";
for (T t : v) {
o << t << ",";
}
o << "]";
return o;
}
struct SegTree {
int n;
vector<ll> dat;
ll mod;
// 初期化
SegTree(int _n, ll _mod) {
n = 1;
while (n < _n)
n *= 2;
dat = vector<ll>(2 * n - 1, 0);
mod = _mod;
}
// k番目(0-indexed)の値をaに変更
void update(int k, ll a) {
k += n - 1;
dat[k] = a;
// 更新
while (k > 0) {
k = (k - 1) / 2;
dat[k] = (dat[2 * k + 1] + dat[2 * k + 2]) % mod;
}
}
// 内部的に投げられるクエリ
ll _query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return 0;
if (a <= l && r <= b)
return dat[k];
ll vl = _query(a, b, 2 * k + 1, l, (l + r) / 2);
ll vr = _query(a, b, 2 * k + 2, (l + r) / 2, r);
return (vl + vr) % mod;
}
//[a,b)
ll query(int a, int b) { return _query(a, b, 0, 0, n); }
};
using P = pair<string, int>;
int main() {
int a, b, p;
while (cin >> a >> b >> p, a) {
int n = b - a + 1;
SegTree st(n + 1, p);
vector<P> v;
for (int i = 1; i <= b - a + 1; ++i) {
int val = a + i - 1;
v.pb({to_string(val), i});
}
sort(all(v));
st.update(0, 1);
rep(i, v.size()) {
int idx = v[i].se;
st.update(idx, st.query(0, idx));
}
cout << st.query(1, n + 1) << endl;
}
return 0;
}
| replace | 68 | 69 | 68 | 69 | 0 | |
p01447 | C++ | Time Limit Exceeded | #include <iostream>
using namespace std;
int main() {
for (;;) {
int n;
cin >> n;
if (n == 0)
break;
int ret = 0;
while (n != 1) {
if (n % 3 == 0) {
n /= 3;
} else {
n /= 3;
n++;
}
ret++;
}
cout << ret << endl;
}
return 0;
} | #include <iostream>
using namespace std;
int main() {
int n;
while (cin >> n) {
if (n == 0)
break;
int ret = 0;
while (n != 1) {
if (n % 3 == 0) {
n /= 3;
} else {
n /= 3;
n++;
}
ret++;
}
cout << ret << endl;
}
return 0;
} | replace | 3 | 6 | 3 | 5 | TLE | |
p01447 | C++ | Time Limit Exceeded | #include <iostream>
using namespace std;
int calc(int n) {
return n <= 1 ? 0 : (n % 3 ? calc(n / 3 + 1) : calc(n / 3)) + 1;
}
int main() {
for (int N; cin >> N, N; cout << calc(N) << '\n')
;
return 0;
} | #include <iostream>
using namespace std;
int calc(int n) {
return n <= 1 ? 0 : (n % 3 ? calc(n / 3 + 1) : calc(n / 3)) + 1;
}
int main() {
for (int N; cin >> N; cout << calc(N) << '\n')
;
return 0;
} | replace | 9 | 10 | 9 | 10 | TLE | |
p01447 | C++ | Time Limit Exceeded | // Earth Invasion Diary of Miyabi-sensei
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ll N;
while (cin >> N, N != 0)
cout << ceil(log((double)N) / log(3.0)) << endl;
return 0;
} | // Earth Invasion Diary of Miyabi-sensei
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ll N;
cin >> N;
cout << ceil(log((double)N) / log(3.0)) << endl;
return 0;
} | replace | 8 | 10 | 8 | 10 | TLE | |
p01447 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, ans = 0;
cin >> n;
while (n > 1)
n = n / 3 + min(1, n % (n / 3)), ans++;
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, ans = 0;
cin >> n;
while (n > 1)
n = n / 3 + min(1, n % 3), ans++;
cout << ans << endl;
return 0;
} | replace | 6 | 7 | 6 | 7 | -8 | |
p01448 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define PI 4 * atan(1)
#define INF 1e8
typedef long long ll;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
int main() {
int N;
cin >> N;
vector<int> c(N + 1, 0);
for (int i = 0; i < N; i++) {
int a, b;
cin >> a >> b;
c[a - 1]++;
c[b]--;
}
int sum = 0, ans = 0;
for (int i = 1; i <= N; i++) {
sum += c[i];
if (i <= sum)
ans = i;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define PI 4 * atan(1)
#define INF 1e8
typedef long long ll;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
int main() {
int N;
cin >> N;
vector<int> c(100000 + 2, 0);
for (int i = 0; i < N; i++) {
int a, b;
cin >> a >> b;
c[a - 1]++;
c[b]--;
}
int sum = 0, ans = 0;
for (int i = 1; i <= N; i++) {
sum += c[i];
if (i <= sum)
ans = i;
}
cout << ans << endl;
} | replace | 14 | 15 | 14 | 15 | -6 | malloc(): corrupted top size
|
p01448 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N;
vector<int> F;
cin >> N;
for (int i = 0; i < N + 1; i++) {
F.push_back(0);
}
for (int i = 0; i < N; i++) {
int x, y;
cin >> x >> y;
int xn = max(0, x - 1);
F[xn]++;
if (y <= N) {
F[y]--;
}
}
for (int i = 0; i < N; i++) {
F[i + 1] += F[i];
}
int ans;
for (int i = 0; i < N + 1; i++) {
if (F[i] >= i) {
ans = i;
}
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N;
vector<int> F;
cin >> N;
for (int i = 0; i < N + 1; i++) {
F.push_back(0);
}
for (int i = 0; i < N; i++) {
int x, y;
cin >> x >> y;
int xn = max(0, x - 1);
if (xn <= N) {
F[xn]++;
}
if (y <= N) {
F[y]--;
}
}
for (int i = 0; i < N; i++) {
F[i + 1] += F[i];
}
int ans;
for (int i = 0; i < N + 1; i++) {
if (F[i] >= i) {
ans = i;
}
}
cout << ans << endl;
return 0;
} | replace | 19 | 20 | 19 | 22 | 0 | |
p01449 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> pii;
int main() {
int n;
std::cin >> n;
vector<int> p(n), cell(n, 1e9);
for (int i = 0; i < n; i++) {
std::cin >> p[i];
}
queue<pii> que;
cell[0] = 0;
que.push(pii(0, 0));
while (not que.empty()) {
int s = que.front().first;
int cost = que.front().second;
que.pop();
for (int i = 1; i <= 6; i++) {
int pos = s + i;
bool flag = false;
for (int j = 0; j < 2 * n; j++) {
pos = min(n - 1, pos);
if (p[pos] != 0) {
cell[pos] = cost;
pos += p[pos];
} else {
break;
}
if (j == 2 * n - 1)
flag = true;
}
pos = min(n - 1, pos);
if (flag == true)
continue;
if (cell[pos] > cost + 1) {
cell[pos] = cost + 1;
que.push(pii(pos, cost + 1));
}
}
}
std::cout << cell[n - 1] << std::endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> pii;
int main() {
int n;
std::cin >> n;
vector<int> p(n), cell(n, 1e9);
for (int i = 0; i < n; i++) {
std::cin >> p[i];
}
queue<pii> que;
cell[0] = 0;
que.push(pii(0, 0));
while (not que.empty()) {
int s = que.front().first;
int cost = que.front().second;
que.pop();
for (int i = 1; i <= 6; i++) {
int pos = s + i;
bool flag = false;
for (int j = 0; j < 2 * n; j++) {
pos = min(n - 1, pos);
if (p[pos] != 0 and cell[pos] > cost) {
cell[pos] = cost;
pos += p[pos];
} else {
break;
}
if (j == 2 * n - 1)
flag = true;
}
pos = min(n - 1, pos);
if (flag == true)
continue;
if (cell[pos] > cost + 1) {
cell[pos] = cost + 1;
que.push(pii(pos, cost + 1));
}
}
}
std::cout << cell[n - 1] << std::endl;
return 0;
} | replace | 23 | 24 | 23 | 24 | TLE | |
p01449 | C++ | Time Limit Exceeded | #include <iostream>
#include <queue>
#include <string.h>
#include <vector>
using namespace std;
vector<int> T;
vector<int> M;
vector<bool> check;
int N;
const int NOT = -2;
int calc(int idx) {
if (T[idx] == NOT)
return NOT;
if (T[idx] >= 0)
return T[idx];
if (check[idx]) {
T[idx] = NOT;
return NOT;
}
check[idx] = true;
if (M[idx] == 0) {
T[idx] = idx;
return idx;
}
return T[idx] = calc(idx + M[idx]);
}
class Node {
public:
int idx, cost;
Node(int idx, int cost) : idx(idx), cost(cost) {}
Node();
};
bool operator<(Node a, Node b) { return a.cost < b.cost; }
int main() {
cin >> N;
T.resize(N, -1);
check.resize(N, false);
M.resize(N);
for (int i = 0; i < N; i++)
cin >> M[i];
T[0] = 0;
T[N - 1] = N - 1;
for (int i = N - 1; i >= 1; i--) {
if (!check[i])
calc(i);
}
vector<int> ans(N, N + 1);
priority_queue<Node> que;
que.push(Node(0, 0));
// cout<<endl;
int res = N + 1;
while (!que.empty()) {
Node now = que.top();
que.pop();
// cout<<now.idx<<endl;
if (T[now.idx] == NOT)
continue;
if (ans[now.idx] <= now.cost)
continue;
ans[now.idx] = now.cost;
for (int i = 1; i <= 6; i++) {
if (now.idx + i <= N - 1) {
if (T[now.idx + i] >= 0)
que.push(Node(T[now.idx + i], now.cost + 1));
}
}
}
cout << ans[N - 1] << endl;
return 0;
} | #include <iostream>
#include <queue>
#include <string.h>
#include <vector>
using namespace std;
vector<int> T;
vector<int> M;
vector<bool> check;
int N;
const int NOT = -2;
int calc(int idx) {
if (T[idx] == NOT)
return NOT;
if (T[idx] >= 0)
return T[idx];
if (check[idx]) {
T[idx] = NOT;
return NOT;
}
check[idx] = true;
if (M[idx] == 0) {
T[idx] = idx;
return idx;
}
return T[idx] = calc(idx + M[idx]);
}
class Node {
public:
int idx, cost;
Node(int idx, int cost) : idx(idx), cost(cost) {}
Node();
};
bool operator<(Node a, Node b) { return a.cost > b.cost; }
int main() {
cin >> N;
T.resize(N, -1);
check.resize(N, false);
M.resize(N);
for (int i = 0; i < N; i++)
cin >> M[i];
T[0] = 0;
T[N - 1] = N - 1;
for (int i = N - 1; i >= 1; i--) {
if (!check[i])
calc(i);
}
vector<int> ans(N, N + 1);
priority_queue<Node> que;
que.push(Node(0, 0));
// cout<<endl;
int res = N + 1;
while (!que.empty()) {
Node now = que.top();
que.pop();
// cout<<now.idx<<endl;
if (T[now.idx] == NOT)
continue;
if (ans[now.idx] <= now.cost)
continue;
ans[now.idx] = now.cost;
for (int i = 1; i <= 6; i++) {
if (now.idx + i <= N - 1) {
if (T[now.idx + i] >= 0)
que.push(Node(T[now.idx + i], now.cost + 1));
}
}
}
cout << ans[N - 1] << endl;
return 0;
} | replace | 36 | 37 | 36 | 37 | TLE | |
p01449 | C++ | Memory Limit Exceeded | #include <iostream>
#include <queue>
using namespace std;
int main() {
int N, p[100000], v[100000];
cin >> N;
for (int i = 0; i < N; i++) {
cin >> p[i];
v[i] = (1 << 24);
}
queue<int> q;
q.push(0);
v[0] = 0;
while (!q.empty()) {
int t = q.front();
q.pop();
if (t == N - 1) {
cout << v[t] << endl;
break;
}
for (int d = 1; d <= 6; d++) {
int nt = t + d;
if (nt >= N)
continue;
while (v[t] + 1 < v[nt]) {
v[nt] = v[t] + 1;
nt += p[nt];
}
if (p[nt] == 0) {
q.push(nt);
}
}
}
} | #include <iostream>
#include <queue>
using namespace std;
int main() {
int N, p[100000], v[100000];
cin >> N;
for (int i = 0; i < N; i++) {
cin >> p[i];
v[i] = (1 << 24);
}
queue<int> q;
q.push(0);
v[0] = 0;
while (!q.empty()) {
int t = q.front();
q.pop();
if (t == N - 1) {
cout << v[t] << endl;
break;
}
for (int d = 1; d <= 6; d++) {
int nt = t + d;
if (nt >= N)
continue;
while (v[t] + 1 < v[nt]) {
v[nt] = v[t] + 1;
nt += p[nt];
}
if (p[nt] == 0 && v[nt] == v[t] + 1) {
q.push(nt);
}
}
}
} | replace | 35 | 36 | 35 | 36 | MLE | |
p01449 | C++ | Memory Limit Exceeded | #include <cstdio>
#include <map>
#include <queue>
#define fst first
#define snd second
using namespace std;
typedef pair<int, int> que;
int p[100500];
char tbl[100500];
int main(void) {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++)
scanf("%d", &p[i]);
priority_queue<que> q;
q.push(que(-0, 0));
while (!q.empty()) {
que t = q.top();
q.pop();
int cost = -t.fst;
int i = t.snd;
tbl[i] = 1;
if (i == n - 1) {
printf("%d\n", cost);
break;
}
if (p[i]) {
if (0 <= i + p[i] && i + p[i] < n && !tbl[i + p[i]])
q.push(que(-cost, i + p[i]));
} else
for (int dice = 1; dice <= 6; dice++)
if (i + dice < n)
q.push(que(-(cost + 1), i + dice));
}
return 0;
} | #include <cstdio>
#include <map>
#include <queue>
#define fst first
#define snd second
using namespace std;
typedef pair<int, int> que;
int p[100500];
char tbl[100500];
int main(void) {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++)
scanf("%d", &p[i]);
priority_queue<que> q;
q.push(que(-0, 0));
while (!q.empty()) {
que t = q.top();
q.pop();
int cost = -t.fst;
int i = t.snd;
tbl[i] = 1;
if (i == n - 1) {
printf("%d\n", cost);
break;
}
if (p[i]) {
if (0 <= i + p[i] && i + p[i] < n && !tbl[i + p[i]])
q.push(que(-cost, i + p[i]));
} else
for (int dice = 1; dice <= 6; dice++)
if (i + dice < n && !tbl[i + dice])
q.push(que(-(cost + 1), i + dice));
}
return 0;
} | replace | 37 | 38 | 37 | 38 | MLE | |
p01449 | C++ | Memory Limit Exceeded | #include <algorithm>
#include <complex>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
typedef long long int ll;
typedef double D; // ??§?¨?????????????double???long double?????????
typedef complex<D> P; // Point
typedef pair<P, P> L; // Line
typedef vector<P> VP;
const int INF = (1 << 30) - 1;
const D EPS = 1e-9;
#define X real()
#define Y imag()
#define LE(n, m) ((n) < (m) + EPS)
#define GE(n, m) ((n) + EPS > (m))
#define EQ(n, m) (abs((n) - (m)) < EPS)
int dfs(vector<int> &ps, vector<int> &d, vector<bool> visited, int v) {
if (visited[v])
return d[v];
visited[v] = true;
if (ps[v] == 0)
return d[v] = v;
return d[v] = dfs(ps, d, visited, v + ps[v]);
}
int bfs(vector<int> &d, vector<int> &dp) {
int N = d.size();
queue<int> q;
dp[0] = 0;
q.push(0);
while (!q.empty()) {
int v = q.front();
q.pop();
for (int i = 1; i <= 6; i++) {
if (N - 1 <= v + i || d[v + i] == N - 1)
return dp[v] + 1;
if (d[v + i] >= 0 && dp[d[v + i]] == INF) {
dp[d[v + i]] = dp[v] + 1;
q.push(d[v + i]);
}
}
}
// No Implement
return -1;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N;
cin >> N;
vector<int> ps(N);
vector<int> d(N, -1);
vector<int> dp(N, INF);
vector<bool> visited(N, false);
for (auto &p : ps)
cin >> p;
for (int i = 0; i < N; i++)
d[i] = dfs(ps, d, visited, i);
cout << bfs(d, dp) << endl;
return 0;
} | #include <algorithm>
#include <complex>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
typedef long long int ll;
typedef double D; // ??§?¨?????????????double???long double?????????
typedef complex<D> P; // Point
typedef pair<P, P> L; // Line
typedef vector<P> VP;
const int INF = (1 << 30) - 1;
const D EPS = 1e-9;
#define X real()
#define Y imag()
#define LE(n, m) ((n) < (m) + EPS)
#define GE(n, m) ((n) + EPS > (m))
#define EQ(n, m) (abs((n) - (m)) < EPS)
int dfs(vector<int> &ps, vector<int> &d, vector<bool> &visited, int v) {
if (visited[v])
return d[v];
visited[v] = true;
if (ps[v] == 0)
return d[v] = v;
return d[v] = dfs(ps, d, visited, v + ps[v]);
}
int bfs(vector<int> &d, vector<int> &dp) {
int N = d.size();
queue<int> q;
dp[0] = 0;
q.push(0);
while (!q.empty()) {
int v = q.front();
q.pop();
for (int i = 1; i <= 6; i++) {
if (N - 1 <= v + i || d[v + i] == N - 1)
return dp[v] + 1;
if (d[v + i] >= 0 && dp[d[v + i]] == INF) {
dp[d[v + i]] = dp[v] + 1;
q.push(d[v + i]);
}
}
}
// No Implement
return -1;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N;
cin >> N;
vector<int> ps(N);
vector<int> d(N, -1);
vector<int> dp(N, INF);
vector<bool> visited(N, false);
for (auto &p : ps)
cin >> p;
for (int i = 0; i < N; i++)
d[i] = dfs(ps, d, visited, i);
cout << bfs(d, dp) << endl;
return 0;
} | replace | 32 | 33 | 32 | 33 | MLE | |
p01450 | C++ | Runtime Error | #include "bits/stdc++.h"
#include <unordered_map>
#include <unordered_set>
#pragma warning(disable : 4996)
using namespace std;
using ld = long double;
template <class T> using Table = vector<vector<T>>;
const ld eps = 1e-9;
// < "D:\D_Download\Visual Studio
// 2015\Projects\programing_contest_c++\Debug\a.txt"
int dp[2][201][10001];
int main() {
int N, W;
cin >> N >> W;
vector<int> ws(N);
for (int i = 0; i < N; ++i) {
int a;
cin >> a;
ws[i] = a;
}
if (*min_element(ws.begin(), ws.end()) > W) {
cout << 1 << endl;
return 0;
}
if (accumulate(ws.begin(), ws.end(), 0) <= W) {
cout << 1 << endl;
return 0;
}
sort(ws.begin(), ws.end(), greater<int>());
for (int f = 0; f < 201; ++f) {
for (int j = 0; j < 10001; ++j) {
dp[0][f][j] = 0;
}
}
dp[0][200][0] = 1;
int tar, cur;
for (int i = 0; i < N; ++i) {
tar = i & 1;
cur = tar ^ 1;
if (i == 0)
assert(tar == 0 && cur == 1);
for (int f = 0; f < 201; ++f) {
for (int j = 0; j < 10001; ++j) {
dp[cur][f][j] = 0;
dp[tar][f][j] %= 1000000007;
}
}
for (int f = 0; f < i; ++f) {
for (int w = 0; w < 10001; ++w) {
int nextw = w + ws[i];
if (nextw <= W) {
dp[cur][f][nextw] += dp[tar][f][w];
}
{ dp[cur][i][w] += dp[tar][f][w]; }
}
}
{
int f = 200;
{
for (int w = 0; w < 10001; ++w) {
int nextw = w + ws[i];
if (nextw <= W) {
dp[cur][f][nextw] += dp[tar][f][w];
}
{ dp[cur][i][w] += dp[tar][f][w]; }
}
}
}
}
long long int ans = 0;
for (int f = 0; f < N; ++f) {
for (int j = W - ws[f] + 1; j <= W; ++j) {
ans += dp[cur][f][j];
}
}
cout << ans % 1000000007 << endl;
return 0;
}
//
// int N, W; cin >> N >> W;
// vector<int>ws(N);
// for (int i = 0; i < N; ++i) {
// int a; cin >> a;
// ws[i] = a;
//}
// int dp[2][10001]; | #include "bits/stdc++.h"
#include <unordered_map>
#include <unordered_set>
#pragma warning(disable : 4996)
using namespace std;
using ld = long double;
template <class T> using Table = vector<vector<T>>;
const ld eps = 1e-9;
// < "D:\D_Download\Visual Studio
// 2015\Projects\programing_contest_c++\Debug\a.txt"
int dp[2][201][10001];
int main() {
int N, W;
cin >> N >> W;
vector<int> ws(N);
for (int i = 0; i < N; ++i) {
int a;
cin >> a;
ws[i] = a;
}
if (*min_element(ws.begin(), ws.end()) > W) {
cout << 1 << endl;
return 0;
}
if (accumulate(ws.begin(), ws.end(), 0) <= W) {
cout << 1 << endl;
return 0;
}
sort(ws.begin(), ws.end(), greater<int>());
for (int f = 0; f < 201; ++f) {
for (int j = 0; j < 10001; ++j) {
dp[0][f][j] = 0;
}
}
dp[0][200][0] = 1;
int tar, cur;
for (int i = 0; i < N; ++i) {
tar = i & 1;
cur = tar ^ 1;
if (i == 0)
assert(tar == 0 && cur == 1);
for (int f = 0; f < 201; ++f) {
for (int j = 0; j < 10001; ++j) {
dp[cur][f][j] = 0;
dp[tar][f][j] %= 1000000007;
}
}
for (int f = 0; f < i; ++f) {
for (int w = 0; w < 10001; ++w) {
int nextw = w + ws[i];
if (nextw <= W) {
dp[cur][f][nextw] += dp[tar][f][w];
}
{ dp[cur][i][w] += dp[tar][f][w]; }
}
}
{
int f = 200;
{
for (int w = 0; w < 10001; ++w) {
int nextw = w + ws[i];
if (nextw <= W) {
dp[cur][f][nextw] += dp[tar][f][w];
}
{ dp[cur][i][w] += dp[tar][f][w]; }
}
}
}
}
long long int ans = 0;
for (int f = 0; f < N; ++f) {
for (int j = max(0, W - ws[f] + 1); j <= W; ++j) {
ans += dp[cur][f][j];
}
}
cout << ans % 1000000007 << endl;
return 0;
}
//
// int N, W; cin >> N >> W;
// vector<int>ws(N);
// for (int i = 0; i < N; ++i) {
// int a; cin >> a;
// ws[i] = a;
//}
// int dp[2][10001]; | replace | 74 | 75 | 74 | 75 | 0 | |
p01450 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
typedef long long int ll;
const int MAX_N = 205;
const int MAX_W = 10005;
const ll MOD = 1000000007;
int N, W;
ll dp[MAX_N][MAX_W];
ll func(vector<ll> &vec, int sum, int id) {
for (int i = 0; i <= N; i++)
for (int j = 0; j <= W; j++)
dp[i][j] = 0;
dp[id + 1][sum] = 1;
ll ret = 0;
for (int i = id + 1; i < N; i++) {
for (int j = 0; j <= W; j++) {
if (dp[i][j] == 0)
continue;
dp[i + 1][j] = (dp[i + 1][j] + dp[i][j]) % MOD;
if (j + vec[i] > W)
continue;
dp[i + 1][j + vec[i]] = (dp[i + 1][j + vec[i]] + dp[i][j]) % MOD;
}
}
for (int i = 0; i <= W; i++) {
if (W - i < vec[id]) {
ret = (ret + dp[N][i]) % MOD;
}
}
return ret;
}
int main() {
cin >> N >> W;
vector<ll> vec(N);
for (int i = 0; i < N; i++) {
cin >> vec[i];
}
sort(vec.begin(), vec.end());
int sum = 0;
ll res = 0;
for (int i = 0; i < N; i++) {
res = (res + func(vec, sum, i)) % MOD;
sum += vec[i];
}
if (sum <= W)
res = (res + 1LL) % MOD;
cout << res << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
typedef long long int ll;
const int MAX_N = 205;
const int MAX_W = 10005;
const ll MOD = 1000000007;
int N, W;
ll dp[MAX_N][MAX_W];
ll func(vector<ll> &vec, int sum, int id) {
for (int i = 0; i <= N; i++)
for (int j = 0; j <= W; j++)
dp[i][j] = 0;
dp[id + 1][sum] = 1;
ll ret = 0;
for (int i = id + 1; i < N; i++) {
for (int j = 0; j <= W; j++) {
if (dp[i][j] == 0)
continue;
dp[i + 1][j] = (dp[i + 1][j] + dp[i][j]) % MOD;
if (j + vec[i] > W)
continue;
dp[i + 1][j + vec[i]] = (dp[i + 1][j + vec[i]] + dp[i][j]) % MOD;
}
}
for (int i = 0; i <= W; i++) {
if (W - i < vec[id]) {
ret = (ret + dp[N][i]) % MOD;
}
}
return ret;
}
int main() {
cin >> N >> W;
vector<ll> vec(N);
for (int i = 0; i < N; i++) {
cin >> vec[i];
}
sort(vec.begin(), vec.end());
int sum = 0;
ll res = 0;
for (int i = 0; i < N; i++) {
if (sum > W)
continue;
res = (res + func(vec, sum, i)) % MOD;
sum += vec[i];
}
if (sum <= W)
res = (res + 1LL) % MOD;
cout << res << endl;
return 0;
} | insert | 53 | 53 | 53 | 55 | 0 | |
p01450 | C++ | Time Limit Exceeded | #define _CRT_SECURE_NO_WARNINGS 1
#define _USE_MATH_DEFINES
#include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <forward_list>
#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 <unordered_set>
#include <vector>
using namespace std;
#define INF ((int)(1 << 25))
#define REP(i, n) for (int i = 0; i < (int)n; i++)
#define FOR(i, n) REP(i, n)
#define FORI(i, k, n) for (int i = k; i < (int)n; i++)
#define TORAD 2.0 * M_PI / 360.0
#define INT(x) \
int x; \
cin >> x;
#define STR(x) \
string x; \
cin >> x;
#define ALL(x) begin(x), end(x)
#define RALL(x) (x).rbegin(), (x).rend()
#define DEBUG(x) cout << #x << ":" << x << endl;
#define EPS 1e-12
#ifdef _MSC_VER
#include <intrin.h>
#define __builtin_popcount __popcnt
#endif
typedef long long lint;
typedef vector<bool> vb;
typedef vector<char> vc;
typedef vector<int> vi;
typedef vector<lint> vl;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef pair<int, pii> piii;
const int dx[4] = {0, 1, 0, -1}, dy[4] = {-1, 0, 1, 0};
const int M = 1000000007;
template <class T> void debug(T a) {
for (auto i : a)
cout << i << endl;
}
int N, W;
int memo[250][11000];
vi a;
int t, z;
int dp(int now, int w) {
if (now == a.size() && w == 0)
return 1;
if (now == a.size())
return 0;
if (w < 0)
return 0;
if (memo[now][w] != -1)
return memo[now][w];
int ans = 0;
ans += dp(now + 1, w - a[now]);
if (a[now] > z)
ans += dp(now + 1, w);
ans %= M;
return memo[now][w] = ans;
}
int main() {
cin >> N >> W;
FOR(i, N) {
INT(x);
a.push_back(x);
}
sort(ALL(a));
int ans = 0;
for (t = 0; t <= W; t++) {
z = W - t;
memset(memo, -1, sizeof memo);
ans = (ans + dp(0, t)) % M;
}
cout << ans << endl;
} | #define _CRT_SECURE_NO_WARNINGS 1
#define _USE_MATH_DEFINES
#include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <forward_list>
#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 <unordered_set>
#include <vector>
using namespace std;
#define INF ((int)(1 << 25))
#define REP(i, n) for (int i = 0; i < (int)n; i++)
#define FOR(i, n) REP(i, n)
#define FORI(i, k, n) for (int i = k; i < (int)n; i++)
#define TORAD 2.0 * M_PI / 360.0
#define INT(x) \
int x; \
cin >> x;
#define STR(x) \
string x; \
cin >> x;
#define ALL(x) begin(x), end(x)
#define RALL(x) (x).rbegin(), (x).rend()
#define DEBUG(x) cout << #x << ":" << x << endl;
#define EPS 1e-12
#ifdef _MSC_VER
#include <intrin.h>
#define __builtin_popcount __popcnt
#endif
typedef long long lint;
typedef vector<bool> vb;
typedef vector<char> vc;
typedef vector<int> vi;
typedef vector<lint> vl;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef pair<int, pii> piii;
const int dx[4] = {0, 1, 0, -1}, dy[4] = {-1, 0, 1, 0};
const int M = 1000000007;
template <class T> void debug(T a) {
for (auto i : a)
cout << i << endl;
}
int N, W;
int memo[200][10001];
vi a;
int t, z;
int dp(int now, int w) {
if (now == a.size() && w == 0)
return 1;
if (now == a.size())
return 0;
if (w < 0)
return 0;
if (memo[now][w] != -1)
return memo[now][w];
int ans = 0;
ans += dp(now + 1, w - a[now]);
if (a[now] > z)
ans += dp(now + 1, w);
ans %= M;
return memo[now][w] = ans;
}
int main() {
cin >> N >> W;
FOR(i, N) {
INT(x);
a.push_back(x);
}
sort(ALL(a));
int ans = 0;
for (t = 0; t <= W; t++) {
z = W - t;
memset(memo, -1, sizeof memo);
ans = (ans + dp(0, t)) % M;
}
cout << ans << endl;
} | replace | 62 | 63 | 62 | 63 | TLE | |
p01450 | C++ | Runtime Error | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define PI 3.1415926535897932384626433832795028841971
#define INF 1000000000
#define EPS 1e-10
#define MOD 1000000007
using namespace std;
typedef long long ll;
typedef pair<double, double> P;
typedef pair<double, P> PQ;
int n, w;
int a[200];
ll dp[10001];
ll ans;
int main() {
cin >> n >> w;
rep(i, n) cin >> a[i];
sort(a, a + n);
if (a[0] > w) {
cout << 1 << endl;
return 0;
}
int sum = 0;
rep(i, n) sum += a[i];
if (sum <= w)
ans++;
rep(i, n) {
memset(dp, 0, sizeof(dp));
int ini = 0;
int mini = a[i];
for (int j = 0; j < i; j++) {
ini += a[j];
}
dp[ini] = 1;
for (int j = i + 1; j < n; j++) {
for (int k = w - a[j]; k >= 0; k--) {
dp[k + a[j]] += dp[k];
}
}
for (int j = 0; j <= w; j++)
dp[j] %= MOD;
for (int j = w - mini + 1; j <= w; j++)
ans += dp[j];
ans %= MOD;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define PI 3.1415926535897932384626433832795028841971
#define INF 1000000000
#define EPS 1e-10
#define MOD 1000000007
using namespace std;
typedef long long ll;
typedef pair<double, double> P;
typedef pair<double, P> PQ;
int n, w;
int a[200];
ll dp[10001];
ll ans;
int main() {
cin >> n >> w;
rep(i, n) cin >> a[i];
sort(a, a + n);
if (a[0] > w) {
cout << 1 << endl;
return 0;
}
int sum = 0;
rep(i, n) sum += a[i];
if (sum <= w)
ans++;
rep(i, n) {
memset(dp, 0, sizeof(dp));
int ini = 0;
int mini = a[i];
for (int j = 0; j < i; j++) {
ini += a[j];
}
if (ini > w)
break;
dp[ini] = 1;
for (int j = i + 1; j < n; j++) {
for (int k = w - a[j]; k >= 0; k--) {
dp[k + a[j]] += dp[k];
}
}
for (int j = 0; j <= w; j++)
dp[j] %= MOD;
for (int j = w - mini + 1; j <= w; j++)
ans += dp[j];
ans %= MOD;
}
cout << ans << endl;
} | insert | 35 | 35 | 35 | 37 | 0 | |
p01450 | 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;
// const int INF = 1e8;
using namespace std;
#define int long long
const int M = 1000000007;
int dp[205][10005];
signed main() {
int n, w;
cin >> n >> w;
vector<int> a(n + 1, -1);
rep(i, n) cin >> a[i + 1];
sort(all(a));
vector<int> sum(all(a));
sum[0] = 0;
range(i, 1, n + 1) { sum[i] += sum[i - 1]; }
dp[0][0] = 1;
range(i, 1, n + 1) { //???????????¨?????????????????\????????¨???
if (sum[i] > w)
break;
dp[0][sum[i]] = 1;
}
range(i, 1, n + 1) { // i - 1????????????????????¨??¨??\??????i
// ????????????????????\???????????¨???
dp[i][sum[i - 1]] = 1;
range(j, i + 1, n + 1) {
for (int k = w; k >= sum[i - 1]; k--) {
if (k + a[j] > w)
continue;
// show(k)
(dp[i][k + a[j]] += dp[i][k]) %= M;
}
}
}
// rep(i,n + 1){ rep(j,w + 1){ cout << dp[i][j] <<' '; } cout << endl; }
int ans = 0;
range(i, 1, n + 1) {
range(j, sum[i], w + 1) {
if (j + a[i] <= w)
continue;
// show(dp[i][j])
// cout << i << ' ' << j << endl;
(ans += dp[i][j]) %= M;
}
}
cout << ans + 1 << endl; //????????????????????\????????¨??????1??????
} | #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;
// const int INF = 1e8;
using namespace std;
#define int long long
const int M = 1000000007;
int dp[205][10005];
signed main() {
int n, w;
cin >> n >> w;
vector<int> a(n + 1, -1);
rep(i, n) cin >> a[i + 1];
sort(all(a));
vector<int> sum(all(a));
sum[0] = 0;
range(i, 1, n + 1) { sum[i] += sum[i - 1]; }
dp[0][0] = 1;
range(i, 1, n + 1) { //???????????¨?????????????????\????????¨???
if (sum[i] > w)
break;
dp[0][sum[i]] = 1;
}
range(i, 1, n + 1) { // i - 1????????????????????¨??¨??\??????i
// ????????????????????\???????????¨???
if (sum[i] > w)
break;
dp[i][sum[i - 1]] = 1;
range(j, i + 1, n + 1) {
for (int k = w; k >= sum[i - 1]; k--) {
if (k + a[j] > w)
continue;
// show(k)
(dp[i][k + a[j]] += dp[i][k]) %= M;
}
}
}
// rep(i,n + 1){ rep(j,w + 1){ cout << dp[i][j] <<' '; } cout << endl; }
int ans = 0;
range(i, 1, n + 1) {
range(j, sum[i], w + 1) {
if (j + a[i] <= w)
continue;
// show(dp[i][j])
// cout << i << ' ' << j << endl;
(ans += dp[i][j]) %= M;
}
}
cout << ans + 1 << endl; //????????????????????\????????¨??????1??????
} | insert | 33 | 33 | 33 | 35 | 0 | |
p01450 | C++ | Memory Limit Exceeded | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <set>
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
inline int getInt() {
int s;
scanf("%d", &s);
return s;
}
using namespace std;
const int mod = 1000000007;
int a[100000 + 10];
int dp[200][100000 + 10];
int w, n;
int memo;
int solve(int pos, int rest) {
if (pos == n)
return rest < a[memo] ? 1 : 0;
if (dp[pos][rest] != -1)
return dp[pos][rest];
int ret = 0;
if (pos >= memo)
ret = (ret + solve(pos + 1, rest)) % mod;
if (pos != memo && rest >= a[pos])
ret = (ret + solve(pos + 1, rest - a[pos])) % mod;
return dp[pos][rest] = ret;
}
int main() {
int ans = 0;
n = getInt();
w = getInt();
REP(i, n) a[i] = getInt();
sort(a, a + n);
int sum = 0;
REP(i, n) {
memset(dp, -1, sizeof(dp));
memo = i;
ans = (ans + solve(0, w)) % mod;
sum += a[i];
if (sum > w)
break;
}
if (sum <= w)
ans++;
if (ans == 0)
ans = 1;
printf("%d\n", ans);
return 0;
} | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <set>
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
inline int getInt() {
int s;
scanf("%d", &s);
return s;
}
using namespace std;
const int mod = 1000000007;
int a[10000 + 10];
int dp[200][10000 + 10];
int w, n;
int memo;
int solve(int pos, int rest) {
if (pos == n)
return rest < a[memo] ? 1 : 0;
if (dp[pos][rest] != -1)
return dp[pos][rest];
int ret = 0;
if (pos >= memo)
ret = (ret + solve(pos + 1, rest)) % mod;
if (pos != memo && rest >= a[pos])
ret = (ret + solve(pos + 1, rest - a[pos])) % mod;
return dp[pos][rest] = ret;
}
int main() {
int ans = 0;
n = getInt();
w = getInt();
REP(i, n) a[i] = getInt();
sort(a, a + n);
int sum = 0;
REP(i, n) {
memset(dp, -1, sizeof(dp));
memo = i;
ans = (ans + solve(0, w)) % mod;
sum += a[i];
if (sum > w)
break;
}
if (sum <= w)
ans++;
if (ans == 0)
ans = 1;
printf("%d\n", ans);
return 0;
} | replace | 15 | 17 | 15 | 17 | MLE | |
p01450 | C++ | Runtime Error | #include <algorithm>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <functional>
#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;
#ifdef _MSC_VER
#define __typeof__ decltype
template <class T> int __builtin_popcount(T n) {
return n ? 1 + __builtin_popcount(n & (n - 1)) : 0;
}
#endif
#define foreach(it, c) \
for (__typeof__((c).begin()) it = (c).begin(); it != (c).end(); ++it)
#define all(c) (c).begin(), (c).end()
#define rall(c) (c).rbegin(), (c).rend()
#define popcount __builtin_popcount
#define CLEAR(arr, val) memset(arr, val, sizeof(arr))
#define rep(i, n) for (int i = 0; i < n; ++i)
template <class T> void max_swap(T &a, const T &b) { a = max(a, b); }
template <class T> void min_swap(T &a, const T &b) { a = min(a, b); }
typedef long long ll;
typedef pair<int, int> pint;
const double PI = acos(-1.0);
const int dx[] = {0, 1, 0, -1};
const int dy[] = {1, 0, -1, 0};
int main() {
int n, limit, w[222];
cin >> n >> limit;
rep(i, n) cin >> w[i];
sort(w, w + n, greater<int>());
w[n] = 0;
const int mod = 1000000007;
static int dp[222][12345];
dp[0][0] = 1;
for (int i = 0; i < n; ++i) {
for (int j = 0; j <= limit; ++j) {
dp[i + 1][j] = dp[i][j];
if (j >= w[i])
(dp[i + 1][j] += dp[i][j - w[i]]) %= mod;
}
}
int res = 0;
int s = 0;
for (int i = n; i > 0; --i) {
s += w[i];
for (int j = limit - w[i - 1] - s + 1; j <= limit - w[i] - s; ++j)
res += dp[i][j];
}
printf("%d\n", res);
} | #include <algorithm>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <functional>
#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;
#ifdef _MSC_VER
#define __typeof__ decltype
template <class T> int __builtin_popcount(T n) {
return n ? 1 + __builtin_popcount(n & (n - 1)) : 0;
}
#endif
#define foreach(it, c) \
for (__typeof__((c).begin()) it = (c).begin(); it != (c).end(); ++it)
#define all(c) (c).begin(), (c).end()
#define rall(c) (c).rbegin(), (c).rend()
#define popcount __builtin_popcount
#define CLEAR(arr, val) memset(arr, val, sizeof(arr))
#define rep(i, n) for (int i = 0; i < n; ++i)
template <class T> void max_swap(T &a, const T &b) { a = max(a, b); }
template <class T> void min_swap(T &a, const T &b) { a = min(a, b); }
typedef long long ll;
typedef pair<int, int> pint;
const double PI = acos(-1.0);
const int dx[] = {0, 1, 0, -1};
const int dy[] = {1, 0, -1, 0};
int main() {
int n, limit, w[222];
cin >> n >> limit;
rep(i, n) cin >> w[i];
sort(w, w + n, greater<int>());
w[n] = 0;
const int mod = 1000000007;
static int dp[222][12345];
dp[0][0] = 1;
for (int i = 0; i < n; ++i) {
for (int j = 0; j <= limit; ++j) {
dp[i + 1][j] = dp[i][j];
if (j >= w[i])
(dp[i + 1][j] += dp[i][j - w[i]]) %= mod;
}
}
int res = 0;
int use = 0;
for (int i = n - 1; i >= 0 && use < limit; --i) {
for (int j = limit - w[i] - use + 1; j <= limit - w[i + 1] - use; ++j)
(res += dp[i + 1][j]) %= mod;
use += w[i];
}
printf("%d\n", res);
} | replace | 70 | 75 | 70 | 75 | 0 | |
p01450 | C++ | Memory Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define fs first
#define sc second
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define All(A) A.begin(), A.end()
#define RAll(A) A.rbegin(), A.rend()
typedef long long LL;
typedef pair<double, double> P;
const LL mod = 1e9 + 7;
const LL LINF = 1LL << 62;
const LL INF = 1 << 30;
LL dp[100001][201];
int main() {
int N;
int W;
cin >> N >> W;
vector<int> w(N);
for (int i = 0; i < N; i++) {
cin >> w[i];
}
sort(All(w));
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
for (int i = 0; i < N; i++) {
for (int j = W; j >= 0; j--) {
for (int k = 0; k <= i; k++) {
if (dp[j][k] == 0)
continue;
if (k == 0) {
if (j + w[i] <= W)
dp[j + w[i]][k] = (dp[j + w[i]][k] + dp[j][k]) % mod;
dp[j][i + 1] = (dp[j][i + 1] + dp[j][k]) % mod;
dp[j][k] = 0;
} else {
if (j + w[i] <= W)
dp[j + w[i]][k] = (dp[j + w[i]][k] + dp[j][k]) % mod;
}
}
}
}
LL ans = 0;
for (int i = 0; i <= W; i++) {
for (int j = 0; j <= N; j++) {
if (j == 0) {
ans = (ans + dp[i][j]) % mod;
} else {
if (w[j - 1] > W - i) {
ans = (ans + dp[i][j]) % mod;
}
}
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define fs first
#define sc second
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define All(A) A.begin(), A.end()
#define RAll(A) A.rbegin(), A.rend()
typedef long long LL;
typedef pair<double, double> P;
const LL mod = 1e9 + 7;
const LL LINF = 1LL << 62;
const LL INF = 1 << 30;
int dp[100001][201];
int main() {
int N;
int W;
cin >> N >> W;
vector<int> w(N);
for (int i = 0; i < N; i++) {
cin >> w[i];
}
sort(All(w));
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
for (int i = 0; i < N; i++) {
for (int j = W; j >= 0; j--) {
for (int k = 0; k <= i; k++) {
if (dp[j][k] == 0)
continue;
if (k == 0) {
if (j + w[i] <= W)
dp[j + w[i]][k] = (dp[j + w[i]][k] + dp[j][k]) % mod;
dp[j][i + 1] = (dp[j][i + 1] + dp[j][k]) % mod;
dp[j][k] = 0;
} else {
if (j + w[i] <= W)
dp[j + w[i]][k] = (dp[j + w[i]][k] + dp[j][k]) % mod;
}
}
}
}
LL ans = 0;
for (int i = 0; i <= W; i++) {
for (int j = 0; j <= N; j++) {
if (j == 0) {
ans = (ans + dp[i][j]) % mod;
} else {
if (w[j - 1] > W - i) {
ans = (ans + dp[i][j]) % mod;
}
}
}
}
cout << ans << endl;
return 0;
}
| replace | 15 | 16 | 15 | 16 | MLE | |
p01450 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
#define INF 1000000007
typedef /*long long*/ int LLI;
int n;
int W;
int myws[201];
int imos[201];
LLI dp[2][1145][201];
int main() {
scanf("%d%d", &n, &W);
for (int i = 1; i <= n; i++) {
scanf("%d", &myws[i]);
}
sort(myws + 1, myws + n + 1);
int src = 0;
int dst = 1;
dp[src][0][0] = 1;
for (int i = 1; i <= n; i++) {
for (int k = 1; k < i; k++) {
for (int j = 0; j <= W; j++) {
dp[dst][j][k] = dp[src][j][k];
}
}
for (int j = 0; j <= W; j++) {
dp[dst][j][i] = dp[src][j][0];
}
int w = myws[i];
for (int j = 0; j <= W - w; j++) {
for (int k = 0; k < i; k++) {
dp[dst][j + w][k] = (dp[dst][j + w][k] + dp[src][j][k]) % MOD;
}
}
swap(src, dst);
fill(dp[dst][0], dp[dst][W + 1], 0);
}
/*for (int i=0; i<=n; i++) {
printf("%d:", i);
for (int j=0; j<=W; j++) {
int sum = 0;
for (int k=0; k<=n; k++) sum += dp[i][j][k];
printf(" %d", sum);
}
puts("");
}*/
LLI ans = 0;
for (int k = 0; k <= n; k++) {
int st = 0;
if (k != 0)
st = max(W - myws[k] + 1, 0);
for (int j = st; j <= W; j++) {
ans = (ans + dp[src][j][k]) % MOD;
}
}
printf("%d\n", ans % MOD);
} | #include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
#define INF 1000000007
typedef /*long long*/ int LLI;
int n;
int W;
int myws[201];
int imos[201];
LLI dp[2][11451][201];
int main() {
scanf("%d%d", &n, &W);
for (int i = 1; i <= n; i++) {
scanf("%d", &myws[i]);
}
sort(myws + 1, myws + n + 1);
int src = 0;
int dst = 1;
dp[src][0][0] = 1;
for (int i = 1; i <= n; i++) {
for (int k = 1; k < i; k++) {
for (int j = 0; j <= W; j++) {
dp[dst][j][k] = dp[src][j][k];
}
}
for (int j = 0; j <= W; j++) {
dp[dst][j][i] = dp[src][j][0];
}
int w = myws[i];
for (int j = 0; j <= W - w; j++) {
for (int k = 0; k < i; k++) {
dp[dst][j + w][k] = (dp[dst][j + w][k] + dp[src][j][k]) % MOD;
}
}
swap(src, dst);
fill(dp[dst][0], dp[dst][W + 1], 0);
}
/*for (int i=0; i<=n; i++) {
printf("%d:", i);
for (int j=0; j<=W; j++) {
int sum = 0;
for (int k=0; k<=n; k++) sum += dp[i][j][k];
printf(" %d", sum);
}
puts("");
}*/
LLI ans = 0;
for (int k = 0; k <= n; k++) {
int st = 0;
if (k != 0)
st = max(W - myws[k] + 1, 0);
for (int j = st; j <= W; j++) {
ans = (ans + dp[src][j][k]) % MOD;
}
}
printf("%d\n", ans % MOD);
} | replace | 11 | 12 | 11 | 12 | 0 | |
p01450 | C++ | Runtime Error | #ifndef LOCAL
#pragma GCC optimize("Ofast")
#endif
#include <algorithm>
#include <bitset>
#include <cassert>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <unordered_map>
#include <unordered_set>
using namespace std;
using i64 = int_fast64_t;
using db = double;
using ldb = long double;
using pii = pair<int, int>;
using pli = pair<int_fast64_t, int>;
using pll = pair<int_fast64_t, int_fast64_t>;
using pdi = pair<double, int>;
using pdd = pair<double, double>;
template <class T> using vct = vector<T>;
template <class T> using heap = priority_queue<T>;
template <class T> using minheap = priority_queue<T, vector<T>, greater<T>>;
template <class T> constexpr T inf = numeric_limits<T>::max() / (T)16;
constexpr int dx[9] = {1, 0, -1, 0, 1, -1, -1, 1, 0};
constexpr int dy[9] = {0, 1, 0, -1, 1, 1, -1, -1, 0};
constexpr long double Pi = 3.1415926535897932384626433832795028;
constexpr long double Golden = 1.61803398874989484820;
constexpr long double eps = 1e-15;
#define iostream_untie true
#define mod 1000000007LL
#define stdout_precision 10
#define stderr_precision 6
#define itrep(i, v) for (auto i = begin(v); i != end(v); ++i)
#define ritrep(i, v) for (auto i = rbegin(v); i != rend(v); ++i)
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = (n)-1; i >= 0; --i)
#define all(v) begin(v), end(v)
#define rall(v) rbegin(v), rend(v)
#define fir first
#define sec second
#define u_map unordered_map
#define u_set unordered_set
#define l_bnd lower_bound
#define u_bnd upper_bound
#define rsz resize
#define ers erase
#define emp emplace
#define emf emplace_front
#define emb emplace_back
#define pof pop_front
#define pob pop_back
#define mkp make_pair
#define mkt make_tuple
#define popcnt __builtin_popcount
namespace setup {
struct setupper {
setupper() {
if (iostream_untie) {
ios::sync_with_stdio(false);
std::cin.tie(nullptr);
std::cout.tie(nullptr);
std::cerr.tie(nullptr);
}
std::cout << std::fixed << std::setprecision(stdout_precision);
std::cerr << std::fixed << std::setprecision(stderr_precision);
#ifdef LOCAL
if (!freopen("input.txt", "rt", stdin)) {
std::cerr << "Failed to open the input file.\n";
std::exit(EXIT_FAILURE);
}
// if(!freopen("output.txt","wt",stdout)) {
// cerr << "Failed to open the output file.\n"; exit(EXIT_FAILURE);
// }
// std::cerr << "\n---stderr---\n";
// auto print_atexit = []() {
// std::cerr << "Exec time : " << clock() / (double)CLOCKS_PER_SEC *
// 1000.0 << "ms\n"; std::cerr << "------------\n";
// };
// atexit((void(*)())print_atexit);
// atexit((void(*)())fclose(stdin));
#endif
}
} __setupper;
} // namespace setup
namespace std {
template <class RAitr> void rsort(RAitr __first, RAitr __last) {
sort(__first, __last, greater<>());
}
template <class T> void hash_combine(size_t &seed, T const &key) {
seed ^= hash<T>()(key) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}
template <class T, class U> struct hash<pair<T, U>> {
size_t operator()(pair<T, U> const &pr) const {
size_t seed = 0;
hash_combine(seed, pr.first);
hash_combine(seed, pr.second);
return seed;
}
};
template <class Tup, size_t index = tuple_size<Tup>::value - 1>
struct hashval_calc {
static void apply(size_t &seed, Tup const &tup) {
hashval_calc<Tup, index - 1>::apply(seed, tup);
hash_combine(seed, get<index>(tup));
}
};
template <class Tup> struct hashval_calc<Tup, 0> {
static void apply(size_t &seed, Tup const &tup) {
hash_combine(seed, get<0>(tup));
}
};
template <class... T> struct hash<tuple<T...>> {
size_t operator()(tuple<T...> const &tup) const {
size_t seed = 0;
hashval_calc<tuple<T...>>::apply(seed, tup);
return seed;
}
};
} // namespace std
template <class T, class U> istream &operator>>(istream &s, pair<T, U> &p) {
return s >> p.first >> p.second;
}
template <class T, class U>
ostream &operator<<(ostream &s, const pair<T, U> p) {
return s << p.first << " " << p.second;
}
template <class T> istream &operator>>(istream &s, vector<T> &v) {
for (T &e : v)
s >> e;
return s;
}
template <class T> ostream &operator<<(ostream &s, const vector<T> &v) {
for (size_t i = 0; i < v.size(); ++i)
s << (i ? " " : "") << v[i];
return s;
}
#define dump(...) \
cerr << " [ " << __LINE__ << " : " << __FUNCTION__ << " ] " << #__VA_ARGS__ \
<< " : "; \
dump_func(__VA_ARGS__)
template <class T> void dump_func(T x) { cerr << x << '\n'; }
template <class T, class... Rest> void dump_func(T x, Rest... rest) {
cerr << x << ",";
dump_func(rest...);
}
template <class T = i64> T read() {
T x;
return cin >> x, x;
}
template <class T> void write(T x) { cout << x << '\n'; }
template <class T, class... Rest> void write(T x, Rest... rest) {
cout << x << ' ';
write(rest...);
}
void writeln() {}
template <class T, class... Rest> void writeln(T x, Rest... rest) {
cout << x << '\n';
writeln(rest...);
}
#define esc(...) writeln(__VA_ARGS__), exit(0)
namespace updater {
template <class T> static void add(T &x, const T &y) { x += y; }
template <class T> static void ext_add(T &x, const T &y, size_t w) {
x += y * w;
}
template <class T> static void mul(T &x, const T &y) { x *= y; }
template <class T> static void ext_mul(T &x, const T &y, size_t w) {
x *= (T)pow(y, w);
}
template <class T> static bool chmax(T &x, const T &y) {
return x < y ? x = y, true : false;
}
template <class T> static bool chmin(T &x, const T &y) {
return x > y ? x = y, true : false;
}
}; // namespace updater
using updater::add;
using updater::chmax;
using updater::chmin;
template <class T> constexpr T minf(const T &x, const T &y) {
return min(x, y);
}
template <class T> constexpr T maxf(const T &x, const T &y) {
return max(x, y);
}
constexpr bool bit(i64 n, int e) { return (n >> e) & 1; }
constexpr int_fast64_t mask(int_fast64_t n, int e) {
return n & ((1 << e) - 1);
}
constexpr int ilog(int_fast64_t x, int_fast64_t b = 2) {
return x ? 1 + ilog(x / b, b) : -1;
}
template <class F>
int_fast64_t binry(int_fast64_t ok, int_fast64_t ng, const F &fn) {
while (abs(ok - ng) > 1) {
int_fast64_t mid = (ok + ng) / 2;
(fn(mid) ? ok : ng) = mid;
}
return ok;
}
template <class A, size_t N, class T> void init(A (&array)[N], const T &val) {
fill((T *)array, (T *)(array + N), val);
}
template <class T> vector<int> cmprs(const vector<T> &v) {
vector<T> tmp = v;
vector<int> ret;
sort(begin(tmp), end(tmp));
tmp.erase(unique(begin(tmp), end(tmp)), end(tmp));
for (T i : v)
ret.emplace_back(lower_bound(begin(tmp), end(tmp), i) - begin(tmp));
return ret;
}
template <class T> vector<int> cmprs(const T *__first, const T *__last) {
return cmprs(vector<T>(__first, __last));
}
template <class F> void for_subset(uint_fast64_t s, const F &fn) {
uint_fast64_t tmp = s;
do {
fn(tmp);
} while ((--tmp &= s) != s);
}
/* The main code follows. */
struct modint {
int x;
constexpr modint() : x(0) {}
constexpr modint(int_fast64_t y)
: x(y >= 0 ? y % mod : (mod - (-y) % mod) % mod) {}
constexpr modint &operator+=(const modint &p) {
if ((x += p.x) >= mod)
x -= mod;
return *this;
}
constexpr modint &operator++() { return ++x, *this; }
constexpr modint operator++(int) {
modint t = *this;
return ++x, t;
}
constexpr modint &operator-=(const modint &p) {
if ((x += mod - p.x) >= mod)
x -= mod;
return *this;
}
constexpr modint &operator--() { return --x, *this; }
constexpr modint operator--(int) {
modint t = *this;
return --x, t;
}
constexpr modint &operator*=(const modint &p) {
x = (int)(1LL * x * p.x % mod);
return *this;
}
constexpr modint &operator/=(const modint &p) {
*this *= inverse(p);
return *this;
}
constexpr modint operator-() { return modint(-x); }
constexpr modint operator+(const modint &p) { return modint(*this) += p; }
constexpr modint operator-(const modint &p) { return modint(*this) -= p; }
constexpr modint operator*(const modint &p) { return modint(*this) *= p; }
constexpr modint operator/(const modint &p) { return modint(*this) /= p; }
constexpr bool operator==(const modint &p) { return x == p.x; }
constexpr bool operator!=(const modint &p) { return x != p.x; }
constexpr bool operator!() { return !x; }
constexpr bool operator>(const modint &p) { return x > p.x; }
constexpr bool operator<(const modint &p) { return x < p.x; }
constexpr bool operator>=(const modint &p) { return x >= p.x; }
constexpr bool operator<=(const modint &p) { return x <= p.x; }
constexpr static modint inverse(const modint &p) {
int a = p.x, b = mod, u = 1, v = 0;
while (b > 0) {
int t = a / b;
a -= t * b;
a ^= b ^= a ^= b;
u -= t * v;
u ^= v ^= u ^= v;
}
return modint(u);
}
constexpr static modint pow(modint p, uint_fast64_t e) {
if (!e)
return 1;
return pow(p * p, e >> 1) * (e & 1 ? p : 1);
}
friend ostream &operator<<(ostream &s, const modint &p) { return s << p.x; }
friend istream &operator>>(istream &s, modint &p) {
uint_fast64_t x;
p = modint((s >> x, x));
return s;
}
};
int n, W;
int w[210];
int s[210];
modint dp[10101], ans;
signed main() {
cin >> n >> W;
rep(i, n) { cin >> w[i]; }
sort(w, w + n);
for (int i = 0; i < n; ++i) {
s[i + 1] = s[i] + w[i];
}
dp[W] = 1;
if (W >= s[n])
ans++;
for (int i = n - 1; i >= 0; --i) {
for (int x = s[i]; x - s[i] < w[i]; ++x) {
ans += dp[x];
}
for (int x = 0; x + w[i] <= W; ++x) {
dp[x] += dp[x + w[i]];
}
}
esc(ans);
}
| #ifndef LOCAL
#pragma GCC optimize("Ofast")
#endif
#include <algorithm>
#include <bitset>
#include <cassert>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <unordered_map>
#include <unordered_set>
using namespace std;
using i64 = int_fast64_t;
using db = double;
using ldb = long double;
using pii = pair<int, int>;
using pli = pair<int_fast64_t, int>;
using pll = pair<int_fast64_t, int_fast64_t>;
using pdi = pair<double, int>;
using pdd = pair<double, double>;
template <class T> using vct = vector<T>;
template <class T> using heap = priority_queue<T>;
template <class T> using minheap = priority_queue<T, vector<T>, greater<T>>;
template <class T> constexpr T inf = numeric_limits<T>::max() / (T)16;
constexpr int dx[9] = {1, 0, -1, 0, 1, -1, -1, 1, 0};
constexpr int dy[9] = {0, 1, 0, -1, 1, 1, -1, -1, 0};
constexpr long double Pi = 3.1415926535897932384626433832795028;
constexpr long double Golden = 1.61803398874989484820;
constexpr long double eps = 1e-15;
#define iostream_untie true
#define mod 1000000007LL
#define stdout_precision 10
#define stderr_precision 6
#define itrep(i, v) for (auto i = begin(v); i != end(v); ++i)
#define ritrep(i, v) for (auto i = rbegin(v); i != rend(v); ++i)
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = (n)-1; i >= 0; --i)
#define all(v) begin(v), end(v)
#define rall(v) rbegin(v), rend(v)
#define fir first
#define sec second
#define u_map unordered_map
#define u_set unordered_set
#define l_bnd lower_bound
#define u_bnd upper_bound
#define rsz resize
#define ers erase
#define emp emplace
#define emf emplace_front
#define emb emplace_back
#define pof pop_front
#define pob pop_back
#define mkp make_pair
#define mkt make_tuple
#define popcnt __builtin_popcount
namespace setup {
struct setupper {
setupper() {
if (iostream_untie) {
ios::sync_with_stdio(false);
std::cin.tie(nullptr);
std::cout.tie(nullptr);
std::cerr.tie(nullptr);
}
std::cout << std::fixed << std::setprecision(stdout_precision);
std::cerr << std::fixed << std::setprecision(stderr_precision);
#ifdef LOCAL
if (!freopen("input.txt", "rt", stdin)) {
std::cerr << "Failed to open the input file.\n";
std::exit(EXIT_FAILURE);
}
// if(!freopen("output.txt","wt",stdout)) {
// cerr << "Failed to open the output file.\n"; exit(EXIT_FAILURE);
// }
// std::cerr << "\n---stderr---\n";
// auto print_atexit = []() {
// std::cerr << "Exec time : " << clock() / (double)CLOCKS_PER_SEC *
// 1000.0 << "ms\n"; std::cerr << "------------\n";
// };
// atexit((void(*)())print_atexit);
// atexit((void(*)())fclose(stdin));
#endif
}
} __setupper;
} // namespace setup
namespace std {
template <class RAitr> void rsort(RAitr __first, RAitr __last) {
sort(__first, __last, greater<>());
}
template <class T> void hash_combine(size_t &seed, T const &key) {
seed ^= hash<T>()(key) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}
template <class T, class U> struct hash<pair<T, U>> {
size_t operator()(pair<T, U> const &pr) const {
size_t seed = 0;
hash_combine(seed, pr.first);
hash_combine(seed, pr.second);
return seed;
}
};
template <class Tup, size_t index = tuple_size<Tup>::value - 1>
struct hashval_calc {
static void apply(size_t &seed, Tup const &tup) {
hashval_calc<Tup, index - 1>::apply(seed, tup);
hash_combine(seed, get<index>(tup));
}
};
template <class Tup> struct hashval_calc<Tup, 0> {
static void apply(size_t &seed, Tup const &tup) {
hash_combine(seed, get<0>(tup));
}
};
template <class... T> struct hash<tuple<T...>> {
size_t operator()(tuple<T...> const &tup) const {
size_t seed = 0;
hashval_calc<tuple<T...>>::apply(seed, tup);
return seed;
}
};
} // namespace std
template <class T, class U> istream &operator>>(istream &s, pair<T, U> &p) {
return s >> p.first >> p.second;
}
template <class T, class U>
ostream &operator<<(ostream &s, const pair<T, U> p) {
return s << p.first << " " << p.second;
}
template <class T> istream &operator>>(istream &s, vector<T> &v) {
for (T &e : v)
s >> e;
return s;
}
template <class T> ostream &operator<<(ostream &s, const vector<T> &v) {
for (size_t i = 0; i < v.size(); ++i)
s << (i ? " " : "") << v[i];
return s;
}
#define dump(...) \
cerr << " [ " << __LINE__ << " : " << __FUNCTION__ << " ] " << #__VA_ARGS__ \
<< " : "; \
dump_func(__VA_ARGS__)
template <class T> void dump_func(T x) { cerr << x << '\n'; }
template <class T, class... Rest> void dump_func(T x, Rest... rest) {
cerr << x << ",";
dump_func(rest...);
}
template <class T = i64> T read() {
T x;
return cin >> x, x;
}
template <class T> void write(T x) { cout << x << '\n'; }
template <class T, class... Rest> void write(T x, Rest... rest) {
cout << x << ' ';
write(rest...);
}
void writeln() {}
template <class T, class... Rest> void writeln(T x, Rest... rest) {
cout << x << '\n';
writeln(rest...);
}
#define esc(...) writeln(__VA_ARGS__), exit(0)
namespace updater {
template <class T> static void add(T &x, const T &y) { x += y; }
template <class T> static void ext_add(T &x, const T &y, size_t w) {
x += y * w;
}
template <class T> static void mul(T &x, const T &y) { x *= y; }
template <class T> static void ext_mul(T &x, const T &y, size_t w) {
x *= (T)pow(y, w);
}
template <class T> static bool chmax(T &x, const T &y) {
return x < y ? x = y, true : false;
}
template <class T> static bool chmin(T &x, const T &y) {
return x > y ? x = y, true : false;
}
}; // namespace updater
using updater::add;
using updater::chmax;
using updater::chmin;
template <class T> constexpr T minf(const T &x, const T &y) {
return min(x, y);
}
template <class T> constexpr T maxf(const T &x, const T &y) {
return max(x, y);
}
constexpr bool bit(i64 n, int e) { return (n >> e) & 1; }
constexpr int_fast64_t mask(int_fast64_t n, int e) {
return n & ((1 << e) - 1);
}
constexpr int ilog(int_fast64_t x, int_fast64_t b = 2) {
return x ? 1 + ilog(x / b, b) : -1;
}
template <class F>
int_fast64_t binry(int_fast64_t ok, int_fast64_t ng, const F &fn) {
while (abs(ok - ng) > 1) {
int_fast64_t mid = (ok + ng) / 2;
(fn(mid) ? ok : ng) = mid;
}
return ok;
}
template <class A, size_t N, class T> void init(A (&array)[N], const T &val) {
fill((T *)array, (T *)(array + N), val);
}
template <class T> vector<int> cmprs(const vector<T> &v) {
vector<T> tmp = v;
vector<int> ret;
sort(begin(tmp), end(tmp));
tmp.erase(unique(begin(tmp), end(tmp)), end(tmp));
for (T i : v)
ret.emplace_back(lower_bound(begin(tmp), end(tmp), i) - begin(tmp));
return ret;
}
template <class T> vector<int> cmprs(const T *__first, const T *__last) {
return cmprs(vector<T>(__first, __last));
}
template <class F> void for_subset(uint_fast64_t s, const F &fn) {
uint_fast64_t tmp = s;
do {
fn(tmp);
} while ((--tmp &= s) != s);
}
/* The main code follows. */
struct modint {
int x;
constexpr modint() : x(0) {}
constexpr modint(int_fast64_t y)
: x(y >= 0 ? y % mod : (mod - (-y) % mod) % mod) {}
constexpr modint &operator+=(const modint &p) {
if ((x += p.x) >= mod)
x -= mod;
return *this;
}
constexpr modint &operator++() { return ++x, *this; }
constexpr modint operator++(int) {
modint t = *this;
return ++x, t;
}
constexpr modint &operator-=(const modint &p) {
if ((x += mod - p.x) >= mod)
x -= mod;
return *this;
}
constexpr modint &operator--() { return --x, *this; }
constexpr modint operator--(int) {
modint t = *this;
return --x, t;
}
constexpr modint &operator*=(const modint &p) {
x = (int)(1LL * x * p.x % mod);
return *this;
}
constexpr modint &operator/=(const modint &p) {
*this *= inverse(p);
return *this;
}
constexpr modint operator-() { return modint(-x); }
constexpr modint operator+(const modint &p) { return modint(*this) += p; }
constexpr modint operator-(const modint &p) { return modint(*this) -= p; }
constexpr modint operator*(const modint &p) { return modint(*this) *= p; }
constexpr modint operator/(const modint &p) { return modint(*this) /= p; }
constexpr bool operator==(const modint &p) { return x == p.x; }
constexpr bool operator!=(const modint &p) { return x != p.x; }
constexpr bool operator!() { return !x; }
constexpr bool operator>(const modint &p) { return x > p.x; }
constexpr bool operator<(const modint &p) { return x < p.x; }
constexpr bool operator>=(const modint &p) { return x >= p.x; }
constexpr bool operator<=(const modint &p) { return x <= p.x; }
constexpr static modint inverse(const modint &p) {
int a = p.x, b = mod, u = 1, v = 0;
while (b > 0) {
int t = a / b;
a -= t * b;
a ^= b ^= a ^= b;
u -= t * v;
u ^= v ^= u ^= v;
}
return modint(u);
}
constexpr static modint pow(modint p, uint_fast64_t e) {
if (!e)
return 1;
return pow(p * p, e >> 1) * (e & 1 ? p : 1);
}
friend ostream &operator<<(ostream &s, const modint &p) { return s << p.x; }
friend istream &operator>>(istream &s, modint &p) {
uint_fast64_t x;
p = modint((s >> x, x));
return s;
}
};
int n, W;
int w[210];
int s[210];
modint dp[10101], ans;
signed main() {
cin >> n >> W;
rep(i, n) { cin >> w[i]; }
sort(w, w + n);
for (int i = 0; i < n; ++i) {
s[i + 1] = s[i] + w[i];
}
dp[W] = 1;
if (W >= s[n])
ans++;
for (int i = n - 1; i >= 0; --i) {
for (int x = s[i]; x <= W && x - s[i] < w[i]; ++x) {
ans += dp[x];
}
for (int x = 0; x + w[i] <= W; ++x) {
dp[x] += dp[x + w[i]];
}
}
esc(ans);
}
| replace | 349 | 350 | 349 | 350 | 0 | |
p01450 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
using namespace std;
int w[400], n, W, dp[20005];
int main() {
cin >> n >> W;
for (int i = 0; i < n; i++)
cin >> w[i];
sort(w, w + n);
int sum = 0;
int cnt = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j <= W; j++)
dp[j] = 0;
dp[cnt] = 1;
for (int j = i + 1; j < n; j++) {
for (int k = W - w[j]; k >= cnt; k--) {
dp[k + w[j]] += dp[k];
dp[k + w[j]] %= 1000000007;
}
}
for (int j = W - w[i] + 1; j <= W; j++) {
sum += dp[j];
sum %= 1000000007;
}
cnt += w[i];
}
if (cnt <= W)
sum++;
cout << sum << endl;
return 0;
} | #include <algorithm>
#include <iostream>
using namespace std;
int w[400], n, W, dp[20005];
int main() {
cin >> n >> W;
for (int i = 0; i < n; i++)
cin >> w[i];
sort(w, w + n);
int sum = 0;
int cnt = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j <= W; j++)
dp[j] = 0;
dp[cnt] = 1;
for (int j = i + 1; j < n; j++) {
for (int k = W - w[j]; k >= cnt; k--) {
dp[k + w[j]] += dp[k];
dp[k + w[j]] %= 1000000007;
}
}
for (int j = W - w[i] + 1; j <= W; j++) {
sum += dp[j];
sum %= 1000000007;
}
cnt += w[i];
if (cnt > W)
break;
}
if (cnt <= W)
sum++;
cout << sum << endl;
return 0;
} | insert | 26 | 26 | 26 | 28 | 0 | |
p01452 | C++ | Runtime Error | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const long long int MOD = 1000000007;
const int INF = 1000000000;
ll n, m, k;
ll kai[300000];
ll mod_pow(ll x, ll y) {
ll ret = 1;
while (y) {
if (y & 1)
ret = ret * x % MOD;
x = x * x % MOD;
y /= 2;
}
return ret;
}
ll conb(ll x, ll y) {
ll ret = kai[x + y];
ret = ret * mod_pow(kai[x], MOD - 2) % MOD;
ret = ret * mod_pow(kai[y], MOD - 2) % MOD;
return ret;
}
void init() {
kai[0] = 1;
for (ll i = 1; i <= 300000; i++) {
kai[i] = (kai[i - 1] * i) % MOD;
}
}
ll pre(ll x, ll y) {
ll ret = 1;
return ret;
}
int main() {
cin >> n >> m >> k;
init();
ll ans = 0;
for (ll i = 0; i <= k; i++) {
ll j = k - i;
ll add = conb(n + 2 * i, m + 2 * j);
ll add2 = conb(n + i, i);
if (i > 0)
add2 = (add2 - conb(n + i + 1, i - 1) + MOD) % MOD;
ll add3 = conb(m + j, j);
if (j > 0)
add3 = (add3 - conb(m + j + 1, j - 1) + MOD) % MOD;
add = add * add2 % MOD;
add = add * add3 % MOD;
ans = (ans + add) % MOD;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const long long int MOD = 1000000007;
const int INF = 1000000000;
ll n, m, k;
ll kai[300000];
ll mod_pow(ll x, ll y) {
ll ret = 1;
while (y) {
if (y & 1)
ret = ret * x % MOD;
x = x * x % MOD;
y /= 2;
}
return ret;
}
ll conb(ll x, ll y) {
ll ret = kai[x + y];
ret = ret * mod_pow(kai[x], MOD - 2) % MOD;
ret = ret * mod_pow(kai[y], MOD - 2) % MOD;
return ret;
}
void init() {
kai[0] = 1;
for (ll i = 1; i < 300000; i++) {
kai[i] = (kai[i - 1] * i) % MOD;
}
}
ll pre(ll x, ll y) {
ll ret = 1;
return ret;
}
int main() {
cin >> n >> m >> k;
init();
ll ans = 0;
for (ll i = 0; i <= k; i++) {
ll j = k - i;
ll add = conb(n + 2 * i, m + 2 * j);
ll add2 = conb(n + i, i);
if (i > 0)
add2 = (add2 - conb(n + i + 1, i - 1) + MOD) % MOD;
ll add3 = conb(m + j, j);
if (j > 0)
add3 = (add3 - conb(m + j + 1, j - 1) + MOD) % MOD;
add = add * add2 % MOD;
add = add * add3 % MOD;
ans = (ans + add) % MOD;
}
cout << ans << endl;
} | replace | 31 | 32 | 31 | 32 | 0 | |
p01452 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef complex<double> P;
typedef pair<int, int> pii;
#define REP(i, n) for (ll i = 0; i < n; ++i)
#define REPR(i, n) for (ll i = 1; i < n; ++i)
#define FOR(i, a, b) for (ll i = a; i < b; ++i)
#define DEBUG(x) cout << #x << ": " << x << endl
#define DEBUG_VEC(v) \
cout << #v << ":"; \
REP(i, v.size()) cout << " " << v[i]; \
cout << endl
#define ALL(a) (a).begin(), (a).end()
#define MOD (ll)(1e9 + 7)
#define ADD(a, b) a = ((a) + (b)) % MOD
#define FIX(a) ((a) % MOD + MOD) % MOD
ll inv(ll x) {
ll t = MOD - 2;
ll ans = 1;
while (t) {
if (t & 1)
ans = (ans * x) % MOD;
x = (x * x) % MOD;
t >>= 1;
}
return ans;
}
#define N_MAX 210010
ll fact[N_MAX];
ll comb(ll a, ll b) {
if (a < b)
return 0;
return fact[a] * inv(fact[b]) % MOD * inv(fact[a - b]) % MOD;
}
int main() {
fact[0] = 1;
REPR(i, N_MAX) fact[i] = fact[i - 1] * i % MOD;
ll n, m, k;
cin >> n >> m >> k;
ll result = 0;
REP(i, k + 1) {
ll l = i;
ll r = n + i;
ll d = k - i;
ll u = m + (k - i);
// http://kakuritsu.com/catalan.html
ll hor = FIX(comb(r + l, r) - comb(r + l, r + 1));
ll ver = FIX(comb(u + d, u) - comb(u + d, u + 1));
ll v = hor * ver % MOD * comb(r + l + u + d, r + l) % MOD;
result += v;
result %= MOD;
}
cout << result << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef complex<double> P;
typedef pair<int, int> pii;
#define REP(i, n) for (ll i = 0; i < n; ++i)
#define REPR(i, n) for (ll i = 1; i < n; ++i)
#define FOR(i, a, b) for (ll i = a; i < b; ++i)
#define DEBUG(x) cout << #x << ": " << x << endl
#define DEBUG_VEC(v) \
cout << #v << ":"; \
REP(i, v.size()) cout << " " << v[i]; \
cout << endl
#define ALL(a) (a).begin(), (a).end()
#define MOD (ll)(1e9 + 7)
#define ADD(a, b) a = ((a) + (b)) % MOD
#define FIX(a) ((a) % MOD + MOD) % MOD
ll inv(ll x) {
ll t = MOD - 2;
ll ans = 1;
while (t) {
if (t & 1)
ans = (ans * x) % MOD;
x = (x * x) % MOD;
t >>= 1;
}
return ans;
}
#define N_MAX 220010
ll fact[N_MAX];
ll comb(ll a, ll b) {
if (a < b)
return 0;
return fact[a] * inv(fact[b]) % MOD * inv(fact[a - b]) % MOD;
}
int main() {
fact[0] = 1;
REPR(i, N_MAX) fact[i] = fact[i - 1] * i % MOD;
ll n, m, k;
cin >> n >> m >> k;
ll result = 0;
REP(i, k + 1) {
ll l = i;
ll r = n + i;
ll d = k - i;
ll u = m + (k - i);
// http://kakuritsu.com/catalan.html
ll hor = FIX(comb(r + l, r) - comb(r + l, r + 1));
ll ver = FIX(comb(u + d, u) - comb(u + d, u + 1));
ll v = hor * ver % MOD * comb(r + l + u + d, r + l) % MOD;
result += v;
result %= MOD;
}
cout << result << endl;
return 0;
} | replace | 36 | 37 | 36 | 37 | 0 | |
p01452 | C++ | Runtime Error | #include <algorithm>
#include <array>
#include <assert.h>
#include <bitset>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdio.h>
#include <string.h>
#include <string>
#include <vector>
using namespace std;
const int mod = 1000000007;
struct Mod {
public:
int num;
Mod() : num(0) { ; }
Mod(long long int n) : num((n % mod + mod) % mod) { ; }
Mod(int n) : num((n % mod + mod) % mod) { ; }
operator int() { return num; }
};
Mod operator+(const Mod a, const Mod b) { return Mod((a.num + b.num) % mod); }
Mod operator+(const long long int a, const Mod b) { return Mod(a) + b; }
Mod operator++(Mod &a) { return a + Mod(1); }
Mod operator-(const Mod a, const Mod b) {
return Mod((mod + a.num - b.num) % mod);
}
Mod operator-(const long long int a, const Mod b) { return Mod(a) - b; }
Mod operator--(Mod &a) { return a - Mod(1); }
Mod operator*(const Mod a, const Mod b) {
return Mod(((long long)a.num * b.num) % mod);
}
Mod operator*(const long long int a, const Mod b) { return Mod(a) * b; }
Mod operator+=(Mod &a, const Mod b) { return a = a + b; }
Mod operator+=(long long int &a, const Mod b) { return a = a + b; }
Mod operator-=(Mod &a, const Mod b) { return a = a - b; }
Mod operator-=(long long int &a, const Mod b) { return a = a - b; }
Mod operator*=(Mod &a, const Mod b) { return a = a * b; }
Mod operator*=(long long int &a, const Mod b) { return a = a * b; }
Mod operator^(const Mod a, const int n) {
if (n == 0)
return Mod(1);
Mod res = (a * a) ^ (n / 2);
if (n % 2)
res = res * a;
return res;
}
Mod inv(const Mod a) { return a ^ (mod - 2); }
Mod operator/(const Mod a, const Mod b) {
assert(b.num != 0);
return a * inv(b);
}
Mod operator/(const long long int a, const Mod b) {
assert(b.num != 0);
return Mod(a) * inv(b);
}
Mod operator/=(Mod &a, const Mod b) {
assert(b.num != 0);
return a = a * inv(b);
}
#define MAX_N 102400
Mod fact[MAX_N], factinv[MAX_N];
void init() {
fact[0] = Mod(1);
factinv[0] = 1;
for (int i = 0; i < MAX_N - 1; ++i) {
fact[i + 1] = fact[i] * Mod(i + 1);
factinv[i + 1] = factinv[i] / Mod(i + 1);
}
}
Mod comb(const int a, const int b) {
return fact[a] * factinv[b] * factinv[a - b];
}
Mod getans(int m, int p) {
if (m == 0)
return 1;
Mod bb(comb(p + m, m) - comb(p + m, m - 1));
return comb(p + m, m) - comb(p + m, m - 1);
}
int main() {
init();
int N, M, K;
cin >> N >> M >> K;
Mod totalans(0);
for (int pxtime = N; pxtime <= N + K; ++pxtime) {
int mxtime = pxtime - N;
int pytime = M + (K - pxtime + N);
int mytime = K - pxtime + N;
Mod ans(1);
ans *= getans(mxtime, pxtime);
ans *= getans(mytime, pytime);
ans *= comb(N + M + 2 * K, pxtime + mxtime);
totalans += ans;
}
cout << totalans << endl;
return 0;
} | #include <algorithm>
#include <array>
#include <assert.h>
#include <bitset>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdio.h>
#include <string.h>
#include <string>
#include <vector>
using namespace std;
const int mod = 1000000007;
struct Mod {
public:
int num;
Mod() : num(0) { ; }
Mod(long long int n) : num((n % mod + mod) % mod) { ; }
Mod(int n) : num((n % mod + mod) % mod) { ; }
operator int() { return num; }
};
Mod operator+(const Mod a, const Mod b) { return Mod((a.num + b.num) % mod); }
Mod operator+(const long long int a, const Mod b) { return Mod(a) + b; }
Mod operator++(Mod &a) { return a + Mod(1); }
Mod operator-(const Mod a, const Mod b) {
return Mod((mod + a.num - b.num) % mod);
}
Mod operator-(const long long int a, const Mod b) { return Mod(a) - b; }
Mod operator--(Mod &a) { return a - Mod(1); }
Mod operator*(const Mod a, const Mod b) {
return Mod(((long long)a.num * b.num) % mod);
}
Mod operator*(const long long int a, const Mod b) { return Mod(a) * b; }
Mod operator+=(Mod &a, const Mod b) { return a = a + b; }
Mod operator+=(long long int &a, const Mod b) { return a = a + b; }
Mod operator-=(Mod &a, const Mod b) { return a = a - b; }
Mod operator-=(long long int &a, const Mod b) { return a = a - b; }
Mod operator*=(Mod &a, const Mod b) { return a = a * b; }
Mod operator*=(long long int &a, const Mod b) { return a = a * b; }
Mod operator^(const Mod a, const int n) {
if (n == 0)
return Mod(1);
Mod res = (a * a) ^ (n / 2);
if (n % 2)
res = res * a;
return res;
}
Mod inv(const Mod a) { return a ^ (mod - 2); }
Mod operator/(const Mod a, const Mod b) {
assert(b.num != 0);
return a * inv(b);
}
Mod operator/(const long long int a, const Mod b) {
assert(b.num != 0);
return Mod(a) * inv(b);
}
Mod operator/=(Mod &a, const Mod b) {
assert(b.num != 0);
return a = a * inv(b);
}
#define MAX_N 1024000
Mod fact[MAX_N], factinv[MAX_N];
void init() {
fact[0] = Mod(1);
factinv[0] = 1;
for (int i = 0; i < MAX_N - 1; ++i) {
fact[i + 1] = fact[i] * Mod(i + 1);
factinv[i + 1] = factinv[i] / Mod(i + 1);
}
}
Mod comb(const int a, const int b) {
return fact[a] * factinv[b] * factinv[a - b];
}
Mod getans(int m, int p) {
if (m == 0)
return 1;
Mod bb(comb(p + m, m) - comb(p + m, m - 1));
return comb(p + m, m) - comb(p + m, m - 1);
}
int main() {
init();
int N, M, K;
cin >> N >> M >> K;
Mod totalans(0);
for (int pxtime = N; pxtime <= N + K; ++pxtime) {
int mxtime = pxtime - N;
int pytime = M + (K - pxtime + N);
int mytime = K - pxtime + N;
Mod ans(1);
ans *= getans(mxtime, pxtime);
ans *= getans(mytime, pytime);
ans *= comb(N + M + 2 * K, pxtime + mxtime);
totalans += ans;
}
cout << totalans << endl;
return 0;
} | replace | 72 | 73 | 72 | 73 | 0 | |
p01452 | C++ | Runtime Error | #include <bits/stdc++.h>
#define rep(i, a, b) for (int i = a; i < b; i++)
#define rrep(i, a, b) for (int i = a; i >= b; i--)
#define fore(i, a) for (auto &i : a)
#define all(x) (x).begin(), (x).end()
#pragma GCC optimize("-O3")
using namespace std;
void _main();
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
_main();
}
typedef long long ll;
const int inf = INT_MAX / 2;
const ll infl = 1LL << 60;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
//---------------------------------------------------------------------------------------------------
template <int MOD> struct ModInt {
static const int Mod = MOD;
unsigned x;
ModInt() : x(0) {}
ModInt(signed sig) { x = sig < 0 ? sig % MOD + MOD : sig % MOD; }
ModInt(signed long long sig) { x = sig < 0 ? sig % MOD + MOD : sig % MOD; }
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 {
long long a = x, b = MOD, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
std::swap(a, b);
u -= t * v;
std::swap(u, v);
}
return ModInt(u);
}
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> ostream &operator<<(ostream &st, const ModInt<MOD> a) {
st << a.get();
return st;
};
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;
}
template <typename T, int FAC_MAX> struct Comb {
vector<T> fac, ifac;
Comb() {
fac.resize(FAC_MAX, 1);
ifac.resize(FAC_MAX, 1);
rep(i, 1, FAC_MAX) fac[i] = fac[i - 1] * i;
rep(i, 1, FAC_MAX) ifac[i] = T(1) / fac[i];
}
T aPb(int a, int b) {
if (b < 0 || a < b)
return T(0);
return fac[a] * ifac[a - b];
}
T aCb(int a, int b) {
if (b < 0 || a < b)
return T(0);
return fac[a] * ifac[a - b] * ifac[b];
}
T nHk(int n, int k) {
if (n == 0 && k == 0)
return T(1);
if (n <= 0 || k < 0)
return 0;
return aCb(n + k - 1, k);
}
}; // nHk = (n+k-1)Ck
typedef ModInt<1000000007> mint;
/*---------------------------------------------------------------------------------------------------
∧＿∧
∧＿∧ （´<_｀ ） Welcome to My Coding Space!
（ ´_ゝ`） / ⌒i
／ ＼ | |
/ /￣￣￣￣/ |
＿_(__ﾆつ/ ＿/ .| .|＿＿＿＿
＼/＿＿＿＿/ （u ⊃
---------------------------------------------------------------------------------------------------*/
int N, M, K;
Comb<mint, 201010> com;
//---------------------------------------------------------------------------------------------------
void _main() {
cin >> N >> M >> K;
mint ans = 0;
rep(x, 0, K + 1) {
int y = K - x;
mint co = com.aCb(N + M + K * 2, N + x * 2);
mint w = com.aCb(N + x * 2, x) - com.aCb(N + x * 2, x - 1);
mint h = com.aCb(M + y * 2, y) - com.aCb(M + y * 2, y - 1);
ans += co * h * w;
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
#define rep(i, a, b) for (int i = a; i < b; i++)
#define rrep(i, a, b) for (int i = a; i >= b; i--)
#define fore(i, a) for (auto &i : a)
#define all(x) (x).begin(), (x).end()
#pragma GCC optimize("-O3")
using namespace std;
void _main();
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
_main();
}
typedef long long ll;
const int inf = INT_MAX / 2;
const ll infl = 1LL << 60;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
//---------------------------------------------------------------------------------------------------
template <int MOD> struct ModInt {
static const int Mod = MOD;
unsigned x;
ModInt() : x(0) {}
ModInt(signed sig) { x = sig < 0 ? sig % MOD + MOD : sig % MOD; }
ModInt(signed long long sig) { x = sig < 0 ? sig % MOD + MOD : sig % MOD; }
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 {
long long a = x, b = MOD, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
std::swap(a, b);
u -= t * v;
std::swap(u, v);
}
return ModInt(u);
}
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> ostream &operator<<(ostream &st, const ModInt<MOD> a) {
st << a.get();
return st;
};
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;
}
template <typename T, int FAC_MAX> struct Comb {
vector<T> fac, ifac;
Comb() {
fac.resize(FAC_MAX, 1);
ifac.resize(FAC_MAX, 1);
rep(i, 1, FAC_MAX) fac[i] = fac[i - 1] * i;
rep(i, 1, FAC_MAX) ifac[i] = T(1) / fac[i];
}
T aPb(int a, int b) {
if (b < 0 || a < b)
return T(0);
return fac[a] * ifac[a - b];
}
T aCb(int a, int b) {
if (b < 0 || a < b)
return T(0);
return fac[a] * ifac[a - b] * ifac[b];
}
T nHk(int n, int k) {
if (n == 0 && k == 0)
return T(1);
if (n <= 0 || k < 0)
return 0;
return aCb(n + k - 1, k);
}
}; // nHk = (n+k-1)Ck
typedef ModInt<1000000007> mint;
/*---------------------------------------------------------------------------------------------------
∧＿∧
∧＿∧ （´<_｀ ） Welcome to My Coding Space!
（ ´_ゝ`） / ⌒i
／ ＼ | |
/ /￣￣￣￣/ |
＿_(__ﾆつ/ ＿/ .| .|＿＿＿＿
＼/＿＿＿＿/ （u ⊃
---------------------------------------------------------------------------------------------------*/
int N, M, K;
Comb<mint, 301010> com;
//---------------------------------------------------------------------------------------------------
void _main() {
cin >> N >> M >> K;
mint ans = 0;
rep(x, 0, K + 1) {
int y = K - x;
mint co = com.aCb(N + M + K * 2, N + x * 2);
mint w = com.aCb(N + x * 2, x) - com.aCb(N + x * 2, x - 1);
mint h = com.aCb(M + y * 2, y) - com.aCb(M + y * 2, y - 1);
ans += co * h * w;
}
cout << ans << endl;
}
| replace | 128 | 129 | 128 | 129 | 0 | |
p01452 | C++ | Runtime Error | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < ((int)(n)); i++)
#define reg(i, a, b) for (int i = ((int)(a)); i <= ((int)(b)); i++)
#define irep(i, n) for (int i = ((int)(n)) - 1; i >= 0; i--)
#define ireg(i, a, b) for (int i = ((int)(b)); i >= ((int)(a)); i--)
typedef long long int lli;
typedef pair<int, int> mp;
#define fir first
#define sec second
#define IINF INT_MAX
#define LINF LLONG_MAX
#define eprintf(...) fprintf(stderr, __VA_ARGS__)
#define pque(type) priority_queue<type, vector<type>, greater<type>>
#define memst(a, b) memset(a, b, sizeof(a))
#define MOD ((lli)(1000000007))
lli mop(lli p, lli q) {
lli res = 1, bp = p, b = 1;
while (q) {
if (q & b) {
res = (res * bp) % MOD;
q -= b;
}
bp = (bp * bp) % MOD;
b *= 2;
}
return res;
}
lli inv(lli p) { return mop(p, MOD - 2); }
lli fdat[100005];
lli fact(int p) {
if (fdat[p] >= 0)
return fdat[p];
lli res = 1;
reg(i, 1, p) res = (res * i) % MOD;
return (fdat[p] = res);
}
lli comb(lli p, lli q) {
lli res = (((fact(p) * inv(fact(q))) % MOD) * inv(fact(p - q))) % MOD;
return res;
}
lli nk(int p, int q) { // p+q susumi q modoru
if (q <= 0)
return 1;
return (MOD + comb(p + 2 * q, q) - comb(p + q * 2, q - 1)) % MOD;
//
}
int n, m, k;
int main(void) {
memset(fdat, -1, sizeof(fdat));
// printf("%lld\n",nk(2,1));
// printf("%lld\n",nk(3,2));
scanf("%d%d%d", &n, &m, &k);
lli ans = 0;
reg(i, 0, k) {
lli na = comb(n + m + k * 2, n + i * 2);
// printf("%lld\n",na);
na = (na * nk(n, i)) % MOD;
na = (na * nk(m, k - i)) % MOD;
ans = (ans + na) % MOD;
}
printf("%lld\n", ans);
return 0;
} | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < ((int)(n)); i++)
#define reg(i, a, b) for (int i = ((int)(a)); i <= ((int)(b)); i++)
#define irep(i, n) for (int i = ((int)(n)) - 1; i >= 0; i--)
#define ireg(i, a, b) for (int i = ((int)(b)); i >= ((int)(a)); i--)
typedef long long int lli;
typedef pair<int, int> mp;
#define fir first
#define sec second
#define IINF INT_MAX
#define LINF LLONG_MAX
#define eprintf(...) fprintf(stderr, __VA_ARGS__)
#define pque(type) priority_queue<type, vector<type>, greater<type>>
#define memst(a, b) memset(a, b, sizeof(a))
#define MOD ((lli)(1000000007))
lli mop(lli p, lli q) {
lli res = 1, bp = p, b = 1;
while (q) {
if (q & b) {
res = (res * bp) % MOD;
q -= b;
}
bp = (bp * bp) % MOD;
b *= 2;
}
return res;
}
lli inv(lli p) { return mop(p, MOD - 2); }
lli fdat[500005];
lli fact(int p) {
if (fdat[p] >= 0)
return fdat[p];
lli res = 1;
reg(i, 1, p) res = (res * i) % MOD;
return (fdat[p] = res);
}
lli comb(lli p, lli q) {
lli res = (((fact(p) * inv(fact(q))) % MOD) * inv(fact(p - q))) % MOD;
return res;
}
lli nk(int p, int q) { // p+q susumi q modoru
if (q <= 0)
return 1;
return (MOD + comb(p + 2 * q, q) - comb(p + q * 2, q - 1)) % MOD;
//
}
int n, m, k;
int main(void) {
memset(fdat, -1, sizeof(fdat));
// printf("%lld\n",nk(2,1));
// printf("%lld\n",nk(3,2));
scanf("%d%d%d", &n, &m, &k);
lli ans = 0;
reg(i, 0, k) {
lli na = comb(n + m + k * 2, n + i * 2);
// printf("%lld\n",na);
na = (na * nk(n, i)) % MOD;
na = (na * nk(m, k - i)) % MOD;
ans = (ans + na) % MOD;
}
printf("%lld\n", ans);
return 0;
} | replace | 42 | 43 | 42 | 43 | 0 | |
p01453 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define max(a, b) ((a) > (b) ? (a) : (b))
#define min(a, b) ((a) < (b) ? (a) : (b))
typedef long long LL;
struct position {
LL x;
LL y;
LL count;
};
int main() {
LL w, h;
LL houkou[5] = {0, 1, 0, -1, 0};
cin >> w >> h;
vector<vector<LL>> field(h, vector<LL>(w));
list<struct position> spring;
char c;
LL sx, sy, gx, gy;
LL numofFloor = 0;
for (LL i = 0; i < h; i++) {
for (LL j = 0; j < w; j++) {
cin >> c;
if (c == '.') {
field[i][j] = 1;
numofFloor++;
} else if (c == '#') {
field[i][j] = 0;
} else if (c == '*') {
field[i][j] = 2;
spring.push_back({j, i, 0});
} else if (c == 's') {
field[i][j] = 1;
sx = j;
sy = i;
numofFloor++;
} else {
field[i][j] = 3;
gx = j;
gy = i;
}
}
}
vector<vector<LL>> toGoal(h, vector<LL>(w, 0));
vector<vector<LL>> toSpring(h, vector<LL>(w, 0));
queue<struct position> bfs;
struct position now;
LL nx, ny;
bfs.push({gx, gy, 0});
while (!bfs.empty()) {
now = bfs.front();
bfs.pop();
for (LL i = 0; i < 4; i++) {
nx = now.x + houkou[i];
ny = now.y + houkou[i + 1];
if (0 <= nx && nx <= w && 0 <= ny && ny <= h) {
if (toGoal[ny][nx] == 0 && field[ny][nx] == 1) {
toGoal[ny][nx] = now.count + 1;
bfs.push({nx, ny, now.count + 1});
}
}
}
}
for (auto itr = spring.begin(); itr != spring.end(); itr++) {
bfs.push({(*itr).x, (*itr).y, 0});
}
while (!bfs.empty()) {
now = bfs.front();
bfs.pop();
for (LL i = 0; i < 4; i++) {
nx = now.x + houkou[i];
ny = now.y + houkou[i + 1];
if (0 <= nx && nx <= w && 0 <= ny && ny <= h) {
if (toSpring[ny][nx] == 0 && field[ny][nx] == 1) {
toSpring[ny][nx] = now.count + 1;
bfs.push({nx, ny, now.count + 1});
}
}
}
}
// for(LL i=0;i<h;i++){
// for(LL j=0;j<w;j++){
// cout << toGoal[i][j] << " ";
// }
// cout << endl;
// }
// cout << endl;
// for(LL i=0;i<h;i++){
// for(LL j=0;j<w;j++){
// cout << toSpring[i][j] << " ";
// }
// cout << endl;
// }
// cout << numofFloor << endl;
cout << fixed << setprecision(12);
double left = 0;
double right = 10000000000000000;
double mid;
double count;
int spcount = 0;
while (right - left > 0.0000000000000002 * right) {
mid = (left + right) / 2;
spcount = 0;
count = 0;
for (LL i = 1; i < h - 1; i++) {
for (LL j = 1; j < w - 1; j++) {
if (field[i][j] == 1) {
if (toGoal[i][j] != 0) {
if (toSpring[i][j] != 0) {
if ((double)toGoal[i][j] <
(double)toSpring[i][j] + (double)mid / (double)numofFloor) {
count += (double)toGoal[i][j];
} else {
count += (double)toSpring[i][j];
spcount++;
}
} else {
count += (double)toGoal[i][j];
}
} else {
if (toSpring[i][j] != 0) {
count += (double)toSpring[i][j];
spcount++;
}
}
}
}
}
count += (double)mid * (double)spcount / (double)numofFloor;
if (count < mid) {
right = mid;
} else {
left = mid;
}
}
// cout << left << endl;
// cout << right << endl;
// cout << count << endl;
// cout << toSpring[sy][sx] << endl;
// for(LL i=0;i<h;i++){
// for(LL j=0;j<w;j++){
// if(field[i][j]==1){
// if(toGoal[i][j]!=0){
// if(toSpring[i][j]!=0){
// cout <<
// min((double)toGoal[i][j],(double)toSpring[i][j]+(double)left/(double)numofFloor)
// << " ";
// }else{
// cout << (double)toGoal[i][j] << " ";
// }
// }else{
// if(toSpring[sy][sx]!=0) cout <<
// (double)toSpring[i][j]+(double)left/(double)numofFloor << " ";
// }
// }else{
// cout << 0 << " ";
// }
// }
// cout << endl;
// }
if (toGoal[sy][sx] != 0) {
if (toSpring[sy][sx] != 0) {
cout << min((double)toGoal[sy][sx],
(double)toSpring[sy][sx] + (double)left / (double)numofFloor)
<< endl;
} else {
cout << (double)toGoal[sy][sx] << endl;
}
} else {
if (toSpring[sy][sx] != 0)
cout << (double)toSpring[sy][sx] + (double)left / (double)numofFloor
<< endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define max(a, b) ((a) > (b) ? (a) : (b))
#define min(a, b) ((a) < (b) ? (a) : (b))
typedef long long LL;
struct position {
LL x;
LL y;
LL count;
};
int main() {
LL w, h;
LL houkou[5] = {0, 1, 0, -1, 0};
cin >> w >> h;
vector<vector<LL>> field(h, vector<LL>(w));
list<struct position> spring;
char c;
LL sx, sy, gx, gy;
LL numofFloor = 0;
for (LL i = 0; i < h; i++) {
for (LL j = 0; j < w; j++) {
cin >> c;
if (c == '.') {
field[i][j] = 1;
numofFloor++;
} else if (c == '#') {
field[i][j] = 0;
} else if (c == '*') {
field[i][j] = 2;
spring.push_back({j, i, 0});
} else if (c == 's') {
field[i][j] = 1;
sx = j;
sy = i;
numofFloor++;
} else {
field[i][j] = 3;
gx = j;
gy = i;
}
}
}
vector<vector<LL>> toGoal(h, vector<LL>(w, 0));
vector<vector<LL>> toSpring(h, vector<LL>(w, 0));
queue<struct position> bfs;
struct position now;
LL nx, ny;
bfs.push({gx, gy, 0});
while (!bfs.empty()) {
now = bfs.front();
bfs.pop();
for (LL i = 0; i < 4; i++) {
nx = now.x + houkou[i];
ny = now.y + houkou[i + 1];
if (0 <= nx && nx <= w && 0 <= ny && ny <= h) {
if (toGoal[ny][nx] == 0 && field[ny][nx] == 1) {
toGoal[ny][nx] = now.count + 1;
bfs.push({nx, ny, now.count + 1});
}
}
}
}
for (auto itr = spring.begin(); itr != spring.end(); itr++) {
bfs.push({(*itr).x, (*itr).y, 0});
}
while (!bfs.empty()) {
now = bfs.front();
bfs.pop();
for (LL i = 0; i < 4; i++) {
nx = now.x + houkou[i];
ny = now.y + houkou[i + 1];
if (0 <= nx && nx <= w && 0 <= ny && ny <= h) {
if (toSpring[ny][nx] == 0 && field[ny][nx] == 1) {
toSpring[ny][nx] = now.count + 1;
bfs.push({nx, ny, now.count + 1});
}
}
}
}
// for(LL i=0;i<h;i++){
// for(LL j=0;j<w;j++){
// cout << toGoal[i][j] << " ";
// }
// cout << endl;
// }
// cout << endl;
// for(LL i=0;i<h;i++){
// for(LL j=0;j<w;j++){
// cout << toSpring[i][j] << " ";
// }
// cout << endl;
// }
// cout << numofFloor << endl;
cout << fixed << setprecision(12);
double left = 0;
double right = 10000000000000000;
double mid;
double count;
int spcount = 0;
while (right - left > 0.0000000002 * right) {
mid = (left + right) / 2;
spcount = 0;
count = 0;
for (LL i = 1; i < h - 1; i++) {
for (LL j = 1; j < w - 1; j++) {
if (field[i][j] == 1) {
if (toGoal[i][j] != 0) {
if (toSpring[i][j] != 0) {
if ((double)toGoal[i][j] <
(double)toSpring[i][j] + (double)mid / (double)numofFloor) {
count += (double)toGoal[i][j];
} else {
count += (double)toSpring[i][j];
spcount++;
}
} else {
count += (double)toGoal[i][j];
}
} else {
if (toSpring[i][j] != 0) {
count += (double)toSpring[i][j];
spcount++;
}
}
}
}
}
count += (double)mid * (double)spcount / (double)numofFloor;
if (count < mid) {
right = mid;
} else {
left = mid;
}
}
// cout << left << endl;
// cout << right << endl;
// cout << count << endl;
// cout << toSpring[sy][sx] << endl;
// for(LL i=0;i<h;i++){
// for(LL j=0;j<w;j++){
// if(field[i][j]==1){
// if(toGoal[i][j]!=0){
// if(toSpring[i][j]!=0){
// cout <<
// min((double)toGoal[i][j],(double)toSpring[i][j]+(double)left/(double)numofFloor)
// << " ";
// }else{
// cout << (double)toGoal[i][j] << " ";
// }
// }else{
// if(toSpring[sy][sx]!=0) cout <<
// (double)toSpring[i][j]+(double)left/(double)numofFloor << " ";
// }
// }else{
// cout << 0 << " ";
// }
// }
// cout << endl;
// }
if (toGoal[sy][sx] != 0) {
if (toSpring[sy][sx] != 0) {
cout << min((double)toGoal[sy][sx],
(double)toSpring[sy][sx] + (double)left / (double)numofFloor)
<< endl;
} else {
cout << (double)toGoal[sy][sx] << endl;
}
} else {
if (toSpring[sy][sx] != 0)
cout << (double)toSpring[sy][sx] + (double)left / (double)numofFloor
<< endl;
}
return 0;
}
| replace | 103 | 104 | 103 | 104 | TLE | |
p01453 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define reep(i, a, b) for (int i = (a); i < (b); i++)
#define rep(i, n) reep((i), 0, (n))
#define PB push_back
#define mkp make_pair
#define F first
#define S second
#define INF 0x3f3f3f3f
#define EPS 1e-8
typedef vector<int> vint;
typedef pair<int, int> pii;
int main() {
int H, W;
cin >> W >> H;
vector<string> v(H);
rep(i, H) cin >> v[i];
vector<vint> vv1(H, vint(W, INF));
vector<vint> vv2(H, vint(W, INF));
pii s;
queue<pii> q1, q2;
long double p = 0;
rep(i, H) {
rep(j, W) {
if (v[i][j] == 'g') {
q1.push(pii(i, j));
} else if (v[i][j] == 's') {
s = pii(i, j);
v[i][j] = '.';
p += 1.0;
} else if (v[i][j] == '*') {
q2.push(pii(i, j));
} else if (v[i][j] == '.') {
p += 1.0;
}
}
}
p = 1 / p;
int cnt = 0;
int dd[] = {0, 1, 0, -1, 0};
while (q1.size()) {
int qs = q1.size();
rep(i, qs) {
pii top = q1.front();
q1.pop();
if (vv1[top.F][top.S] != INF)
continue;
vv1[top.F][top.S] = cnt;
rep(j, 4) {
pii nex = top;
nex.F += dd[j];
nex.S += dd[j + 1];
if (v[nex.F][nex.S] == '#')
continue;
if (v[nex.F][nex.S] == '*')
continue;
q1.push(nex);
}
}
cnt++;
}
cnt = 0;
while (q2.size()) {
int qs = q2.size();
rep(i, qs) {
pii top = q2.front();
q2.pop();
if (vv2[top.F][top.S] != INF)
continue;
vv2[top.F][top.S] = cnt;
rep(j, 4) {
pii nex = top;
nex.F += dd[j];
nex.S += dd[j + 1];
if (v[nex.F][nex.S] == '#')
continue;
if (v[nex.F][nex.S] == '*')
continue;
q2.push(nex);
}
}
cnt++;
}
int maxn = 0;
rep(i, H) rep(j, W) {
if (vv1[i][j] != INF)
maxn = max(maxn, vv1[i][j]);
if (vv2[i][j] != INF)
maxn = max(maxn, vv2[i][j]);
}
map<pair<int, int>, int> ma;
double bb = 0;
rep(i, H) {
rep(j, W) {
if (v[i][j] != '.')
continue;
int x = vv1[i][j];
int y = vv2[i][j];
int t = min(x, y);
bb += t * p;
x -= t;
y -= t;
pii z = pii(x, y);
if (ma.count(z) == 0)
ma[z] = 0;
ma[z] += 1;
}
}
long double ans = 1e100;
rep(o, maxn + 1) {
long double a = 0;
long double b = bb;
for (auto x : ma) {
if (x.F.F - x.F.S <= o) {
b += p * x.F.F * x.S;
} else {
b += p * x.F.S * x.S;
a += p * x.S;
}
}
long double e = b / (1 - a);
long double tmp;
if (vv1[s.F][s.S] - vv2[s.F][s.S] <= o)
tmp = vv1[s.F][s.S];
else
tmp = vv2[s.F][s.S] + e;
ans = min(ans, tmp);
}
cout << fixed << setprecision(20);
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define reep(i, a, b) for (int i = (a); i < (b); i++)
#define rep(i, n) reep((i), 0, (n))
#define PB push_back
#define mkp make_pair
#define F first
#define S second
#define INF 0x3f3f3f3f
#define EPS 1e-8
typedef vector<int> vint;
typedef pair<int, int> pii;
int main() {
int H, W;
cin >> W >> H;
vector<string> v(H);
rep(i, H) cin >> v[i];
vector<vint> vv1(H, vint(W, INF));
vector<vint> vv2(H, vint(W, INF));
pii s;
queue<pii> q1, q2;
long double p = 0;
rep(i, H) {
rep(j, W) {
if (v[i][j] == 'g') {
q1.push(pii(i, j));
} else if (v[i][j] == 's') {
s = pii(i, j);
v[i][j] = '.';
p += 1.0;
} else if (v[i][j] == '*') {
q2.push(pii(i, j));
} else if (v[i][j] == '.') {
p += 1.0;
}
}
}
p = 1 / p;
int cnt = 0;
int dd[] = {0, 1, 0, -1, 0};
while (q1.size()) {
int qs = q1.size();
rep(i, qs) {
pii top = q1.front();
q1.pop();
if (vv1[top.F][top.S] != INF)
continue;
vv1[top.F][top.S] = cnt;
rep(j, 4) {
pii nex = top;
nex.F += dd[j];
nex.S += dd[j + 1];
if (v[nex.F][nex.S] == '#')
continue;
if (v[nex.F][nex.S] == '*')
continue;
q1.push(nex);
}
}
cnt++;
}
cnt = 0;
while (q2.size()) {
int qs = q2.size();
rep(i, qs) {
pii top = q2.front();
q2.pop();
if (vv2[top.F][top.S] != INF)
continue;
vv2[top.F][top.S] = cnt;
rep(j, 4) {
pii nex = top;
nex.F += dd[j];
nex.S += dd[j + 1];
if (v[nex.F][nex.S] == '#')
continue;
if (v[nex.F][nex.S] == '*')
continue;
q2.push(nex);
}
}
cnt++;
}
int maxn = 0;
rep(i, H) rep(j, W) {
if (vv1[i][j] != INF)
maxn = max(maxn, vv1[i][j]);
}
map<pair<int, int>, int> ma;
double bb = 0;
rep(i, H) {
rep(j, W) {
if (v[i][j] != '.')
continue;
int x = vv1[i][j];
int y = vv2[i][j];
int t = min(x, y);
bb += t * p;
x -= t;
y -= t;
pii z = pii(x, y);
if (ma.count(z) == 0)
ma[z] = 0;
ma[z] += 1;
}
}
long double ans = 1e100;
rep(o, maxn + 1) {
long double a = 0;
long double b = bb;
for (auto x : ma) {
if (x.F.F - x.F.S <= o) {
b += p * x.F.F * x.S;
} else {
b += p * x.F.S * x.S;
a += p * x.S;
}
}
long double e = b / (1 - a);
long double tmp;
if (vv1[s.F][s.S] - vv2[s.F][s.S] <= o)
tmp = vv1[s.F][s.S];
else
tmp = vv2[s.F][s.S] + e;
ans = min(ans, tmp);
}
cout << fixed << setprecision(20);
cout << ans << endl;
} | delete | 90 | 92 | 90 | 90 | TLE | |
p01453 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
/*
*/
using namespace std;
typedef pair<long long int, pair<long long int, long long int>> one;
#define mod 1000000007LL
int main() {
long long int W, H;
cin >> W >> H;
vector<string> D(H);
long long int counttile = 0;
pair<long long int, long long int> start, goal;
vector<pair<long long int, long long int>> warp;
vector<vector<pair<long long int, long long int>>> len(
H, vector<pair<long long int, long long int>>(
W, make_pair(LLONG_MAX / 500 / 500 / 500,
LLONG_MAX / 500 / 500 / 500)));
vector<pair<long long int, long long int>> tile;
for (size_t i = 0; i < H; i++) {
cin >> D[i];
for (size_t j = 0; j < D[i].length(); j++) {
if (D[i][j] == 's') {
D[i][j] = '.';
tile.push_back(make_pair(i, j));
start.first = i;
start.second = j;
counttile++;
} else if (D[i][j] == 'g') {
goal.first = i;
goal.second = j;
} else if (D[i][j] == '*') {
warp.push_back(make_pair(i, j));
} else if (D[i][j] == '.') {
counttile++;
tile.push_back(make_pair(i, j));
}
}
}
int dx[] = {0, 1, 0, -1};
int dy[] = {1, 0, -1, 0};
{
priority_queue<one, vector<one>, greater<one>> que;
que.push(make_pair(0, goal));
while (que.size()) {
auto now = que.top();
que.pop();
for (size_t i = 0; i < 4; i++) {
auto next = now;
next.first++;
next.second.first += dx[i];
next.second.second += dy[i];
if (0 <= next.second.first && next.second.first < H &&
0 <= next.second.second && next.second.second < W) {
if (D[next.second.first][next.second.second] == '.') {
if (len[next.second.first][next.second.second].first > next.first) {
len[next.second.first][next.second.second].first = next.first;
que.push(next);
}
}
}
}
}
}
queue<one> que;
for (auto x : warp) {
que.push(make_pair(0, x));
}
while (que.size()) {
auto now = que.front();
que.pop();
if (len[now.second.first][now.second.second].second < now.first) {
continue;
}
for (size_t i = 0; i < 4; i++) {
auto next = now;
next.first++;
next.second.first += dx[i];
next.second.second += dy[i];
if (0 <= next.second.first && next.second.first < H &&
0 <= next.second.second && next.second.second < W) {
if (D[next.second.first][next.second.second] == '.') {
if (len[next.second.first][next.second.second].second > next.first) {
len[next.second.first][next.second.second].second = next.first;
que.push(next);
}
}
}
}
}
long double maxExpectedValue = W * H * W * H, minExpectedValue = 0;
for (size_t indexindex = 0; indexindex < 16300; indexindex++) {
long double midExpectedValue = (maxExpectedValue + minExpectedValue) / 2.L;
// cout << fixed << setprecision( 20 ) << maxExpectedValue << " " <<
// minExpectedValue << endl;
long double countExpectedValue = 0;
for (auto point : tile) {
long long int i = point.first, j = point.second;
countExpectedValue +=
min(1.L * len[i][j].first, len[i][j].second + midExpectedValue);
}
countExpectedValue /= counttile;
if (midExpectedValue < countExpectedValue) {
minExpectedValue = midExpectedValue;
} else {
maxExpectedValue = midExpectedValue;
}
}
// cout << fixed << setprecision( 20 ) << 1.L*
// len[start.first][start.second].first << " " <<
// len[start.first][start.second].second + maxExpectedValue << endl;
cout << fixed << setprecision(20)
<< min(1.L * len[start.first][start.second].first,
len[start.first][start.second].second + maxExpectedValue)
<< endl;
} | #include <bits/stdc++.h>
/*
*/
using namespace std;
typedef pair<long long int, pair<long long int, long long int>> one;
#define mod 1000000007LL
int main() {
long long int W, H;
cin >> W >> H;
vector<string> D(H);
long long int counttile = 0;
pair<long long int, long long int> start, goal;
vector<pair<long long int, long long int>> warp;
vector<vector<pair<long long int, long long int>>> len(
H, vector<pair<long long int, long long int>>(
W, make_pair(LLONG_MAX / 500 / 500 / 500,
LLONG_MAX / 500 / 500 / 500)));
vector<pair<long long int, long long int>> tile;
for (size_t i = 0; i < H; i++) {
cin >> D[i];
for (size_t j = 0; j < D[i].length(); j++) {
if (D[i][j] == 's') {
D[i][j] = '.';
tile.push_back(make_pair(i, j));
start.first = i;
start.second = j;
counttile++;
} else if (D[i][j] == 'g') {
goal.first = i;
goal.second = j;
} else if (D[i][j] == '*') {
warp.push_back(make_pair(i, j));
} else if (D[i][j] == '.') {
counttile++;
tile.push_back(make_pair(i, j));
}
}
}
int dx[] = {0, 1, 0, -1};
int dy[] = {1, 0, -1, 0};
{
priority_queue<one, vector<one>, greater<one>> que;
que.push(make_pair(0, goal));
while (que.size()) {
auto now = que.top();
que.pop();
for (size_t i = 0; i < 4; i++) {
auto next = now;
next.first++;
next.second.first += dx[i];
next.second.second += dy[i];
if (0 <= next.second.first && next.second.first < H &&
0 <= next.second.second && next.second.second < W) {
if (D[next.second.first][next.second.second] == '.') {
if (len[next.second.first][next.second.second].first > next.first) {
len[next.second.first][next.second.second].first = next.first;
que.push(next);
}
}
}
}
}
}
queue<one> que;
for (auto x : warp) {
que.push(make_pair(0, x));
}
while (que.size()) {
auto now = que.front();
que.pop();
if (len[now.second.first][now.second.second].second < now.first) {
continue;
}
for (size_t i = 0; i < 4; i++) {
auto next = now;
next.first++;
next.second.first += dx[i];
next.second.second += dy[i];
if (0 <= next.second.first && next.second.first < H &&
0 <= next.second.second && next.second.second < W) {
if (D[next.second.first][next.second.second] == '.') {
if (len[next.second.first][next.second.second].second > next.first) {
len[next.second.first][next.second.second].second = next.first;
que.push(next);
}
}
}
}
}
long double maxExpectedValue = W * H * 100000, minExpectedValue = 0;
for (size_t indexindex = 0; indexindex < 16300; indexindex++) {
long double midExpectedValue = (maxExpectedValue + minExpectedValue) / 2.L;
// cout << fixed << setprecision( 20 ) << maxExpectedValue << " " <<
// minExpectedValue << endl;
long double countExpectedValue = 0;
for (auto point : tile) {
long long int i = point.first, j = point.second;
countExpectedValue +=
min(1.L * len[i][j].first, len[i][j].second + midExpectedValue);
}
countExpectedValue /= counttile;
if (midExpectedValue < countExpectedValue) {
minExpectedValue = midExpectedValue;
} else {
maxExpectedValue = midExpectedValue;
}
}
// cout << fixed << setprecision( 20 ) << 1.L*
// len[start.first][start.second].first << " " <<
// len[start.first][start.second].second + maxExpectedValue << endl;
cout << fixed << setprecision(20)
<< min(1.L * len[start.first][start.second].first,
len[start.first][start.second].second + maxExpectedValue)
<< endl;
} | replace | 93 | 94 | 93 | 94 | TLE | |
p01457 | C++ | Runtime Error | // Header {{{
// includes {{{
#include <algorithm>
#include <cassert>
#include <cctype>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iostream>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <sys/time.h>
#include <unistd.h>
#include <vector>
// }}}
using namespace std;
// consts {{{
static const int INF = 1e9;
static const double PI = acos(-1.0);
static const double EPS = 1e-10;
// }}}
// typedefs {{{
typedef long long int LL;
typedef unsigned long long int ULL;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
typedef vector<ULL> VULL;
typedef vector<VULL> VVULL;
typedef vector<double> VD;
typedef vector<VD> VVD;
typedef vector<bool> VB;
typedef vector<VB> VVB;
typedef vector<char> VC;
typedef vector<VC> VVC;
typedef vector<string> VS;
typedef vector<VS> VVS;
typedef pair<int, int> PII;
typedef complex<int> P;
// }}}
// macros & inline functions {{{
// syntax sugars {{{
#define FOR(i, b, e) for (typeof(e) i = (b); i < (e); ++i)
#define FORI(i, b, e) for (typeof(e) i = (b); i <= (e); ++i)
#define REP(i, n) FOR(i, 0, n)
#define REPI(i, n) FORI(i, 0, n)
#define OPOVER(_op, _type) inline bool operator _op(const _type &t) const
// }}}
// conversion {{{
inline int toInt(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();
}
// }}}
// array and STL {{{
#define ARRSIZE(a) (sizeof(a) / sizeof(a[0]))
#define ZERO(a, v) (assert(v == 0 || v == -1), memset(a, v, sizeof(a)))
#define F first
#define S second
#define MP(a, b) make_pair(a, b)
#define SIZE(a) ((LL)a.size())
#define PB(e) push_back(e)
#define SORT(v) sort((v).begin(), (v).end())
#define RSORT(v) sort((v).rbegin(), (v).rend())
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define EACH(c, it) \
for (typeof((c).begin()) it = (c).begin(); it != (c).end(); ++it)
#define REACH(c, it) \
for (typeof((c).rbegin()) it = (c).rbegin(); it != (c).rend(); ++it)
#define EXIST(s, e) ((s).find(e) != (s).end())
// }}}
// bit manipulation {{{
// singed integers are not for bitwise operations, specifically arithmetic
// shifts ('>>', and maybe not good for '<<' too)
#define IS_UNSIGNED(n) (!numeric_limits<typeof(n)>::is_signed)
#define BIT(n) (assert(IS_UNSIGNED(n)), assert(n < 64), (1ULL << (n)))
#define BITOF(n, m) \
(assert(IS_UNSIGNED(n)), assert(m < 64), ((ULL)(n) >> (m)&1))
inline int BITS_COUNT(ULL b) {
int c = 0;
while (b != 0) {
c += (b & 1);
b >>= 1;
}
return c;
}
inline int MSB(ULL b) {
int c = 0;
while (b != 0) {
++c;
b >>= 1;
}
return c - 1;
}
inline int MAKE_MASK(ULL upper, ULL lower) {
assert(lower < 64 && upper < 64 && lower <= upper);
return (BIT(upper) - 1) ^ (BIT(lower) - 1);
}
// }}}
// for readable code {{{
#define EVEN(n) (n % 2 == 0)
#define ODD(n) (!EVEN(n))
// }}}
// debug {{{
#define arrsz(a) (sizeof(a) / sizeof(a[0]))
#define dprt(fmt, ...) \
if (opt_debug) { \
fprintf(stderr, fmt, ##__VA_ARGS__); \
}
#define darr(a) \
if (opt_debug) { \
copy((a), (a) + arrsz(a), ostream_iterator<int>(cerr, " ")); \
cerr << endl; \
}
#define darr_range(a, f, t) \
if (opt_debug) { \
copy((a) + (f), (a) + (t), ostream_iterator<int>(cerr, " ")); \
cerr << endl; \
}
#define dvec(v) \
if (opt_debug) { \
copy(ALL(v), ostream_iterator<int>(cerr, " ")); \
cerr << endl; \
}
#define darr2(a) \
if (opt_debug) { \
FOR(__i, 0, (arrsz(a))) { darr((a)[__i]); } \
}
#define WAIT() \
if (opt_debug) { \
string _wait_; \
cerr << "(hit return to continue)" << endl; \
getline(cin, _wait_); \
}
#define dump(x) \
if (opt_debug) { \
cerr << " [L" << __LINE__ << "] " << #x << " = " << (x) << endl; \
}
#define dumpl(x) \
if (opt_debug) { \
cerr << " [L" << __LINE__ << "] " << #x << endl << (x) << endl; \
}
#define dumpf() \
if (opt_debug) { \
cerr << __PRETTY_FUNCTION__ << endl; \
}
#define where() \
if (opt_debug) { \
cerr << __FILE__ << ": " << __PRETTY_FUNCTION__ << " [L: " << __LINE__ \
<< "]" << endl; \
}
#define show_bits(b, s) \
if (opt_debug) { \
REP(i, s) { \
cerr << BITOF(b, s - 1 - i); \
if (i % 4 == 3) \
cerr << ' '; \
} \
cerr << endl; \
}
// ostreams {{{
// complex
template <typename T> ostream &operator<<(ostream &s, const complex<T> &d) {
return s << "(" << d.real() << ", " << d.imag() << ")";
}
// pair
template <typename T1, typename T2>
ostream &operator<<(ostream &s, const pair<T1, T2> &d) {
return s << "(" << d.first << ", " << d.second << ")";
}
// vector
template <typename T> ostream &operator<<(ostream &s, const vector<T> &d) {
int len = d.size();
REP(i, len) {
s << d[i];
if (i < len - 1)
s << "\t";
}
return s;
}
// 2 dimentional vector
template <typename T>
ostream &operator<<(ostream &s, const vector<vector<T>> &d) {
int len = d.size();
REP(i, len) { s << d[i] << endl; }
return s;
}
// map
template <typename T1, typename T2>
ostream &operator<<(ostream &s, const map<T1, T2> &m) {
s << "{" << endl;
for (typeof(m.begin()) itr = m.begin(); itr != m.end(); ++itr) {
s << "\t" << (*itr).first << " : " << (*itr).second << endl;
}
s << "}" << endl;
return s;
}
// }}}
// }}}
// }}}
// time {{{
inline double now() {
struct timeval tv;
gettimeofday(&tv, NULL);
return (static_cast<double>(tv.tv_sec) +
static_cast<double>(tv.tv_usec) * 1e-6);
}
// }}}
// string manipulation {{{
inline VS split(string s, char delimiter) {
VS v;
string t;
REP(i, s.length()) {
if (s[i] == delimiter)
v.PB(t), t = "";
else
t += s[i];
}
v.PB(t);
return v;
}
inline string join(VS s, string j) {
string t;
REP(i, s.size()) { t += s[i] + j; }
return t;
}
// }}}
// geometry {{{
#define Y real()
#define X imag()
// }}}
// 2 dimentional array {{{
P dydx4[4] = {P(-1, 0), P(0, 1), P(1, 0), P(0, -1)};
P dydx8[8] = {P(-1, 0), P(0, 1), P(1, 0), P(0, -1),
P(-1, 1), P(1, 1), P(1, -1), P(-1, -1)};
int g_height, g_width;
bool in_field(P p) {
return (0 <= p.Y && p.Y < g_height) && (0 <= p.X && p.X < g_width);
}
// }}}
// input and output {{{
inline void input(string filename) { freopen(filename.c_str(), "r", stdin); }
inline void output(string filename) { freopen(filename.c_str(), "w", stdout); }
// }}}
// }}}
// Header under development {{{
int LCM(int a, int b) {
// FIXME
return a * b;
}
// Fraction class {{{
// ref: http://martin-thoma.com/fractions-in-cpp/
class Fraction {
public:
ULL numerator;
ULL denominator;
Fraction(ULL _numerator, ULL _denominator) {
assert(_denominator > 0);
numerator = _numerator;
denominator = _denominator;
};
Fraction operator*(const ULL rhs) {
return Fraction(this->numerator * rhs, this->denominator);
};
Fraction operator*(const Fraction &rhs) {
return Fraction(this->numerator * rhs.numerator,
this->denominator * rhs.denominator);
}
Fraction operator+(const Fraction &rhs) {
ULL lcm = LCM(this->denominator, rhs.denominator);
ULL numer_lhs = this->numerator * (this->denominator / lcm);
ULL numer_rhs = rhs.numerator * (rhs.numerator / lcm);
return Fraction(numer_lhs + numer_rhs, lcm);
}
Fraction &operator+=(const Fraction &rhs) {
Fraction result = (*this) + rhs;
this->numerator = result.numerator;
this->denominator = result.denominator;
return *this;
}
};
std::ostream &operator<<(std::ostream &s, const Fraction &a) {
if (a.denominator == 1) {
s << a.numerator;
} else {
s << a.numerator << "/" << a.denominator;
}
return s;
}
// }}}
// }}}
bool opt_debug = false;
int main(int argc, char **argv) {
std::ios_base::sync_with_stdio(false);
// set options {{{
int __c;
while ((__c = getopt(argc, argv, "d")) != -1) {
switch (__c) {
case 'd':
opt_debug = true;
break;
default:
abort();
}
}
// }}}
input("./inputs/1.txt");
// output("./outputs/0.txt");
int q;
cin >> q;
ULL r_cnt = 0, l_cnt = 0;
while (q--) {
int p;
char c;
int n;
cin >> p >> c >> n;
if (c == '(') {
r_cnt += n;
} else {
l_cnt += n;
}
if (r_cnt == l_cnt) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
return 0;
}
// vim: foldmethod=marker | // Header {{{
// includes {{{
#include <algorithm>
#include <cassert>
#include <cctype>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iostream>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <sys/time.h>
#include <unistd.h>
#include <vector>
// }}}
using namespace std;
// consts {{{
static const int INF = 1e9;
static const double PI = acos(-1.0);
static const double EPS = 1e-10;
// }}}
// typedefs {{{
typedef long long int LL;
typedef unsigned long long int ULL;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
typedef vector<ULL> VULL;
typedef vector<VULL> VVULL;
typedef vector<double> VD;
typedef vector<VD> VVD;
typedef vector<bool> VB;
typedef vector<VB> VVB;
typedef vector<char> VC;
typedef vector<VC> VVC;
typedef vector<string> VS;
typedef vector<VS> VVS;
typedef pair<int, int> PII;
typedef complex<int> P;
// }}}
// macros & inline functions {{{
// syntax sugars {{{
#define FOR(i, b, e) for (typeof(e) i = (b); i < (e); ++i)
#define FORI(i, b, e) for (typeof(e) i = (b); i <= (e); ++i)
#define REP(i, n) FOR(i, 0, n)
#define REPI(i, n) FORI(i, 0, n)
#define OPOVER(_op, _type) inline bool operator _op(const _type &t) const
// }}}
// conversion {{{
inline int toInt(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();
}
// }}}
// array and STL {{{
#define ARRSIZE(a) (sizeof(a) / sizeof(a[0]))
#define ZERO(a, v) (assert(v == 0 || v == -1), memset(a, v, sizeof(a)))
#define F first
#define S second
#define MP(a, b) make_pair(a, b)
#define SIZE(a) ((LL)a.size())
#define PB(e) push_back(e)
#define SORT(v) sort((v).begin(), (v).end())
#define RSORT(v) sort((v).rbegin(), (v).rend())
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define EACH(c, it) \
for (typeof((c).begin()) it = (c).begin(); it != (c).end(); ++it)
#define REACH(c, it) \
for (typeof((c).rbegin()) it = (c).rbegin(); it != (c).rend(); ++it)
#define EXIST(s, e) ((s).find(e) != (s).end())
// }}}
// bit manipulation {{{
// singed integers are not for bitwise operations, specifically arithmetic
// shifts ('>>', and maybe not good for '<<' too)
#define IS_UNSIGNED(n) (!numeric_limits<typeof(n)>::is_signed)
#define BIT(n) (assert(IS_UNSIGNED(n)), assert(n < 64), (1ULL << (n)))
#define BITOF(n, m) \
(assert(IS_UNSIGNED(n)), assert(m < 64), ((ULL)(n) >> (m)&1))
inline int BITS_COUNT(ULL b) {
int c = 0;
while (b != 0) {
c += (b & 1);
b >>= 1;
}
return c;
}
inline int MSB(ULL b) {
int c = 0;
while (b != 0) {
++c;
b >>= 1;
}
return c - 1;
}
inline int MAKE_MASK(ULL upper, ULL lower) {
assert(lower < 64 && upper < 64 && lower <= upper);
return (BIT(upper) - 1) ^ (BIT(lower) - 1);
}
// }}}
// for readable code {{{
#define EVEN(n) (n % 2 == 0)
#define ODD(n) (!EVEN(n))
// }}}
// debug {{{
#define arrsz(a) (sizeof(a) / sizeof(a[0]))
#define dprt(fmt, ...) \
if (opt_debug) { \
fprintf(stderr, fmt, ##__VA_ARGS__); \
}
#define darr(a) \
if (opt_debug) { \
copy((a), (a) + arrsz(a), ostream_iterator<int>(cerr, " ")); \
cerr << endl; \
}
#define darr_range(a, f, t) \
if (opt_debug) { \
copy((a) + (f), (a) + (t), ostream_iterator<int>(cerr, " ")); \
cerr << endl; \
}
#define dvec(v) \
if (opt_debug) { \
copy(ALL(v), ostream_iterator<int>(cerr, " ")); \
cerr << endl; \
}
#define darr2(a) \
if (opt_debug) { \
FOR(__i, 0, (arrsz(a))) { darr((a)[__i]); } \
}
#define WAIT() \
if (opt_debug) { \
string _wait_; \
cerr << "(hit return to continue)" << endl; \
getline(cin, _wait_); \
}
#define dump(x) \
if (opt_debug) { \
cerr << " [L" << __LINE__ << "] " << #x << " = " << (x) << endl; \
}
#define dumpl(x) \
if (opt_debug) { \
cerr << " [L" << __LINE__ << "] " << #x << endl << (x) << endl; \
}
#define dumpf() \
if (opt_debug) { \
cerr << __PRETTY_FUNCTION__ << endl; \
}
#define where() \
if (opt_debug) { \
cerr << __FILE__ << ": " << __PRETTY_FUNCTION__ << " [L: " << __LINE__ \
<< "]" << endl; \
}
#define show_bits(b, s) \
if (opt_debug) { \
REP(i, s) { \
cerr << BITOF(b, s - 1 - i); \
if (i % 4 == 3) \
cerr << ' '; \
} \
cerr << endl; \
}
// ostreams {{{
// complex
template <typename T> ostream &operator<<(ostream &s, const complex<T> &d) {
return s << "(" << d.real() << ", " << d.imag() << ")";
}
// pair
template <typename T1, typename T2>
ostream &operator<<(ostream &s, const pair<T1, T2> &d) {
return s << "(" << d.first << ", " << d.second << ")";
}
// vector
template <typename T> ostream &operator<<(ostream &s, const vector<T> &d) {
int len = d.size();
REP(i, len) {
s << d[i];
if (i < len - 1)
s << "\t";
}
return s;
}
// 2 dimentional vector
template <typename T>
ostream &operator<<(ostream &s, const vector<vector<T>> &d) {
int len = d.size();
REP(i, len) { s << d[i] << endl; }
return s;
}
// map
template <typename T1, typename T2>
ostream &operator<<(ostream &s, const map<T1, T2> &m) {
s << "{" << endl;
for (typeof(m.begin()) itr = m.begin(); itr != m.end(); ++itr) {
s << "\t" << (*itr).first << " : " << (*itr).second << endl;
}
s << "}" << endl;
return s;
}
// }}}
// }}}
// }}}
// time {{{
inline double now() {
struct timeval tv;
gettimeofday(&tv, NULL);
return (static_cast<double>(tv.tv_sec) +
static_cast<double>(tv.tv_usec) * 1e-6);
}
// }}}
// string manipulation {{{
inline VS split(string s, char delimiter) {
VS v;
string t;
REP(i, s.length()) {
if (s[i] == delimiter)
v.PB(t), t = "";
else
t += s[i];
}
v.PB(t);
return v;
}
inline string join(VS s, string j) {
string t;
REP(i, s.size()) { t += s[i] + j; }
return t;
}
// }}}
// geometry {{{
#define Y real()
#define X imag()
// }}}
// 2 dimentional array {{{
P dydx4[4] = {P(-1, 0), P(0, 1), P(1, 0), P(0, -1)};
P dydx8[8] = {P(-1, 0), P(0, 1), P(1, 0), P(0, -1),
P(-1, 1), P(1, 1), P(1, -1), P(-1, -1)};
int g_height, g_width;
bool in_field(P p) {
return (0 <= p.Y && p.Y < g_height) && (0 <= p.X && p.X < g_width);
}
// }}}
// input and output {{{
inline void input(string filename) { freopen(filename.c_str(), "r", stdin); }
inline void output(string filename) { freopen(filename.c_str(), "w", stdout); }
// }}}
// }}}
// Header under development {{{
int LCM(int a, int b) {
// FIXME
return a * b;
}
// Fraction class {{{
// ref: http://martin-thoma.com/fractions-in-cpp/
class Fraction {
public:
ULL numerator;
ULL denominator;
Fraction(ULL _numerator, ULL _denominator) {
assert(_denominator > 0);
numerator = _numerator;
denominator = _denominator;
};
Fraction operator*(const ULL rhs) {
return Fraction(this->numerator * rhs, this->denominator);
};
Fraction operator*(const Fraction &rhs) {
return Fraction(this->numerator * rhs.numerator,
this->denominator * rhs.denominator);
}
Fraction operator+(const Fraction &rhs) {
ULL lcm = LCM(this->denominator, rhs.denominator);
ULL numer_lhs = this->numerator * (this->denominator / lcm);
ULL numer_rhs = rhs.numerator * (rhs.numerator / lcm);
return Fraction(numer_lhs + numer_rhs, lcm);
}
Fraction &operator+=(const Fraction &rhs) {
Fraction result = (*this) + rhs;
this->numerator = result.numerator;
this->denominator = result.denominator;
return *this;
}
};
std::ostream &operator<<(std::ostream &s, const Fraction &a) {
if (a.denominator == 1) {
s << a.numerator;
} else {
s << a.numerator << "/" << a.denominator;
}
return s;
}
// }}}
// }}}
bool opt_debug = false;
int main(int argc, char **argv) {
std::ios_base::sync_with_stdio(false);
// set options {{{
int __c;
while ((__c = getopt(argc, argv, "d")) != -1) {
switch (__c) {
case 'd':
opt_debug = true;
break;
default:
abort();
}
}
// }}}
// input("./inputs/1.txt");
// output("./outputs/0.txt");
int q;
cin >> q;
ULL r_cnt = 0, l_cnt = 0;
while (q--) {
int p;
char c;
int n;
cin >> p >> c >> n;
if (c == '(') {
r_cnt += n;
} else {
l_cnt += n;
}
if (r_cnt == l_cnt) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
return 0;
}
// vim: foldmethod=marker | replace | 345 | 346 | 345 | 346 | 0 | |
p01459 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int N, M, A;
string s[111];
int dp[11][11][4][111][111];
bool in(int y, int x) { return 0 <= y && y < N && 0 <= x && x < M; }
int P(int d) {
if (d & 1)
return (d + 1) % 4;
return (d + 3) % 4;
}
int Q(int d) {
if (d & 1)
return (d + 3) % 4;
return (d + 1) % 4;
}
struct st {
int y, x, d, p, q;
st() {}
st(int y, int x, int d, int p, int q) : y(y), x(x), d(d), p(p), q(q) {}
};
signed main() {
cin >> N >> M >> A;
for (int i = 0; i < N; i++)
cin >> s[i];
int ans = A * 2 + 1;
int sy, sx;
for (int i = 0; i < N; i++)
for (int j = 0; j < M; j++)
if (s[i][j] == 'S')
sy = i, sx = j;
memset(dp, -1, sizeof(dp));
int ax[] = {0, 1, 0, -1};
int ay[] = {-1, 0, 1, 0};
deque<st> dq;
dq.push_back(st(sy, sx, 2, 0, 0));
dp[sy][sx][2][0][0] = 0;
while (!dq.empty()) {
st r = dq.front();
dq.pop_front();
int y = r.y, x = r.x, d = r.d, p = r.p, q = r.q;
// cout<<y<<" "<<x<<" "<<d<<" "<<p<<" "<<q<<endl;
if (p + q >= ans)
break;
if (s[y][x] == 'G') {
ans = min(ans, p + q);
break;
}
if (s[y][x] == 'S' && d == 0)
continue;
{
int ny = y + ay[d], nx = x + ax[d], nd = d;
if (in(ny, nx) && s[ny][nx] != '#') {
if (dp[ny][nx][nd][p][q] < 0 ||
dp[ny][nx][nd][p][q] > dp[y][x][d][p][q]) {
dp[ny][nx][nd][p][q] = dp[y][x][d][p][q];
dq.push_front(st(ny, nx, nd, p, q));
}
}
}
if (s[y][x] != 'S' && p < A) {
int nd = P(d);
int ny = y + ay[nd], nx = x + ax[nd];
if (in(ny, nx) && s[ny][nx] != '#') {
if (dp[ny][nx][nd][p + 1][q] < 0 ||
dp[ny][nx][nd][p + 1][q] > dp[y][x][d][p][q] + 1) {
dp[ny][nx][nd][p + 1][q] = dp[y][x][d][p][q] + 1;
// cout<<p+1<<" "<<q<<endl;
dq.push_back(st(ny, nx, nd, p + 1, q));
}
}
}
if (s[y][x] != 'S' && q < A) {
int nd = Q(d);
int ny = y + ay[nd], nx = x + ax[nd];
if (in(ny, nx) && s[ny][nx] != '#') {
if (dp[ny][nx][nd][p][q + 1] < 0 ||
dp[ny][nx][nd][p][q + 1] > dp[y][x][d][p][q] + 1) {
dp[ny][nx][nd][p][q + 1] = dp[y][x][d][p][q] + 1;
dq.push_back(st(ny, nx, nd, p, q + 1));
}
}
}
}
cout << (ans > A * 2 ? -1 : ans) << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int N, M, A;
string s[111];
int dp[111][111][4][11][11];
bool in(int y, int x) { return 0 <= y && y < N && 0 <= x && x < M; }
int P(int d) {
if (d & 1)
return (d + 1) % 4;
return (d + 3) % 4;
}
int Q(int d) {
if (d & 1)
return (d + 3) % 4;
return (d + 1) % 4;
}
struct st {
int y, x, d, p, q;
st() {}
st(int y, int x, int d, int p, int q) : y(y), x(x), d(d), p(p), q(q) {}
};
signed main() {
cin >> N >> M >> A;
for (int i = 0; i < N; i++)
cin >> s[i];
int ans = A * 2 + 1;
int sy, sx;
for (int i = 0; i < N; i++)
for (int j = 0; j < M; j++)
if (s[i][j] == 'S')
sy = i, sx = j;
memset(dp, -1, sizeof(dp));
int ax[] = {0, 1, 0, -1};
int ay[] = {-1, 0, 1, 0};
deque<st> dq;
dq.push_back(st(sy, sx, 2, 0, 0));
dp[sy][sx][2][0][0] = 0;
while (!dq.empty()) {
st r = dq.front();
dq.pop_front();
int y = r.y, x = r.x, d = r.d, p = r.p, q = r.q;
// cout<<y<<" "<<x<<" "<<d<<" "<<p<<" "<<q<<endl;
if (p + q >= ans)
break;
if (s[y][x] == 'G') {
ans = min(ans, p + q);
break;
}
if (s[y][x] == 'S' && d == 0)
continue;
{
int ny = y + ay[d], nx = x + ax[d], nd = d;
if (in(ny, nx) && s[ny][nx] != '#') {
if (dp[ny][nx][nd][p][q] < 0 ||
dp[ny][nx][nd][p][q] > dp[y][x][d][p][q]) {
dp[ny][nx][nd][p][q] = dp[y][x][d][p][q];
dq.push_front(st(ny, nx, nd, p, q));
}
}
}
if (s[y][x] != 'S' && p < A) {
int nd = P(d);
int ny = y + ay[nd], nx = x + ax[nd];
if (in(ny, nx) && s[ny][nx] != '#') {
if (dp[ny][nx][nd][p + 1][q] < 0 ||
dp[ny][nx][nd][p + 1][q] > dp[y][x][d][p][q] + 1) {
dp[ny][nx][nd][p + 1][q] = dp[y][x][d][p][q] + 1;
// cout<<p+1<<" "<<q<<endl;
dq.push_back(st(ny, nx, nd, p + 1, q));
}
}
}
if (s[y][x] != 'S' && q < A) {
int nd = Q(d);
int ny = y + ay[nd], nx = x + ax[nd];
if (in(ny, nx) && s[ny][nx] != '#') {
if (dp[ny][nx][nd][p][q + 1] < 0 ||
dp[ny][nx][nd][p][q + 1] > dp[y][x][d][p][q] + 1) {
dp[ny][nx][nd][p][q + 1] = dp[y][x][d][p][q] + 1;
dq.push_back(st(ny, nx, nd, p, q + 1));
}
}
}
}
cout << (ans > A * 2 ? -1 : ans) << endl;
return 0;
} | replace | 4 | 5 | 4 | 5 | 0 | |
p01461 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define reps(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define rep(i, n) reps(i, 0, n)
#define MAX_N 500005
using vint = vector<int>;
using Graph = vector<vint>;
int n;
Graph graph;
int dp1[MAX_N];
void dfs1(int root) {
memset(dp1, -1, sizeof(dp1));
stack<int> stk;
stk.push(root);
while (!stk.empty()) {
int u = stk.top();
if (dp1[u] == -1) {
dp1[u] = 2 - graph[u].size();
for (int v : graph[u]) {
stk.push(v);
}
} else {
for (int v : graph[u]) {
dp1[u] += dp1[v];
}
stk.pop();
}
}
}
int dp2[MAX_N];
int depth[MAX_N];
void dfs2(int root) {
memset(dp2, -1, sizeof(dp2));
stack<int> stk;
stk.push(root);
while (!stk.empty()) {
int u = stk.top();
if (dp2[u] == -1) {
dp2[u] = dp1[u];
for (int v : graph[u]) {
depth[v] = depth[u] + 1;
stk.push(v);
}
} else {
for (int v : graph[u]) {
dp2[u] += dp2[v];
}
stk.pop();
}
}
}
int dp3[MAX_N];
void dfs3(int root) {
memset(dp3, -1, sizeof(dp3));
stack<int> stk;
stk.push(root);
while (!stk.empty()) {
int u = stk.top();
if (dp3[u] == -1) {
dp3[u] = 0;
for (int v : graph[u]) {
stk.push(v);
}
} else {
if (graph[u].size() == 2) {
int l = graph[u][0], r = graph[u][1];
dp3[u] =
min({dp3[l] + 1 + dp3[r] + 1 + depth[u],
dp3[l] + 1 + dp2[r] + dp1[r], dp2[l] + dp1[l] + dp3[r] + 1});
} else if (graph[u].size() == 1) {
int ch = graph[u][0];
dp3[u] = min({dp3[ch] + 1 + 1 + depth[u], dp3[ch] + 1 + 1,
1 + dp2[ch] + dp1[ch]});
} else {
dp3[u] = dp1[u];
}
}
}
}
signed main() {
cin >> n;
graph.resize(n);
rep(i, n - 1) {
int a, b;
cin >> a >> b;
--a, --b;
if (a != n - 1)
graph[i].push_back(a);
if (b != n - 1)
graph[i].push_back(b);
}
dfs1(0);
dfs2(0);
dfs3(0);
cout << dp3[0] << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
#define reps(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define rep(i, n) reps(i, 0, n)
#define MAX_N 500005
using vint = vector<int>;
using Graph = vector<vint>;
int n;
Graph graph;
int dp1[MAX_N];
void dfs1(int root) {
memset(dp1, -1, sizeof(dp1));
stack<int> stk;
stk.push(root);
while (!stk.empty()) {
int u = stk.top();
if (dp1[u] == -1) {
dp1[u] = 2 - graph[u].size();
for (int v : graph[u]) {
stk.push(v);
}
} else {
for (int v : graph[u]) {
dp1[u] += dp1[v];
}
stk.pop();
}
}
}
int dp2[MAX_N];
int depth[MAX_N];
void dfs2(int root) {
memset(dp2, -1, sizeof(dp2));
stack<int> stk;
stk.push(root);
while (!stk.empty()) {
int u = stk.top();
if (dp2[u] == -1) {
dp2[u] = dp1[u];
for (int v : graph[u]) {
depth[v] = depth[u] + 1;
stk.push(v);
}
} else {
for (int v : graph[u]) {
dp2[u] += dp2[v];
}
stk.pop();
}
}
}
int dp3[MAX_N];
void dfs3(int root) {
memset(dp3, -1, sizeof(dp3));
stack<int> stk;
stk.push(root);
while (!stk.empty()) {
int u = stk.top();
if (dp3[u] == -1) {
dp3[u] = 0;
for (int v : graph[u]) {
stk.push(v);
}
} else {
if (graph[u].size() == 2) {
int l = graph[u][0], r = graph[u][1];
dp3[u] =
min({dp3[l] + 1 + dp3[r] + 1 + depth[u],
dp3[l] + 1 + dp2[r] + dp1[r], dp2[l] + dp1[l] + dp3[r] + 1});
} else if (graph[u].size() == 1) {
int ch = graph[u][0];
dp3[u] = min({dp3[ch] + 1 + 1 + depth[u], dp3[ch] + 1 + 1,
1 + dp2[ch] + dp1[ch]});
} else {
dp3[u] = dp1[u];
}
stk.pop();
}
}
}
signed main() {
cin >> n;
graph.resize(n);
rep(i, n - 1) {
int a, b;
cin >> a >> b;
--a, --b;
if (a != n - 1)
graph[i].push_back(a);
if (b != n - 1)
graph[i].push_back(b);
}
dfs1(0);
dfs2(0);
dfs3(0);
cout << dp3[0] << endl;
return 0;
}
| insert | 86 | 86 | 86 | 87 | TLE | |
p01462 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int V, E;
double P, Q;
vector<int> G[15];
void printbit(int S) {
for (int i = 0; i < V; i++) {
cout << (S >> i & 1) << ' ';
}
cout << endl;
}
double func(int S, int U) {
double res = 1;
for (int i = 0; i < V; i++) {
if (S >> i & 1) {
for (int j = 0; j < (int)G[i].size(); j++) {
int w = G[i][j];
if (S >> w & 1)
continue;
if (U >> w & 1)
res *= P;
}
}
}
return res;
}
double dp[(1 << 14)];
double rec(int S) {
if (dp[S] != -1)
return dp[S];
if (S == 1)
return 1.0;
double res = 0;
int sup = S;
int sub = sup;
do {
if (sub & 1) {
if (sub != S) {
double A = rec(sub);
double B = func(sub, S);
res += A * B;
}
}
sub = (sub - 1);
} while (sub != sup);
res = 1.0 - res;
return dp[S] = res;
}
void init() {
for (int i = 0; i < 15; i++)
G[i].clear();
for (int i = 0; i < (1 << 14); i++) {
dp[i] = -1;
}
}
bool check() {
bool visited[15] = {};
visited[0] = true;
queue<int> que;
que.push(0);
while (!que.empty()) {
int pos = que.front();
que.pop();
for (int i = 0; i < (int)G[pos].size(); i++) {
int w = G[pos][i];
if (visited[w])
continue;
visited[w] = true;
que.push(w);
}
}
for (int i = 0; i < V; i++)
if (!visited[i])
return false;
return true;
}
int main() {
while (cin >> V >> E >> P) {
init();
P /= 100.0;
Q = 1.0 - P;
for (int i = 0; i < E; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
G[a].push_back(b);
G[b].push_back(a);
}
if (!check()) {
printf("0.0\n");
continue;
}
printf("%.10f\n", rec((1 << V) - 1));
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int V, E;
double P, Q;
vector<int> G[15];
void printbit(int S) {
for (int i = 0; i < V; i++) {
cout << (S >> i & 1) << ' ';
}
cout << endl;
}
double func(int S, int U) {
double res = 1;
for (int i = 0; i < V; i++) {
if (S >> i & 1) {
for (int j = 0; j < (int)G[i].size(); j++) {
int w = G[i][j];
if (S >> w & 1)
continue;
if (U >> w & 1)
res *= P;
}
}
}
return res;
}
double dp[(1 << 14)];
double rec(int S) {
if (dp[S] != -1)
return dp[S];
if (S == 1)
return 1.0;
double res = 0;
int sup = S;
int sub = sup;
do {
if (sub & 1) {
if (sub != S) {
double A = rec(sub);
double B = func(sub, S);
res += A * B;
}
}
sub = (sub - 1) & sup;
} while (sub != sup);
res = 1.0 - res;
return dp[S] = res;
}
void init() {
for (int i = 0; i < 15; i++)
G[i].clear();
for (int i = 0; i < (1 << 14); i++) {
dp[i] = -1;
}
}
bool check() {
bool visited[15] = {};
visited[0] = true;
queue<int> que;
que.push(0);
while (!que.empty()) {
int pos = que.front();
que.pop();
for (int i = 0; i < (int)G[pos].size(); i++) {
int w = G[pos][i];
if (visited[w])
continue;
visited[w] = true;
que.push(w);
}
}
for (int i = 0; i < V; i++)
if (!visited[i])
return false;
return true;
}
int main() {
while (cin >> V >> E >> P) {
init();
P /= 100.0;
Q = 1.0 - P;
for (int i = 0; i < E; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
G[a].push_back(b);
G[b].push_back(a);
}
if (!check()) {
printf("0.0\n");
continue;
}
printf("%.10f\n", rec((1 << V) - 1));
}
return 0;
} | replace | 52 | 53 | 52 | 53 | -11 | |
p01463 | 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)
#define EPS (1e-8)
#define equals(a, b) (fabs((a) - (b)) < EPS)
#define COUNTER_CLOCKWISE 1
#define CLOCKWISE -1
#define ONLINE_BACK 2
#define ONLINE_FRONT -2
#define ON_SEGMENT 0
using namespace std;
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(a * x, a * y); }
Point operator/(double a) { return Point(x / a, y / a); }
Point operator*(Point a) {
return Point(x * a.x - y * a.y, x * a.y + y * a.x);
}
bool operator<(const Point &p) const {
return !equals(x, p.x) ? x < p.x : (!equals(y, p.y) && y < p.y);
}
bool operator==(const Point &p) const {
return fabs(x - p.x) < EPS && fabs(y - p.y) < EPS;
}
};
struct Segment {
Point p1, p2;
Segment(Point p1 = Point(), Point p2 = Point()) : p1(p1), p2(p2) {}
bool operator<(const Segment &s) const {
return (p2 == s.p2) ? p1 < s.p1 : p2 < s.p2;
}
bool operator==(const Segment &s) const {
return (s.p1 == p1 && s.p2 == p2) || (s.p1 == p2 && s.p2 == p1);
}
};
typedef Point Vector;
typedef Segment Line;
typedef vector<Point> Polygon;
ostream &operator<<(ostream &os, const Point &a) {
os << "(" << a.x << "," << a.y << ")";
}
ostream &operator<<(ostream &os, const Segment &a) {
os << "( " << a.p1 << " , " << a.p2 << " )";
}
double dot(Point a, Point b) { return a.x * b.x + a.y * b.y; }
double cross(Point a, Point b) { return a.x * b.y - a.y * b.x; }
double norm(Point a) { return a.x * a.x + a.y * a.y; }
double abs(Point a) { return sqrt(norm(a)); }
// rad は角度をラジアンで持たせること
Point rotate(Point a, double rad) {
return Point(cos(rad) * a.x - sin(rad) * a.y,
sin(rad) * a.x + cos(rad) * a.y);
}
// 度をラジアンに変換
double toRad(double agl) { return agl * M_PI / 180.0; }
// a => prev, b => cur, c=> next
// prev から cur へ行って next へ行く際の角度を求める
double getArg(Point a, Point b, Point c) {
double arg1 = atan2(b.y - a.y, b.x - a.x);
double arg2 = atan2(c.y - b.y, c.x - b.x);
double arg = fabs(arg1 - arg2);
while (arg > M_PI)
arg -= 2.0 * M_PI;
return fabs(arg);
}
int ccw(Point p0, Point p1, Point p2) {
Point a = p1 - p0;
Point b = p2 - p0;
if (cross(a, b) > EPS)
return COUNTER_CLOCKWISE;
if (cross(a, b) < -EPS)
return CLOCKWISE;
if (dot(a, b) < -EPS)
return ONLINE_BACK;
if (norm(a) < norm(b))
return ONLINE_FRONT;
return ON_SEGMENT;
}
bool intersectLL(Line l, Line m) {
return abs(cross(l.p2 - l.p1, m.p2 - m.p1)) > EPS || // non-parallel
abs(cross(l.p2 - l.p1, m.p1 - l.p1)) < EPS; // same line
}
bool intersectLS(Line l, Line s) {
return cross(l.p2 - l.p1, s.p1 - l.p1) * // s[0] is left of l
cross(l.p2 - l.p1, s.p2 - l.p1) <
EPS; // s[1] is right of l
}
bool intersectLP(Line l, Point p) {
return abs(cross(l.p2 - p, l.p1 - p)) < EPS;
}
bool intersectSS(Line s, Line t) {
return ccw(s.p1, s.p2, t.p1) * ccw(s.p1, s.p2, t.p2) <= 0 &&
ccw(t.p1, t.p2, s.p1) * ccw(t.p1, t.p2, s.p2) <= 0;
}
bool intersectSP(Line s, Point p) {
return abs(s.p1 - p) + abs(s.p2 - p) - abs(s.p2 - s.p1) <
EPS; // triangle inequality
}
Point projection(Line l, Point p) {
double t = dot(p - l.p1, l.p1 - l.p2) / norm(l.p1 - l.p2);
return l.p1 + (l.p1 - l.p2) * t;
}
Point reflection(Line l, Point p) { return p + (projection(l, p) - p) * 2; }
double distanceLP(Line l, Point p) { return abs(p - projection(l, p)); }
double distanceLL(Line l, Line m) {
return intersectLL(l, m) ? 0 : distanceLP(l, m.p1);
}
double distanceLS(Line l, Line s) {
if (intersectLS(l, s))
return 0;
return min(distanceLP(l, s.p1), distanceLP(l, s.p2));
}
double distanceSP(Line s, Point p) {
Point r = projection(s, p);
if (intersectSP(s, r))
return abs(r - p);
return min(abs(s.p1 - p), abs(s.p2 - p));
}
double distanceSS(Line s, Line t) {
if (intersectSS(s, t))
return 0;
return min(min(distanceSP(s, t.p1), distanceSP(s, t.p2)),
min(distanceSP(t, s.p1), distanceSP(t, s.p2)));
}
Point crosspoint(Line l, Line m) {
double A = cross(l.p2 - l.p1, m.p2 - m.p1);
double B = cross(l.p2 - l.p1, l.p2 - m.p1);
if (abs(A) < EPS && abs(B) < EPS) {
vector<Point> vec;
vec.push_back(l.p1), vec.push_back(l.p2), vec.push_back(m.p1),
vec.push_back(m.p2);
sort(vec.begin(), vec.end());
assert(vec[1] == vec[2]); // 同じセグメントかもよ
return vec[1];
// return m.p1;
}
if (abs(A) < EPS)
assert(false);
return m.p1 + (m.p2 - m.p1) * (B / A);
}
// cross product of pq and pr
double cross3p(Point p, Point q, Point r) {
return (r.x - q.x) * (p.y - q.y) - (r.y - q.y) * (p.x - q.x);
}
// returns true if point r is on the same line as the line pq
bool collinear(Point p, Point q, Point r) {
return fabs(cross3p(p, q, r)) < EPS;
}
// returns true if point t is on the left side of line pq
bool ccwtest(Point p, Point q, Point r) {
return cross3p(p, q, r) > 0; // can be modified to accept collinear points
}
bool onSegment(Point p, Point q, Point r) {
return collinear(p, q, r) &&
equals(sqrt(pow(p.x - r.x, 2) + pow(p.y - r.y, 2)) +
sqrt(pow(r.x - q.x, 2) + pow(r.y - q.y, 2)),
sqrt(pow(p.x - q.x, 2) + pow(p.y - q.y, 2)));
}
bool isConvex(vector<Point> p) {
int sz = (int)p.size();
if (sz < 3)
return false; // boundary case, we treat a point or a line as not convex
bool isLeft = ccwtest(p[0], p[1], p[2]);
for (int i = 1; i < (int)p.size(); i++)
if (ccwtest(p[i], p[(i + 1) % sz], p[(i + 2) % sz]) != isLeft)
return false;
return true;
}
double angle(Point a, Point b, Point c) {
double ux = b.x - a.x, uy = b.y - a.y;
double vx = c.x - a.x, vy = c.y - a.y;
return acos((ux * vx + uy * vy) /
sqrt((ux * ux + uy * uy) * (vx * vx + vy * vy)));
}
// 多角形poly内（線分上も含む）に点pが存在するかどうは判定する
bool inPolygon(Polygon poly, Point p) {
if ((int)poly.size() == 0)
return false;
rep(i, poly.size()) if (onSegment(poly[i], poly[(i + 1) % poly.size()],
p)) return true;
double sum = 0;
for (int i = 0; i < (int)poly.size(); i++) {
if (equals(cross(poly[i] - p, poly[(i + 1) % poly.size()] - p), 0.0))
continue; // ３点が平行だとangleがnanを返しsumがnanになり死ぬ
if (cross3p(p, poly[i], poly[(i + 1) % poly.size()]) < 0)
sum -= angle(p, poly[i], poly[(i + 1) % poly.size()]);
else
sum += angle(p, poly[i], poly[(i + 1) % poly.size()]);
}
// あまり誤差を厳しくしすぎると良くないので以下のほうが良い
const double eps = 1e-5;
return (fabs(sum - 2 * M_PI) < eps || fabs(sum + 2 * M_PI) < eps);
}
int n, tp;
vector<Point> ps, nps;
Point topple, sp;
double v[2];
inline bool isValid(int x) { return 0 <= x && x < nps.size(); }
inline bool LTE(double a, double b) { return equals(a, b) || a < b; }
inline bool LT(double a, double b) { return !equals(a, b) && a < b; }
Point getPoint(double t, int dir) {
int coef = (dir ? 1 : -1);
int cur = tp;
double remain = t;
while (isValid(cur + coef)) {
double len = abs(nps[cur + coef] - nps[cur]);
Vector e = (nps[cur + coef] - nps[cur]) / len;
Point p = nps[cur] + e * (remain * v[0]);
if (onSegment(nps[cur], nps[cur + coef], p))
return p;
cur += coef;
remain -= len / v[0];
assert(LTE(0, remain));
}
return nps[cur];
}
bool check(double limit, int dir) {
Point LP = getPoint(limit, dir);
Point temp_P = getPoint(limit, !dir);
if ((LP == nps[0] || LP == nps[(int)nps.size() - 1]) &&
(temp_P == nps[0] || temp_P == nps[(int)nps.size() - 1]))
return true;
double len_temp = abs(LP - sp);
double time_temp = len_temp / v[1];
if (!LTE(time_temp, limit))
return false;
Point p = getPoint(limit, !dir);
if (p == nps[0] || p == nps[(int)nps.size() - 1]) {
double len = abs(LP - sp);
double ntime = len / v[1];
if (LTE(ntime, limit))
return true;
}
double L = 0, R = limit;
bool success = false;
rep(_, 120) {
double M = (L + R) * 0.5;
p = getPoint(limit - M, !dir);
double len = abs(LP - p);
double ntime = len / v[1];
if (!LTE(ntime, M)) {
L = M;
} else
R = M, success = true;
}
if (!success)
return false;
p = getPoint(limit - L, !dir);
double len = abs(LP - p) + abs(p - sp);
double ntime = len / v[1];
return LTE(ntime, limit);
}
void compute() {
nps.clear();
nps.push_back(ps[0]);
bool already = false;
REP(i, 1, n) {
if (!already && onSegment(ps[i - 1], ps[i], topple)) {
tp = nps.size();
nps.push_back(topple);
already = true;
}
nps.push_back(ps[i]);
}
assert(already);
// cout << check(7,1) << endl;
// return;
/*
double t;
int d;
while( cin >> t >> d){
cout << getPoint(t,d) << endl;
cout << "check = " << check(t,d) << endl;
Point p1 = getPoint(t,d), p2 = getPoint(t,!d);
cout << p1 << " " << p2 << endl;
cout << ( abs( p1 - p2 ) + abs( p2 - sp ) ) / v[1] << endl;
}
return;
*/
double L = 0, R = 1e10;
bool success = false;
rep(_, 120) {
double M = (L + R) * 0.5;
if (check(M, 0) || check(M, 1))
R = M;
else
L = M;
}
printf("%.10f\n", L);
}
int main() {
cin >> n;
ps.resize(n);
rep(i, n) cin >> ps[i].x >> ps[i].y;
cin >> topple.x >> topple.y >> v[0];
cin >> sp.x >> sp.y >> v[1];
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)
#define EPS (1e-7)
#define equals(a, b) (fabs((a) - (b)) < EPS)
#define COUNTER_CLOCKWISE 1
#define CLOCKWISE -1
#define ONLINE_BACK 2
#define ONLINE_FRONT -2
#define ON_SEGMENT 0
using namespace std;
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(a * x, a * y); }
Point operator/(double a) { return Point(x / a, y / a); }
Point operator*(Point a) {
return Point(x * a.x - y * a.y, x * a.y + y * a.x);
}
bool operator<(const Point &p) const {
return !equals(x, p.x) ? x < p.x : (!equals(y, p.y) && y < p.y);
}
bool operator==(const Point &p) const {
return fabs(x - p.x) < EPS && fabs(y - p.y) < EPS;
}
};
struct Segment {
Point p1, p2;
Segment(Point p1 = Point(), Point p2 = Point()) : p1(p1), p2(p2) {}
bool operator<(const Segment &s) const {
return (p2 == s.p2) ? p1 < s.p1 : p2 < s.p2;
}
bool operator==(const Segment &s) const {
return (s.p1 == p1 && s.p2 == p2) || (s.p1 == p2 && s.p2 == p1);
}
};
typedef Point Vector;
typedef Segment Line;
typedef vector<Point> Polygon;
ostream &operator<<(ostream &os, const Point &a) {
os << "(" << a.x << "," << a.y << ")";
}
ostream &operator<<(ostream &os, const Segment &a) {
os << "( " << a.p1 << " , " << a.p2 << " )";
}
double dot(Point a, Point b) { return a.x * b.x + a.y * b.y; }
double cross(Point a, Point b) { return a.x * b.y - a.y * b.x; }
double norm(Point a) { return a.x * a.x + a.y * a.y; }
double abs(Point a) { return sqrt(norm(a)); }
// rad は角度をラジアンで持たせること
Point rotate(Point a, double rad) {
return Point(cos(rad) * a.x - sin(rad) * a.y,
sin(rad) * a.x + cos(rad) * a.y);
}
// 度をラジアンに変換
double toRad(double agl) { return agl * M_PI / 180.0; }
// a => prev, b => cur, c=> next
// prev から cur へ行って next へ行く際の角度を求める
double getArg(Point a, Point b, Point c) {
double arg1 = atan2(b.y - a.y, b.x - a.x);
double arg2 = atan2(c.y - b.y, c.x - b.x);
double arg = fabs(arg1 - arg2);
while (arg > M_PI)
arg -= 2.0 * M_PI;
return fabs(arg);
}
int ccw(Point p0, Point p1, Point p2) {
Point a = p1 - p0;
Point b = p2 - p0;
if (cross(a, b) > EPS)
return COUNTER_CLOCKWISE;
if (cross(a, b) < -EPS)
return CLOCKWISE;
if (dot(a, b) < -EPS)
return ONLINE_BACK;
if (norm(a) < norm(b))
return ONLINE_FRONT;
return ON_SEGMENT;
}
bool intersectLL(Line l, Line m) {
return abs(cross(l.p2 - l.p1, m.p2 - m.p1)) > EPS || // non-parallel
abs(cross(l.p2 - l.p1, m.p1 - l.p1)) < EPS; // same line
}
bool intersectLS(Line l, Line s) {
return cross(l.p2 - l.p1, s.p1 - l.p1) * // s[0] is left of l
cross(l.p2 - l.p1, s.p2 - l.p1) <
EPS; // s[1] is right of l
}
bool intersectLP(Line l, Point p) {
return abs(cross(l.p2 - p, l.p1 - p)) < EPS;
}
bool intersectSS(Line s, Line t) {
return ccw(s.p1, s.p2, t.p1) * ccw(s.p1, s.p2, t.p2) <= 0 &&
ccw(t.p1, t.p2, s.p1) * ccw(t.p1, t.p2, s.p2) <= 0;
}
bool intersectSP(Line s, Point p) {
return abs(s.p1 - p) + abs(s.p2 - p) - abs(s.p2 - s.p1) <
EPS; // triangle inequality
}
Point projection(Line l, Point p) {
double t = dot(p - l.p1, l.p1 - l.p2) / norm(l.p1 - l.p2);
return l.p1 + (l.p1 - l.p2) * t;
}
Point reflection(Line l, Point p) { return p + (projection(l, p) - p) * 2; }
double distanceLP(Line l, Point p) { return abs(p - projection(l, p)); }
double distanceLL(Line l, Line m) {
return intersectLL(l, m) ? 0 : distanceLP(l, m.p1);
}
double distanceLS(Line l, Line s) {
if (intersectLS(l, s))
return 0;
return min(distanceLP(l, s.p1), distanceLP(l, s.p2));
}
double distanceSP(Line s, Point p) {
Point r = projection(s, p);
if (intersectSP(s, r))
return abs(r - p);
return min(abs(s.p1 - p), abs(s.p2 - p));
}
double distanceSS(Line s, Line t) {
if (intersectSS(s, t))
return 0;
return min(min(distanceSP(s, t.p1), distanceSP(s, t.p2)),
min(distanceSP(t, s.p1), distanceSP(t, s.p2)));
}
Point crosspoint(Line l, Line m) {
double A = cross(l.p2 - l.p1, m.p2 - m.p1);
double B = cross(l.p2 - l.p1, l.p2 - m.p1);
if (abs(A) < EPS && abs(B) < EPS) {
vector<Point> vec;
vec.push_back(l.p1), vec.push_back(l.p2), vec.push_back(m.p1),
vec.push_back(m.p2);
sort(vec.begin(), vec.end());
assert(vec[1] == vec[2]); // 同じセグメントかもよ
return vec[1];
// return m.p1;
}
if (abs(A) < EPS)
assert(false);
return m.p1 + (m.p2 - m.p1) * (B / A);
}
// cross product of pq and pr
double cross3p(Point p, Point q, Point r) {
return (r.x - q.x) * (p.y - q.y) - (r.y - q.y) * (p.x - q.x);
}
// returns true if point r is on the same line as the line pq
bool collinear(Point p, Point q, Point r) {
return fabs(cross3p(p, q, r)) < EPS;
}
// returns true if point t is on the left side of line pq
bool ccwtest(Point p, Point q, Point r) {
return cross3p(p, q, r) > 0; // can be modified to accept collinear points
}
bool onSegment(Point p, Point q, Point r) {
return collinear(p, q, r) &&
equals(sqrt(pow(p.x - r.x, 2) + pow(p.y - r.y, 2)) +
sqrt(pow(r.x - q.x, 2) + pow(r.y - q.y, 2)),
sqrt(pow(p.x - q.x, 2) + pow(p.y - q.y, 2)));
}
bool isConvex(vector<Point> p) {
int sz = (int)p.size();
if (sz < 3)
return false; // boundary case, we treat a point or a line as not convex
bool isLeft = ccwtest(p[0], p[1], p[2]);
for (int i = 1; i < (int)p.size(); i++)
if (ccwtest(p[i], p[(i + 1) % sz], p[(i + 2) % sz]) != isLeft)
return false;
return true;
}
double angle(Point a, Point b, Point c) {
double ux = b.x - a.x, uy = b.y - a.y;
double vx = c.x - a.x, vy = c.y - a.y;
return acos((ux * vx + uy * vy) /
sqrt((ux * ux + uy * uy) * (vx * vx + vy * vy)));
}
// 多角形poly内（線分上も含む）に点pが存在するかどうは判定する
bool inPolygon(Polygon poly, Point p) {
if ((int)poly.size() == 0)
return false;
rep(i, poly.size()) if (onSegment(poly[i], poly[(i + 1) % poly.size()],
p)) return true;
double sum = 0;
for (int i = 0; i < (int)poly.size(); i++) {
if (equals(cross(poly[i] - p, poly[(i + 1) % poly.size()] - p), 0.0))
continue; // ３点が平行だとangleがnanを返しsumがnanになり死ぬ
if (cross3p(p, poly[i], poly[(i + 1) % poly.size()]) < 0)
sum -= angle(p, poly[i], poly[(i + 1) % poly.size()]);
else
sum += angle(p, poly[i], poly[(i + 1) % poly.size()]);
}
// あまり誤差を厳しくしすぎると良くないので以下のほうが良い
const double eps = 1e-5;
return (fabs(sum - 2 * M_PI) < eps || fabs(sum + 2 * M_PI) < eps);
}
int n, tp;
vector<Point> ps, nps;
Point topple, sp;
double v[2];
inline bool isValid(int x) { return 0 <= x && x < nps.size(); }
inline bool LTE(double a, double b) { return equals(a, b) || a < b; }
inline bool LT(double a, double b) { return !equals(a, b) && a < b; }
Point getPoint(double t, int dir) {
int coef = (dir ? 1 : -1);
int cur = tp;
double remain = t;
while (isValid(cur + coef)) {
double len = abs(nps[cur + coef] - nps[cur]);
Vector e = (nps[cur + coef] - nps[cur]) / len;
Point p = nps[cur] + e * (remain * v[0]);
if (onSegment(nps[cur], nps[cur + coef], p))
return p;
cur += coef;
remain -= len / v[0];
assert(LTE(0, remain));
}
return nps[cur];
}
bool check(double limit, int dir) {
Point LP = getPoint(limit, dir);
Point temp_P = getPoint(limit, !dir);
if ((LP == nps[0] || LP == nps[(int)nps.size() - 1]) &&
(temp_P == nps[0] || temp_P == nps[(int)nps.size() - 1]))
return true;
double len_temp = abs(LP - sp);
double time_temp = len_temp / v[1];
if (!LTE(time_temp, limit))
return false;
Point p = getPoint(limit, !dir);
if (p == nps[0] || p == nps[(int)nps.size() - 1]) {
double len = abs(LP - sp);
double ntime = len / v[1];
if (LTE(ntime, limit))
return true;
}
double L = 0, R = limit;
bool success = false;
rep(_, 120) {
double M = (L + R) * 0.5;
p = getPoint(limit - M, !dir);
double len = abs(LP - p);
double ntime = len / v[1];
if (!LTE(ntime, M)) {
L = M;
} else
R = M, success = true;
}
if (!success)
return false;
p = getPoint(limit - L, !dir);
double len = abs(LP - p) + abs(p - sp);
double ntime = len / v[1];
return LTE(ntime, limit);
}
void compute() {
nps.clear();
nps.push_back(ps[0]);
bool already = false;
REP(i, 1, n) {
if (!already && onSegment(ps[i - 1], ps[i], topple)) {
tp = nps.size();
nps.push_back(topple);
already = true;
}
nps.push_back(ps[i]);
}
assert(already);
// cout << check(7,1) << endl;
// return;
/*
double t;
int d;
while( cin >> t >> d){
cout << getPoint(t,d) << endl;
cout << "check = " << check(t,d) << endl;
Point p1 = getPoint(t,d), p2 = getPoint(t,!d);
cout << p1 << " " << p2 << endl;
cout << ( abs( p1 - p2 ) + abs( p2 - sp ) ) / v[1] << endl;
}
return;
*/
double L = 0, R = 1e10;
bool success = false;
rep(_, 120) {
double M = (L + R) * 0.5;
if (check(M, 0) || check(M, 1))
R = M;
else
L = M;
}
printf("%.10f\n", L);
}
int main() {
cin >> n;
ps.resize(n);
rep(i, n) cin >> ps[i].x >> ps[i].y;
cin >> topple.x >> topple.y >> v[0];
cin >> sp.x >> sp.y >> v[1];
compute();
return 0;
} | replace | 4 | 5 | 4 | 5 | 0 | |
p01465 | C++ | Runtime Error | #include <bits/stdc++.h>
#define ALL(a) (a).begin(), (a).end()
#define ll long long
using namespace std;
const ll MOD = (ll)1e9 + 7;
string str;
// vector<ll> dp;
ll dp[20];
ll power(int num) {
ll ret = 1;
for (int i = 0; i < 20; i++) {
if ((num & (1 << i))) {
ret = (ret * dp[i]) % MOD;
}
}
// cerr << num << " " << "ret" << ret << endl;
return ret;
}
pair<ll, int> expression(int &i);
pair<ll, int> term(int &i);
pair<ll, int> factor(int &i);
pair<ll, int> variable(int &i);
signed main() {
dp[0] = 2;
for (int i = 1; i < 20; i++) {
dp[i] = (dp[i - 1] * dp[i - 1]) % MOD;
}
cin >> str;
int i = 0;
auto ans = expression(i);
// cerr << ans.second << endl;
cout << ans.first << endl;
return 0;
}
pair<ll, int> expression(int &i) {
auto ret = term(i);
if (str[i] == '|') {
i++;
auto right = expression(i);
ll val = (power(ret.second) * right.first) % MOD;
val = (val + power(right.second) * ret.first) % MOD;
val = (val - (ret.first * right.first) % MOD + MOD) % MOD;
ret = make_pair(val, ret.second + right.second);
}
// cerr << str.substr(0,i+1) << endl;
// cerr << ret.first << " " << ret.second << endl;
return ret;
}
pair<ll, int> term(int &i) {
auto ret = factor(i);
if (str[i] == '&') {
i++;
auto right = term(i);
ret = make_pair((ret.first * right.first) % MOD, ret.second + right.second);
}
return ret;
}
pair<ll, int> factor(int &i) {
switch (str[i]) {
case '~': {
auto ret = factor(++i);
ret.first = (MOD + power(ret.second) - ret.first) % MOD;
return ret;
}
case '(': {
auto ret = expression(++i);
assert(str[i] == ')');
++i;
return ret;
}
default:
return variable(i);
}
}
pair<ll, int> variable(int &i) {
assert(str[i] == 'x');
i++;
while (isdigit(str[i]))
i++;
return make_pair(1ll, 1);
}
| #include <bits/stdc++.h>
#define ALL(a) (a).begin(), (a).end()
#define ll long long
using namespace std;
const ll MOD = (ll)1e9 + 7;
// string str;
char str[1000001];
// vector<ll> dp;
ll dp[20];
ll power(int num) {
ll ret = 1;
for (int i = 0; i < 20; i++) {
if ((num & (1 << i))) {
ret = (ret * dp[i]) % MOD;
}
}
// cerr << num << " " << "ret" << ret << endl;
return ret;
}
pair<ll, int> expression(int &i);
pair<ll, int> term(int &i);
pair<ll, int> factor(int &i);
pair<ll, int> variable(int &i);
signed main() {
dp[0] = 2;
for (int i = 1; i < 20; i++) {
dp[i] = (dp[i - 1] * dp[i - 1]) % MOD;
}
cin >> str;
int i = 0;
auto ans = expression(i);
// cerr << ans.second << endl;
cout << ans.first << endl;
return 0;
}
pair<ll, int> expression(int &i) {
auto ret = term(i);
if (str[i] == '|') {
i++;
auto right = expression(i);
ll val = (power(ret.second) * right.first) % MOD;
val = (val + power(right.second) * ret.first) % MOD;
val = (val - (ret.first * right.first) % MOD + MOD) % MOD;
ret = make_pair(val, ret.second + right.second);
}
// cerr << str.substr(0,i+1) << endl;
// cerr << ret.first << " " << ret.second << endl;
return ret;
}
pair<ll, int> term(int &i) {
auto ret = factor(i);
if (str[i] == '&') {
i++;
auto right = term(i);
ret = make_pair((ret.first * right.first) % MOD, ret.second + right.second);
}
return ret;
}
pair<ll, int> factor(int &i) {
switch (str[i]) {
case '~': {
auto ret = factor(++i);
ret.first = (MOD + power(ret.second) - ret.first) % MOD;
return ret;
}
case '(': {
auto ret = expression(++i);
assert(str[i] == ')');
++i;
return ret;
}
default:
return variable(i);
}
}
pair<ll, int> variable(int &i) {
assert(str[i] == 'x');
i++;
while (isdigit(str[i]))
i++;
return make_pair(1ll, 1);
}
| replace | 9 | 10 | 9 | 11 | 0 | |
p01465 | C++ | Runtime Error | #include <algorithm>
#include <cassert>
#include <cctype>
#include <cstdlib>
#include <iostream>
#include <utility>
#include <vector>
using namespace std;
constexpr long long mod = 1000000007;
typedef pair<long long, long long> result; // true, false
#define T first
#define F second
struct parse_t {
char c;
result value;
parse_t(char c_ = '#', const result &value_ = result())
: c(c_), value(value_) {}
};
template <class T> T take_back(vector<T> &vec) {
const T res = vec.back();
vec.pop_back();
return res;
}
void push_value(vector<parse_t> &sta, result value) {
while (!sta.empty(), sta.back().c == '~') {
sta.pop_back();
swap(value.T, value.F);
}
sta.emplace_back('v', value);
}
result calculate_binary_operator(char ope, const result &a, const result &b) {
switch (ope) {
case '|':
return result((a.T * (b.T + b.F) + a.F * b.T) % mod, a.F * b.F % mod);
case '&':
return result(a.T * b.T % mod, (a.F * (b.T + b.F) + a.T * b.F) % mod);
default:
assert(false);
}
}
void evaluate_binary_operator(vector<parse_t> &sta) {
const result b = take_back(sta).value;
const char ope = take_back(sta).c;
const result a = take_back(sta).value;
push_value(sta, calculate_binary_operator(ope, a, b));
}
result parse(const string &expression) {
vector<parse_t> sta;
sta.reserve(1000000);
int priority[256] = {};
priority['|'] = 2;
priority['&'] = 3;
priority['('] = 100;
priority[')'] = 1;
for (auto it = expression.cbegin(); it != expression.cend();) {
if (*it == 'x') {
++it; // x
while (isdigit(*it))
++it;
push_value(sta, result(1, 1));
} else if (*it == '~') {
sta.emplace_back('~');
++it;
} else {
while (sta.size() >= 3 && sta[sta.size() - 2].c != '(' &&
priority[sta[sta.size() - 2].c] >= priority[*it]) {
evaluate_binary_operator(sta);
}
if (*it == ')') {
const auto tmp = take_back(sta);
sta.pop_back(); // (
push_value(sta, tmp.value);
} else {
sta.emplace_back(*it);
}
++it;
}
}
while (sta.size() >= 3)
evaluate_binary_operator(sta);
return sta.back().value;
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
string expression;
cin >> expression;
cout << parse(expression).T << endl;
return EXIT_SUCCESS;
} | #include <algorithm>
#include <cassert>
#include <cctype>
#include <cstdlib>
#include <iostream>
#include <utility>
#include <vector>
using namespace std;
constexpr long long mod = 1000000007;
typedef pair<long long, long long> result; // true, false
#define T first
#define F second
struct parse_t {
char c;
result value;
parse_t(char c_ = '#', const result &value_ = result())
: c(c_), value(value_) {}
};
template <class T> T take_back(vector<T> &vec) {
const T res = vec.back();
vec.pop_back();
return res;
}
void push_value(vector<parse_t> &sta, result value) {
while (!sta.empty() && sta.back().c == '~') {
sta.pop_back();
swap(value.T, value.F);
}
sta.emplace_back('v', value);
}
result calculate_binary_operator(char ope, const result &a, const result &b) {
switch (ope) {
case '|':
return result((a.T * (b.T + b.F) + a.F * b.T) % mod, a.F * b.F % mod);
case '&':
return result(a.T * b.T % mod, (a.F * (b.T + b.F) + a.T * b.F) % mod);
default:
assert(false);
}
}
void evaluate_binary_operator(vector<parse_t> &sta) {
const result b = take_back(sta).value;
const char ope = take_back(sta).c;
const result a = take_back(sta).value;
push_value(sta, calculate_binary_operator(ope, a, b));
}
result parse(const string &expression) {
vector<parse_t> sta;
sta.reserve(1000000);
int priority[256] = {};
priority['|'] = 2;
priority['&'] = 3;
priority['('] = 100;
priority[')'] = 1;
for (auto it = expression.cbegin(); it != expression.cend();) {
if (*it == 'x') {
++it; // x
while (isdigit(*it))
++it;
push_value(sta, result(1, 1));
} else if (*it == '~') {
sta.emplace_back('~');
++it;
} else {
while (sta.size() >= 3 && sta[sta.size() - 2].c != '(' &&
priority[sta[sta.size() - 2].c] >= priority[*it]) {
evaluate_binary_operator(sta);
}
if (*it == ')') {
const auto tmp = take_back(sta);
sta.pop_back(); // (
push_value(sta, tmp.value);
} else {
sta.emplace_back(*it);
}
++it;
}
}
while (sta.size() >= 3)
evaluate_binary_operator(sta);
return sta.back().value;
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
string expression;
cin >> expression;
cout << parse(expression).T << endl;
return EXIT_SUCCESS;
} | replace | 29 | 30 | 29 | 30 | -11 | |
p01465 | C++ | Memory Limit Exceeded | #include "bits/stdc++.h"
#include <unordered_map>
#include <unordered_set>
#pragma warning(disable : 4996)
using namespace std;
using ld = long double;
template <class T> using Table = vector<vector<T>>;
const ld eps = 1e-9;
// < "D:\D_Download\Visual Studio
// 2015\Projects\programing_contest_c++\Debug\a.txt" > "D:\D_Download\Visual
// Studio 2015\Projects\programing_contest_c++\Debug\b.answer"
const int mod = 1000000007;
struct Mod {
public:
int num;
Mod() : Mod(0) { ; }
Mod(long long int n) : num((n % mod + mod) % mod) {
static_assert(mod < INT_MAX / 2,
"mod is too big, please make num 'long long int' from 'int'");
}
Mod(int n) : Mod(static_cast<long long int>(n)) { ; }
operator int() { return num; }
};
Mod operator+(const Mod a, const Mod b) { return Mod((a.num + b.num) % mod); }
Mod operator+(const long long int a, const Mod b) { return Mod(a) + b; }
Mod operator+(const Mod a, const long long int b) { return b + a; }
Mod operator++(Mod &a) { return a + Mod(1); }
Mod operator-(const Mod a, const Mod b) {
return Mod((mod + a.num - b.num) % mod);
}
Mod operator-(const long long int a, const Mod b) { return Mod(a) - b; }
Mod operator--(Mod &a) { return a - Mod(1); }
Mod operator*(const Mod a, const Mod b) {
return Mod(((long long)a.num * b.num) % mod);
}
Mod operator*(const long long int a, const Mod b) { return Mod(a) * b; }
Mod operator*(const Mod a, const long long int b) { return Mod(b) * a; }
Mod operator*(const Mod a, const int b) { return Mod(b) * a; }
Mod operator+=(Mod &a, const Mod b) { return a = a + b; }
Mod operator+=(long long int &a, const Mod b) { return a = a + b; }
Mod operator-=(Mod &a, const Mod b) { return a = a - b; }
Mod operator-=(long long int &a, const Mod b) { return a = a - b; }
Mod operator*=(Mod &a, const Mod b) { return a = a * b; }
Mod operator*=(long long int &a, const Mod b) { return a = a * b; }
Mod operator*=(Mod &a, const long long int &b) { return a = a * b; }
Mod operator^(const Mod a, const int n) {
if (n == 0)
return Mod(1);
Mod res = (a * a) ^ (n / 2);
if (n % 2)
res = res * a;
return res;
}
Mod mod_pow(const Mod a, const int n) {
if (n == 0)
return Mod(1);
Mod res = mod_pow((a * a), (n / 2));
if (n % 2)
res = res * a;
return res;
}
Mod inv(const Mod a) { return a ^ (mod - 2); }
Mod operator/(const Mod a, const Mod b) {
assert(b.num != 0);
return a * inv(b);
}
Mod operator/(const long long int a, const Mod b) { return Mod(a) / b; }
Mod operator/=(Mod &a, const Mod b) { return a = a / b; }
#define MAX_MOD_N 1024000
Mod fact[MAX_MOD_N], factinv[MAX_MOD_N];
void init(const int amax = MAX_MOD_N) {
fact[0] = Mod(1);
factinv[0] = 1;
for (int i = 0; i < amax - 1; ++i) {
fact[i + 1] = fact[i] * Mod(i + 1);
factinv[i + 1] = factinv[i] / Mod(i + 1);
}
}
Mod comb(const int a, const int b) {
return fact[a] * factinv[b] * factinv[a - b];
}
string st;
int a;
pair<int, int> getexpr();
pair<int, int> getval() {
assert(st[a] == 'x');
a++;
int num = 0;
while (a != st.size() && isdigit(st[a])) {
num = num * 10 + st[a] - '0';
a++;
}
return make_pair(1, 1);
}
pair<int, int> getfact() {
if (st[a] == '~') {
a++;
auto p = getfact();
return make_pair(p.second, p.first);
} else if (st[a] == '(') {
a++;
auto p(getexpr());
a++;
return p;
} else {
auto p(getval());
return p;
}
}
pair<int, int> getterm() {
auto p = getfact();
while (a != st.size()) {
if (st[a] == '|' || st[a] == ')')
return p;
else if (st[a] == '&') {
a++;
auto q = getfact();
long long int aa = p.first, ab = p.second, ba = q.first, bb = q.second;
long long int fst = ba * aa;
long long int scd = (aa + ab) * (ba + bb) - ba * aa;
p = make_pair(fst % mod, scd % mod);
}
}
return p;
}
pair<int, int> getexpr() {
auto p(getterm());
while (a != st.size()) {
if (st[a] == '|') {
a++;
auto q = getterm();
long long int aa = p.first, ab = p.second, ba = q.first, bb = q.second;
long long int fst = (aa + ab) * (ba + bb) - bb * ab;
long long int scd = bb * ab;
p = make_pair(fst % mod, scd % mod);
} else if (st[a] == ')') {
break;
} else {
break;
assert(false);
}
}
return p;
}
long long int eord, enew;
int main() {
const int SZ = 128 * 1024 * 1024;
void *p = malloc(SZ);
enew = (long long)p + SZ - 1;
__asm__("mov %rsp, eord");
__asm__("mov enew, %rsp");
cin >> st;
a = 0;
int ans = getexpr().first;
cout << ans << endl;
__asm__("mov eord, %rsp");
return 0;
} | #include "bits/stdc++.h"
#include <unordered_map>
#include <unordered_set>
#pragma warning(disable : 4996)
using namespace std;
using ld = long double;
template <class T> using Table = vector<vector<T>>;
const ld eps = 1e-9;
// < "D:\D_Download\Visual Studio
// 2015\Projects\programing_contest_c++\Debug\a.txt" > "D:\D_Download\Visual
// Studio 2015\Projects\programing_contest_c++\Debug\b.answer"
const int mod = 1000000007;
string st;
int a;
pair<int, int> getexpr();
pair<int, int> getval() {
assert(st[a] == 'x');
a++;
int num = 0;
while (a != st.size() && isdigit(st[a])) {
num = num * 10 + st[a] - '0';
a++;
}
return make_pair(1, 1);
}
pair<int, int> getfact() {
if (st[a] == '~') {
a++;
auto p = getfact();
return make_pair(p.second, p.first);
} else if (st[a] == '(') {
a++;
auto p(getexpr());
a++;
return p;
} else {
auto p(getval());
return p;
}
}
pair<int, int> getterm() {
auto p = getfact();
while (a != st.size()) {
if (st[a] == '|' || st[a] == ')')
return p;
else if (st[a] == '&') {
a++;
auto q = getfact();
long long int aa = p.first, ab = p.second, ba = q.first, bb = q.second;
long long int fst = ba * aa;
long long int scd = (aa + ab) * (ba + bb) - ba * aa;
p = make_pair(fst % mod, scd % mod);
}
}
return p;
}
pair<int, int> getexpr() {
auto p(getterm());
while (a != st.size()) {
if (st[a] == '|') {
a++;
auto q = getterm();
long long int aa = p.first, ab = p.second, ba = q.first, bb = q.second;
long long int fst = (aa + ab) * (ba + bb) - bb * ab;
long long int scd = bb * ab;
p = make_pair(fst % mod, scd % mod);
} else if (st[a] == ')') {
break;
} else {
break;
assert(false);
}
}
return p;
}
long long int eord, enew;
int main() {
const int SZ = 128 * 1024 * 1024;
void *p = malloc(SZ);
enew = (long long)p + SZ - 1;
__asm__("mov %rsp, eord");
__asm__("mov enew, %rsp");
cin >> st;
a = 0;
int ans = getexpr().first;
cout << ans << endl;
__asm__("mov eord, %rsp");
return 0;
} | delete | 14 | 86 | 14 | 14 | MLE | |
p01468 | C++ | Time Limit Exceeded | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define dump(a) (cerr << (#a) << " = " << (a) << endl)
#define FOR(it, c) \
for (__typeof((c).begin()) it = (c).begin(); it != (c).end(); ++it)
#define RFOR(it, c) \
for (__typeof((c).rbegin()) it = (c).rbegin(); it != (c).rend(); ++it)
#define exist(c, v) (find((c).begin(), (c).end(), (v)) != (c).end())
template <class T> inline void chmax(T &a, const T &b) {
if (b > a)
a = b;
}
template <class T> inline void chmin(T &a, const T &b) {
if (b < a)
a = b;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << '(' << p.first << ", " << p.second << ')';
return os;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
copy(v.begin(), v.end(), ostream_iterator<T>(os, " "));
return os;
}
const double EPS = 1e-9;
struct point {
double x, y;
point(double x = 0.0, double y = 0.0) : x(x), y(y) {}
point(const point &p) : x(p.x), y(p.y) {}
point operator+(const point &p) const { return point(x + p.x, y + p.y); }
point operator-(const point &p) const { return point(x - p.x, y - p.y); }
point operator*(const double s) const { return point(x * s, y * s); }
point operator*(const point &p) const {
return point(x * p.x - y * p.y, x * p.y + y * p.x);
}
point operator/(const double s) const { return point(x / s, y / s); }
bool operator<(const point &p) const {
return x + EPS < p.x || abs(x - p.x) < EPS && y + EPS < p.y;
}
bool operator==(const point &p) const {
return abs(x - p.x) < EPS && abs(y - p.y) < EPS;
}
};
inline point rotate90(const point &p) { return point(-p.y, p.x); }
inline point rotate(const point &p, const double theta) {
const double s = sin(theta), c = cos(theta);
return point(c * p.x - s * p.y, s * p.x + c * p.y);
}
inline double angle(const point &p) { return atan2(p.y, p.x); }
inline double abs(const point &p) { return sqrt(p.x * p.x + p.y * p.y); }
inline double norm(const point &p) { return p.x * p.x + p.y * p.y; }
inline double dot(const point &l, const point &r) {
return l.x * r.x + l.y * r.y;
}
inline double cross(const point &l, const point &r) {
return l.x * r.y - l.y * r.x;
}
struct line {
point a, b;
line(point a, point b) : a(a), b(b) {}
};
struct segment {
point a, b;
segment(point a, point b) : a(a), b(b) {}
};
struct circle {
point c;
double r;
circle(point c, double r) : c(c), r(r) {}
};
typedef vector<point> polygon;
inline int ccw(const point &a, point b, point c) {
b = b - a;
c = c - a;
const double tmp = cross(b, c);
if (tmp > EPS)
return 1; // ccw
if (tmp < -EPS)
return -1; // cw
if (dot(b, c) < 0)
return 2; // c, a, b 順に一直線上
if (norm(b) < norm(c))
return -2; // a, b, c 順に一直線上
return 0; // a, c, b 順で一直線上
}
inline point projection(const line &l, const point &p) {
const point dif = l.b - l.a;
const double tmp = dot(p - l.a, dif) / norm(dif);
return l.a + dif * tmp;
}
inline bool intersect(const line &l, const line &m) {
return abs(cross(l.b - l.a, m.b - m.a)) > EPS ||
abs(cross(l.b - l.a, m.b - l.a)) < EPS;
}
inline bool intersect(const line &l, const segment &s) {
return cross(l.b - l.a, s.a - l.a) * cross(l.b - l.a, s.b - l.a) < EPS;
}
inline bool intersect(const line &l, const point &p) {
return abs(ccw(l.a, l.b, p)) != -1;
}
inline bool intersect(const segment &s, const segment &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;
}
inline bool intersect(const segment &s, const point &p) {
return ccw(s.a, s.b, p) == 0;
}
inline bool intersect(const circle &c, const point &p) {
return abs(c.c - p) <= c.r + EPS;
}
inline bool intersect(const circle &c, const circle &d) {
return abs(c.c - d.c) <= c.r + d.r && abs(c.c - d.c) >= abs(c.r - d.r);
}
inline double dist(const line &l, const point &p) {
return abs(cross((l.b - l.a), (p - l.a))) / abs(l.b - l.a);
}
inline double dist(const line &l, const line &m) {
return intersect(l, m) ? 0 : dist(l, m.a);
}
inline double dist(const line &l, const segment &s) {
return intersect(l, s) ? 0 : min(dist(l, s.a), dist(l, s.b));
}
inline double dist(const segment &s, const point &p) {
if (dot((s.b - s.a), (p - s.a)) < 0)
return abs(p - s.a);
if (dot((s.a - s.b), (p - s.b)) < 0)
return abs(p - s.b);
return dist(line(s.a, s.b), p);
}
inline double dist(const segment &s, const segment &t) {
if (intersect(s, t))
return 0;
return min(min(dist(s, t.a), dist(s, t.b)), min(dist(t, s.a), dist(t, s.b)));
}
inline double dist(const point &a, const point &b) { return abs(a - b); }
inline bool intersect(const circle &c, const segment &s) {
return dist(s, c.c) < c.r + EPS;
}
inline point crosspoint(const line &l, const line &m) {
const double tmp = cross(l.b - l.a, m.b - m.a);
if (abs(tmp) < EPS) // 平行
return l.a;
return m.a + (m.b - m.a) * cross(l.b - l.a, l.a - m.a) * (1.0 / tmp);
}
inline point crosspoint(const segment &s, const segment &t) {
if (!intersect(s, t)) // 交点を持たない
return s.a; // 用改善
const double tmp = cross(s.b - s.a, t.b - t.a);
if (abs(tmp) < EPS) { // 一直線上
if (intersect(s, t.a))
return t.a;
if (intersect(s, t.b))
return t.b;
if (intersect(t, s.a))
return s.a;
return s.b;
}
return t.a + (t.b - t.a) * cross(s.b - s.a, s.b - t.a) * (1.0 / tmp);
}
// 先に，intersectを用いて交差判定を行うこと
inline vector<point> crosspoint(const circle &c, const circle &d) {
vector<point> res;
if (abs(c.c - d.c) < EPS) // 中心の座標が同じ
return res;
const double tmp = abs(c.c - d.c);
const double rc = (tmp * tmp + c.r * c.r - d.r * d.r) / (tmp + tmp);
const double rs = sqrt(c.r * c.r - rc * rc);
const point diff = (d.c - c.c) / tmp;
res.push_back(point(c.c + diff * point(rc, rs)));
res.push_back(point(c.c + diff * point(rc, -rs)));
return res;
}
inline vector<point> crosspoint(const circle &c, const line &l) {
vector<point> res;
const point h = projection(l, c.c);
const double d = abs(h - c.c);
if (d > c.r - EPS) {
res.push_back(h);
} else if (d <= c.r - EPS) {
point v = l.b - l.a;
v = v * sqrt(c.r * c.r - d * d) / abs(v);
res.push_back(h + v);
res.push_back(h - v);
}
return res;
}
inline vector<point> crosspoint(const circle &c, const segment &s) {
vector<point> res;
vector<point> tmp = crosspoint(c, line(s.a, s.b));
for (int i = 0; i < tmp.size(); ++i)
if (intersect(s, tmp[i]))
res.push_back(tmp[i]);
return res;
}
inline double areaTriangle(point a, point b, const point &c) {
a = a - c;
b = b - c;
return fabs(a.x * b.y - b.x * a.y) / 2.0;
}
inline double area(const polygon &p) {
const int num = p.size();
if (num < 3)
return 0;
if (num == 3)
return areaTriangle(p[0], p[1], p[2]);
double res = cross(p[num - 1], p[0]);
for (int i = 1; i < num; ++i)
res += cross(p[i - 1], p[i]);
return abs(res) * 0.5;
}
// L.aからL.bの方向を見た場合に，点aが左側に来る．
inline line bisector(const point &a, const point &b) {
return line(
point((a.x - a.y + b.x + b.y) / 2.0, (a.y + a.x + b.y - b.x) / 2.0),
point((a.x + a.y + b.x - b.y) / 2.0, (a.y - a.x + b.y + b.x) / 2.0));
}
// 点集合 pointsの凸包を求める．
inline polygon convex_hull(vector<point> points) {
const int n = points.size();
if (n <= 3)
return points;
sort(points.begin(), points.end());
int k = 0;
polygon res;
res.resize(2 * n);
for (int i = 0; i < n; res[k++] = points[i++])
while (k >= 2 && ccw(res[k - 2], res[k - 1], points[i]) <= 0)
--k;
const int t = k + 1;
for (int i = n - 2; i >= 0; res[k++] = points[i--])
while (k >= t && ccw(res[k - 2], res[k - 1], points[i]) <= 0)
--k;
res.resize(k - 1);
return res;
}
// L.aからL.bを向いた時の左側を残して切断する．
inline polygon convex_cut(const polygon &p, const line &l) {
const int num = p.size();
polygon res;
for (int i = 0; i < num; ++i) {
const int next = (i + 1) % num;
const int tmp = ccw(l.a, l.b, p[i]);
if (tmp != -1)
res.push_back(p[i]);
if (tmp * ccw(l.a, l.b, p[next]) < 0)
res.push_back(crosspoint(l, line(p[i], p[next])));
}
return res;
}
vector<point> tangent(const circle &c, const point &p) {
const double x = norm(p - c.c);
double d = x - c.r * c.r;
if (d < -EPS)
return vector<point>();
d = max(d, 0.0);
const point q1 = (p - c.c) * (c.r * c.r / x);
const point q2 = rotate90((p - c.c) * (-c.r * sqrt(d) / x));
vector<point> res;
res.push_back(c.c + q1 - q2);
res.push_back(c.c + q1 + q2);
return res;
}
vector<line> tangent(const circle &a, const circle &b) {
vector<line> res;
if (abs(a.r - b.r) < EPS) {
point dir = b.c - a.c;
dir = rotate90(dir * (a.r / abs(dir)));
res.push_back(line(a.c + dir, b.c + dir));
res.push_back(line(a.c - dir, b.c - dir));
} else {
point p = a.c * (-b.r) + b.c * a.r;
p = p * (1.0 / (a.r - b.r));
vector<point> ps = tangent(a, p), qs = tangent(b, p);
for (int i = 0; i < min<int>(ps.size(), qs.size()); ++i)
res.push_back(line(ps[i], qs[i]));
}
point p = a.c * b.r + b.c * a.r;
p = p * (1.0 / (a.r + b.r));
vector<point> ps = tangent(a, p), qs = tangent(b, p);
for (int i = 0; i < min<int>(ps.size(), qs.size()); ++i)
res.push_back(line(ps[i], qs[i]));
return res;
}
// 三角形と点の包含関係，境界は含まない．
// 含める場合は == -1を <= 0とする．
bool contain_triangle(const polygon &triangle, const point &p) {
const int d1 = ccw(p, triangle[0], triangle[1]),
d2 = ccw(p, triangle[1], triangle[2]),
d3 = ccw(p, triangle[2], triangle[0]);
return !(d1 * d2 == -1 || d2 * d3 == -1 || d3 * d1 == -1);
}
// 多角形と点の包含関係．境界を含む．
bool contain(const polygon &P, const point &p) {
const int n = P.size();
bool res = false;
for (int i = 0; i < n; ++i) {
point v1 = P[i] - p, v2 = P[(i + 1) % n] - p;
if (v1.y > v2.y)
swap(v1, v2);
if (v1.y < EPS && EPS < v2.y && cross(v1, v2) > EPS)
res = !res;
if (abs(cross(v1, v2)) < EPS && dot(v1, v2) < EPS)
return true; // 境界を含まないなら，falseにする．
}
return res;
}
const int limit = 101 * 101 / 2;
int main() {
int n;
scanf("%d", &n);
if (n > limit) {
printf("%.lf\n", 0.0);
}
vector<segment> segments;
segments.reserve(n);
for (int i = 0; i < n; ++i) {
int x1, y1, x2, y2;
scanf("%d %d %d %d", &x1, &y1, &x2, &y2);
segments.push_back(segment(point(x1, y1), point(x2, y2)));
}
double ans = 200;
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
chmin(ans, dist(segments[i], segments[j]));
}
}
printf("%.10lf\n", ans);
return EXIT_SUCCESS;
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define dump(a) (cerr << (#a) << " = " << (a) << endl)
#define FOR(it, c) \
for (__typeof((c).begin()) it = (c).begin(); it != (c).end(); ++it)
#define RFOR(it, c) \
for (__typeof((c).rbegin()) it = (c).rbegin(); it != (c).rend(); ++it)
#define exist(c, v) (find((c).begin(), (c).end(), (v)) != (c).end())
template <class T> inline void chmax(T &a, const T &b) {
if (b > a)
a = b;
}
template <class T> inline void chmin(T &a, const T &b) {
if (b < a)
a = b;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << '(' << p.first << ", " << p.second << ')';
return os;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
copy(v.begin(), v.end(), ostream_iterator<T>(os, " "));
return os;
}
const double EPS = 1e-9;
struct point {
double x, y;
point(double x = 0.0, double y = 0.0) : x(x), y(y) {}
point(const point &p) : x(p.x), y(p.y) {}
point operator+(const point &p) const { return point(x + p.x, y + p.y); }
point operator-(const point &p) const { return point(x - p.x, y - p.y); }
point operator*(const double s) const { return point(x * s, y * s); }
point operator*(const point &p) const {
return point(x * p.x - y * p.y, x * p.y + y * p.x);
}
point operator/(const double s) const { return point(x / s, y / s); }
bool operator<(const point &p) const {
return x + EPS < p.x || abs(x - p.x) < EPS && y + EPS < p.y;
}
bool operator==(const point &p) const {
return abs(x - p.x) < EPS && abs(y - p.y) < EPS;
}
};
inline point rotate90(const point &p) { return point(-p.y, p.x); }
inline point rotate(const point &p, const double theta) {
const double s = sin(theta), c = cos(theta);
return point(c * p.x - s * p.y, s * p.x + c * p.y);
}
inline double angle(const point &p) { return atan2(p.y, p.x); }
inline double abs(const point &p) { return sqrt(p.x * p.x + p.y * p.y); }
inline double norm(const point &p) { return p.x * p.x + p.y * p.y; }
inline double dot(const point &l, const point &r) {
return l.x * r.x + l.y * r.y;
}
inline double cross(const point &l, const point &r) {
return l.x * r.y - l.y * r.x;
}
struct line {
point a, b;
line(point a, point b) : a(a), b(b) {}
};
struct segment {
point a, b;
segment(point a, point b) : a(a), b(b) {}
};
struct circle {
point c;
double r;
circle(point c, double r) : c(c), r(r) {}
};
typedef vector<point> polygon;
inline int ccw(const point &a, point b, point c) {
b = b - a;
c = c - a;
const double tmp = cross(b, c);
if (tmp > EPS)
return 1; // ccw
if (tmp < -EPS)
return -1; // cw
if (dot(b, c) < 0)
return 2; // c, a, b 順に一直線上
if (norm(b) < norm(c))
return -2; // a, b, c 順に一直線上
return 0; // a, c, b 順で一直線上
}
inline point projection(const line &l, const point &p) {
const point dif = l.b - l.a;
const double tmp = dot(p - l.a, dif) / norm(dif);
return l.a + dif * tmp;
}
inline bool intersect(const line &l, const line &m) {
return abs(cross(l.b - l.a, m.b - m.a)) > EPS ||
abs(cross(l.b - l.a, m.b - l.a)) < EPS;
}
inline bool intersect(const line &l, const segment &s) {
return cross(l.b - l.a, s.a - l.a) * cross(l.b - l.a, s.b - l.a) < EPS;
}
inline bool intersect(const line &l, const point &p) {
return abs(ccw(l.a, l.b, p)) != -1;
}
inline bool intersect(const segment &s, const segment &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;
}
inline bool intersect(const segment &s, const point &p) {
return ccw(s.a, s.b, p) == 0;
}
inline bool intersect(const circle &c, const point &p) {
return abs(c.c - p) <= c.r + EPS;
}
inline bool intersect(const circle &c, const circle &d) {
return abs(c.c - d.c) <= c.r + d.r && abs(c.c - d.c) >= abs(c.r - d.r);
}
inline double dist(const line &l, const point &p) {
return abs(cross((l.b - l.a), (p - l.a))) / abs(l.b - l.a);
}
inline double dist(const line &l, const line &m) {
return intersect(l, m) ? 0 : dist(l, m.a);
}
inline double dist(const line &l, const segment &s) {
return intersect(l, s) ? 0 : min(dist(l, s.a), dist(l, s.b));
}
inline double dist(const segment &s, const point &p) {
if (dot((s.b - s.a), (p - s.a)) < 0)
return abs(p - s.a);
if (dot((s.a - s.b), (p - s.b)) < 0)
return abs(p - s.b);
return dist(line(s.a, s.b), p);
}
inline double dist(const segment &s, const segment &t) {
if (intersect(s, t))
return 0;
return min(min(dist(s, t.a), dist(s, t.b)), min(dist(t, s.a), dist(t, s.b)));
}
inline double dist(const point &a, const point &b) { return abs(a - b); }
inline bool intersect(const circle &c, const segment &s) {
return dist(s, c.c) < c.r + EPS;
}
inline point crosspoint(const line &l, const line &m) {
const double tmp = cross(l.b - l.a, m.b - m.a);
if (abs(tmp) < EPS) // 平行
return l.a;
return m.a + (m.b - m.a) * cross(l.b - l.a, l.a - m.a) * (1.0 / tmp);
}
inline point crosspoint(const segment &s, const segment &t) {
if (!intersect(s, t)) // 交点を持たない
return s.a; // 用改善
const double tmp = cross(s.b - s.a, t.b - t.a);
if (abs(tmp) < EPS) { // 一直線上
if (intersect(s, t.a))
return t.a;
if (intersect(s, t.b))
return t.b;
if (intersect(t, s.a))
return s.a;
return s.b;
}
return t.a + (t.b - t.a) * cross(s.b - s.a, s.b - t.a) * (1.0 / tmp);
}
// 先に，intersectを用いて交差判定を行うこと
inline vector<point> crosspoint(const circle &c, const circle &d) {
vector<point> res;
if (abs(c.c - d.c) < EPS) // 中心の座標が同じ
return res;
const double tmp = abs(c.c - d.c);
const double rc = (tmp * tmp + c.r * c.r - d.r * d.r) / (tmp + tmp);
const double rs = sqrt(c.r * c.r - rc * rc);
const point diff = (d.c - c.c) / tmp;
res.push_back(point(c.c + diff * point(rc, rs)));
res.push_back(point(c.c + diff * point(rc, -rs)));
return res;
}
inline vector<point> crosspoint(const circle &c, const line &l) {
vector<point> res;
const point h = projection(l, c.c);
const double d = abs(h - c.c);
if (d > c.r - EPS) {
res.push_back(h);
} else if (d <= c.r - EPS) {
point v = l.b - l.a;
v = v * sqrt(c.r * c.r - d * d) / abs(v);
res.push_back(h + v);
res.push_back(h - v);
}
return res;
}
inline vector<point> crosspoint(const circle &c, const segment &s) {
vector<point> res;
vector<point> tmp = crosspoint(c, line(s.a, s.b));
for (int i = 0; i < tmp.size(); ++i)
if (intersect(s, tmp[i]))
res.push_back(tmp[i]);
return res;
}
inline double areaTriangle(point a, point b, const point &c) {
a = a - c;
b = b - c;
return fabs(a.x * b.y - b.x * a.y) / 2.0;
}
inline double area(const polygon &p) {
const int num = p.size();
if (num < 3)
return 0;
if (num == 3)
return areaTriangle(p[0], p[1], p[2]);
double res = cross(p[num - 1], p[0]);
for (int i = 1; i < num; ++i)
res += cross(p[i - 1], p[i]);
return abs(res) * 0.5;
}
// L.aからL.bの方向を見た場合に，点aが左側に来る．
inline line bisector(const point &a, const point &b) {
return line(
point((a.x - a.y + b.x + b.y) / 2.0, (a.y + a.x + b.y - b.x) / 2.0),
point((a.x + a.y + b.x - b.y) / 2.0, (a.y - a.x + b.y + b.x) / 2.0));
}
// 点集合 pointsの凸包を求める．
inline polygon convex_hull(vector<point> points) {
const int n = points.size();
if (n <= 3)
return points;
sort(points.begin(), points.end());
int k = 0;
polygon res;
res.resize(2 * n);
for (int i = 0; i < n; res[k++] = points[i++])
while (k >= 2 && ccw(res[k - 2], res[k - 1], points[i]) <= 0)
--k;
const int t = k + 1;
for (int i = n - 2; i >= 0; res[k++] = points[i--])
while (k >= t && ccw(res[k - 2], res[k - 1], points[i]) <= 0)
--k;
res.resize(k - 1);
return res;
}
// L.aからL.bを向いた時の左側を残して切断する．
inline polygon convex_cut(const polygon &p, const line &l) {
const int num = p.size();
polygon res;
for (int i = 0; i < num; ++i) {
const int next = (i + 1) % num;
const int tmp = ccw(l.a, l.b, p[i]);
if (tmp != -1)
res.push_back(p[i]);
if (tmp * ccw(l.a, l.b, p[next]) < 0)
res.push_back(crosspoint(l, line(p[i], p[next])));
}
return res;
}
vector<point> tangent(const circle &c, const point &p) {
const double x = norm(p - c.c);
double d = x - c.r * c.r;
if (d < -EPS)
return vector<point>();
d = max(d, 0.0);
const point q1 = (p - c.c) * (c.r * c.r / x);
const point q2 = rotate90((p - c.c) * (-c.r * sqrt(d) / x));
vector<point> res;
res.push_back(c.c + q1 - q2);
res.push_back(c.c + q1 + q2);
return res;
}
vector<line> tangent(const circle &a, const circle &b) {
vector<line> res;
if (abs(a.r - b.r) < EPS) {
point dir = b.c - a.c;
dir = rotate90(dir * (a.r / abs(dir)));
res.push_back(line(a.c + dir, b.c + dir));
res.push_back(line(a.c - dir, b.c - dir));
} else {
point p = a.c * (-b.r) + b.c * a.r;
p = p * (1.0 / (a.r - b.r));
vector<point> ps = tangent(a, p), qs = tangent(b, p);
for (int i = 0; i < min<int>(ps.size(), qs.size()); ++i)
res.push_back(line(ps[i], qs[i]));
}
point p = a.c * b.r + b.c * a.r;
p = p * (1.0 / (a.r + b.r));
vector<point> ps = tangent(a, p), qs = tangent(b, p);
for (int i = 0; i < min<int>(ps.size(), qs.size()); ++i)
res.push_back(line(ps[i], qs[i]));
return res;
}
// 三角形と点の包含関係，境界は含まない．
// 含める場合は == -1を <= 0とする．
bool contain_triangle(const polygon &triangle, const point &p) {
const int d1 = ccw(p, triangle[0], triangle[1]),
d2 = ccw(p, triangle[1], triangle[2]),
d3 = ccw(p, triangle[2], triangle[0]);
return !(d1 * d2 == -1 || d2 * d3 == -1 || d3 * d1 == -1);
}
// 多角形と点の包含関係．境界を含む．
bool contain(const polygon &P, const point &p) {
const int n = P.size();
bool res = false;
for (int i = 0; i < n; ++i) {
point v1 = P[i] - p, v2 = P[(i + 1) % n] - p;
if (v1.y > v2.y)
swap(v1, v2);
if (v1.y < EPS && EPS < v2.y && cross(v1, v2) > EPS)
res = !res;
if (abs(cross(v1, v2)) < EPS && dot(v1, v2) < EPS)
return true; // 境界を含まないなら，falseにする．
}
return res;
}
const int limit = 101 * 101 / 2;
int main() {
int n;
scanf("%d", &n);
if (n > limit) {
printf("%.lf\n", 0.0);
return EXIT_SUCCESS;
}
vector<segment> segments;
segments.reserve(n);
for (int i = 0; i < n; ++i) {
int x1, y1, x2, y2;
scanf("%d %d %d %d", &x1, &y1, &x2, &y2);
segments.push_back(segment(point(x1, y1), point(x2, y2)));
}
double ans = 200;
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
chmin(ans, dist(segments[i], segments[j]));
}
}
printf("%.10lf\n", ans);
return EXIT_SUCCESS;
} | insert | 412 | 412 | 412 | 413 | TLE | |
p01468 | C++ | Time Limit Exceeded | #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;
#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; }
};
// output
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;
}
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;
}
// input
char tmp[1000];
#define nextInt(n) scanf("%d", &n)
#define nextLong(n) scanf("%lld", &n) // I64d
#define nextDouble(n) scanf("%lf", &n)
#define nextChar(n) scanf("%c", &n)
#define nextString(n) \
scanf("%s", tmp); \
n = tmp
// values
template <typename T> T INF() { assert(false); };
template <> int INF<int>() { return 1 << 28; };
template <> ll INF<ll>() { return 1LL << 58; };
template <> float INF<float>() { return 1e10; };
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 <> float EPS<float>() { return 1e-8; };
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; }
namespace _double_tmpl {
typedef double D;
static constexpr D Ae = 0;
D A(D a, D b) { return a + b; }
D Ainv(D a) { return -a; }
D S(D a, D b) { return A(a, Ainv(b)); }
static constexpr D Me = 1;
D M(D a, D b) { return a * b; }
D Minv(D a) { return 1.0 / a; };
int sig(D a, D b = 0) {
return a < b - EPS<D>() ? -1 : a > b + EPS<D>() ? 1 : 0;
}
template <typename T> bool eq(const T &a, const T &b) {
return sig(abs(a - b)) == 0;
}
D pfmod(D v, D MOD = 2 * M_PI) { return fmod(fmod(v, MOD) + MOD, MOD); }
//[0,PI)
D AbsArg(D a) {
D ret = pfmod(max(a, -a), 2 * M_PI);
return min(ret, 2 * M_PI - ret);
}
} // namespace _double_tmpl
using namespace _double_tmpl;
namespace _P {
// using namespace _double_tmpl;
typedef complex<D> P, Vec;
const P O = P(0, 0);
#define X real()
#define Y imag()
istream &operator>>(istream &is, complex<D> &p) {
D x, y;
is >> x >> y;
p = P(x, y);
return is;
}
bool compX(const P &a, const P &b) {
return !eq(a.X, b.X) ? sig(a.X, b.X) < 0 : sig(a.Y, b.Y) < 0;
}
bool compY(const P &a, const P &b) {
return !eq(a.Y, b.Y) ? sig(a.Y, b.Y) < 0 : sig(a.X, b.X) < 0;
}
// a×b
D cross(const Vec &a, const Vec &b) { return imag(conj(a) * b); }
// a・b
D dot(const Vec &a, const Vec &b) { return real(conj(a) * b); }
int ccw(const P &a, P b, P c) {
b -= a;
c -= a;
if (sig(cross(b, c)) > 0)
return +1; // counter clockwise
if (sig(cross(b, c)) < 0)
return -1; // clockwise
if (sig(dot(b, c)) < 0)
return +2; // c--a--b on line
if (sig(norm(b), norm(c)) < 0)
return -2; // a--b--c on line
return 0;
}
// 最近点対
// O(n logn)
// verified by AOJLIB
// http://judge.u-aizu.ac.jp/onlinejudge/review.jsp?rid=1093043
D closestPair(vector<P> &ps, int l, int r) {
if (r - l < 2)
return INF<D>();
D res = min(closestPair(ps, l, (l + r) / 2), closestPair(ps, (l + r) / 2, r));
vector<P> ips;
FOR(i, l, r) if (abs(ps[i].X - ps[(l + r) / 2].X) < res) ips.push_back(ps[i]);
sort(ALL(ips), compY);
REP(i, ips.size())
for (int j = i - 10; j < i; j++) if (j >= 0) res =
min(res, abs(ips[i] - ips[j]));
return res;
}
D closestPair(vector<P> &ps) { return closestPair(ps, 0, ps.size()); }
// verified by
// 事前にs-g
// O-s → O-gの回転方向に関してソート．
// (同角度の場合、距離が遠い方が前)
P s, g;
bool CompArg(const P &p1, const P &p2) {
if (abs(ccw(O, p1, p2)) != 1)
return abs(p1) > abs(p2); // sameline
return ccw(O, p1, p2) == ccw(O, s, g);
}
//!!
// 角度ソート
P dir; // 基準方向
bool Comp(const P &p1, const P &p2) {
if (sig(pfmod(arg(p1) - arg(dir)), pfmod(arg(p2) - arg(dir))) == 0)
return abs(p1) > abs(p2);
return sig(pfmod(arg(p1) - arg(dir)), pfmod(arg(p2) - arg(dir)));
}
} // namespace _P
using namespace _P;
namespace std {
bool operator<(const P &a, const P &b) { return _P::compX(a, b); }
bool operator==(const P &a, const P &b) { return eq(a, b); }
}; // namespace std
namespace _L {
struct L : public vector<P> {
P vec() const { return this->at(1) - this->at(0); }
L(const P &a, const P &b) {
push_back(a);
push_back(b);
}
L() {
push_back(P(0, 0));
push_back(P(0, 0));
}
};
istream &operator>>(istream &is, L &l) {
P s, t;
is >> s >> t;
l = L(s, t);
return is;
}
bool isIntersectLL(const L &l, const L &m) {
return sig(cross(l.vec(), m.vec())) != 0 || // non-parallel
sig(cross(l.vec(), m[0] - l[0])) == 0; // same line
}
bool isIntersectLS(const L &l, const L &s) {
return sig(cross(l.vec(), s[0] - l[0]) * // s[0] is left of l
cross(l.vec(), s[1] - l[0])) <= 0; // s[1] is right of l
}
bool isIntersectLP(const L &l, const P &p) {
return sig(cross(l[1] - p, l[0] - p)) == 0;
}
// verified by ACAC003 B
// http://judge.u-aizu.ac.jp/onlinejudge/creview.jsp?rid=899178&cid=ACAC003
bool isIntersectSS(const L &s, const L &t) {
return ccw(s[0], s[1], t[0]) * ccw(s[0], s[1], t[1]) <= 0 &&
ccw(t[0], t[1], s[0]) * ccw(t[0], t[1], s[1]) <= 0;
}
bool isIntersectSP(const L &s, const P &p) {
return sig(abs(s[0] - p) + abs(s[1] - p), abs(s[1] - s[0])) <=
0; // triangle inequality
}
// 直線へ射影した時の点
// verified by AOJLIB
// http://judge.u-aizu.ac.jp/onlinejudge/review.jsp?rid=1092212
P projection(const L &l, const P &p) {
D t = dot(p - l[0], l.vec()) / norm(l.vec());
return l[0] + t * l.vec();
}
// 対称な点
// verified by AOJLIB
// http://judge.u-aizu.ac.jp/onlinejudge/review.jsp?rid=1092214
P reflection(const L &l, const P &p) {
return p + 2.0 * (projection(l, p) - p);
}
D distanceLP(const L &l, const P &p) { return abs(p - projection(l, p)); }
D distanceLL(const L &l, const L &m) {
return isIntersectLL(l, m) ? 0 : distanceLP(l, m[0]);
}
D distanceLS(const L &l, const L &s) {
if (isIntersectLS(l, s))
return 0;
return min(distanceLP(l, s[0]), distanceLP(l, s[1]));
}
D distanceSP(const L &s, const P &p) {
const P r = projection(s, p);
if (isIntersectSP(s, r))
return abs(r - p);
return min(abs(s[0] - p), abs(s[1] - p));
}
D distanceSS(const L &s, const L &t) {
if (isIntersectSS(s, t))
return 0;
return min(min(distanceSP(s, t[0]), distanceSP(s, t[1])),
min(distanceSP(t, s[0]), distanceSP(t, s[1])));
}
// 交点計算
// verified by AOJLIB
// http://judge.u-aizu.ac.jp/onlinejudge/review.jsp?rid=1092231
P crosspoint(const L &l, const L &m) {
D A = cross(l.vec(), m.vec()), B = cross(l.vec(), l[1] - m[0]);
if (sig(A) == 0 && sig(B) == 0)
return m[0]; // same line
assert(sig(A) != 0); // err -> 交点を持たない．
return m[0] + B / A * (m[1] - m[0]);
}
} // namespace _L
using namespace _L;
class Main {
public:
void run() {
int N;
cin >> N;
vector<L> ls(N);
REP(i, N) {
cin >> ls[i][0] >> ls[i][1];
if (ls[i][0].X > ls[i][1].X)
swap(ls[i][0], ls[i][1]);
}
if (N * 2 > 101 * 101) {
cout << 0 << endl;
return;
}
D res = INF<D>();
sort(ALL(ls), [&](L l, L r) { return l[0].X < r[0].X; });
REP(i, N) for (int j = i + 1; j < N; j++) if (i != j) {
if (ls[i][0].X - ls[j][1].X > res)
break;
res = min(res, distanceSS(ls[i], ls[j]));
}
cout << res << 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;
#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; }
};
// output
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;
}
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;
}
// input
char tmp[1000];
#define nextInt(n) scanf("%d", &n)
#define nextLong(n) scanf("%lld", &n) // I64d
#define nextDouble(n) scanf("%lf", &n)
#define nextChar(n) scanf("%c", &n)
#define nextString(n) \
scanf("%s", tmp); \
n = tmp
// values
template <typename T> T INF() { assert(false); };
template <> int INF<int>() { return 1 << 28; };
template <> ll INF<ll>() { return 1LL << 58; };
template <> float INF<float>() { return 1e10; };
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 <> float EPS<float>() { return 1e-8; };
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; }
namespace _double_tmpl {
typedef double D;
static constexpr D Ae = 0;
D A(D a, D b) { return a + b; }
D Ainv(D a) { return -a; }
D S(D a, D b) { return A(a, Ainv(b)); }
static constexpr D Me = 1;
D M(D a, D b) { return a * b; }
D Minv(D a) { return 1.0 / a; };
int sig(D a, D b = 0) {
return a < b - EPS<D>() ? -1 : a > b + EPS<D>() ? 1 : 0;
}
template <typename T> bool eq(const T &a, const T &b) {
return sig(abs(a - b)) == 0;
}
D pfmod(D v, D MOD = 2 * M_PI) { return fmod(fmod(v, MOD) + MOD, MOD); }
//[0,PI)
D AbsArg(D a) {
D ret = pfmod(max(a, -a), 2 * M_PI);
return min(ret, 2 * M_PI - ret);
}
} // namespace _double_tmpl
using namespace _double_tmpl;
namespace _P {
// using namespace _double_tmpl;
typedef complex<D> P, Vec;
const P O = P(0, 0);
#define X real()
#define Y imag()
istream &operator>>(istream &is, complex<D> &p) {
D x, y;
is >> x >> y;
p = P(x, y);
return is;
}
bool compX(const P &a, const P &b) {
return !eq(a.X, b.X) ? sig(a.X, b.X) < 0 : sig(a.Y, b.Y) < 0;
}
bool compY(const P &a, const P &b) {
return !eq(a.Y, b.Y) ? sig(a.Y, b.Y) < 0 : sig(a.X, b.X) < 0;
}
// a×b
D cross(const Vec &a, const Vec &b) { return imag(conj(a) * b); }
// a・b
D dot(const Vec &a, const Vec &b) { return real(conj(a) * b); }
int ccw(const P &a, P b, P c) {
b -= a;
c -= a;
if (sig(cross(b, c)) > 0)
return +1; // counter clockwise
if (sig(cross(b, c)) < 0)
return -1; // clockwise
if (sig(dot(b, c)) < 0)
return +2; // c--a--b on line
if (sig(norm(b), norm(c)) < 0)
return -2; // a--b--c on line
return 0;
}
// 最近点対
// O(n logn)
// verified by AOJLIB
// http://judge.u-aizu.ac.jp/onlinejudge/review.jsp?rid=1093043
D closestPair(vector<P> &ps, int l, int r) {
if (r - l < 2)
return INF<D>();
D res = min(closestPair(ps, l, (l + r) / 2), closestPair(ps, (l + r) / 2, r));
vector<P> ips;
FOR(i, l, r) if (abs(ps[i].X - ps[(l + r) / 2].X) < res) ips.push_back(ps[i]);
sort(ALL(ips), compY);
REP(i, ips.size())
for (int j = i - 10; j < i; j++) if (j >= 0) res =
min(res, abs(ips[i] - ips[j]));
return res;
}
D closestPair(vector<P> &ps) { return closestPair(ps, 0, ps.size()); }
// verified by
// 事前にs-g
// O-s → O-gの回転方向に関してソート．
// (同角度の場合、距離が遠い方が前)
P s, g;
bool CompArg(const P &p1, const P &p2) {
if (abs(ccw(O, p1, p2)) != 1)
return abs(p1) > abs(p2); // sameline
return ccw(O, p1, p2) == ccw(O, s, g);
}
//!!
// 角度ソート
P dir; // 基準方向
bool Comp(const P &p1, const P &p2) {
if (sig(pfmod(arg(p1) - arg(dir)), pfmod(arg(p2) - arg(dir))) == 0)
return abs(p1) > abs(p2);
return sig(pfmod(arg(p1) - arg(dir)), pfmod(arg(p2) - arg(dir)));
}
} // namespace _P
using namespace _P;
namespace std {
bool operator<(const P &a, const P &b) { return _P::compX(a, b); }
bool operator==(const P &a, const P &b) { return eq(a, b); }
}; // namespace std
namespace _L {
struct L : public vector<P> {
P vec() const { return this->at(1) - this->at(0); }
L(const P &a, const P &b) {
push_back(a);
push_back(b);
}
L() {
push_back(P(0, 0));
push_back(P(0, 0));
}
};
istream &operator>>(istream &is, L &l) {
P s, t;
is >> s >> t;
l = L(s, t);
return is;
}
bool isIntersectLL(const L &l, const L &m) {
return sig(cross(l.vec(), m.vec())) != 0 || // non-parallel
sig(cross(l.vec(), m[0] - l[0])) == 0; // same line
}
bool isIntersectLS(const L &l, const L &s) {
return sig(cross(l.vec(), s[0] - l[0]) * // s[0] is left of l
cross(l.vec(), s[1] - l[0])) <= 0; // s[1] is right of l
}
bool isIntersectLP(const L &l, const P &p) {
return sig(cross(l[1] - p, l[0] - p)) == 0;
}
// verified by ACAC003 B
// http://judge.u-aizu.ac.jp/onlinejudge/creview.jsp?rid=899178&cid=ACAC003
bool isIntersectSS(const L &s, const L &t) {
return ccw(s[0], s[1], t[0]) * ccw(s[0], s[1], t[1]) <= 0 &&
ccw(t[0], t[1], s[0]) * ccw(t[0], t[1], s[1]) <= 0;
}
bool isIntersectSP(const L &s, const P &p) {
return sig(abs(s[0] - p) + abs(s[1] - p), abs(s[1] - s[0])) <=
0; // triangle inequality
}
// 直線へ射影した時の点
// verified by AOJLIB
// http://judge.u-aizu.ac.jp/onlinejudge/review.jsp?rid=1092212
P projection(const L &l, const P &p) {
D t = dot(p - l[0], l.vec()) / norm(l.vec());
return l[0] + t * l.vec();
}
// 対称な点
// verified by AOJLIB
// http://judge.u-aizu.ac.jp/onlinejudge/review.jsp?rid=1092214
P reflection(const L &l, const P &p) {
return p + 2.0 * (projection(l, p) - p);
}
D distanceLP(const L &l, const P &p) { return abs(p - projection(l, p)); }
D distanceLL(const L &l, const L &m) {
return isIntersectLL(l, m) ? 0 : distanceLP(l, m[0]);
}
D distanceLS(const L &l, const L &s) {
if (isIntersectLS(l, s))
return 0;
return min(distanceLP(l, s[0]), distanceLP(l, s[1]));
}
D distanceSP(const L &s, const P &p) {
const P r = projection(s, p);
if (isIntersectSP(s, r))
return abs(r - p);
return min(abs(s[0] - p), abs(s[1] - p));
}
D distanceSS(const L &s, const L &t) {
if (isIntersectSS(s, t))
return 0;
return min(min(distanceSP(s, t[0]), distanceSP(s, t[1])),
min(distanceSP(t, s[0]), distanceSP(t, s[1])));
}
// 交点計算
// verified by AOJLIB
// http://judge.u-aizu.ac.jp/onlinejudge/review.jsp?rid=1092231
P crosspoint(const L &l, const L &m) {
D A = cross(l.vec(), m.vec()), B = cross(l.vec(), l[1] - m[0]);
if (sig(A) == 0 && sig(B) == 0)
return m[0]; // same line
assert(sig(A) != 0); // err -> 交点を持たない．
return m[0] + B / A * (m[1] - m[0]);
}
} // namespace _L
using namespace _L;
class Main {
public:
void run() {
int N;
cin >> N;
vector<L> ls(N);
REP(i, N) {
cin >> ls[i][0] >> ls[i][1];
if (ls[i][0].X > ls[i][1].X)
swap(ls[i][0], ls[i][1]);
}
if (N * 2 > 101 * 101) {
cout << 0 << endl;
return;
}
D res = INF<D>();
sort(ALL(ls), [](L l, L r) { return l[0].X < r[0].X; });
REP(i, N) for (int j = i + 1; j < N; j++) {
if (ls[j][0].X - ls[i][1].X > res)
break;
res = min(res, distanceSS(ls[i], ls[j]));
}
cout << res << endl;
}
};
int main() {
cout << fixed << setprecision(20);
cin.tie(0);
ios::sync_with_stdio(false);
Main().run();
return 0;
} | replace | 382 | 385 | 382 | 385 | TLE | |
p01468 | C++ | Time Limit Exceeded | #include <algorithm>
#include <assert.h>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;
static const double EPS = 1e-9;
static const double PI = acos(-1.0);
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define FOR(i, s, n) for (int i = (s); i < (int)(n); i++)
#define FOREQ(i, s, n) for (int i = (s); i <= (int)(n); i++)
#define FORIT(it, c) \
for (__typeof((c).begin()) it = (c).begin(); it != (c).end(); it++)
#define MEMSET(v, h) memset((v), h, sizeof(v))
#include <complex>
typedef complex<double> Point;
typedef vector<Point> Polygon;
static const double INF = 1e+10;
#define CURR(P, i) (P[i])
#define NEXT(P, i) (P[(i + 1) % P.size()])
struct Line : public vector<Point> {
Line() { ; }
Line(Point a, Point b) {
push_back(a);
push_back(b);
}
};
struct Circle {
Point p;
double r;
Circle() { ; }
Circle(Point p, double r) : p(p), r(r) { ; }
};
namespace std {
bool operator<(const Point &lhs, const Point &rhs) {
return lhs.real() == rhs.real() ? lhs.imag() < rhs.imag()
: lhs.real() < rhs.real();
}
} // namespace std
inline double cross(const Point &a, const Point &b) {
return imag(conj(a) * b);
}
inline double dot(const Point &a, const Point &b) { return real(conj(a) * b); }
inline int ccw(Point a, Point b, Point c) {
b -= a;
c -= a;
if (cross(b, c) > 0) {
return 1;
}
if (cross(b, c) < 0) {
return -1;
}
if (dot(b, c) < 0) {
return 2;
}
if (norm(b) < norm(c)) {
return -2;
}
return 0;
}
bool intersectSS(const Line &s, const Line &t) {
return ccw(s[0], s[1], t[0]) * ccw(s[0], s[1], t[1]) <= 0 &&
ccw(t[0], t[1], s[0]) * ccw(t[0], t[1], s[1]) <= 0;
}
bool intersectSP(const Line &s, const Point &p) {
return abs(s[0] - p) + abs(s[1] - p) - abs(s[1] - s[0]) < EPS;
}
Point projection(const Line &l, const Point &p) {
double t = dot(p - l[0], l[0] - l[1]) / norm(l[0] - l[1]);
return l[0] + t * (l[0] - l[1]);
}
double distanceLP(const Line &l, const Point &p) {
return abs(p - projection(l, p));
}
double distanceSP(const Line &s, const Point &p) {
const Point r = projection(s, p);
if (intersectSP(s, r)) {
return abs(r - p);
}
return min(abs(s[0] - p), abs(s[1] - p));
}
double distanceSS(const Line &s, const Line &t) {
if (intersectSS(s, t)) {
return 0;
}
return min(min(distanceSP(s, t[0]), distanceSP(s, t[1])),
min(distanceSP(t, s[0]), distanceSP(t, s[1])));
}
struct Event {
int x;
int out;
int index;
Event() { ; }
Event(int x, int out, int index) : x(x), out(out), index(index) { ; }
bool operator<(const Event &rhs) const {
if (x != rhs.x) {
return x < rhs.x;
}
return out < rhs.out;
}
};
vector<Event> events;
Line lines[100010];
int n;
int main() {
while (scanf("%d", &n) > 0) {
events.clear();
queue<int> que;
REP(i, n) {
int x1, y1, x2, y2;
scanf("%d %d %d %d", &x1, &y1, &x2, &y2);
if (x2 < x1) {
swap(x1, x2);
swap(y1, y2);
}
lines[i] = Line(Point(x1, y1), Point(x2, y2));
events.push_back(Event(x1, 0, i));
events.push_back(Event(x2, 1, i));
}
if (n > 101 * 101 / 2 + 2) {
puts("0");
continue;
}
sort(events.begin(), events.end());
double ans = 1e+10;
set<int> open;
REP(i, n * 2) {
Event e = events[i];
if (e.out) {
que.push(e.index);
} else {
while (!que.empty() && lines[que.front()][1] < e.x - ans) {
que.pop();
}
FORIT(it, open) {
ans = min(ans, distanceSS(lines[e.index], lines[*it]));
}
open.insert(e.index);
}
}
printf("%.8f\n", ans);
}
} | #include <algorithm>
#include <assert.h>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;
static const double EPS = 1e-9;
static const double PI = acos(-1.0);
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define FOR(i, s, n) for (int i = (s); i < (int)(n); i++)
#define FOREQ(i, s, n) for (int i = (s); i <= (int)(n); i++)
#define FORIT(it, c) \
for (__typeof((c).begin()) it = (c).begin(); it != (c).end(); it++)
#define MEMSET(v, h) memset((v), h, sizeof(v))
#include <complex>
typedef complex<double> Point;
typedef vector<Point> Polygon;
static const double INF = 1e+10;
#define CURR(P, i) (P[i])
#define NEXT(P, i) (P[(i + 1) % P.size()])
struct Line : public vector<Point> {
Line() { ; }
Line(Point a, Point b) {
push_back(a);
push_back(b);
}
};
struct Circle {
Point p;
double r;
Circle() { ; }
Circle(Point p, double r) : p(p), r(r) { ; }
};
namespace std {
bool operator<(const Point &lhs, const Point &rhs) {
return lhs.real() == rhs.real() ? lhs.imag() < rhs.imag()
: lhs.real() < rhs.real();
}
} // namespace std
inline double cross(const Point &a, const Point &b) {
return imag(conj(a) * b);
}
inline double dot(const Point &a, const Point &b) { return real(conj(a) * b); }
inline int ccw(Point a, Point b, Point c) {
b -= a;
c -= a;
if (cross(b, c) > 0) {
return 1;
}
if (cross(b, c) < 0) {
return -1;
}
if (dot(b, c) < 0) {
return 2;
}
if (norm(b) < norm(c)) {
return -2;
}
return 0;
}
bool intersectSS(const Line &s, const Line &t) {
return ccw(s[0], s[1], t[0]) * ccw(s[0], s[1], t[1]) <= 0 &&
ccw(t[0], t[1], s[0]) * ccw(t[0], t[1], s[1]) <= 0;
}
bool intersectSP(const Line &s, const Point &p) {
return abs(s[0] - p) + abs(s[1] - p) - abs(s[1] - s[0]) < EPS;
}
Point projection(const Line &l, const Point &p) {
double t = dot(p - l[0], l[0] - l[1]) / norm(l[0] - l[1]);
return l[0] + t * (l[0] - l[1]);
}
double distanceLP(const Line &l, const Point &p) {
return abs(p - projection(l, p));
}
double distanceSP(const Line &s, const Point &p) {
const Point r = projection(s, p);
if (intersectSP(s, r)) {
return abs(r - p);
}
return min(abs(s[0] - p), abs(s[1] - p));
}
double distanceSS(const Line &s, const Line &t) {
if (intersectSS(s, t)) {
return 0;
}
return min(min(distanceSP(s, t[0]), distanceSP(s, t[1])),
min(distanceSP(t, s[0]), distanceSP(t, s[1])));
}
struct Event {
int x;
int out;
int index;
Event() { ; }
Event(int x, int out, int index) : x(x), out(out), index(index) { ; }
bool operator<(const Event &rhs) const {
if (x != rhs.x) {
return x < rhs.x;
}
return out < rhs.out;
}
};
vector<Event> events;
Line lines[100010];
int n;
int main() {
while (scanf("%d", &n) > 0) {
events.clear();
queue<int> que;
REP(i, n) {
int x1, y1, x2, y2;
scanf("%d %d %d %d", &x1, &y1, &x2, &y2);
if (x2 < x1) {
swap(x1, x2);
swap(y1, y2);
}
lines[i] = Line(Point(x1, y1), Point(x2, y2));
events.push_back(Event(x1, 0, i));
events.push_back(Event(x2, 1, i));
}
if (n > 101 * 101 / 2 + 2) {
puts("0");
continue;
}
sort(events.begin(), events.end());
double ans = 1e+10;
set<int> open;
REP(i, n * 2) {
Event e = events[i];
if (e.out) {
que.push(e.index);
} else {
while (!que.empty() && lines[que.front()][1] < e.x - ans) {
open.erase(que.front());
que.pop();
}
FORIT(it, open) {
ans = min(ans, distanceSS(lines[e.index], lines[*it]));
}
open.insert(e.index);
}
}
printf("%.8f\n", ans);
}
} | insert | 162 | 162 | 162 | 163 | TLE | |
p01469 | C++ | Runtime Error | #include <algorithm>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdarg>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <sys/time.h>
#include <vector>
// #include "cout.h"
using namespace std;
#define SZ(x) ((int)x.size())
#define MSET(x, a) memset(x, a, (int)sizeof(x))
#define PB push_back
#define VI vector<int>
#define PII pair<int, int>
#define LL long long
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define REP(i, n) FOR(i, 0, n)
#define ALL(v) (v).begin(), (v).end()
#define FIT(it, v) \
for (typeof((v).begin()) it = (v).begin(); it != (v).end(); it++)
#define OUT(A) cout << #A << " = " << (A) << endl
#define OUT2(A, B) \
cout << "(" << #A << ", " << #B << ") = (" << (A) << ", " << (B) << ")" \
<< endl
template <class T> void chmin(T &t, T f) {
if (t > f)
t = f;
}
template <class T> void chmax(T &t, T f) {
if (t < f)
t = f;
}
#define present(c, e) ((c).find((e)) != (c).end())
#define cpresent(c, e) (find(all(c), (e)) != (c).end())
int n, x[110];
const int MAX_V = 110;
int V; // 左の頂点数。忘れずに設定すること。
// ちなみに、Vは左右合わせた全部の頂点数でも問題ない。（左が終わった後に右からのをチェックしても、マッチ数は絶対増えない）
VI G[MAX_V]; // ちゃんとGもケースごとに全部clear。
int match[MAX_V];
bool used[MAX_V];
void add_edge(int u, int v) {
G[u].PB(v);
G[v].PB(u);
}
bool dfs(int v) {
used[v] = true;
REP(i, SZ(G[v])) {
int u = G[v][i], w = match[u];
if (w < 0 || (!used[w] && dfs(w))) {
match[v] = u;
match[u] = v;
return true;
}
}
return false;
}
int bipartite_matching() {
int res = 0;
MSET(match, -1);
REP(v, V) {
if (match[v] < 0) {
MSET(used, 0);
if (dfs(v))
res++;
}
}
return res;
}
void init() {}
void input() {
cin >> n;
REP(i, n) cin >> x[i];
}
bool g[110][110];
VI res;
int cnt(VI used, int a) {
bool canuse[n];
REP(i, n) canuse[i] = true;
REP(i, a) canuse[i] = false;
REP(i, SZ(used)) {
canuse[used[i]] = false;
REP(j, n) if (g[used[i]][j] || g[j][used[i]]) canuse[j] = false;
}
map<int, int> idx;
V = 0;
REP(i, MAX_V) G[i].clear();
REP(i, n) if (canuse[i]) idx[i] = V++;
REP(i, n)
REP(j, n) if (i != j && canuse[i] && canuse[j] && g[i][j])
add_edge(idx[i], idx[j] + V);
return V - bipartite_matching();
}
void solve() {
REP(i, 110) REP(j, 110) g[i][j] = false;
REP(i, n) REP(j, n) if (i != j && x[i] % x[j] == 0) g[i][j] = true;
res.clear();
REP(i, n) {
int cnt1 = cnt(res, i + 1);
int cnt2 = 0;
bool test = true;
REP(j, SZ(res)) if (g[res[j]][i] || g[i][res[j]]) test = false;
VI tmp = res;
tmp.push_back(i);
if (test)
cnt2 = cnt(tmp, i + 1) + 1;
if (cnt2 >= cnt1 && cnt2 != 0)
res.push_back(i);
}
REP(i, SZ(res)) cout << res[i] + 1 << (i == SZ(res) - 1 ? "" : " ");
cout << endl;
}
int main() {
init();
input();
solve();
return 0;
} | #include <algorithm>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdarg>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <sys/time.h>
#include <vector>
// #include "cout.h"
using namespace std;
#define SZ(x) ((int)x.size())
#define MSET(x, a) memset(x, a, (int)sizeof(x))
#define PB push_back
#define VI vector<int>
#define PII pair<int, int>
#define LL long long
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define REP(i, n) FOR(i, 0, n)
#define ALL(v) (v).begin(), (v).end()
#define FIT(it, v) \
for (typeof((v).begin()) it = (v).begin(); it != (v).end(); it++)
#define OUT(A) cout << #A << " = " << (A) << endl
#define OUT2(A, B) \
cout << "(" << #A << ", " << #B << ") = (" << (A) << ", " << (B) << ")" \
<< endl
template <class T> void chmin(T &t, T f) {
if (t > f)
t = f;
}
template <class T> void chmax(T &t, T f) {
if (t < f)
t = f;
}
#define present(c, e) ((c).find((e)) != (c).end())
#define cpresent(c, e) (find(all(c), (e)) != (c).end())
int n, x[110];
const int MAX_V = 210;
int V; // 左の頂点数。忘れずに設定すること。
// ちなみに、Vは左右合わせた全部の頂点数でも問題ない。（左が終わった後に右からのをチェックしても、マッチ数は絶対増えない）
VI G[MAX_V]; // ちゃんとGもケースごとに全部clear。
int match[MAX_V];
bool used[MAX_V];
void add_edge(int u, int v) {
G[u].PB(v);
G[v].PB(u);
}
bool dfs(int v) {
used[v] = true;
REP(i, SZ(G[v])) {
int u = G[v][i], w = match[u];
if (w < 0 || (!used[w] && dfs(w))) {
match[v] = u;
match[u] = v;
return true;
}
}
return false;
}
int bipartite_matching() {
int res = 0;
MSET(match, -1);
REP(v, V) {
if (match[v] < 0) {
MSET(used, 0);
if (dfs(v))
res++;
}
}
return res;
}
void init() {}
void input() {
cin >> n;
REP(i, n) cin >> x[i];
}
bool g[110][110];
VI res;
int cnt(VI used, int a) {
bool canuse[n];
REP(i, n) canuse[i] = true;
REP(i, a) canuse[i] = false;
REP(i, SZ(used)) {
canuse[used[i]] = false;
REP(j, n) if (g[used[i]][j] || g[j][used[i]]) canuse[j] = false;
}
map<int, int> idx;
V = 0;
REP(i, MAX_V) G[i].clear();
REP(i, n) if (canuse[i]) idx[i] = V++;
REP(i, n)
REP(j, n) if (i != j && canuse[i] && canuse[j] && g[i][j])
add_edge(idx[i], idx[j] + V);
return V - bipartite_matching();
}
void solve() {
REP(i, 110) REP(j, 110) g[i][j] = false;
REP(i, n) REP(j, n) if (i != j && x[i] % x[j] == 0) g[i][j] = true;
res.clear();
REP(i, n) {
int cnt1 = cnt(res, i + 1);
int cnt2 = 0;
bool test = true;
REP(j, SZ(res)) if (g[res[j]][i] || g[i][res[j]]) test = false;
VI tmp = res;
tmp.push_back(i);
if (test)
cnt2 = cnt(tmp, i + 1) + 1;
if (cnt2 >= cnt1 && cnt2 != 0)
res.push_back(i);
}
REP(i, SZ(res)) cout << res[i] + 1 << (i == SZ(res) - 1 ? "" : " ");
cout << endl;
}
int main() {
init();
input();
solve();
return 0;
} | replace | 52 | 53 | 52 | 53 | 0 | |
p01470 | C++ | Time Limit Exceeded | #include <iostream>
using namespace std;
typedef long long ll;
ll mod = 8589934609ll;
ll mul(ll x, ll y) { // x * y
ll res = (x * (y >> 30)) % mod;
for (int i = 0; i < 30; ++i)
res = (res << 1) % mod;
res += x * (((y >> 30) << 30) ^ y);
res %= mod;
return res;
}
ll powmod(ll x, ll p) {
if (p == 0)
return 1;
if (p == 1)
return x;
if (p % 2)
return mul(x, powmod(x, p - 1));
else
return powmod(mul(x, x), p / 2);
}
ll modInverse(ll x) { // x^(mod-2)
return powmod(x, mod - 2);
}
int main() {
int n, o, y;
ll ans = 0;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> o >> y;
switch (o) {
case 1:
ans += y;
ans %= mod;
break;
case 2:
ans -= y;
ans = (ans + mod) % mod;
break;
case 3:
ans = mul(ans, y);
break;
case 4:
ans = mul(ans, modInverse(y));
break;
}
}
if (ans >= 1ll << 31)
ans -= mod;
cout << ans << endl;
} | #include <iostream>
using namespace std;
typedef long long ll;
ll mod = 8589934609ll;
ll mul(ll x, ll y) { // x * y
ll res = (x * (y >> 30)) % mod;
res = (res << 15) % mod;
res = (res << 15) % mod;
res += x * (((y >> 30) << 30) ^ y);
res %= mod;
return res;
}
ll powmod(ll x, ll p) {
if (p == 0)
return 1;
if (p == 1)
return x;
if (p % 2)
return mul(x, powmod(x, p - 1));
else
return powmod(mul(x, x), p / 2);
}
ll modInverse(ll x) { // x^(mod-2)
return powmod(x, mod - 2);
}
int main() {
int n, o, y;
ll ans = 0;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> o >> y;
switch (o) {
case 1:
ans += y;
ans %= mod;
break;
case 2:
ans -= y;
ans = (ans + mod) % mod;
break;
case 3:
ans = mul(ans, y);
break;
case 4:
ans = mul(ans, modInverse(y));
break;
}
}
if (ans >= 1ll << 31)
ans -= mod;
cout << ans << endl;
} | replace | 9 | 11 | 9 | 12 | TLE | |
p01471 | C++ | Runtime Error | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;
struct node {
double w, v, u;
};
vector<node> list;
bool cmp(node A, node B) { return A.v / A.w > B.v / B.w; }
int main() {
// freopen("input.txt","r",stdin);
int N;
double W;
while (scanf("%d%lf", &N, &W) == 2) {
list.clear();
double ans = 0.0;
for (int i = 0; i < N; i++) {
node obj;
scanf("%lf%lf", &obj.w, &obj.v);
obj.u = obj.v / obj.w;
if (obj.w <= 0 && obj.v >= 0) {
W -= obj.w;
ans += obj.v;
continue;
}
if (obj.w >= 0 && obj.v <= 0)
continue;
if (obj.w <= 0 && obj.v <= 0) {
W -= obj.w;
ans += obj.v;
obj.w *= -1.0;
obj.v *= -1.0;
}
list.push_back(obj);
}
sort(list.begin(), list.end(), cmp);
for (int i = 0; i < N; i++) {
if (list[i].w <= W) {
W -= list[i].w;
ans += list[i].v;
} else {
ans += list[i].u * W;
W = 0.0;
}
}
printf("%.8lf\n", ans);
}
return 0;
} | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;
struct node {
double w, v, u;
};
vector<node> list;
bool cmp(node A, node B) { return A.v / A.w > B.v / B.w; }
int main() {
// freopen("input.txt","r",stdin);
int N;
double W;
while (scanf("%d%lf", &N, &W) == 2) {
list.clear();
double ans = 0.0;
for (int i = 0; i < N; i++) {
node obj;
scanf("%lf%lf", &obj.w, &obj.v);
obj.u = obj.v / obj.w;
if (obj.w <= 0 && obj.v >= 0) {
W -= obj.w;
ans += obj.v;
continue;
}
if (obj.w >= 0 && obj.v <= 0)
continue;
if (obj.w <= 0 && obj.v <= 0) {
W -= obj.w;
ans += obj.v;
obj.w *= -1.0;
obj.v *= -1.0;
}
list.push_back(obj);
}
sort(list.begin(), list.end(), cmp);
for (int i = 0; i < list.size(); i++) {
if (list[i].w <= W) {
W -= list[i].w;
ans += list[i].v;
} else {
ans += list[i].u * W;
W = 0.0;
}
}
printf("%.8lf\n", ans);
}
return 0;
} | replace | 37 | 38 | 37 | 38 | 0 | |
p01473 | C++ | Time Limit Exceeded | #include <iostream>
#include <map>
#include <string>
#define rep(i, a, b) for (int i = a; i < b; i++)
using namespace std;
typedef long long ll;
string s;
ll fact(ll x) {
if (x == 1)
return 1;
return x * fact(x - 1);
}
int main() {
cin >> s;
map<char, int> mp;
rep(i, 0, s.size()) mp[s[i]]++;
int cnt = 0;
int sum = 0;
ll ans;
map<char, int>::iterator itr = mp.begin();
while (itr != mp.end()) {
// cout << itr->first << " "<< itr->second << endl;
if (itr->second % 2 == 1) {
(itr->second)--;
cnt++;
}
sum += itr->second / 2;
itr++;
}
if (s.size() == 1) {
cout << 1 << endl;
} else if (cnt > 0 && s.size() % 2 == 0)
cout << 0 << endl;
else if (cnt > 1)
cout << 0 << endl;
else {
ans = fact(sum);
itr = mp.begin();
while (itr != mp.end()) {
// cout << itr->first << " A "<< itr->second << endl;
ans /= fact(itr->second / 2);
itr++;
}
cout << ans << endl;
}
} | #include <iostream>
#include <map>
#include <string>
#define rep(i, a, b) for (int i = a; i < b; i++)
using namespace std;
typedef long long ll;
string s;
ll fact(ll x) {
if (x == 0)
return 1;
return x * fact(x - 1);
}
int main() {
cin >> s;
map<char, int> mp;
rep(i, 0, s.size()) mp[s[i]]++;
int cnt = 0;
int sum = 0;
ll ans;
map<char, int>::iterator itr = mp.begin();
while (itr != mp.end()) {
// cout << itr->first << " "<< itr->second << endl;
if (itr->second % 2 == 1) {
(itr->second)--;
cnt++;
}
sum += itr->second / 2;
itr++;
}
if (s.size() == 1) {
cout << 1 << endl;
} else if (cnt > 0 && s.size() % 2 == 0)
cout << 0 << endl;
else if (cnt > 1)
cout << 0 << endl;
else {
ans = fact(sum);
itr = mp.begin();
while (itr != mp.end()) {
// cout << itr->first << " A "<< itr->second << endl;
ans /= fact(itr->second / 2);
itr++;
}
cout << ans << endl;
}
} | replace | 10 | 11 | 10 | 11 | TLE | |
p01477 | C++ | Runtime Error | #include <algorithm>
#include <cassert>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)n; i++)
#define fr(i, c) for (__typeof(c.begin()) i = c.begin(); i != c.end(); i++)
#define pb push_back
#define mp make_pair
#define all(c) c.begin(), c.end()
#define dbg(x) cerr << #x << " = " << (x) << endl
typedef vector<int> vi;
typedef pair<int, int> pi;
typedef long long ll;
const int inf = (int)1e9;
const double EPS = 1e-9, INF = 1e12;
const int mod = (int)1e9 + 7;
int n, m, y[1000][2];
vector<vi> e;
int deg[1000];
bool v[1000], loop[1000];
void rec(int c, int p) {
v[c] = 1;
rep(i, e[c].size()) if (!v[e[c][i]]) {
rep(j, 2) rep(k, 2) if (abs(y[c][j]) == abs(y[e[c][i]][k])) {
if (j == 0)
swap(y[c][0], y[c][1]);
if (k == 1)
swap(y[e[c][i]][0], y[e[c][i]][1]);
}
rec(e[c][i], c);
}
}
ll dp[1000][2][2];
ll calc(int c, int lv, int p, int s, int sv) {
// cerr<<"c: "<<c<<" lv: "<<lv<<" p: "<<p<<" s: "<<s<<" sv: "<<sv<<endl;
ll &res = dp[c][lv][sv];
if (res >= 0)
return res;
v[c] = 1;
int nxt = e[c][p == e[c][0] ? 1 : 0];
if (nxt == s)
return res = lv ? 1 : sv == (y[c][1] == y[nxt][0]);
res = calc(nxt, y[c][1] == y[nxt][0], c, s, sv);
if (lv)
res += calc(nxt, y[c][1] != y[nxt][0], c, s, sv);
res %= mod;
return res;
}
ll dp2[1000][2];
ll calc2(int c, int lv, int p) {
// cerr<<"c: "<<c<<" lv: "<<lv<<" p: "<<p<<endl;
ll &res = dp2[c][lv];
if (res >= 0)
return res;
v[c] = 1;
if (e[c].size() == 1 && e[c][0] == p)
return lv ? 2 : 1;
int nxt = e[c][p == e[c][0] ? 1 : 0];
res = calc2(nxt, y[c][1] == y[nxt][0], c);
if (lv)
res += calc2(nxt, y[c][1] != y[nxt][0], c);
res %= mod;
return res;
}
int main() {
cin >> n >> m;
ll ans = 1;
rep(i, m) {
cin >> y[i][0] >> y[i][1];
if (abs(y[i][0]) == abs(y[i][1])) {
if (y[i][0] != y[i][1])
ans *= 2, ans %= mod;
m--;
i--;
}
}
e.resize(m);
rep(i, m) rep(j, i) rep(k, 2) rep(l, 2) {
if (abs(y[i][k]) == abs(y[j][l])) {
e[i].pb(j);
e[j].pb(i);
}
}
rep(i, m) v[i] = 0;
rep(i, m) if (!v[i] && e[i].size() == 1) rec(i, -1);
rep(i, m) if (!v[i]) rec(i, -1);
rep(i, m) v[i] = 0;
// rep(i,m)cerr<<"i: "<<i<<" : "<<y[i][0]<<" "<<y[i][1]<<"
// sz:"<<e[i].size()<<endl;
memset(dp2, -1, sizeof(dp2));
rep(i, m) if (e[i].size() == 1 && !v[i]) {
ll tmp = calc2(i, 0, -1) + calc2(i, 1, -1);
ans *= tmp;
ans %= mod;
}
memset(dp, -1, sizeof(dp));
rep(i, m) if (e[i].size() == 2 && !v[i]) {
ll tmp = calc(i, 0, -1, i, 0) + calc(i, 1, -1, i, 1);
ans *= tmp;
ans %= mod;
if (tmp != 149)
dbg(tmp);
}
rep(i, m) if (e[i].empty()) ans *= 3, ans %= mod;
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <cassert>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)n; i++)
#define fr(i, c) for (__typeof(c.begin()) i = c.begin(); i != c.end(); i++)
#define pb push_back
#define mp make_pair
#define all(c) c.begin(), c.end()
#define dbg(x) cerr << #x << " = " << (x) << endl
typedef vector<int> vi;
typedef pair<int, int> pi;
typedef long long ll;
const int inf = (int)1e9;
const double EPS = 1e-9, INF = 1e12;
const int mod = (int)1e9 + 7;
int n, m, y[1000][2];
vector<vi> e;
int deg[1000];
bool v[1000], loop[1000];
void rec(int c, int p) {
v[c] = 1;
rep(i, e[c].size()) if (!v[e[c][i]]) {
rep(j, 2) rep(k, 2) if (abs(y[c][j]) == abs(y[e[c][i]][k])) {
if (j == 0)
swap(y[c][0], y[c][1]);
if (k == 1)
swap(y[e[c][i]][0], y[e[c][i]][1]);
}
rec(e[c][i], c);
}
}
ll dp[1000][2][2];
ll calc(int c, int lv, int p, int s, int sv) {
// cerr<<"c: "<<c<<" lv: "<<lv<<" p: "<<p<<" s: "<<s<<" sv: "<<sv<<endl;
ll &res = dp[c][lv][sv];
if (res >= 0)
return res;
v[c] = 1;
int nxt = e[c][p == e[c][0] ? 1 : 0];
if (nxt == s)
return res = lv ? 1 : sv == (y[c][1] == y[nxt][0]);
res = calc(nxt, y[c][1] == y[nxt][0], c, s, sv);
if (lv)
res += calc(nxt, y[c][1] != y[nxt][0], c, s, sv);
res %= mod;
return res;
}
ll dp2[1000][2];
ll calc2(int c, int lv, int p) {
// cerr<<"c: "<<c<<" lv: "<<lv<<" p: "<<p<<endl;
ll &res = dp2[c][lv];
if (res >= 0)
return res;
v[c] = 1;
if (e[c].size() == 1 && e[c][0] == p)
return lv ? 2 : 1;
int nxt = e[c][p == e[c][0] ? 1 : 0];
res = calc2(nxt, y[c][1] == y[nxt][0], c);
if (lv)
res += calc2(nxt, y[c][1] != y[nxt][0], c);
res %= mod;
return res;
}
int main() {
cin >> n >> m;
ll ans = 1;
rep(i, m) {
cin >> y[i][0] >> y[i][1];
if (abs(y[i][0]) == abs(y[i][1])) {
if (y[i][0] != y[i][1])
ans *= 2, ans %= mod;
m--;
i--;
}
}
e.resize(m);
rep(i, m) rep(j, i) rep(k, 2) rep(l, 2) {
if (abs(y[i][k]) == abs(y[j][l])) {
e[i].pb(j);
e[j].pb(i);
}
}
rep(i, m) v[i] = 0;
rep(i, m) if (!v[i] && e[i].size() == 1) rec(i, -1);
rep(i, m) if (!v[i]) rec(i, -1);
rep(i, m) v[i] = 0;
// rep(i,m)cerr<<"i: "<<i<<" : "<<y[i][0]<<" "<<y[i][1]<<"
// sz:"<<e[i].size()<<endl;
memset(dp2, -1, sizeof(dp2));
rep(i, m) if (e[i].size() == 1 && !v[i]) {
ll tmp = calc2(i, 0, -1) + calc2(i, 1, -1);
ans *= tmp;
ans %= mod;
}
memset(dp, -1, sizeof(dp));
rep(i, m) if (e[i].size() == 2 && !v[i]) {
ll tmp = calc(i, 0, -1, i, 0) + calc(i, 1, -1, i, 1);
ans *= tmp;
ans %= mod;
}
rep(i, m) if (e[i].empty()) ans *= 3, ans %= mod;
cout << ans << endl;
return 0;
} | delete | 119 | 121 | 119 | 119 | 0 | |
p01478 | C++ | Memory Limit Exceeded | #include <iostream>
#include <queue>
using namespace std;
int dp[1 << 24], x[8][8];
queue<int> Q;
int main() {
int n;
cin >> n;
int minp = 0, maxp = 0;
for (int i = 0; i < n; i++) {
minp += (n - 1 - i) * (1 << (3 * i));
maxp += i * (1 << (3 * i));
}
for (int i = minp; i <= maxp; i++)
dp[i] = 1000000007;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++)
cin >> x[i][j];
}
int G = 0, maxn = 0;
for (int i = 0; i < n; i++) {
G += (1 << (3 * i)) * i;
}
Q.push(G);
dp[G] = 0;
while (!Q.empty()) {
int H = Q.front();
Q.pop();
int I[8], J[8];
for (int i = 0; i < 8; i++)
I[i] = (H / (1 << (3 * i))) % 8;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
for (int k = 0; k < 8; k++)
J[k] = I[k];
swap(J[i], J[j]);
int K = 0;
for (int k = 0; k < 8; k++)
K += (1 << (3 * k)) * J[k];
if (dp[K] > dp[H] + x[i][j]) {
dp[K] = dp[H] + x[i][j];
Q.push(K);
}
}
}
}
for (int i = minp; i <= maxp; i++) {
if (dp[i] != 1000000007 && maxn < dp[i])
maxn = dp[i];
}
cout << maxn << endl;
return 0;
} | #include <iostream>
#include <queue>
using namespace std;
int dp[16434825], x[8][8];
queue<int> Q;
int main() {
int n;
cin >> n;
int minp = 0, maxp = 0;
for (int i = 0; i < n; i++) {
minp += (n - 1 - i) * (1 << (3 * i));
maxp += i * (1 << (3 * i));
}
for (int i = minp; i <= maxp; i++)
dp[i] = 1000000007;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++)
cin >> x[i][j];
}
int G = 0, maxn = 0;
for (int i = 0; i < n; i++) {
G += (1 << (3 * i)) * i;
}
Q.push(G);
dp[G] = 0;
while (!Q.empty()) {
int H = Q.front();
Q.pop();
int I[8], J[8];
for (int i = 0; i < 8; i++)
I[i] = (H / (1 << (3 * i))) % 8;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
for (int k = 0; k < 8; k++)
J[k] = I[k];
swap(J[i], J[j]);
int K = 0;
for (int k = 0; k < 8; k++)
K += (1 << (3 * k)) * J[k];
if (dp[K] > dp[H] + x[i][j]) {
dp[K] = dp[H] + x[i][j];
Q.push(K);
}
}
}
}
for (int i = minp; i <= maxp; i++) {
if (dp[i] != 1000000007 && maxn < dp[i])
maxn = dp[i];
}
cout << maxn << endl;
return 0;
} | replace | 3 | 4 | 3 | 4 | MLE | |
p01478 | C++ | Runtime Error | #include <iostream>
#include <map>
#include <queue>
#include <vector>
using namespace std;
typedef pair<int, int> pii;
const int INF = 1000000000;
inline int swap(int cur, int i, int j) {
int result = cur & ~(7 << (i * 3)) & ~(7 << (j * 3));
result |= ((cur >> (i * 3)) & 7) << (j * 3);
result |= ((cur >> (j * 3)) & 7) << (i * 3);
return result;
}
void recur(map<int, int> &mp, int cur, int mask) {
if (mask == 0) {
mp.insert(pii(cur, mp.size()));
} else {
for (int i = 0; i < 7; ++i) {
if (!(mask & (1 << i))) {
continue;
}
recur(mp, (cur << 3) | i, mask & ~(1 << i));
}
}
}
int main() {
int n;
cin >> n;
vector<vector<int>> c(n, vector<int>(n));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
cin >> c[i][j];
}
}
int init = 0;
for (int i = 0; i < n; ++i) {
init |= i << (i * 3);
}
map<int, int> mp;
recur(mp, 0, (1 << n) - 1);
vector<int> minval(mp.size(), INF);
priority_queue<pii, vector<pii>, greater<pii>> pq;
pq.push(pii(0, init));
minval[mp[init]] = 0;
while (!pq.empty()) {
pii p = pq.top();
pq.pop();
int v = p.second, cost = p.first;
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
int w = swap(v, i, j), wi = mp[w];
int nc = cost + c[i][j];
if (nc < minval[wi]) {
pq.push(pii(nc, w));
minval[wi] = nc;
}
}
}
}
int answer = 0;
for (int i = 0; i < minval.size(); ++i) {
answer = max(answer, minval[i]);
}
cout << answer << endl;
return 0;
} | #include <iostream>
#include <map>
#include <queue>
#include <vector>
using namespace std;
typedef pair<int, int> pii;
const int INF = 1000000000;
inline int swap(int cur, int i, int j) {
int result = cur & ~(7 << (i * 3)) & ~(7 << (j * 3));
result |= ((cur >> (i * 3)) & 7) << (j * 3);
result |= ((cur >> (j * 3)) & 7) << (i * 3);
return result;
}
void recur(map<int, int> &mp, int cur, int mask) {
if (mask == 0) {
mp.insert(pii(cur, mp.size()));
} else {
for (int i = 0; i < 8; ++i) {
if (!(mask & (1 << i))) {
continue;
}
recur(mp, (cur << 3) | i, mask & ~(1 << i));
}
}
}
int main() {
int n;
cin >> n;
vector<vector<int>> c(n, vector<int>(n));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
cin >> c[i][j];
}
}
int init = 0;
for (int i = 0; i < n; ++i) {
init |= i << (i * 3);
}
map<int, int> mp;
recur(mp, 0, (1 << n) - 1);
vector<int> minval(mp.size(), INF);
priority_queue<pii, vector<pii>, greater<pii>> pq;
pq.push(pii(0, init));
minval[mp[init]] = 0;
while (!pq.empty()) {
pii p = pq.top();
pq.pop();
int v = p.second, cost = p.first;
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
int w = swap(v, i, j), wi = mp[w];
int nc = cost + c[i][j];
if (nc < minval[wi]) {
pq.push(pii(nc, w));
minval[wi] = nc;
}
}
}
}
int answer = 0;
for (int i = 0; i < minval.size(); ++i) {
answer = max(answer, minval[i]);
}
cout << answer << endl;
return 0;
} | replace | 20 | 21 | 20 | 21 | 0 | |
p01478 | C++ | Memory Limit Exceeded | // 33
#include <algorithm>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
struct S {
int t;
vector<int> v;
bool operator<(S a) const { return t > a.t; }
};
int fact(int x) { return (x == 1) ? 1 : x * fact(x - 1); }
int dec(vector<int> v) {
vector<int> n(v.size());
for (int i = 0; i < n.size(); i++) {
n[i] = i;
}
int r = 0;
for (int i = 0; i < v.size(); i++) {
r *= n.size();
vector<int>::iterator it = find(n.begin(), n.end(), v[i]);
r += it - n.begin();
n.erase(it);
}
return r;
}
int main() {
int n;
cin >> n;
int cs[8][8];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> cs[i][j];
}
}
vector<int> v(n);
for (int i = 0; i < n; i++) {
v[i] = i;
}
bool p[50000] = {};
int r = fact(n);
S is = {0, v};
priority_queue<S> que;
que.push(is);
int lt;
while (r) {
S c = que.top();
que.pop();
if (p[dec(c.v)]++)
continue;
r--;
lt = c.t;
for (int i = 0; i < n; i++) {
for (int j = 0; j < i; j++) {
S n = c;
n.t += cs[i][j];
swap(n.v[i], n.v[j]);
que.push(n);
}
}
}
cout << lt << endl;
return 0;
} | // 33
#include <algorithm>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
struct S {
int t;
vector<int> v;
bool operator<(S a) const { return t > a.t; }
};
int fact(int x) { return (x == 1) ? 1 : x * fact(x - 1); }
int dec(vector<int> v) {
vector<int> n(v.size());
for (int i = 0; i < n.size(); i++) {
n[i] = i;
}
int r = 0;
for (int i = 0; i < v.size(); i++) {
r *= n.size();
vector<int>::iterator it = find(n.begin(), n.end(), v[i]);
r += it - n.begin();
n.erase(it);
}
return r;
}
int main() {
int n;
cin >> n;
int cs[8][8];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> cs[i][j];
}
}
vector<int> v(n);
for (int i = 0; i < n; i++) {
v[i] = i;
}
bool p[50000] = {};
int r = fact(n);
S is = {0, v};
priority_queue<S> que;
que.push(is);
int lt;
while (r) {
S c = que.top();
que.pop();
if (p[dec(c.v)]++)
continue;
r--;
lt = c.t;
for (int i = 0; i < n; i++) {
for (int j = 0; j < i; j++) {
S n = c;
n.t += cs[i][j];
swap(n.v[i], n.v[j]);
if (!p[dec(n.v)])
que.push(n);
}
}
}
cout << lt << endl;
return 0;
} | replace | 62 | 63 | 62 | 64 | MLE | |
p01478 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
using namespace std;
int cost[9][9];
struct node {
string num;
int cost;
node(string n, int c) : num(n), cost(c) {}
node() {}
bool operator>(const node &arg) const { return cost > arg.cost; }
};
int main() {
int n;
string str = "";
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> cost[i][j];
}
}
for (int i = 0; i < n; i++)
str += (char)('1' + i);
priority_queue<node, vector<node>, greater<node>> q;
map<string, bool> mb;
map<string, int> mi;
string tmpstr, working;
int tmpcost;
node tmpnode;
q.push(node(str, 0));
while (!q.empty()) {
tmpnode = q.top();
q.pop();
tmpstr = tmpnode.num;
tmpcost = tmpnode.cost;
if (mb[tmpstr] == true)
continue;
mb[tmpstr] = true;
mi[tmpstr] = tmpcost;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
working = tmpstr;
swap(working[i], working[j]);
q.push(
node(working, tmpcost + cost[working[i] - '1'][working[j] - '1']));
}
}
}
map<string, int>::iterator it = mi.begin();
int ret = -1;
while (it != mi.end()) {
ret = max(ret, (*it).second);
++it;
}
cout << ret << endl;
} | #include <algorithm>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
using namespace std;
int cost[9][9];
struct node {
string num;
int cost;
node(string n, int c) : num(n), cost(c) {}
node() {}
bool operator>(const node &arg) const { return cost > arg.cost; }
};
int main() {
int n;
string str = "";
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> cost[i][j];
}
}
for (int i = 0; i < n; i++)
str += (char)('1' + i);
priority_queue<node, vector<node>, greater<node>> q;
map<string, bool> mb;
map<string, int> mi;
string tmpstr, working;
int tmpcost;
node tmpnode;
q.push(node(str, 0));
while (!q.empty()) {
tmpnode = q.top();
q.pop();
tmpstr = tmpnode.num;
tmpcost = tmpnode.cost;
if (mb[tmpstr] == true)
continue;
mb[tmpstr] = true;
mi[tmpstr] = tmpcost;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
working = tmpstr;
swap(working[i], working[j]);
if (mb[working] == false) {
q.push(node(working,
tmpcost + cost[working[i] - '1'][working[j] - '1']));
}
}
}
}
map<string, int>::iterator it = mi.begin();
int ret = -1;
while (it != mi.end()) {
ret = max(ret, (*it).second);
++it;
}
cout << ret << endl;
} | replace | 55 | 57 | 55 | 59 | TLE | |
p01478 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <vector>
using namespace std;
const int INF = 1e+9;
const int MAX_V = 8;
struct edge {
int to, cost;
};
typedef pair<int, int> P;
int n;
int c[10][10];
map<vector<int>, int> m;
int fact[9] = {1, 1, 2, 6, 24, 120, 720, 5040, 40320};
int V;
vector<edge> G[MAX_V];
int d[MAX_V];
void dijkstra(int s) {
priority_queue<P, vector<P>, greater<P>> que;
fill(d, d + V, INF);
d[s] = 0;
que.push(P(0, s));
while (!que.empty()) {
P p = que.top();
que.pop();
int v = p.second;
if (d[v] < p.first)
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;
que.push(P(d[e.to], e.to));
}
}
}
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> c[i][j];
}
}
// m[hÍ n!
V = fact[n];
// {1, 2, ... , n}ÌñðÂé
vector<int> p;
for (int i = 1; i <= n; i++) {
p.push_back(i);
}
// CÓÌñ p É 0 ©ç (n!-1)ÌÔðUé
int k = 0;
do {
m[p] = k;
k++;
} while (next_permutation(p.begin(), p.end()));
// CÓÌñ p É¢ÄCÓÌi,j(0 <= i < j < n
// )ðð··éRXgc[i][j]ÅGbWÌRXgð£é
do {
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
int u = m[p];
swap(p[i], p[j]);
int v = m[p];
swap(p[i], p[j]);
edge e;
e.to = v;
e.cost = c[i][j];
G[u].push_back(e);
e.to = u;
G[v].push_back(e);
}
}
} while (next_permutation(p.begin(), p.end()));
// m[h0 ({1, 2, ... , n})
// ©çÌÅZoH(f(p)É)ðßé
dijkstra(0);
// f(p)ÌÅålðßé
int ans = 0;
for (int i = 1; i < V; i++) {
ans = max(ans, d[i]);
}
cout << ans << endl;
} | #include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <vector>
using namespace std;
const int INF = 1e+9;
const int MAX_V = 40320;
struct edge {
int to, cost;
};
typedef pair<int, int> P;
int n;
int c[10][10];
map<vector<int>, int> m;
int fact[9] = {1, 1, 2, 6, 24, 120, 720, 5040, 40320};
int V;
vector<edge> G[MAX_V];
int d[MAX_V];
void dijkstra(int s) {
priority_queue<P, vector<P>, greater<P>> que;
fill(d, d + V, INF);
d[s] = 0;
que.push(P(0, s));
while (!que.empty()) {
P p = que.top();
que.pop();
int v = p.second;
if (d[v] < p.first)
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;
que.push(P(d[e.to], e.to));
}
}
}
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> c[i][j];
}
}
// m[hÍ n!
V = fact[n];
// {1, 2, ... , n}ÌñðÂé
vector<int> p;
for (int i = 1; i <= n; i++) {
p.push_back(i);
}
// CÓÌñ p É 0 ©ç (n!-1)ÌÔðUé
int k = 0;
do {
m[p] = k;
k++;
} while (next_permutation(p.begin(), p.end()));
// CÓÌñ p É¢ÄCÓÌi,j(0 <= i < j < n
// )ðð··éRXgc[i][j]ÅGbWÌRXgð£é
do {
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
int u = m[p];
swap(p[i], p[j]);
int v = m[p];
swap(p[i], p[j]);
edge e;
e.to = v;
e.cost = c[i][j];
G[u].push_back(e);
e.to = u;
G[v].push_back(e);
}
}
} while (next_permutation(p.begin(), p.end()));
// m[h0 ({1, 2, ... , n})
// ©çÌÅZoH(f(p)É)ðßé
dijkstra(0);
// f(p)ÌÅålðßé
int ans = 0;
for (int i = 1; i < V; i++) {
ans = max(ans, d[i]);
}
cout << ans << endl;
} | replace | 8 | 9 | 8 | 9 | 0 | |
p01479 | 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 <utility>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repc(i, s, e) for (int i = (s); i < (e); i++)
#define pb(n) push_back((n))
#define mp(n, m) make_pair((n), (m))
#define all(r) r.begin(), r.end()
#define fi first
#define se second
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vii;
typedef vector<ll> vl;
typedef vector<vl> vll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int INF = 10000000;
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, -1, 0, 1};
// 2362
int main() {
string s;
cin >> s;
string ec[2] = {"egg", "chicken"};
vii v;
vi u;
int last = -1;
for (int i = 0; i < s.size(); i++) {
for (int j = 0; j < 2; j++) {
if (s[i] == ec[j][0]) {
if (j == last) {
v.pb(u);
u.clear();
u.pb(j);
} else {
u.pb(j);
last = j;
}
i += ec[j].size() - 1;
}
}
}
int m = 0;
for (int i = 1; i < v.size(); i++) {
if (v[m].size() < v[i].size())
m = i;
}
cout << ec[v[m][v[m].size() - 1]] << endl;
} | #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 <utility>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repc(i, s, e) for (int i = (s); i < (e); i++)
#define pb(n) push_back((n))
#define mp(n, m) make_pair((n), (m))
#define all(r) r.begin(), r.end()
#define fi first
#define se second
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vii;
typedef vector<ll> vl;
typedef vector<vl> vll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int INF = 10000000;
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, -1, 0, 1};
// 2362
int main() {
string s;
cin >> s;
string ec[2] = {"egg", "chicken"};
vii v;
vi u;
int last = -1;
for (int i = 0; i < s.size(); i++) {
for (int j = 0; j < 2; j++) {
if (s[i] == ec[j][0]) {
if (j == last) {
v.pb(u);
u.clear();
u.pb(j);
} else {
u.pb(j);
last = j;
}
i += ec[j].size() - 1;
}
}
}
v.pb(u);
int m = 0;
for (int i = 1; i < v.size(); i++) {
if (v[m].size() < v[i].size())
m = i;
}
cout << ec[v[m][v[m].size() - 1]] << endl;
} | replace | 61 | 62 | 61 | 62 | -11 | |
p01479 | C++ | Runtime Error | // 59
#include <iostream>
using namespace std;
int main() {
char s[1001];
cin >> s;
char p = 0;
int l = 0;
char r;
int rl = -1;
for (int i = 0; s[i]; i += (p == 'e') ? 3 : 7) {
if (p == s[i]) {
l = 0;
}
l++;
p = s[i];
if (l > rl) {
rl = l;
r = p;
}
}
cout << ((r == 'e') ? "egg" : "chicken") << endl;
return 0;
} | // 59
#include <iostream>
using namespace std;
int main() {
char s[7 * 1001];
cin >> s;
char p = 0;
int l = 0;
char r;
int rl = -1;
for (int i = 0; s[i]; i += (p == 'e') ? 3 : 7) {
if (p == s[i]) {
l = 0;
}
l++;
p = s[i];
if (l > rl) {
rl = l;
r = p;
}
}
cout << ((r == 'e') ? "egg" : "chicken") << endl;
return 0;
} | replace | 6 | 7 | 6 | 7 | 0 | |
p01479 | C++ | Runtime Error | #include <algorithm>
#include <functional>
#include <stdio.h>
#include <vector>
using namespace std;
struct S {
int length, ancestor;
bool operator>(const S &s) const { return length > s.length; }
};
vector<S> v;
S s;
void F(int id) {
if (s.ancestor == id) {
v.push_back(s);
s.length = 1;
s.ancestor = id;
} else {
++s.length;
s.ancestor = id;
}
}
int main() {
char str[1024];
scanf("%s", str);
s.length = 0;
s.ancestor = -1;
for (int i = 0; str[i];) {
if (str[i] == 'e') {
F(0);
i += 3;
} else {
F(1);
i += 7;
}
}
if (s.ancestor >= 0)
v.push_back(s);
stable_sort(v.begin(), v.end(), greater<S>());
puts(v[0].ancestor ? "chicken" : "egg");
} | #include <algorithm>
#include <functional>
#include <stdio.h>
#include <vector>
using namespace std;
struct S {
int length, ancestor;
bool operator>(const S &s) const { return length > s.length; }
};
vector<S> v;
S s;
void F(int id) {
if (s.ancestor == id) {
v.push_back(s);
s.length = 1;
s.ancestor = id;
} else {
++s.length;
s.ancestor = id;
}
}
int main() {
char str[8192];
scanf("%s", str);
s.length = 0;
s.ancestor = -1;
for (int i = 0; str[i];) {
if (str[i] == 'e') {
F(0);
i += 3;
} else {
F(1);
i += 7;
}
}
if (s.ancestor >= 0)
v.push_back(s);
stable_sort(v.begin(), v.end(), greater<S>());
puts(v[0].ancestor ? "chicken" : "egg");
} | replace | 23 | 24 | 23 | 24 | 0 | |
p01481 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <complex>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
// common
#define BR "\n"
#define ALL(c) (c).begin(), (c).end()
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
#define EACH(it, o) for (auto it = (o).begin(); it != (o).end(); ++it)
#define IN(l, v, r) ((l) <= (v) && (v) < (r))
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef vector<pair<int, int>> vpii;
typedef long long ll;
typedef vector<long long> vl;
typedef pair<long long, long long> pll;
typedef vector<pair<long long, long long>> vpll;
typedef vector<string> vs;
typedef long double ld;
// debug
#ifdef NDEBUG
#define DUMP(x)
#define DUMPLN(x)
#define DEBUG(x)
#define DEBUGLN(x)
#define LINE()
#define LINELN()
#define CHECK(exp, act)
#define STOP(e)
#else
#define DUMP(x) cerr << #x << " = " << (x)
#define DUMPLN(x) DUMP(x) << endl
#define DEBUG(x) DUMP(x) << LINE() << " " << __FILE__
#define DEBUGLN(x) DEBUG(x) << endl
#define LINE() cerr << " (L" << __LINE__ << ")"
#define LINELN() LINE() << endl
#define CHECK(exp, act) \
if (exp != act) { \
DUMPLN(exp); \
DEBUGLN(act); \
}
#define STOP(e) \
CHECK(e, true); \
if (!(e)) \
exit(1);
#endif
template <class T> inline string toString(const vector<T> &x) {
stringstream ss;
REP(i, x.size()) {
if (i != 0)
ss << " ";
ss << x[i];
}
return ss.str();
}
template <class T> inline string toString(const vector<vector<T>> &map) {
stringstream ss;
REP(i, map.size()) {
if (i != 0)
ss << BR;
ss << toString(map[i]);
}
return ss.str();
}
template <class K, class V> string toString(map<K, V> &x) {
string res;
stringstream ss;
for (auto &p : x)
ss << p.first << ":" << p.second << " ";
return ss.str();
}
template <typename T, typename V> inline T mod(T v, V MOD) {
return (v % MOD + MOD) % MOD;
}
struct UnionFind {
vector<int> par; // 親
vector<int> rank; // 木の深さ
int size;
UnionFind(int n) {
REP(i, n) par.push_back(i);
rank = vector<int>(n);
size = n;
}
int root(int x) {
if (par[x] == x)
return x;
return par[x] = root(par[x]);
}
bool same(int x, int y) { return root(x) == root(y); }
void unite(int x, int y) {
x = root(x);
y = root(y);
if (x == y)
return;
if (rank[x] < rank[y])
par[x] = y;
else
par[y] = x;
if (rank[x] == rank[y])
rank[x]++;
size--;
}
};
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
int INF = 1 << 28;
int H, W;
int enc(int y, int x) { return y * W + x; }
int main() {
cin >> H >> W;
vector<string> map(H);
REP(y, H) cin >> map[y];
int N;
cin >> N;
vector<int> xs(N), ys(N);
REP(i, N) cin >> xs[i] >> ys[i];
int tx, ty;
REP(y, H) REP(x, W) {
if (map[y][x] == 't') {
tx = x;
ty = y;
}
}
UnionFind uf(H * W);
REP(y, H) REP(x, W) {
if (map[y][x] == '#')
continue;
REP(di, 4) {
int nx = x + dx[di], ny = y + dy[di];
if (!IN(0, nx, W) || !IN(0, ny, H))
continue;
if (map[ny][nx] == '#')
continue;
uf.unite(enc(y, x), enc(ny, nx));
}
}
int time = 0;
while (!uf.same(enc(ty, tx), enc(0, 0))) {
time++;
if (time - 1 == N)
break;
int x = xs[time - 1], y = ys[time - 1];
if (!IN(0, x, W) || !IN(0, y, H))
continue;
map[y][x] = '.';
REP(di, 4) {
int nx = x + dx[di], ny = y + dy[di];
if (!IN(0, nx, W) || !IN(0, ny, H))
continue;
if (map[ny][nx] == '#')
continue;
uf.unite(enc(y, x), enc(ny, nx));
}
}
cout << (time != N + 1 ? time : -1) << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <complex>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
// common
#define BR "\n"
#define ALL(c) (c).begin(), (c).end()
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
#define EACH(it, o) for (auto it = (o).begin(); it != (o).end(); ++it)
#define IN(l, v, r) ((l) <= (v) && (v) < (r))
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef vector<pair<int, int>> vpii;
typedef long long ll;
typedef vector<long long> vl;
typedef pair<long long, long long> pll;
typedef vector<pair<long long, long long>> vpll;
typedef vector<string> vs;
typedef long double ld;
// debug
#ifdef NDEBUG
#define DUMP(x)
#define DUMPLN(x)
#define DEBUG(x)
#define DEBUGLN(x)
#define LINE()
#define LINELN()
#define CHECK(exp, act)
#define STOP(e)
#else
#define DUMP(x) cerr << #x << " = " << (x)
#define DUMPLN(x) DUMP(x) << endl
#define DEBUG(x) DUMP(x) << LINE() << " " << __FILE__
#define DEBUGLN(x) DEBUG(x) << endl
#define LINE() cerr << " (L" << __LINE__ << ")"
#define LINELN() LINE() << endl
#define CHECK(exp, act) \
if (exp != act) { \
DUMPLN(exp); \
DEBUGLN(act); \
}
#define STOP(e) \
CHECK(e, true); \
if (!(e)) \
exit(1);
#endif
template <class T> inline string toString(const vector<T> &x) {
stringstream ss;
REP(i, x.size()) {
if (i != 0)
ss << " ";
ss << x[i];
}
return ss.str();
}
template <class T> inline string toString(const vector<vector<T>> &map) {
stringstream ss;
REP(i, map.size()) {
if (i != 0)
ss << BR;
ss << toString(map[i]);
}
return ss.str();
}
template <class K, class V> string toString(map<K, V> &x) {
string res;
stringstream ss;
for (auto &p : x)
ss << p.first << ":" << p.second << " ";
return ss.str();
}
template <typename T, typename V> inline T mod(T v, V MOD) {
return (v % MOD + MOD) % MOD;
}
struct UnionFind {
vector<int> par; // 親
vector<int> rank; // 木の深さ
int size;
UnionFind(int n) {
REP(i, n) par.push_back(i);
rank = vector<int>(n);
size = n;
}
int root(int x) {
if (par[x] == x)
return x;
return par[x] = root(par[x]);
}
bool same(int x, int y) { return root(x) == root(y); }
void unite(int x, int y) {
x = root(x);
y = root(y);
if (x == y)
return;
if (rank[x] < rank[y])
par[x] = y;
else
par[y] = x;
if (rank[x] == rank[y])
rank[x]++;
size--;
}
};
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
int INF = 1 << 28;
int H, W;
int enc(int y, int x) { return y * W + x; }
int main() {
cin >> W >> H;
vector<string> map(H);
REP(y, H) cin >> map[y];
int N;
cin >> N;
vector<int> xs(N), ys(N);
REP(i, N) cin >> xs[i] >> ys[i];
int tx, ty;
REP(y, H) REP(x, W) {
if (map[y][x] == 't') {
tx = x;
ty = y;
}
}
UnionFind uf(H * W);
REP(y, H) REP(x, W) {
if (map[y][x] == '#')
continue;
REP(di, 4) {
int nx = x + dx[di], ny = y + dy[di];
if (!IN(0, nx, W) || !IN(0, ny, H))
continue;
if (map[ny][nx] == '#')
continue;
uf.unite(enc(y, x), enc(ny, nx));
}
}
int time = 0;
while (!uf.same(enc(ty, tx), enc(0, 0))) {
time++;
if (time - 1 == N)
break;
int x = xs[time - 1], y = ys[time - 1];
if (!IN(0, x, W) || !IN(0, y, H))
continue;
map[y][x] = '.';
REP(di, 4) {
int nx = x + dx[di], ny = y + dy[di];
if (!IN(0, nx, W) || !IN(0, ny, H))
continue;
if (map[ny][nx] == '#')
continue;
uf.unite(enc(y, x), enc(ny, nx));
}
}
cout << (time != N + 1 ? time : -1) << endl;
return 0;
} | replace | 134 | 135 | 134 | 135 | 0 | |
p01481 | C++ | Runtime Error | #define _USE_MATH_DEFINES
#define INF 0x3f3f3f3f
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<int, P> PP;
const static int tx[] = {+0, +1, +0, -1};
const static int ty[] = {-1, +0, +1, +0};
static const double EPS = 1e-12;
int W, H;
char stage[1001][1001];
bool visited[1001][1001];
class State {
public:
int x;
int y;
int cost;
State(int _x, int _y, int _c) : x(_x), y(_y), cost(_c) {}
bool operator<(const State &s) const { return cost < s.cost; }
bool operator>(const State &s) const { return cost > s.cost; }
};
void bfs() {
priority_queue<State, vector<State>, greater<State>> que;
que.push(State(0, 0, 0));
while (!que.empty()) {
State s = que.top();
que.pop();
int sx = s.x;
int sy = s.y;
visited[sy][sx] = true;
if (stage[sy][sx] == 't')
break;
for (int i = 0; i < 4; i++) {
int dx = sx + tx[i];
int dy = sy + ty[i];
if (dx < 0 || dy < 0 || dx >= W || dy >= H)
continue;
if (visited[dy][dx])
continue;
if (stage[dy][dx] == '#')
continue;
que.push(State(dx, dy, s.cost + 1));
}
}
}
void dfs(int sx, int sy) {
visited[sy][sx] = true;
for (int i = 0; i < 4; i++) {
int dx = sx + tx[i];
int dy = sy + ty[i];
if (dx < 0 || dy < 0 || dx >= W || dy >= H)
continue;
if (visited[dy][dx])
continue;
if (stage[dy][dx] == '#')
continue;
dfs(dx, dy);
}
}
bool has_route(int time, const vector<P> &gates, int gx, int gy) {
vector<P> skip;
for (int i = 0; i < time; i++) {
int x = gates[i].first;
int y = gates[i].second;
if (stage[y][x] == '.') {
skip.push_back(gates[i]);
}
stage[y][x] = '.';
}
memset(visited, false, sizeof(visited));
bfs();
for (int i = 0; i < time; i++) {
int x = gates[i].first;
int y = gates[i].second;
stage[y][x] = '#';
}
for (int i = 0; i < skip.size(); i++) {
int x = skip[i].first;
int y = skip[i].second;
stage[y][x] = '.';
}
return visited[gy][gx];
}
int main() {
while (~scanf("%d %d", &W, &H)) {
int gx, gy;
for (int y = 0; y < H; y++) {
string line;
cin >> line;
for (int x = 0; x < W; x++) {
stage[y][x] = line[x];
if (line[x] == 't') {
gx = x;
gy = y;
}
}
}
vector<P> gates;
int total_time;
scanf("%d", &total_time);
for (int time = 0; time < total_time; time++) {
int x, y;
scanf("%d %d", &x, &y);
gates.push_back(P(x, y));
}
int min_time = 0;
int max_time = gates.size();
bool isok = false;
for (int round = 0; round < 20; round++) {
int mid = (min_time + max_time) / 2;
if (has_route(mid, gates, gx, gy)) {
max_time = mid;
isok = true;
} else {
min_time = mid + 1;
}
}
printf("%d\n", isok ? max_time : -1);
}
} | #define _USE_MATH_DEFINES
#define INF 0x3f3f3f3f
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<int, P> PP;
const static int tx[] = {+0, +1, +0, -1};
const static int ty[] = {-1, +0, +1, +0};
static const double EPS = 1e-12;
int W, H;
char stage[1001][1001];
bool visited[1001][1001];
class State {
public:
int x;
int y;
int cost;
State(int _x, int _y, int _c) : x(_x), y(_y), cost(_c) {}
bool operator<(const State &s) const { return cost < s.cost; }
bool operator>(const State &s) const { return cost > s.cost; }
};
void bfs() {
priority_queue<State, vector<State>, greater<State>> que;
que.push(State(0, 0, 0));
while (!que.empty()) {
State s = que.top();
que.pop();
int sx = s.x;
int sy = s.y;
if (visited[sy][sx])
continue;
visited[sy][sx] = true;
if (stage[sy][sx] == 't')
break;
for (int i = 0; i < 4; i++) {
int dx = sx + tx[i];
int dy = sy + ty[i];
if (dx < 0 || dy < 0 || dx >= W || dy >= H)
continue;
if (visited[dy][dx])
continue;
if (stage[dy][dx] == '#')
continue;
que.push(State(dx, dy, s.cost + 1));
}
}
}
void dfs(int sx, int sy) {
visited[sy][sx] = true;
for (int i = 0; i < 4; i++) {
int dx = sx + tx[i];
int dy = sy + ty[i];
if (dx < 0 || dy < 0 || dx >= W || dy >= H)
continue;
if (visited[dy][dx])
continue;
if (stage[dy][dx] == '#')
continue;
dfs(dx, dy);
}
}
bool has_route(int time, const vector<P> &gates, int gx, int gy) {
vector<P> skip;
for (int i = 0; i < time; i++) {
int x = gates[i].first;
int y = gates[i].second;
if (stage[y][x] == '.') {
skip.push_back(gates[i]);
}
stage[y][x] = '.';
}
memset(visited, false, sizeof(visited));
bfs();
for (int i = 0; i < time; i++) {
int x = gates[i].first;
int y = gates[i].second;
stage[y][x] = '#';
}
for (int i = 0; i < skip.size(); i++) {
int x = skip[i].first;
int y = skip[i].second;
stage[y][x] = '.';
}
return visited[gy][gx];
}
int main() {
while (~scanf("%d %d", &W, &H)) {
int gx, gy;
for (int y = 0; y < H; y++) {
string line;
cin >> line;
for (int x = 0; x < W; x++) {
stage[y][x] = line[x];
if (line[x] == 't') {
gx = x;
gy = y;
}
}
}
vector<P> gates;
int total_time;
scanf("%d", &total_time);
for (int time = 0; time < total_time; time++) {
int x, y;
scanf("%d %d", &x, &y);
gates.push_back(P(x, y));
}
int min_time = 0;
int max_time = gates.size();
bool isok = false;
for (int round = 0; round < 20; round++) {
int mid = (min_time + max_time) / 2;
if (has_route(mid, gates, gx, gy)) {
max_time = mid;
isok = true;
} else {
min_time = mid + 1;
}
}
printf("%d\n", isok ? max_time : -1);
}
} | insert | 56 | 56 | 56 | 59 | 0 | |
p01481 | C++ | Runtime Error | #include <iostream>
#include <stack>
using namespace std;
// union_find begin
#define MAX 500000
struct node {
int parent, size;
};
node tree[MAX];
void init() {
for (int i = 0; i < MAX; i++) {
tree[i].parent = i;
tree[i].size = 1;
}
}
/*
int find(int x){
if(tree[x].parent==x)return x;
tree[x].parent = find( tree[x].parent );
return tree[x].parent;
}
*/
int find(int x) {
stack<int> st;
while (tree[x].parent != x) {
st.push(x);
x = tree[x].parent;
}
while (!st.empty()) {
tree[st.top()].parent = x;
st.pop();
}
return x;
}
int count(int x) {
x = find(x);
return tree[x].size;
}
bool same(int x, int y) { return (find(x) == find(y)); }
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y)
return;
if (count(x) > count(y))
swap(x, y);
tree[x].parent = y;
tree[y].size += tree[x].size;
}
// union find end
int dy[] = {-1, 0, 1, 0};
int dx[] = {0, 1, 0, -1};
int W, H, N, target;
char t[1005][1005];
int change(int i, int j) { return i * W + j; }
int solve() {
cin >> N;
for (int ans = 1; ans <= N; ans++) {
int i, j;
cin >> j >> i;
if (t[i][j] == '.')
continue;
t[i][j] = '.';
for (int k = 0; k < 4; k++) {
int ni = i + dy[k];
int nj = j + dx[k];
if (ni < 0 || nj < 0 || H <= ni || W <= nj)
continue;
if (t[ni][nj] == '#')
continue;
unite(change(i, j), change(ni, nj));
}
if (same(target, 0))
return ans;
}
return -1;
}
int main() {
init();
cin >> W >> H;
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
cin >> t[i][j];
if (t[i][j] == 't')
target = change(i, j);
}
}
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
if (t[i][j] == '#')
continue;
for (int k = 0; k < 4; k++) {
int ni = i + dy[k];
int nj = j + dx[k];
if (ni < 0 || nj < 0 || H <= ni || W <= nj)
continue;
if (t[ni][nj] == '#')
continue;
unite(change(i, j), change(ni, nj));
}
}
}
if (same(target, 0)) {
cout << "0" << endl;
} else {
cout << solve() << endl;
}
return 0;
} | #include <iostream>
#include <stack>
using namespace std;
// union_find begin
#define MAX 5000000
struct node {
int parent, size;
};
node tree[MAX];
void init() {
for (int i = 0; i < MAX; i++) {
tree[i].parent = i;
tree[i].size = 1;
}
}
/*
int find(int x){
if(tree[x].parent==x)return x;
tree[x].parent = find( tree[x].parent );
return tree[x].parent;
}
*/
int find(int x) {
stack<int> st;
while (tree[x].parent != x) {
st.push(x);
x = tree[x].parent;
}
while (!st.empty()) {
tree[st.top()].parent = x;
st.pop();
}
return x;
}
int count(int x) {
x = find(x);
return tree[x].size;
}
bool same(int x, int y) { return (find(x) == find(y)); }
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y)
return;
if (count(x) > count(y))
swap(x, y);
tree[x].parent = y;
tree[y].size += tree[x].size;
}
// union find end
int dy[] = {-1, 0, 1, 0};
int dx[] = {0, 1, 0, -1};
int W, H, N, target;
char t[1005][1005];
int change(int i, int j) { return i * W + j; }
int solve() {
cin >> N;
for (int ans = 1; ans <= N; ans++) {
int i, j;
cin >> j >> i;
if (t[i][j] == '.')
continue;
t[i][j] = '.';
for (int k = 0; k < 4; k++) {
int ni = i + dy[k];
int nj = j + dx[k];
if (ni < 0 || nj < 0 || H <= ni || W <= nj)
continue;
if (t[ni][nj] == '#')
continue;
unite(change(i, j), change(ni, nj));
}
if (same(target, 0))
return ans;
}
return -1;
}
int main() {
init();
cin >> W >> H;
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
cin >> t[i][j];
if (t[i][j] == 't')
target = change(i, j);
}
}
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
if (t[i][j] == '#')
continue;
for (int k = 0; k < 4; k++) {
int ni = i + dy[k];
int nj = j + dx[k];
if (ni < 0 || nj < 0 || H <= ni || W <= nj)
continue;
if (t[ni][nj] == '#')
continue;
unite(change(i, j), change(ni, nj));
}
}
}
if (same(target, 0)) {
cout << "0" << endl;
} else {
cout << solve() << endl;
}
return 0;
} | replace | 5 | 6 | 5 | 6 | 0 | |
p01481 | C++ | Runtime Error | #include <iostream>
#include <string>
#define N1 1000 + 1
using namespace std;
int find(int);
void unite(int, int);
bool same(int, int);
int tree[N1 * N1];
string str[N1];
int main() {
int W, H, N, x, y, findy, findx;
int dx[4] = {0, 1, 0, -1};
int dy[4] = {-1, 0, 1, 0};
cin >> W >> H;
for (int i = 0; i < H; i++)
cin >> str[i];
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
tree[i * W + j] = i * W + j;
}
}
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
if (str[i][j] == 't')
findy = i, findx = j;
if (str[i][j] != '#') {
for (int k = 0; k < 4; k++)
if (0 <= i + dy[k] && i + dy[k] < H && 0 <= j + dx[k] &&
j + dx[k] < W)
if (str[i + dy[k]][j + dx[k]] != '#')
unite(i * W + j, (i + dy[k]) * W + (j + dx[k]));
}
}
}
cin >> N;
int flag = 0;
if (same(0, findy * W + findx)) {
flag = 1;
cout << 0 << endl;
}
int cnt = 0;
while (N-- && flag == 0) {
cnt++;
cin >> x >> y;
str[y][x] = '.';
for (int i = 0; i < 4; i++)
if (0 <= y + dy[i] && y + dy[i] < H && 0 <= x + dx[i] && x + dx[i] < W &&
str[y + dy[i]][x + dx[i]] != '#')
unite(y * W + x, (y + dy[i]) * W + (x + dx[i]));
if (same(0, findy * W + findx)) {
flag = 1;
cout << cnt << endl;
break;
}
}
if (flag == 0)
cout << -1 << endl;
return 0;
}
int st[N1 * N1];
int find(int x) {
int cnt = 0;
while (x != tree[x]) {
x = tree[x];
st[cnt] = x;
cnt++;
}
while (cnt > 0) {
cnt--;
tree[st[cnt]] = x;
}
return x;
}
void unite(int x, int y) {
x = find(x), y = find(y);
if (x == y)
return;
if (x < y)
swap(x, y);
tree[x] = y;
}
bool same(int x, int y) {
if (find(x) == find(y))
return true;
return false;
} | #include <iostream>
#include <string>
#define N1 (1000 + 1)
using namespace std;
int find(int);
void unite(int, int);
bool same(int, int);
int tree[N1 * N1];
string str[N1];
int main() {
int W, H, N, x, y, findy, findx;
int dx[4] = {0, 1, 0, -1};
int dy[4] = {-1, 0, 1, 0};
cin >> W >> H;
for (int i = 0; i < H; i++)
cin >> str[i];
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
tree[i * W + j] = i * W + j;
}
}
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
if (str[i][j] == 't')
findy = i, findx = j;
if (str[i][j] != '#') {
for (int k = 0; k < 4; k++)
if (0 <= i + dy[k] && i + dy[k] < H && 0 <= j + dx[k] &&
j + dx[k] < W)
if (str[i + dy[k]][j + dx[k]] != '#')
unite(i * W + j, (i + dy[k]) * W + (j + dx[k]));
}
}
}
cin >> N;
int flag = 0;
if (same(0, findy * W + findx)) {
flag = 1;
cout << 0 << endl;
}
int cnt = 0;
while (N-- && flag == 0) {
cnt++;
cin >> x >> y;
str[y][x] = '.';
for (int i = 0; i < 4; i++)
if (0 <= y + dy[i] && y + dy[i] < H && 0 <= x + dx[i] && x + dx[i] < W &&
str[y + dy[i]][x + dx[i]] != '#')
unite(y * W + x, (y + dy[i]) * W + (x + dx[i]));
if (same(0, findy * W + findx)) {
flag = 1;
cout << cnt << endl;
break;
}
}
if (flag == 0)
cout << -1 << endl;
return 0;
}
int st[N1 * N1];
int find(int x) {
int cnt = 0;
while (x != tree[x]) {
x = tree[x];
st[cnt] = x;
cnt++;
}
while (cnt > 0) {
cnt--;
tree[st[cnt]] = x;
}
return x;
}
void unite(int x, int y) {
x = find(x), y = find(y);
if (x == y)
return;
if (x < y)
swap(x, y);
tree[x] = y;
}
bool same(int x, int y) {
if (find(x) == find(y))
return true;
return false;
} | replace | 2 | 3 | 2 | 3 | 0 | |
p01484 | C++ | Memory Limit Exceeded | #include <algorithm>
#include <cassert>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <sstream>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)n; i++)
#define fr(i, c) for (__typeof(c.begin()) i = c.begin(); i != c.end(); i++)
#define pb push_back
#define mp make_pair
#define all(c) c.begin(), c.end()
#define dbg(x) cerr << #x << " = " << (x) << endl
typedef vector<int> vi;
typedef pair<int, int> pi;
typedef long long ll;
const int inf = (int)1e9;
const double EPS = 1e-9, INF = 1e12;
// Larsson-Sadakane's Suffix array Construction: O(n (log n)^2)
struct SAComp {
const int h, *g;
SAComp(int h, int *g) : h(h), g(g) {}
bool operator()(int a, int b) {
return a == b ? false : g[a] != g[b] ? g[a] < g[b] : g[a + h] < g[b + h];
}
};
int *buildSA(char *t, int n) {
int g[n + 1], b[n + 1], *v = new int[n + 1];
rep(i, n + 1) v[i] = i, g[i] = t[i];
b[0] = 0;
b[n] = 0;
sort(v, v + n + 1, SAComp(0, g));
for (int h = 1; b[n] != n; h *= 2) {
SAComp comp(h, g);
sort(v, v + n + 1, comp);
rep(i, n) b[i + 1] = b[i] + comp(v[i], v[i + 1]);
rep(i, n + 1) g[v[i]] = b[i];
}
return v;
}
// Naive matching O(m log n)
int find(char *t, int n, char *p, int m, int *sa) {
int a = 0, b = n;
while (a < b) {
int c = (a + b) / 2;
if (strncmp(t + sa[c], p, m) < 0)
a = c + 1;
else
b = c;
}
return strncmp(t + sa[a], p, m) == 0 ? sa[a] : -1;
}
int n, m, k;
string s;
char *sc, t[500];
int *sa, len;
ll ck() {
ll res = 0;
for (int l = 0, r = 0; l < m; l++) {
while (r < l)
r++;
while (r < m) {
char tmp = t[r + 1];
t[r + 1] = 0;
bool res = find(sc, len, t + l, r - l + 1, sa) >= 0;
t[r + 1] = tmp;
if (!res)
break;
r++;
}
res += r - l;
}
return res;
}
const string rec(int l, int r) {
if (l >= r)
return "";
if (isdigit(s[l])) {
int i, x = 0, d = 0;
for (; l < r && isdigit(s[l]); l++) {
x *= 10;
x += s[l] - '0';
x = min(x, 400);
}
for (i = l; i < r; i++) {
if (s[i] == '(')
d++;
if (s[i] == ')')
d--;
if (d == 0)
break;
}
string res = "", tmp = rec(l + 1, i);
if (x == 1)
return tmp;
rep(i, x - 1) {
res += tmp;
if (res.size() > 400)
break;
}
const string str = res + tmp;
if (str.size() <= 800)
return str + rec(i + 1, r);
const string head400 = str.substr(0, min((int)str.size(), 400));
const string tail400 = str.substr(max(0, (int)str.size() - 400));
const string tail = tmp.substr(max(0, (int)tmp.size() - 400));
const string head = tmp.substr(0, max(0, (int)tmp.size()));
return head400 + "@" + tail + res + head + "@" + tail400 + rec(i + 1, r);
}
return s[l] + rec(l + 1, r);
}
int main() {
cin >> n >> m >> k;
cin >> s;
s = rec(0, n);
len = s.size();
sc = (char *)malloc(len + 1);
sprintf(sc, "%s", s.c_str());
s.clear();
sa = buildSA(sc, len);
int ansi = 0;
ll ans = 0;
rep(i, k) {
cin >> t;
ll tmp = ck();
if (tmp > ans)
ans = tmp, ansi = i;
}
cout << ansi + 1 << " " << ans << endl;
return 0;
} | #include <algorithm>
#include <cassert>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <sstream>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)n; i++)
#define fr(i, c) for (__typeof(c.begin()) i = c.begin(); i != c.end(); i++)
#define pb push_back
#define mp make_pair
#define all(c) c.begin(), c.end()
#define dbg(x) cerr << #x << " = " << (x) << endl
typedef vector<int> vi;
typedef pair<int, int> pi;
typedef long long ll;
const int inf = (int)1e9;
const double EPS = 1e-9, INF = 1e12;
// Larsson-Sadakane's Suffix array Construction: O(n (log n)^2)
struct SAComp {
const int h, *g;
SAComp(int h, int *g) : h(h), g(g) {}
bool operator()(int a, int b) {
return a == b ? false : g[a] != g[b] ? g[a] < g[b] : g[a + h] < g[b + h];
}
};
int *buildSA(char *t, int n) {
int g[n + 1], b[n + 1], *v = new int[n + 1];
rep(i, n + 1) v[i] = i, g[i] = t[i];
b[0] = 0;
b[n] = 0;
sort(v, v + n + 1, SAComp(0, g));
for (int h = 1; b[n] != n; h *= 2) {
SAComp comp(h, g);
sort(v, v + n + 1, comp);
rep(i, n) b[i + 1] = b[i] + comp(v[i], v[i + 1]);
rep(i, n + 1) g[v[i]] = b[i];
}
return v;
}
// Naive matching O(m log n)
int find(char *t, int n, char *p, int m, int *sa) {
int a = 0, b = n;
while (a < b) {
int c = (a + b) / 2;
if (strncmp(t + sa[c], p, m) < 0)
a = c + 1;
else
b = c;
}
return strncmp(t + sa[a], p, m) == 0 ? sa[a] : -1;
}
int n, m, k;
string s;
char *sc, t[500];
int *sa, len;
ll ck() {
ll res = 0;
for (int l = 0, r = 0; l < m; l++) {
while (r < l)
r++;
while (r < m) {
char tmp = t[r + 1];
t[r + 1] = 0;
bool res = find(sc, len, t + l, r - l + 1, sa) >= 0;
t[r + 1] = tmp;
if (!res)
break;
r++;
}
res += r - l;
}
return res;
}
const string rec(int l, int r) {
if (l >= r)
return "";
if (isdigit(s[l])) {
int i, x = 0, d = 0;
for (; l < r && isdigit(s[l]); l++) {
x *= 10;
x += s[l] - '0';
x = min(x, 400);
}
for (i = l; i < r; i++) {
if (s[i] == '(')
d++;
if (s[i] == ')')
d--;
if (d == 0)
break;
}
string res = "", tmp = rec(l + 1, i);
if (x == 1)
return tmp;
rep(i, x - 1) {
res += tmp;
if (res.size() > 400)
break;
}
const string str = res + tmp;
if (str.size() <= 800)
return str + rec(i + 1, r);
const string head400 = str.substr(0, min((int)str.size(), 400));
const string tail400 = str.substr(max(0, (int)str.size() - 400));
const string tail = tmp.substr(max(0, (int)tmp.size() - 400));
const string head = tmp.substr(0, min(400, (int)tmp.size()));
return head400 + "@" + tail + res + head + "@" + tail400 + rec(i + 1, r);
}
return s[l] + rec(l + 1, r);
}
int main() {
cin >> n >> m >> k;
cin >> s;
s = rec(0, n);
len = s.size();
sc = (char *)malloc(len + 1);
sprintf(sc, "%s", s.c_str());
s.clear();
sa = buildSA(sc, len);
int ansi = 0;
ll ans = 0;
rep(i, k) {
cin >> t;
ll tmp = ck();
if (tmp > ans)
ans = tmp, ansi = i;
}
cout << ansi + 1 << " " << ans << endl;
return 0;
} | replace | 120 | 121 | 120 | 121 | MLE | |
p01486 | C++ | Time Limit Exceeded | #include <iostream>
using namespace std;
bool iscat(string s) {
int l = s.length();
if (l == 0 || s == "mew")
return true;
if (s[0] != 'm' || s[l - 1] != 'w' || l % 3 != 0)
return false;
int id = 1;
int n;
while ((n = s.find('e', id)) != string::npos) {
string s1 = s.substr(1, n - 1);
string s2 = s.substr(n + 1, l - n - 2);
if (iscat(s1) && iscat(s2))
return true;
id = n + 1;
}
return false;
}
int main() {
string s;
cin >> s;
if (iscat(s))
cout << "Cat" << endl;
else
cout << "Rabbit" << endl;
return 0;
} | #include <iostream>
using namespace std;
bool iscat(string s) {
int l = s.length();
if (l == 0 || s == "mew")
return true;
if (s[0] != 'm' || s[l - 1] != 'w' || l % 3 != 0)
return false;
int m = 0, e = 0, w = 0;
for (int i = 0; i < l; i++) {
switch (s[i]) {
case 'm':
m++;
break;
case 'e':
e++;
break;
case 'w':
w++;
break;
}
}
if (m != e || e != m)
return false;
int id = 1;
int n;
while ((n = s.find('e', id)) != string::npos) {
string s1 = s.substr(1, n - 1);
string s2 = s.substr(n + 1, l - n - 2);
if (iscat(s1) && iscat(s2))
return true;
id = n + 1;
}
return false;
}
int main() {
string s;
cin >> s;
if (iscat(s))
cout << "Cat" << endl;
else
cout << "Rabbit" << endl;
return 0;
} | insert | 7 | 7 | 7 | 23 | TLE | |
p01486 | C++ | Runtime Error | #include <iostream>
#include <string>
using namespace std;
string S;
int dp[510][510];
bool rec(int l, int r) {
cerr << l << " " << r << endl;
if (dp[l][r] != -1)
return dp[l][r];
dp[l][r] = 0;
if (l > r)
return dp[l][r] = 1;
if (S[l] != 'm' || S[r] != 'w')
return dp[l][r] = 0;
for (int i = l + 1; i < r; i++) {
if (S[i] == 'e')
dp[l][r] = (dp[l][r] | (rec(l + 1, i - 1) & rec(i + 1, r - 1)));
}
return dp[l][r];
}
int main() {
cin >> S;
int N = S.size();
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++)
dp[i][j] = -1;
cout << (rec(0, N - 1) ? "Cat" : "Rabbit") << endl;
/*for(int i=0;i<N;i++){
for(int j=i;j<N;j++) cerr << dp[i][j] << " ";
cerr << endl;
}*/
}
| #include <iostream>
#include <string>
using namespace std;
string S;
int dp[510][510];
bool rec(int l, int r) {
if (dp[l][r] != -1)
return dp[l][r];
dp[l][r] = 0;
if (l > r)
return dp[l][r] = 1;
if (S[l] != 'm' || S[r] != 'w')
return dp[l][r] = 0;
for (int i = l + 1; i < r; i++) {
if (S[i] == 'e')
dp[l][r] = (dp[l][r] | (rec(l + 1, i - 1) & rec(i + 1, r - 1)));
}
return dp[l][r];
}
int main() {
cin >> S;
int N = S.size();
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++)
dp[i][j] = -1;
cout << (rec(0, N - 1) ? "Cat" : "Rabbit") << endl;
/*for(int i=0;i<N;i++){
for(int j=i;j<N;j++) cerr << dp[i][j] << " ";
cerr << endl;
}*/
}
| delete | 8 | 9 | 8 | 8 | 0 | 0 11
1 1
3 10
4 3
5 9
4 6
8 9
4 8
10 9
1 3
5 10
1 6
2 1
3 5
4 3
5 4
2 3
5 5
8 10
9 8
10 9
1 8
10 10
|
p01486 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < int(n); ++i)
bool iscat(const string &S_) {
map<string, int> vis;
function<bool(const string &)> dfs = [&](const string &S) {
if (S.empty())
return true;
if (S[0] != 'm' || S.back() != 'w')
return false;
if (vis.count(S))
return vis[S] == 1;
rep(i, S.size()) if (S[i] == 'e') {
if (iscat(S.substr(1, i - 1)) &&
iscat(S.substr(i + 1, S.size() - i - 2))) {
vis[S] = 1;
return true;
}
}
vis[S] = 0;
return false;
};
return dfs(S_);
}
int main() {
string S;
cin >> S;
cout << (iscat(S) ? "Cat" : "Rabbit") << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < int(n); ++i)
bool iscat(const string &S_) {
map<string, int> vis;
function<bool(const string &)> dfs = [&](const string &S) {
if (S.empty())
return true;
if (S[0] != 'm' || S.back() != 'w')
return false;
if (vis.count(S))
return vis[S] == 1;
rep(i, S.size()) if (S[i] == 'e') {
if (dfs(S.substr(1, i - 1)) && dfs(S.substr(i + 1, S.size() - i - 2))) {
vis[S] = 1;
return true;
}
}
vis[S] = 0;
return false;
};
return dfs(S_);
}
int main() {
string S;
cin >> S;
cout << (iscat(S) ? "Cat" : "Rabbit") << endl;
} | replace | 14 | 16 | 14 | 15 | TLE | |
p01486 | C++ | Runtime Error | #include <iostream>
#include <stack>
#include <string>
using namespace std;
void catChecker(string str) {
stack<char> cnt;
for (int i = 0; i < str.size(); i++) {
char c = str.at(i);
if (c == 'm') {
cnt.push(c);
} else if (c == 'e' && cnt.top() == 'm') {
cnt.pop();
cnt.push(c);
} else if (c == 'w' && cnt.top() == 'e') {
cnt.pop();
} else {
cout << "Rabbit" << endl;
return;
}
if (i < str.size() - 1 && cnt.empty()) {
cout << "Rabbit" << endl;
return;
}
}
if (cnt.empty()) {
cout << "Cat" << endl;
} else {
cout << "Rabbit" << endl;
}
return;
}
int main(void) {
string str;
while (cin >> str)
catChecker(str);
return 0;
} | #include <iostream>
#include <stack>
#include <string>
using namespace std;
void catChecker(string str) {
stack<char> cnt;
for (int i = 0; i < str.size(); i++) {
char c = str.at(i);
if (c == 'm') {
cnt.push(c);
} else if (!cnt.empty()) {
if (c == 'e' && cnt.top() == 'm') {
cnt.pop();
cnt.push(c);
} else if (c == 'w' && cnt.top() == 'e') {
cnt.pop();
} else {
cout << "Rabbit" << endl;
return;
}
} else {
cout << "Rabbit" << endl;
return;
}
if (i < str.size() - 1 && cnt.empty()) {
cout << "Rabbit" << endl;
return;
}
}
if (cnt.empty()) {
cout << "Cat" << endl;
} else {
cout << "Rabbit" << endl;
}
return;
}
int main(void) {
string str;
while (cin >> str)
catChecker(str);
return 0;
} | replace | 15 | 20 | 15 | 25 | 0 | |
p01486 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
// conversion
//------------------------------------------
inline int toInt(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();
}
// typedef
//------------------------------------------
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<double> VEC;
typedef vector<VEC> MAT;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef pair<int, PII> TIII;
typedef pair<int, TIII> QIIII;
typedef long long LL;
typedef vector<LL> VLL;
// 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())
#define MT(a, b, c) MP(a, MP(b, c))
#define MQ(a, b, c, d) MP(a, MT(b, c, d))
#define Q1 first
#define Q2 second.first
#define Q3 second.second.first
#define Q4 second.second.second
// repetition
//------------------------------------------
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define EPS 1e-8
#define MOD 1000000007
int main() {
string str;
cin >> str;
int n = str.length();
while (n) {
unsigned int k = str.find("mew");
if (k == string::npos) {
cout << "Rabbit" << endl;
return 0;
} else if (k == 0) {
if (n == 3)
cout << "Cat" << endl;
else
cout << "Rabbit" << endl;
return 0;
} else {
n -= 3;
str.erase(k, 3);
}
}
return 0;
} | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
// conversion
//------------------------------------------
inline int toInt(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();
}
// typedef
//------------------------------------------
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<double> VEC;
typedef vector<VEC> MAT;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef pair<int, PII> TIII;
typedef pair<int, TIII> QIIII;
typedef long long LL;
typedef vector<LL> VLL;
// 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())
#define MT(a, b, c) MP(a, MP(b, c))
#define MQ(a, b, c, d) MP(a, MT(b, c, d))
#define Q1 first
#define Q2 second.first
#define Q3 second.second.first
#define Q4 second.second.second
// repetition
//------------------------------------------
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define EPS 1e-8
#define MOD 1000000007
int main() {
string str;
cin >> str;
int n = str.length();
while (n) {
string::size_type k = str.find("mew");
if (k == string::npos) {
cout << "Rabbit" << endl;
return 0;
} else if (k == 0) {
if (n == 3)
cout << "Cat" << endl;
else
cout << "Rabbit" << endl;
return 0;
} else {
n -= 3;
str.erase(k, 3);
}
}
return 0;
} | replace | 85 | 86 | 85 | 86 | 0 | |
p01486 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctype.h>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int main() {
string s;
cin >> s;
stack<char> st;
bool ans = true;
for (int i = 0; i < s.length(); i++) {
if (s[i] == 'w' && st.top() == 'e' && st.size() > 1 &&
(i == s.length() - 1 || s[i + 1] != 'm')) {
st.pop();
st.pop();
} else {
st.push(s[i]);
}
if (st.empty() && i < s.length() - 1) {
ans = false;
}
}
if (!st.empty())
ans = false;
if (ans)
cout << "Cat" << endl;
else
cout << "Rabbit" << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctype.h>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int main() {
string s;
cin >> s;
stack<char> st;
bool ans = true;
for (int i = 0; i < s.length(); i++) {
if (s[i] == 'w' && st.size() > 1 && st.top() == 'e' &&
(i == s.length() - 1 || s[i + 1] != 'm')) {
st.pop();
st.pop();
} else {
st.push(s[i]);
}
if (st.empty() && i < s.length() - 1) {
ans = false;
}
}
if (!st.empty())
ans = false;
if (ans)
cout << "Cat" << endl;
else
cout << "Rabbit" << endl;
return 0;
} | replace | 25 | 26 | 25 | 26 | 0 | |
p01486 | C++ | Time Limit Exceeded | #include <cstdio>
#include <iostream>
#include <string>
using namespace std;
bool dfs(string s) {
int res = 0;
if (!s.size())
return 1;
if (s[0] != 'm' || s[s.size() - 1] != 'w')
return 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] != 'e')
continue;
string a = s.substr(1, i - 1);
string b = s.substr(i + 1);
b.erase(b.end() - 1);
if (dfs(a) && dfs(b))
return 1;
}
return 0;
}
int main() {
string s;
cin >> s;
puts(dfs(s) ? "Cat" : "Rabbit");
return 0;
} | #include <cstdio>
#include <iostream>
#include <string>
using namespace std;
bool dfs(string s) {
int res = 0;
if (!s.size())
return 1;
if (s[0] != 'm' || s[s.size() - 1] != 'w')
return 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] != 'e')
continue;
string a = s.substr(1, i - 1);
string b = s.substr(i + 1);
b.erase(b.end() - 1);
if (dfs(a) && dfs(b))
return 1;
}
return 0;
}
int main() {
string s;
cin >> s;
while (1) {
if (s.empty()) {
puts("Cat");
break;
}
string::size_type p = s.find("mew");
if (p == string::npos) {
puts("Rabbit");
break;
} else {
if (!(s.size() == 3 || (s[p - 1] == 'm' && s[p + 3] == 'e') ||
(s[p - 1] == 'e' && s[p + 3] == 'w'))) {
puts("Rabbit");
break;
}
s.erase(p, 3);
}
}
return 0;
} | replace | 27 | 28 | 27 | 47 | TLE | |
p01486 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
char str[1024];
bool f[1024][1024];
int main() {
scanf("%s", str);
int n = strlen(str);
for (int i = 0; i < n; i++) {
f[i][i] = true;
}
for (int t = 0; t < n; t++) {
for (int w1 = 0; w1 < n; w1 += 3) {
for (int w2 = 0; w2 < n; w2 += 3) {
for (int i = 0; i < n; i++) {
int j = i + w1 + 1;
int k = i + w1 + w2 + 2;
if (str[i] != 'm')
continue;
if (str[j] != 'e')
continue;
if (str[k] != 'w')
continue;
if (!f[i + 1][j])
continue;
if (!f[j + 1][k])
continue;
f[i][k + 1] = true;
}
}
}
}
puts(f[0][n] ? "Cat" : "Rabbit");
} | #include <bits/stdc++.h>
using namespace std;
char str[1024];
bool f[1024][1024];
int main() {
scanf("%s", str);
int n = strlen(str);
for (int i = 0; i < n; i++) {
f[i][i] = true;
}
for (int t = 0; t < n / 2; t++) {
for (int w1 = 0; w1 < n; w1 += 3) {
for (int w2 = 0; w2 < n; w2 += 3) {
for (int i = 0; i < n; i++) {
int j = i + w1 + 1;
int k = i + w1 + w2 + 2;
if (str[i] != 'm')
continue;
if (str[j] != 'e')
continue;
if (str[k] != 'w')
continue;
if (!f[i + 1][j])
continue;
if (!f[j + 1][k])
continue;
f[i][k + 1] = true;
}
}
}
}
puts(f[0][n] ? "Cat" : "Rabbit");
} | replace | 12 | 13 | 12 | 13 | TLE | |
p01486 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
inline int toInt(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();
}
template <class T> inline T sqr(T x) { return x * x; }
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef long long ll;
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define pb push_back
#define mp make_pair
#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 range(i, a, b) for (int i = (a); i < (b); ++i)
#define rep(i, n) range(i, 0, n)
#define clr(a, b) memset((a), (b), sizeof(a))
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) \
cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl;
const double eps = 1e-10;
const double pi = acos(-1.0);
const ll INF = 1LL << 62;
const int inf = 1 << 29;
bool dp[510][510];
int main(void) {
string s;
cin >> s;
int n = s.size();
for (int i = 0; i <= n; ++i)
dp[i][i] = true;
for (int d = 3; d <= n; d += 3) {
for (int i = 0; i <= n - d; ++i) {
if (s[i] != 'm')
continue;
if (s[i + d - 1] != 'w')
continue;
for (int j = i + 1; j < i + d - 1; ++j) {
if (s[j] != 'e')
continue;
dump(d) dump(i) dump(j) dp[i][i + d] |=
(dp[i + 1][j] && dp[j + 1][i + d - 1]);
}
}
}
if (dp[0][n])
cout << "Cat" << endl;
else
cout << "Rabbit" << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
inline int toInt(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();
}
template <class T> inline T sqr(T x) { return x * x; }
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef long long ll;
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define pb push_back
#define mp make_pair
#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 range(i, a, b) for (int i = (a); i < (b); ++i)
#define rep(i, n) range(i, 0, n)
#define clr(a, b) memset((a), (b), sizeof(a))
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) \
cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl;
const double eps = 1e-10;
const double pi = acos(-1.0);
const ll INF = 1LL << 62;
const int inf = 1 << 29;
bool dp[510][510];
int main(void) {
string s;
cin >> s;
int n = s.size();
for (int i = 0; i <= n; ++i)
dp[i][i] = true;
for (int d = 3; d <= n; d += 3) {
for (int i = 0; i <= n - d; ++i) {
if (s[i] != 'm')
continue;
if (s[i + d - 1] != 'w')
continue;
for (int j = i + 1; j < i + d - 1; ++j) {
if (s[j] != 'e')
continue;
dp[i][i + d] |= (dp[i + 1][j] && dp[j + 1][i + d - 1]);
}
}
}
if (dp[0][n])
cout << "Cat" << endl;
else
cout << "Rabbit" << endl;
return 0;
} | replace | 61 | 63 | 61 | 62 | 0 | d = 3
i = 3
j = 4
d = 3
i = 8
j = 9
d = 6
i = 0
j = 2
d = 6
i = 0
j = 4
d = 6
i = 1
j = 2
d = 6
i = 1
j = 4
d = 9
i = 3
j = 4
d = 9
i = 3
j = 7
d = 9
i = 3
j = 9
d = 12
i = 0
j = 2
d = 12
i = 0
j = 4
d = 12
i = 0
j = 7
d = 12
i = 0
j = 9
|
p01487 | C++ | Time Limit Exceeded | #include "bits/stdc++.h"
#include <unordered_map>
#include <unordered_set>
#pragma warning(disable : 4996)
using namespace std;
using ld = long double;
template <class T> using Table = vector<vector<T>>;
vector<pair<int, int>> colors;
vector<vector<int>> edges;
pair<int, int> dfs(const int now, const int num) {
const int nextcolor = !colors[now].second;
pair<int, int> nums(0, 0);
if (colors[now].second == 1)
nums.second++;
else
nums.first++;
for (auto e : edges[now]) {
if (colors[e].second == -1) {
colors[e] = make_pair(now, nextcolor);
pair<int, int> p = dfs(e, num);
if (!p.first && !p.second)
return p;
nums.first += p.first;
nums.second += p.second;
} else if (colors[e].second != nextcolor)
return make_pair(0, 0);
}
return nums;
}
bool dp[2][100001];
int main() {
int V, E;
cin >> V >> E;
for (int i = 0; i < V; ++i) {
colors.push_back(make_pair(-1, -1));
}
edges.resize(V);
for (int i = 0; i < E; ++i) {
int a, b;
cin >> a >> b;
a--;
b--;
edges[a].push_back(b);
edges[b].push_back(a);
}
int color = 0;
vector<pair<int, int>> ps;
bool ok = true;
for (int i = 0; i < V; ++i) {
if (colors[i].second == -1) {
colors[i] = make_pair(color, 0);
pair<int, int> p = dfs(i, color);
if (!p.first && !p.second) {
ok = false;
}
if (p.first > p.second)
swap(p.first, p.second);
ps.push_back(p);
color++;
}
}
if (!ok) {
cout << -1 << endl;
} else {
int amin = 0;
map<int, int> pluss;
for (int i = 0; i < ps.size(); ++i) {
amin += ps[i].first;
if (ps[i].first != ps[i].second) {
pluss[ps[i].second - ps[i].first]++;
}
}
for (int i = 1; i < 100000; ++i) {
if (pluss.find(i) != pluss.end()) {
const int bai = (pluss[i] - 1) / 2;
if (bai) {
pluss[2 * i] += bai;
}
}
}
vector<int> naps;
for (int i = 1; i < 100000; ++i) {
if (pluss.find(i) != pluss.end()) {
for (int j = 0; j < pluss[i]; ++j) {
naps.push_back(i);
}
}
}
dp[0][0] = true;
for (int i = 0; i < naps.size(); ++i) {
int tar = i & 1, cur = tar ^ 1;
for (int i = 0; i < 100001; ++i) {
dp[cur][i] = 0;
}
if (i == 0)
assert(tar == 0 && cur == 1);
for (int j = 0; j < 100000; ++j) {
if (dp[tar][j]) {
dp[cur][j] = true;
dp[cur][j + naps[i]] = true;
}
}
}
long long int ans = 0;
for (int i = 0; i < 100000; ++i) {
if (abs(ans + amin - V / 2) > abs(i + amin - V / 2) &&
dp[naps.size() % 2][i]) {
ans = i;
}
}
cout << (amin + ans) * (V - ans - amin) - E << endl;
}
return 0;
} | #include "bits/stdc++.h"
#include <unordered_map>
#include <unordered_set>
#pragma warning(disable : 4996)
using namespace std;
using ld = long double;
template <class T> using Table = vector<vector<T>>;
vector<pair<int, int>> colors;
vector<vector<int>> edges;
pair<int, int> dfs(const int now, const int num) {
const int nextcolor = !colors[now].second;
pair<int, int> nums(0, 0);
if (colors[now].second == 1)
nums.second++;
else
nums.first++;
for (auto e : edges[now]) {
if (colors[e].second == -1) {
colors[e] = make_pair(now, nextcolor);
pair<int, int> p = dfs(e, num);
if (!p.first && !p.second)
return p;
nums.first += p.first;
nums.second += p.second;
} else if (colors[e].second != nextcolor)
return make_pair(0, 0);
}
return nums;
}
bool dp[2][100001];
int main() {
int V, E;
cin >> V >> E;
for (int i = 0; i < V; ++i) {
colors.push_back(make_pair(-1, -1));
}
edges.resize(V);
for (int i = 0; i < E; ++i) {
int a, b;
cin >> a >> b;
a--;
b--;
edges[a].push_back(b);
edges[b].push_back(a);
}
int color = 0;
vector<pair<int, int>> ps;
bool ok = true;
for (int i = 0; i < V; ++i) {
if (colors[i].second == -1) {
colors[i] = make_pair(color, 0);
pair<int, int> p = dfs(i, color);
if (!p.first && !p.second) {
ok = false;
}
if (p.first > p.second)
swap(p.first, p.second);
ps.push_back(p);
color++;
}
}
if (!ok) {
cout << -1 << endl;
} else {
int amin = 0;
map<int, int> pluss;
for (int i = 0; i < ps.size(); ++i) {
amin += ps[i].first;
if (ps[i].first != ps[i].second) {
pluss[ps[i].second - ps[i].first]++;
}
}
for (int i = 1; i < 100000; ++i) {
if (pluss.find(i) != pluss.end()) {
const int bai = (pluss[i] - 1) / 2;
if (bai) {
pluss[2 * i] += bai;
pluss[i] -= bai * 2;
}
}
}
vector<int> naps;
for (int i = 1; i < 100000; ++i) {
if (pluss.find(i) != pluss.end()) {
for (int j = 0; j < pluss[i]; ++j) {
naps.push_back(i);
}
}
}
dp[0][0] = true;
for (int i = 0; i < naps.size(); ++i) {
int tar = i & 1, cur = tar ^ 1;
for (int i = 0; i < 100001; ++i) {
dp[cur][i] = 0;
}
if (i == 0)
assert(tar == 0 && cur == 1);
for (int j = 0; j < 100000; ++j) {
if (dp[tar][j]) {
dp[cur][j] = true;
dp[cur][j + naps[i]] = true;
}
}
}
long long int ans = 0;
for (int i = 0; i < 100000; ++i) {
if (abs(ans + amin - V / 2) > abs(i + amin - V / 2) &&
dp[naps.size() % 2][i]) {
ans = i;
}
}
cout << (amin + ans) * (V - ans - amin) - E << endl;
}
return 0;
} | insert | 80 | 80 | 80 | 81 | TLE | |
p01487 | C++ | Runtime Error | #include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <vector>
using namespace std;
int n, m, a, b, d, u[200000];
vector<int> x[100000], c[100000], H;
bool used[100000], f[200009], g[200009];
vector<pair<int, int>> I;
bool solve() {
vector<int> col(n, -1);
for (int i = 0; i < d; i++) {
queue<int> Q;
col[c[i][0]] = 0;
Q.push(c[i][0]);
while (!Q.empty()) {
int a1 = Q.front();
Q.pop();
for (int j : x[a1]) {
if (col[j] == -1) {
Q.push(j);
col[j] = 1 - col[a1];
} else if (col[j] == col[a1]) {
return false;
}
}
}
int v = 0;
for (int j = 0; j < c[i].size(); j++) {
if (col[c[i][j]] == 0)
v++;
else
v--;
}
H.push_back(abs(v));
}
return true;
}
void knapsack() {
for (int i = 0; i <= n * 2; i++)
f[i] = false;
f[n] = true;
for (int i = 0; i < I.size(); i++) {
for (int j = 0; j <= n * 2; j++) {
g[j] = false;
u[j] = -1;
}
for (int j = 0; j <= n * 2; j++) {
if (f[j] == false)
continue;
int r1 = I[i].first * 2;
int r3 = I[i].first * I[i].second * -1, r4 = -r3;
r4 += j;
r3 += j;
r3 = max(r3, u[r3 % r1]);
for (int k = r3; k <= r4; k += r1) {
g[k] = true;
u[k % r1] = k;
}
}
for (int j = 0; j <= n * 2; j++)
f[j] = g[j];
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> a >> b;
a--;
b--;
x[a].push_back(b);
x[b].push_back(a);
}
for (int i = 0; i < n; i++) {
if (used[i] == true)
continue;
queue<int> Q;
Q.push(i);
used[i] = true;
while (!Q.empty()) {
int a1 = Q.front();
Q.pop();
c[d].push_back(a1);
for (int j : x[a1]) {
if (used[j] == false) {
Q.push(j);
used[j] = true;
}
}
}
d++;
}
bool U = solve();
map<int, int> M, M2;
if (U == false) {
cout << "-1" << endl;
return 0;
}
for (int i = 0; i < H.size(); i++)
M[H[i]]++;
for (int i = 0; i < H.size(); i++) {
if (M2[H[i]] == 0) {
M2[H[i]] = 1;
I.push_back(make_pair(H[i], M[H[i]]));
}
}
knapsack();
long long ret = 0;
for (int i = 0; i <= n; i++) {
if (f[2 * i] == true)
ret = max(ret, 1LL * (n - i) * i);
}
cout << ret - m << endl;
return 0;
} | #include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <vector>
using namespace std;
int n, m, a, b, d, u[200000];
vector<int> x[100000], c[100000], H;
bool used[100000], f[200009], g[200009];
vector<pair<int, int>> I;
bool solve() {
vector<int> col(n, -1);
for (int i = 0; i < d; i++) {
queue<int> Q;
col[c[i][0]] = 0;
Q.push(c[i][0]);
while (!Q.empty()) {
int a1 = Q.front();
Q.pop();
for (int j : x[a1]) {
if (col[j] == -1) {
Q.push(j);
col[j] = 1 - col[a1];
} else if (col[j] == col[a1]) {
return false;
}
}
}
int v = 0;
for (int j = 0; j < c[i].size(); j++) {
if (col[c[i][j]] == 0)
v++;
else
v--;
}
H.push_back(abs(v));
}
return true;
}
void knapsack() {
for (int i = 0; i <= n * 2; i++)
f[i] = false;
f[n] = true;
for (int i = 0; i < I.size(); i++) {
for (int j = 0; j <= n * 2; j++) {
g[j] = false;
u[j] = -1;
}
for (int j = 0; j <= n * 2; j++) {
if (f[j] == false)
continue;
int r1 = I[i].first * 2;
if (r1 == 0) {
g[j] = true;
continue;
}
int r3 = I[i].first * I[i].second * -1, r4 = -r3;
r4 += j;
r3 += j;
r3 = max(r3, u[r3 % r1]);
for (int k = r3; k <= r4; k += r1) {
g[k] = true;
u[k % r1] = k;
}
}
for (int j = 0; j <= n * 2; j++)
f[j] = g[j];
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> a >> b;
a--;
b--;
x[a].push_back(b);
x[b].push_back(a);
}
for (int i = 0; i < n; i++) {
if (used[i] == true)
continue;
queue<int> Q;
Q.push(i);
used[i] = true;
while (!Q.empty()) {
int a1 = Q.front();
Q.pop();
c[d].push_back(a1);
for (int j : x[a1]) {
if (used[j] == false) {
Q.push(j);
used[j] = true;
}
}
}
d++;
}
bool U = solve();
map<int, int> M, M2;
if (U == false) {
cout << "-1" << endl;
return 0;
}
for (int i = 0; i < H.size(); i++)
M[H[i]]++;
for (int i = 0; i < H.size(); i++) {
if (M2[H[i]] == 0) {
M2[H[i]] = 1;
I.push_back(make_pair(H[i], M[H[i]]));
}
}
knapsack();
long long ret = 0;
for (int i = 0; i <= n; i++) {
if (f[2 * i] == true)
ret = max(ret, 1LL * (n - i) * i);
}
cout << ret - m << endl;
return 0;
} | insert | 52 | 52 | 52 | 56 | -8 | |
p01487 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int(i) = 0; (i) < (int)(n); ++(i))
#define all(x) (x).begin(), (x).end()
#define pb push_back
#define fi first
#define se second
#define dbg(x) cout << #x " = " << ((x)) << endl
template <class T, class U>
ostream &operator<<(ostream &o, const pair<T, U> &p) {
o << "(" << p.fi << "," << p.se << ")";
return o;
}
template <class T> ostream &operator<<(ostream &o, const vector<T> &v) {
o << "[";
for (T t : v) {
o << t << ",";
}
o << "]";
return o;
}
using pi = pair<int, int>;
using P = pair<int, pi>;
const int INF = 12345678;
const int B = 320;
const int N = 100010;
vector<int> G[N];
int dp[N][2], nx[N][2];
int dp2[N], nx2[N];
ll solve() {
int n, m;
cin >> n >> m;
rep(i, m) {
int u, v;
cin >> u >> v;
--u;
--v;
G[u].pb(v);
G[v].pb(u);
}
vector<int> d(n, INF);
vector<int> x;
rep(i, n) {
if (d[i] != INF)
continue;
queue<int> que;
vector<int> cc;
d[i] = 0;
que.push(i);
cc.pb(i);
while (!que.empty()) {
int v = que.front();
que.pop();
for (int e : G[v]) {
if (d[e] > d[v] + 1) {
d[e] = d[v] + 1;
que.push(e);
cc.pb(e);
}
}
}
int diff = 0;
for (int v : cc) {
if (d[v] % 2 == 0)
++diff;
else
--diff;
for (int e : G[v]) {
// 奇閉路が存在する
if (abs(d[v] - d[e]) % 2 == 0)
return -1;
}
}
x.pb(abs(diff));
}
vector<int> s, l;
for (int i : x) {
if (i < B)
s.pb(i);
else
l.pb(i);
}
vector<int> Ld, Sd;
// calc small
vector<int> ct(B);
for (int i : s)
++ct[i];
memset(dp, -1, sizeof(dp));
dp[0][0] = 0;
for (int i = 1; i < B; ++i) {
memset(nx, -1, sizeof(nx));
priority_queue<P> pq;
int C = ct[i];
rep(j, N) if (dp[j][0] >= 0) {
pq.push({C, {j, C % 2}});
nx[j][C % 2] = C;
}
while (!pq.empty()) {
P now = pq.top();
pq.pop();
if (now.fi == 0)
continue;
pi p = now.se;
for (int j = -1; j <= 1; j += 2) {
int idx = abs(p.fi + j * i);
if (idx < N && nx[idx][!p.se] < now.fi - 1) {
nx[idx][!p.se] = now.fi - 1;
pq.push({nx[idx][!p.se], {idx, !p.se}});
}
}
}
rep(j, N) rep(k, 2) dp[j][k] = nx[j][k];
}
rep(i, N) if (dp[i][0] >= 0) Sd.pb(i);
// calc large
int L = l.size();
memset(dp2, 0, sizeof(dp2));
queue<pi> que;
dp2[0] = 1;
rep(i, L) {
memset(nx2, 0, sizeof(nx2));
rep(j, N) if (dp2[j]) {
for (int k = -1; k <= 1; k += 2) {
int idx = abs(j + k * Ld[i]);
if (idx < N)
nx2[idx] = 1;
}
}
rep(j, N) dp2[j] = nx2[j];
}
rep(i, N) if (dp2[i]) Ld.pb(i);
// calc ans
ll ans = 0;
int sz = Sd.size();
for (int i : Ld) {
int idx = lower_bound(all(Sd), i) - Sd.begin();
for (int a = -1; a <= 1; ++a) {
int j = idx + a;
if (0 <= j && j < sz) {
int dd = abs(i - Sd[j]);
if (n - dd > 0) {
// assert((n-dd)%2==0);
int xx = (n - dd) / 2;
ll X = xx, Y = xx + dd;
ans = max(ans, X * Y - m);
}
}
}
}
return ans;
}
int main() {
cout << solve() << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int(i) = 0; (i) < (int)(n); ++(i))
#define all(x) (x).begin(), (x).end()
#define pb push_back
#define fi first
#define se second
#define dbg(x) cout << #x " = " << ((x)) << endl
template <class T, class U>
ostream &operator<<(ostream &o, const pair<T, U> &p) {
o << "(" << p.fi << "," << p.se << ")";
return o;
}
template <class T> ostream &operator<<(ostream &o, const vector<T> &v) {
o << "[";
for (T t : v) {
o << t << ",";
}
o << "]";
return o;
}
using pi = pair<int, int>;
using P = pair<int, pi>;
const int INF = 12345678;
const int B = 320;
const int N = 100010;
vector<int> G[N];
int dp[N][2], nx[N][2];
int dp2[N], nx2[N];
ll solve() {
int n, m;
cin >> n >> m;
rep(i, m) {
int u, v;
cin >> u >> v;
--u;
--v;
G[u].pb(v);
G[v].pb(u);
}
vector<int> d(n, INF);
vector<int> x;
rep(i, n) {
if (d[i] != INF)
continue;
queue<int> que;
vector<int> cc;
d[i] = 0;
que.push(i);
cc.pb(i);
while (!que.empty()) {
int v = que.front();
que.pop();
for (int e : G[v]) {
if (d[e] > d[v] + 1) {
d[e] = d[v] + 1;
que.push(e);
cc.pb(e);
}
}
}
int diff = 0;
for (int v : cc) {
if (d[v] % 2 == 0)
++diff;
else
--diff;
for (int e : G[v]) {
// 奇閉路が存在する
if (abs(d[v] - d[e]) % 2 == 0)
return -1;
}
}
x.pb(abs(diff));
}
vector<int> s, l;
for (int i : x) {
if (i < B)
s.pb(i);
else
l.pb(i);
}
vector<int> Ld, Sd;
// calc small
vector<int> ct(B);
for (int i : s)
++ct[i];
memset(dp, -1, sizeof(dp));
dp[0][0] = 0;
for (int i = 1; i < B; ++i) {
memset(nx, -1, sizeof(nx));
priority_queue<P> pq;
int C = ct[i];
rep(j, N) if (dp[j][0] >= 0) {
pq.push({C, {j, C % 2}});
nx[j][C % 2] = C;
}
while (!pq.empty()) {
P now = pq.top();
pq.pop();
if (now.fi == 0)
continue;
pi p = now.se;
for (int j = -1; j <= 1; j += 2) {
int idx = abs(p.fi + j * i);
if (idx < N && nx[idx][!p.se] < now.fi - 1) {
nx[idx][!p.se] = now.fi - 1;
pq.push({nx[idx][!p.se], {idx, !p.se}});
}
}
}
rep(j, N) rep(k, 2) dp[j][k] = nx[j][k];
}
rep(i, N) if (dp[i][0] >= 0) Sd.pb(i);
// calc large
int L = l.size();
memset(dp2, 0, sizeof(dp2));
queue<pi> que;
dp2[0] = 1;
rep(i, L) {
memset(nx2, 0, sizeof(nx2));
rep(j, N) if (dp2[j]) {
for (int k = -1; k <= 1; k += 2) {
int idx = abs(j + k * l[i]);
if (idx < N)
nx2[idx] = 1;
}
}
rep(j, N) dp2[j] = nx2[j];
}
rep(i, N) if (dp2[i]) Ld.pb(i);
// calc ans
ll ans = 0;
int sz = Sd.size();
for (int i : Ld) {
int idx = lower_bound(all(Sd), i) - Sd.begin();
for (int a = -1; a <= 1; ++a) {
int j = idx + a;
if (0 <= j && j < sz) {
int dd = abs(i - Sd[j]);
if (n - dd > 0) {
// assert((n-dd)%2==0);
int xx = (n - dd) / 2;
ll X = xx, Y = xx + dd;
ans = max(ans, X * Y - m);
}
}
}
}
return ans;
}
int main() {
cout << solve() << endl;
return 0;
}
| replace | 148 | 149 | 148 | 149 | 0 | |
p01487 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define MAX_N 100000
#define INF 100000000
#define MOD 1000000007
#define RANK 1000000000
#define EPS 1e-10
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<int, P> IP;
struct UF {
int par[MAX_N];
int rank[MAX_N];
int si[MAX_N];
void init(int n) {
rep(i, n) {
par[i] = i;
rank[i] = 0;
si[i] = 1;
}
}
int find(int x) {
if (par[x] == x)
return x;
else
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;
si[y] += si[x];
} else {
par[y] = x;
if (rank[x] == rank[y])
rank[x]++;
si[x] += si[y];
}
}
bool same(int x, int y) { return find(x) == find(y); }
} uf;
int v, ee;
vector<int> e[100000];
int val[100000];
bool dp[2][100001];
P dfs(int x, int now) {
P ret = P(0, 0);
val[x] = now;
if (now)
ret.second++;
else
ret.first++;
rep(i, e[x].size()) {
if (val[e[x][i]] != 2 && val[e[x][i]] != (now ^ 1)) {
return P(-1, -1);
}
if (val[e[x][i]] != 2)
continue;
P tmp = dfs(e[x][i], now ^ 1);
if (tmp.first == -1)
return P(-1, -1);
ret.first += tmp.first;
ret.second += tmp.second;
}
return ret;
}
int main() {
cin >> v >> ee;
rep(i, v) val[i] = 2;
uf.init(v);
int ho = 0, ge = 1;
dp[ho][0] = true;
rep(i, ee) {
int a, b;
cin >> a >> b;
a--;
b--;
e[a].push_back(b);
e[b].push_back(a);
uf.unite(a, b);
}
rep(i, v) {
if (uf.find(i) != i)
continue;
P d = dfs(i, 0);
if (d.first == -1) {
cout << -1 << endl;
return 0;
}
if (d.first > d.second)
swap(d.first, d.second);
// cout << d.first << " " << d.second << endl;
memset(dp[ge], 0, sizeof(dp[ge]));
for (int j = v; j >= 0; j--) {
if (j >= d.first)
dp[ge][j] |= dp[ho][j - d.first];
else
break;
if (j >= d.second)
dp[ge][j] |= dp[ho][j - d.second];
}
swap(ho, ge);
}
ll ans = 0;
for (ll i = 0; i <= v; i++) {
if (dp[ho][i])
ans = max(ans, i * (v - i));
}
cout << ans - ee << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define MAX_N 100000
#define INF 100000000
#define MOD 1000000007
#define RANK 1000000000
#define EPS 1e-10
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<int, P> IP;
struct UF {
int par[MAX_N];
int rank[MAX_N];
int si[MAX_N];
void init(int n) {
rep(i, n) {
par[i] = i;
rank[i] = 0;
si[i] = 1;
}
}
int find(int x) {
if (par[x] == x)
return x;
else
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;
si[y] += si[x];
} else {
par[y] = x;
if (rank[x] == rank[y])
rank[x]++;
si[x] += si[y];
}
}
bool same(int x, int y) { return find(x) == find(y); }
} uf;
int v, ee;
vector<int> e[100000];
int val[100000];
bool dp[2][100001];
P dfs(int x, int now) {
P ret = P(0, 0);
val[x] = now;
if (now)
ret.second++;
else
ret.first++;
rep(i, e[x].size()) {
if (val[e[x][i]] != 2 && val[e[x][i]] != (now ^ 1)) {
return P(-1, -1);
}
if (val[e[x][i]] != 2)
continue;
P tmp = dfs(e[x][i], now ^ 1);
if (tmp.first == -1)
return P(-1, -1);
ret.first += tmp.first;
ret.second += tmp.second;
}
return ret;
}
int main() {
cin >> v >> ee;
rep(i, v) val[i] = 2;
uf.init(v);
int ho = 0, ge = 1;
dp[ho][0] = true;
rep(i, ee) {
int a, b;
cin >> a >> b;
a--;
b--;
e[a].push_back(b);
e[b].push_back(a);
uf.unite(a, b);
}
rep(i, v) {
if (uf.find(i) != i)
continue;
P d = dfs(i, 0);
if (d.first == -1) {
cout << -1 << endl;
return 0;
}
if (d.first > d.second)
swap(d.first, d.second);
// cout << d.first << " " << d.second << endl;
memset(dp[ge], 0, sizeof(dp[ge]));
for (int j = v / 2 + 1; j >= 0; j--) {
if (j >= d.first)
dp[ge][j] |= dp[ho][j - d.first];
else
break;
if (j >= d.second)
dp[ge][j] |= dp[ho][j - d.second];
}
swap(ho, ge);
}
ll ans = 0;
for (ll i = 0; i <= v; i++) {
if (dp[ho][i])
ans = max(ans, i * (v - i));
}
cout << ans - ee << endl;
} | replace | 106 | 107 | 106 | 107 | TLE | |
p01488 | C++ | Runtime Error | #include <algorithm>
#include <map>
#include <queue>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
char str[16];
map<string, int> m;
vector<pair<int, int>> g[100000];
vector<pair<int, int>> ijk[50000];
pair<int, int> IJK[100000];
vector<int> num[50000];
vector<int> dist[50000];
vector<int> vis[50000];
int VIS[50000];
struct wolf {
int cost;
int chg;
int L;
int Y;
wolf() {}
wolf(int a, int b, int c, int d) {
cost = a;
chg = b;
L = c;
Y = d;
}
};
inline bool operator<(const wolf &a, const wolf &b) {
if (a.cost != b.cost)
return a.cost > b.cost;
return a.chg > b.chg;
}
int main() {
int a, b;
scanf("%d%d", &a, &b);
int v = 0;
scanf("%s", str);
string S = str;
scanf("%s", str);
string T = str;
m[S] = v++;
m[T] = v++;
for (int i = 0; i < a; i++) {
int c;
scanf("%d", &c);
for (int j = 0; j < c; j++) {
scanf("%s", str);
string STR = str;
if (m.count(STR) == 0)
m[STR] = v++;
ijk[i].push_back(make_pair(999999999, 999999999));
num[i].push_back(m[STR]);
vis[i].push_back(0);
g[m[STR]].push_back(make_pair(i, j));
}
for (int j = 0; j < c - 1; j++) {
int d;
scanf("%d", &d);
dist[i].push_back(d);
}
}
for (int i = 0; i < v; i++)
IJK[i] = make_pair(999999999, 999999999);
priority_queue<wolf> Q;
Q.push(wolf(0, 0, -1, m[S]));
IJK[m[S]] = make_pair(0, 0);
while (Q.size()) {
wolf at = Q.top();
Q.pop();
if (at.L == -1) {
if (VIS[at.Y])
continue;
VIS[at.Y] = 1;
} else {
if (vis[at.L][at.Y])
continue;
vis[at.L][at.Y] = 1;
}
if (at.L == -1) {
for (int i = 0; i < g[at.Y].size(); i++) {
int I = g[at.Y][i].first;
int J = g[at.Y][i].second;
if (!vis[I][J] && ijk[I][J] > IJK[at.Y]) {
ijk[I][J] = IJK[at.Y];
Q.push(wolf(at.cost, at.chg, I, J));
}
}
} else {
int N = num[at.L][at.Y];
if (!VIS[N] && IJK[N] > make_pair(at.cost + b, at.chg + 1)) {
IJK[N] = make_pair(at.cost + b, at.chg + 1);
Q.push(wolf(IJK[N].first, IJK[N].second, -1, N));
}
if (at.Y && !vis[at.L][at.Y - 1] &&
ijk[at.L][at.Y - 1] >
make_pair(at.cost + dist[at.L][at.Y - 1], at.chg)) {
ijk[at.L][at.Y - 1] = make_pair(at.cost + dist[at.L][at.Y - 1], at.chg);
Q.push(wolf(at.cost + dist[at.L][at.Y - 1], at.chg, at.L, at.Y - 1));
}
if (at.Y < dist[at.L].size() && !vis[at.L][at.Y + 1] &&
ijk[at.L][at.Y + 1] > make_pair(at.cost + dist[at.L][at.Y], at.chg)) {
ijk[at.L][at.Y + 1] = make_pair(at.cost + dist[at.L][at.Y], at.chg);
Q.push(wolf(at.cost + dist[at.L][at.Y], at.chg, at.L, at.Y + 1));
}
}
}
if (IJK[m[T]].first == 999999999)
printf("-1\n");
else
printf("%d %d\n", IJK[m[T]].first - b, IJK[m[T]].second - 1);
} | #include <algorithm>
#include <map>
#include <queue>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
char str[16];
map<string, int> m;
vector<pair<int, int>> g[100000];
vector<pair<int, int>> ijk[50000];
pair<int, int> IJK[100000];
vector<int> num[50000];
vector<int> dist[50000];
vector<int> vis[50000];
int VIS[100000];
struct wolf {
int cost;
int chg;
int L;
int Y;
wolf() {}
wolf(int a, int b, int c, int d) {
cost = a;
chg = b;
L = c;
Y = d;
}
};
inline bool operator<(const wolf &a, const wolf &b) {
if (a.cost != b.cost)
return a.cost > b.cost;
return a.chg > b.chg;
}
int main() {
int a, b;
scanf("%d%d", &a, &b);
int v = 0;
scanf("%s", str);
string S = str;
scanf("%s", str);
string T = str;
m[S] = v++;
m[T] = v++;
for (int i = 0; i < a; i++) {
int c;
scanf("%d", &c);
for (int j = 0; j < c; j++) {
scanf("%s", str);
string STR = str;
if (m.count(STR) == 0)
m[STR] = v++;
ijk[i].push_back(make_pair(999999999, 999999999));
num[i].push_back(m[STR]);
vis[i].push_back(0);
g[m[STR]].push_back(make_pair(i, j));
}
for (int j = 0; j < c - 1; j++) {
int d;
scanf("%d", &d);
dist[i].push_back(d);
}
}
for (int i = 0; i < v; i++)
IJK[i] = make_pair(999999999, 999999999);
priority_queue<wolf> Q;
Q.push(wolf(0, 0, -1, m[S]));
IJK[m[S]] = make_pair(0, 0);
while (Q.size()) {
wolf at = Q.top();
Q.pop();
if (at.L == -1) {
if (VIS[at.Y])
continue;
VIS[at.Y] = 1;
} else {
if (vis[at.L][at.Y])
continue;
vis[at.L][at.Y] = 1;
}
if (at.L == -1) {
for (int i = 0; i < g[at.Y].size(); i++) {
int I = g[at.Y][i].first;
int J = g[at.Y][i].second;
if (!vis[I][J] && ijk[I][J] > IJK[at.Y]) {
ijk[I][J] = IJK[at.Y];
Q.push(wolf(at.cost, at.chg, I, J));
}
}
} else {
int N = num[at.L][at.Y];
if (!VIS[N] && IJK[N] > make_pair(at.cost + b, at.chg + 1)) {
IJK[N] = make_pair(at.cost + b, at.chg + 1);
Q.push(wolf(IJK[N].first, IJK[N].second, -1, N));
}
if (at.Y && !vis[at.L][at.Y - 1] &&
ijk[at.L][at.Y - 1] >
make_pair(at.cost + dist[at.L][at.Y - 1], at.chg)) {
ijk[at.L][at.Y - 1] = make_pair(at.cost + dist[at.L][at.Y - 1], at.chg);
Q.push(wolf(at.cost + dist[at.L][at.Y - 1], at.chg, at.L, at.Y - 1));
}
if (at.Y < dist[at.L].size() && !vis[at.L][at.Y + 1] &&
ijk[at.L][at.Y + 1] > make_pair(at.cost + dist[at.L][at.Y], at.chg)) {
ijk[at.L][at.Y + 1] = make_pair(at.cost + dist[at.L][at.Y], at.chg);
Q.push(wolf(at.cost + dist[at.L][at.Y], at.chg, at.L, at.Y + 1));
}
}
}
if (IJK[m[T]].first == 999999999)
printf("-1\n");
else
printf("%d %d\n", IJK[m[T]].first - b, IJK[m[T]].second - 1);
} | replace | 15 | 16 | 15 | 16 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.