// Convert Infix to Prefix Expression.
void infixToPrefix(vector<string>& infix, vector<string>& prefix) {
reverse(infix.begin(), infix.end());
stack<string> s;
for (auto& tok : infix) {
if (atoi(tok.c_str())) {
prefix.emplace_back(tok);
} else if (tok == ")") {
s.emplace(tok);
} else if (tok == "(") {
while (!s.empty()) {
tok = s.top();
s.pop();
if (tok == ")") {
break;
}
prefix.emplace_back(tok);
}
} else {
while (!s.empty() && precedence(tok) < precedence(s.top())) {
prefix.emplace_back(s.top());
s.pop();
}
s.emplace(tok);
}
}
while (!s.empty()) {
prefix.emplace_back(s.top());
s.pop();
}
reverse(prefix.begin(), prefix.end());
}
void TMaskCleaner::ProcessPixel(const BYTE *src, int x, int y, int pitch, int w, int h, vector<Coordinates> &coordinates, vector<Coordinates> &white_pixels) {
coordinates.clear();
white_pixels.clear();
coordinates.emplace_back(x, y);
while (!coordinates.empty()) {
/* pop last coordinates */
Coordinates current = coordinates.back();
coordinates.pop_back();
/* check surrounding positions */
int x_min = current.first == 0 ? 0 : current.first - 1;
int x_max = current.first == w - 1 ? w : current.first + 2;
int y_min = current.second == 0 ? 0 : current.second - 1;
int y_max = current.second == h - 1 ? h : current.second + 2;
for (int j = y_min; j < y_max; ++j ) {
for (int i = x_min; i < x_max; ++i ) {
if (!Visited(i,j) && IsWhite(src[j * pitch + i])) {
coordinates.emplace_back(i, j);
white_pixels.emplace_back(i, j);
Visit(i,j);
}
}
}
}
}
int external_morpho::analyze(string_piece form, guesser_mode /*guesser*/, vector<tagged_lemma>& lemmas) const {
lemmas.clear();
if (form.len) {
// Start by skipping the first form
string_piece lemmatags = form;
while (lemmatags.len && *lemmatags.str != ' ') lemmatags.len--, lemmatags.str++;
if (lemmatags.len) lemmatags.len--, lemmatags.str++;
// Split lemmatags using ' ' into lemma-tag pairs.
while (lemmatags.len) {
auto lemma_start = lemmatags.str;
while (lemmatags.len && *lemmatags.str != ' ') lemmatags.len--, lemmatags.str++;
if (!lemmatags.len) break;
auto lemma_len = lemmatags.str - lemma_start;
lemmatags.len--, lemmatags.str++;
auto tag_start = lemmatags.str;
while (lemmatags.len && *lemmatags.str != ' ') lemmatags.len--, lemmatags.str++;
auto tag_len = lemmatags.str - tag_start;
if (lemmatags.len) lemmatags.len--, lemmatags.str++;
lemmas.emplace_back(string(lemma_start, lemma_len), string(tag_start, tag_len));
}
if (!lemmas.empty()) return NO_GUESSER;
}
lemmas.emplace_back(string(form.str, form.len), unknown_tag);
return -1;
}
// // //Add cell to the list
void addCell(initializer_list<int_8 > l) {
if (l.size() == 2) {
listCell.emplace_back( shared_ptr<Cell > (new Line(l)) );
// //listCell.emplace_back(shared_ptr<Cell > (new Line(tmp)) );
} else if (l.size() == 3) {
// //listCell.emplace_back(shared_ptr<Cell > (new Tri(tmp)) );
} else if (l.size() == 4) {
listCell.emplace_back( shared_ptr<Cell > (new Quad(l)) );
} else if (l.size() == 8) {
//listCell.emplace_back( shared_ptr<Cell > (new Hexa(tmp)) );
} else {
cout << "Cell type not understood!"<<endl;
exit(1);
}
nCellSize += l.size() + 1;
auto c = *(listCell.rbegin());
c->id = listCell.size()-1;
c->grid = this;
c->assignCelltoNode();
for (auto v: listVar) {
if (v->loc == 0) {
v->data.push_back(0);
v->data.uncompress();
}
}
c->masterx.resize(levelHighBound[0]+1, false);
c->mastery.resize(levelHighBound[1]+1, false);
c->masterz.resize(levelHighBound[2]+1, false);
}
vector<size_t> &suffixArray(const string &str) {
n = str.size();
result.resize(n);
group.resize(n);
tmp.resize(n);
S = max(MAX, n + 1);
cnt.resize(S);
fill(cnt.begin(), cnt.end(), 0);
for (size_t i = 0; i < n; i++) cnt[group[i] = size_t(str[i])]++;
for (size_t i = 1; i < S && cnt[i - 1] != n; i++) cnt[i] += cnt[i - 1];
for (size_t i = 0; i < n; i++) result[--cnt[group[i]]] = i;
group[result[0]] = 1;
for (size_t i = 1; i < n; i++) group[result[i]] = str[result[i]] == str[result[i - 1]] ? group[result[i - 1]] : i + 1;
fill(cnt.begin(), cnt.end(), 0);
group.emplace_back(0);
tmp.emplace_back(0);
for (size_t t = 1; t < n; t *= 2) {
size_t prev = 0;
for (size_t here = 0; here < n; here++) {
if (group[result[prev]] != group[result[here]]) {
bucketSort(prev, here, t);
prev = here;
}
cnt[getGroup(result[here] + t)]++;
}
bucketSort(prev, n, t);
}
return result;
}
void HDCluster::reportHierarchy(
int& clusterCnt,
vector<int>& nodeMembership, // The clusterid of the immediate parent for each point
vector<double>& lambdas,
vector<int>& clusterParent,
vector<bool>& clusterSelected,
vector<double>& clusterStability,
vector<double>& lambdaBirth,
vector<double>& lambdaDeath,
const int parentCluster) const {
int thisCluster = clusterCnt++;
std::for_each(fallenPoints.begin(), fallenPoints.end(),
[&nodeMembership, &lambdas, &thisCluster](const std::pair<arma::uword, double>& it) {
nodeMembership[it.first] = thisCluster;
lambdas[it.first] = it.second;
});
clusterParent.emplace_back(parentCluster);
clusterSelected.push_back(selected);
clusterStability.emplace_back(stability);
lambdaBirth.emplace_back(lambda_birth);
lambdaDeath.emplace_back(lambda_death);
if (left != nullptr) left->reportHierarchy(clusterCnt, nodeMembership, lambdas,
clusterParent, clusterSelected, clusterStability, lambdaBirth, lambdaDeath, thisCluster);
if (right != nullptr) right->reportHierarchy(clusterCnt, nodeMembership, lambdas,
clusterParent, clusterSelected, clusterStability, lambdaBirth, lambdaDeath, thisCluster);
}
// Convert Infix to Postfix Expression.
void infixToPostfix(vector<string>& infix, vector<string>& postfix) {
stack<string> s;
for (auto tok : infix) {
// Any number would be pushed into stack.
if (atoi(tok.c_str())) {
postfix.emplace_back(tok);
} else if (tok == "(") {
s.emplace(tok);
} else if (tok == ")") {
// Meet ")", then pop until "(".
while (!s.empty()) {
tok = s.top();
s.pop();
if (tok == "(") {
break;
}
postfix.emplace_back(tok);
}
} else {
// Order of tokens in stack should be like "(-*",
// The token will be added in an strictly increasing precedence order.
while (!s.empty() && precedence(tok) <= precedence(s.top())) {
postfix.emplace_back(s.top());
s.pop();
}
s.emplace(tok);
}
}
// Pop the remaining token and add them to the postfix.
while (!s.empty()) {
postfix.emplace_back(s.top());
s.pop();
}
}
int main() {
//Get primes
sieve.set();
sieve[0] = sieve[1] = 0;
for(int i=4;i<MAXM;i+=2)
sieve.reset(i);
primes.emplace_back(2);
for(int i=3;i*i<=MAXN;i+=2)
if(sieve.test(i))
for(int j=i*i;j<MAXN;j+=i)
sieve.reset(j);
//Push into vector
for(int i=3;i<MAXN;i+=2)
if(sieve[i])
primes.emplace_back(i);
scanf("%d%d", &N, &M);
for(int i=1;i<=M;i++)
scanf("%d", cost + i);
dp[0][0] = 1;
for(int i=1;i<=M;i++)
for(int p:primes)
for(int j=p*cost[i];j<MAXN;j++)
if(dp[i-1][j-p*cost[i]])
dp[i].set(j);
for(int p:primes) {
if(p > N) break;
if(dp[M][p])
return puts("its primetime"), 0;
}
puts("not primetime");
}
string gen_anydegree(vector<Edge<uint64_t>>& edges, bool undirected, size_t N, size_t D)
{
std::vector<uint64_t> powA(D + 1);
std::vector<uint64_t> coef(D);
for (size_t p = 0; p <= D; p++) {
powA[p] = static_cast<uint64_t>(pow(N,p));
}
edges.reserve((undirected ? 2 : 1) *D * static_cast<uint64_t>(pow(N, D)));
for (uint64_t i = 0; i < static_cast<uint64_t>(pow(N, D)); i++) {
uint64_t tmp = i;
for (uint64_t p = 0; p < D; p++) {
coef[p] = tmp % N;
tmp /= N;
}
for (uint64_t p = 0; p < D; p++) {
if (coef[p] < N-1) {
edges.emplace_back(i, i + powA[p]);
} else {
edges.emplace_back((i + powA[p]) - powA[p+1], i);
}
}
}
return file_name("degree", D, N);
}
string gen_mesh(vector<Edge<uint64_t>>& edges, bool undirected, size_t H, size_t W)
{
size_t increment = undirected ? 2 : 1;
size_t edge_count = 0;
for (size_t n = 0; n < 2; n++) {
edges.reserve(edge_count);
for (size_t j = 0; j < H; j++) {
for (size_t i = 0; i < W; i++) {
if (i < W-1) {
if (n) {
edges.emplace_back(j*W+i, j*W+i+1);
if (undirected) edges.emplace_back(j*W+i+1, j*W+i);
} else edge_count += increment;
}
if (j < H-1) {
if (n) {
edges.emplace_back(j*W+i, (j+1)*W+i);
if (undirected) edges.emplace_back((j+1)*W+i, j*W+i);
} else edge_count += increment;
}
}
}
}
return file_name("mesh", H, W);
}
void Grid::RetrieveSitesInCell(vector<SiteValue>& result, int col, int row,
int x1, int y1, int x2, int y2, int tq) {
auto p_bucket = get_mutable_instance().grid[col][row].get(); {
lock_guard<mutex>{g_mutex[col][row]};
g_reader[col][row] += 1;
for (int i = p_bucket->current_ - 1; i >= 0; i--) {
auto site = p_bucket->sites_[i].Value();
if (site.x >= x1 && site.x <= x2
&& site.y >= y1 && site.y <= y2
&& (site.tu >= tq || site.tu >= tq))
result.emplace_back(p_bucket->sites_[i].Value());
}
}
p_bucket = p_bucket->next_.get();
while (p_bucket) {
for (int i = p_bucket->current_ - 1; i >= 0; i--) {
auto site = p_bucket->sites_[i].Value();
if (site.x >= x1 && site.x <= x2
&& site.y >= y1 && site.y <= y2
&& (site.tu >= tq || -site.tu >= tq))
result.emplace_back(p_bucket->sites_[i].Value());
}
p_bucket = p_bucket->next_.get();
}
g_reader[col][row] -= 1;
}
// a[start] <= b[start]
void MergeIntersectSkylines(vector<vector<int>>& merged, vector<int>& a, int& a_idx,
vector<int>& b, int& b_idx) {
if (a[end] <= b[end]) {
if (a[height] > b[height]) { // |aaa|
if (b[end] != a[end]) { // |abb|b
b[start] = a[end];
merged.emplace_back(move(a)), ++a_idx;
} else { // aaa
++b_idx; // abb
}
} else if (a[height] == b[height]) { // abb
b[start] = a[start], ++a_idx; // abb
} else { // a[height] < b[height].
if (a[start] != b[start]) { // bb
merged.emplace_back(move(vector<int>{a[start], b[start], a[height]})); // |a|bb
}
++a_idx;
}
} else { // a[end] > b[end].
if (a[height] >= b[height]) { // aaaa
++b_idx; // abba
} else {
// |bb|
// |a||bb|a
if (a[start] != b[start]) {
merged.emplace_back(move(vector<int>{a[start], b[start], a[height]}));
}
a[start] = b[end];
merged.emplace_back(move(b)), ++b_idx;
}
}
}
void prepare(){
go_is_god(1, 1);
vec.emplace_back(0);
for (set<int>::iterator it = st.begin(); it != st.end(); it++) {
vec.emplace_back(*it);
mp[*it] = (int)vec.size()-1;
}
fac[0] = 1;
for (int i = 1; i <= 19; i++) {
wildcard[i] = wildcard[i-1] * 10ULL + 9;
fac[i] = wildcard[i]+1;
}
dp[1][0][1] = 1;
for (int i = 1; i <= 9; i++) {
dp[1][i][mp[i]] = 1;
}
for (int i = 1; i <= 18; i++) {
for (int j = 0; j <= 2520; j++) {
for (int k = 1; k <= 48; k++) {
if(!dp[i][j][k]) continue;
for (int l = 0; l <= 9; l++) {
int nv = (j * 10 + l)%2520;
int nlcm = vec[k];
if(l) nlcm = lcm(nlcm, l);
dp[i+1][nv][mp[nlcm]] += dp[i][j][k];
}
}
}
}
}
int add(int u, int v, LL cap) {
int idx = edges.size();
g[u].push_back(idx);
edges.emplace_back(u, v, cap);
g[v].push_back(idx ^ 1);
edges.emplace_back(v, u, 0);
return idx;
}
void bilou_ner::recognize(const vector<string_piece>& forms, vector<named_entity>& entities) const {
entities.clear();
if (forms.empty() || !tagger || !named_entities.size() || !networks.size()) return;
// Acquire cache
cache* c = caches.pop();
if (!c) c = new cache();
auto& sentence = c->sentence;
// Tag
tagger->tag(forms, sentence);
if (sentence.size) {
sentence.clear_previous_stage();
// Perform required NER stages
for (auto&& network : networks) {
sentence.clear_features();
sentence.clear_probabilities_local_filled();
// Compute per-sentence feature templates
templates.process_sentence(sentence, c->string_buffer);
// Sequentially classify sentence words
for (unsigned i = 0; i < sentence.size; i++) {
if (!sentence.probabilities[i].local_filled) {
network.classify(sentence.features[i], c->outcomes, c->network_buffer);
fill_bilou_probabilities(c->outcomes, sentence.probabilities[i].local);
sentence.probabilities[i].local_filled = true;
}
if (i == 0) {
sentence.probabilities[i].global.init(sentence.probabilities[i].local);
} else {
sentence.probabilities[i].global.update(sentence.probabilities[i].local, sentence.probabilities[i - 1].global);
}
}
sentence.compute_best_decoding();
sentence.fill_previous_stage();
}
// Store entities in the output array
for (unsigned i = 0; i < sentence.size; i++)
if (sentence.probabilities[i].global.best == bilou_type_U) {
entities.emplace_back(i, 1, named_entities.name(sentence.probabilities[i].global.bilou[bilou_type_U].entity));
} else if (sentence.probabilities[i].global.best == bilou_type_B) {
unsigned start = i++;
while (i < sentence.size && sentence.probabilities[i].global.best != bilou_type_L) i++;
entities.emplace_back(start, i - start + (i < sentence.size), named_entities.name(sentence.probabilities[start].global.bilou[bilou_type_B].entity));
}
// Process the entities
templates.process_entities(sentence, entities, c->entities_buffer);
}
caches.push(c);
}
Problem(Count num_plants, const vector<int>& ps, const vector<int>& rs) {
this->num_plants = num_plants;
for (auto i = 0; i < ps.size(); i += 2) {
points.emplace_back(ps[i], ps[i+1]);
}
for (auto i = 0; i < rs.size(); i += 2) {
roots.emplace_back(rs[i], rs[i+1]);
}
}
void PhaseEnumerationLeafInner
( PhaseEnumerationCache<Field>& cache,
const PhaseEnumerationCtrl& ctrl,
vector<pair<Int,Field>>& y,
const Int beg,
const Int baseInf,
const Int baseOne )
{
EL_DEBUG_CSE
const Int n = ctrl.phaseOffsets.back();
const Int minInf = ctrl.minInfNorms.back();
const Int maxInf = ctrl.maxInfNorms.back();
const Int minOne = ctrl.minOneNorms.back();
const Int maxOne = ctrl.maxOneNorms.back();
const bool constrained = (y.size() == 0);
SpiralState<Field> spiral;
spiral.Initialize( constrained );
while( true )
{
const Field beta = spiral.Step();
const Int betaInf = Int(MaxAbs(beta));
const Int betaOne = Int(OneAbs(beta));
const Int newInf = Max(betaInf,baseInf);
const Int newOne = betaOne + baseOne;
if( newInf > maxInf || newOne > maxOne )
break;
if( newOne >= minOne && newInf >= minInf )
{
for( Int i=beg; i<n; ++i )
{
if( ctrl.enqueueProb >= 1. ||
SampleUniform<double>(0,1) <= ctrl.enqueueProb )
{
y.emplace_back( i, beta );
cache.Enqueue( y );
y.pop_back();
}
}
}
if( newOne < maxOne )
{
// We can insert beta into any position and still have room
// left for the one norm bound, so do so and then recurse
for( Int i=beg; i<n-1; ++i )
{
y.emplace_back( i, beta );
PhaseEnumerationLeafInner
( cache, ctrl, y, i+1, newInf, newOne );
y.pop_back();
}
}
}
}
void split(const string& text, char sep, vector<string>& tokens) {
tokens.clear();
if (text.empty()) return;
string::size_type index = 0;
for (string::size_type next; (next = text.find(sep, index)) != string::npos; index = next + 1)
tokens.emplace_back(text, index, next - index);
tokens.emplace_back(text, index);
}
void push_pair(int_8 i, T v) {
auto it = std::find(ind.begin(), ind.end(), i);
if (it == ind.end()) {
ind.emplace_back(i);
val.emplace_back(v);
} else {
auto i = it - ind.begin();
val[i] += v;
}
}
string gen_star(vector<Edge<uint64_t>>& edges, bool undirected, size_t N)
{
edges.reserve(undirected ? 2*N : N);
for (size_t i = 0; i < N; i++) {
edges.emplace_back(0, i+1);
if (undirected) edges.emplace_back(i+1, 0);
}
return file_name("star", N);
}
void helpF(const vector<int>& nums, int idx, vector<int>& res, vector<vector<int>>& ret) {
if (res.size() > 1) ret.emplace_back(res);
unordered_set<int> hash;
for (int i = idx ; i < nums.size() ; ++i) {
if ((!res.empty() && nums.at(i) < res.back()) || hash.find(nums.at(i)) != hash.end()) continue;
res.emplace_back(nums.at(i));
hash.emplace(nums.at(i));
helpF(nums, i+1, res, ret);
res.pop_back();
}
}
string gen_chain(vector<Edge<uint64_t>>& edges, bool undirected, size_t N)
{
edges.reserve(undirected ? 2*N : N);
for (uint64_t i = 0; i < N; i++) {
edges.emplace_back(i, i+1);
if (undirected) edges.emplace_back(i+1, i);
}
return file_name("chain", N);
}
void split_string(string const &k, string const &delim, vector<string> &output)
{
// Due to the use of strpbrk here, this will stop copying at a null char. This is in fact desirable.
char const *last_ptr = k.c_str(), *next_ptr;
while ((next_ptr = strpbrk(last_ptr, delim.c_str())) != nullptr)
{
output.emplace_back(last_ptr, next_ptr - last_ptr);
last_ptr = next_ptr + 1;
}
output.emplace_back(last_ptr);
}
Entity& createEntity(string name){
Entity* entity = new Entity(name, this);
if (!iterating){
unique_ptr<Entity> uniqueEntityPtr{ entity };
entities.emplace_back(move(uniqueEntityPtr));
} else {
queuedEntities.emplace_back(entity);
}
zOrderChanged = true;
return *entity;
}
/*
FILE *fin = freopen("input.txt","r",stdin);
FILE *fout = freopen("output.txt","w",stdout);
*/
int main()
{
int n;
si(n);
for(int i=0; i<n-1; i++)
{
int u,v; si(u); si(v); u--; v--;
Ed[i].u = u;
Ed[i].v = v;
si(Ed[i].w);
fE[u].PB(v); fE[v].PB(u);
}
D[0] = 0; tm_ = 0;
dfs(0,0);
TT.emplace_back(0);
for(int i=0; i<n; i++)
TT[0].insert(i);
for(int i=0; i<n-1; i++)
{
int edge_id; si(edge_id); edge_id--;
int u,v; u = Ed[edge_id].u; v = Ed[edge_id].v; int w = Ed[edge_id].w;
int idx = mT[u];
//assert(idx == mT[v]);
int tp = ((LL)TT[idx].a * w + (LL)TT[idx].b) % mod;
printf("%d\n",tp);
fflush(stdout);
// trace(i,idx,w,tp);
if(D[u]>D[v])swap(u,v);
E[u].erase(v);
int sub_tree = query_range(TT[idx].root, IN[v], OUT[v]);
int rem_tree = TT[idx].n - sub_tree;
int root = v;
if(rem_tree < sub_tree)
{
root = TT[idx].root_node;
TT[idx].root_node = v;
}
TT.emplace_back(root);
TT[TT.size()-1].a = TT[idx].a;
TT[TT.size()-1].b = TT[idx].b;
remove_dfs(root, idx, TT.size() - 1);
int i1 = idx; int i2 = TT.size() - 1;
// for(auto &c : TT)
// trace(c.root_node, c.n, c.a, c.b);
if(TT[i1].n > TT[i2].n or (TT[i1].n == TT[i2].n and *(TT[i2].nodes.begin()) < *(TT[i1].nodes.begin()) )) swap(i2,i1);
// trace(i,i1,i2);
swap(i1,i2);
TT[i2].b = (TT[i2].b * (LL)tp) % mod;
TT[i2].a = (TT[i2].a * (LL)tp) % mod;
TT[i1].b = (TT[i1].b + (LL)tp) % mod;
}
return 0;
}
inline size_t insertWord(const string &str) {
const auto &ret = wordMapper.find(str);
if (ret == wordMapper.end()) {
graph.emplace_back();
revGraph.emplace_back();
wordMapper[str] = words.size();
words.emplace_back(str);
return words.size() - 1;
}
else return ret->second;
}
void GetMonitors(vector<MonitorInfo> &monitors)
{
xcb_connection_t* xcb_conn;
monitors.clear();
xcb_conn = xcb_connect(NULL, NULL);
bool use_xinerama = false;
if (xcb_get_extension_data(xcb_conn, &xcb_xinerama_id)->present) {
xcb_xinerama_is_active_cookie_t xinerama_cookie;
xcb_xinerama_is_active_reply_t* xinerama_reply = NULL;
xinerama_cookie = xcb_xinerama_is_active(xcb_conn);
xinerama_reply = xcb_xinerama_is_active_reply(xcb_conn,
xinerama_cookie, NULL);
if (xinerama_reply && xinerama_reply->state != 0)
use_xinerama = true;
free(xinerama_reply);
}
if (use_xinerama) {
xcb_xinerama_query_screens_cookie_t screens_cookie;
xcb_xinerama_query_screens_reply_t* screens_reply = NULL;
xcb_xinerama_screen_info_iterator_t iter;
screens_cookie = xcb_xinerama_query_screens(xcb_conn);
screens_reply = xcb_xinerama_query_screens_reply(xcb_conn,
screens_cookie, NULL);
iter = xcb_xinerama_query_screens_screen_info_iterator(
screens_reply);
for(; iter.rem; xcb_xinerama_screen_info_next(&iter)) {
monitors.emplace_back(iter.data->x_org,
iter.data->y_org,
iter.data->width,
iter.data->height);
}
free(screens_reply);
} else {
// no xinerama so fall back to basic x11 calls
xcb_screen_iterator_t iter;
iter = xcb_setup_roots_iterator(xcb_get_setup(xcb_conn));
for(; iter.rem; xcb_screen_next(&iter)) {
monitors.emplace_back(0,0,iter.data->width_in_pixels,
iter.data->height_in_pixels);
}
}
xcb_disconnect(xcb_conn);
}
void combinationSum3(const int k, const int n, int pathSum, vector<int> &path,
vector<vector<int>> &result) {
if (path.size() == k && pathSum == n) {
result.emplace_back(path);
} else if (path.size() < k && pathSum < n) {
int start = path.empty() ? 1 : path.back() + 1;
for (int idx = start; idx <= 9; ++idx) {
path.emplace_back(idx);
combinationSum3(k, n, pathSum + idx, path, result);
path.pop_back();
}
}
}
bool compute() {
int W, N, D;
cin >> W >> N >> D;
if (W == 0) {
return false;
}
vector<bool> isSacred(N);
for (int i = 0; i < D; i++) {
int divider;
cin >> divider;
if (!isSacred[divider]) {
for (int j = 0; j < N; j += divider) {
isSacred[j] = true;
}
}
}
vector<int> dividers;
for (int i = 0; i < N; i++) {
if (isSacred[i]) {
dividers.emplace_back(i);
}
}
int n = dividers.size();
if (n <= W) {
cout << 2000.0 << '\n';
return true;
}
chordLengthCache.clear();
chordLengthCache.resize(N / 2 + 1);
partialSums.clear();
partialSums.reserve(n * 2);
partialSums.emplace_back(0);
double sum = 0;
for (int i = 0; i < n - 1; i++) {
sum += getChordLength(dividers[i + 1] - dividers[i], N);
partialSums.emplace_back(sum);
}
sum += getChordLength(N - dividers.back(), N);
partialSums.emplace_back(sum);
for (int i = 0; i < n - 1; i++) {
sum += getChordLength(dividers[i + 1] - dividers[i], N);
partialSums.emplace_back(sum);
}
double best = numeric_limits<double>::max();
for (int i = 0; i < n && best >= partialSums[i]; i++) {
compute(&partialSums[i], n, W);
best = min(best, distances[n - 1]);
}
cout << (2 + best) * 1000 << '\n';
return true;
}
void parse(vector<pair<int, int>>& v, const string& str)
{
auto f = [](const auto& str) {
return make_pair(stoi(str.substr(1)) - 1, str[0] - 'A');
};
auto g = [&](const auto& str) {
int idx = str.find(':');
if(idx == -1)
{
v.emplace_back(f(str));
}
else
{
const auto& a = f(str.substr(0, idx));
const auto& b = f(str.substr(idx + 1));
for(int i = a.first; i <= b.first; ++i)
{
for(int j = a.second; j <= b.second; ++j)
{
v.emplace_back(make_pair(i, j));
}
}
}
};
if(str.find(',') == -1)
{
g(str);
return;
}
int startIdx = -1;
for(int i = 0, n = str.size(); i < n; ++i)
{
if(str[i] == '"')
{
if(startIdx == -1)
{
startIdx = i;
}
else
{
const auto& s = str.substr(startIdx, i - startIdx - 1);
g(s);
startIdx = -1;
}
}
}
}
