int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); int n, m, i = 0; while(cin >> n){ v.clear(); inc.clear(); topo.clear(); order.clear(); string line, line2; while(n--){ //read all nodes cin >> line; v[line]; inc[line] = 0; order[line] = n; } cin >> m; while(m--){ //read vertex cin >> line >> line2; v[line].push_back(line2); ++inc[line2]; } topo_sort(); //prints answer cout << "Case #" << ++i << ": Dilbert should drink beverages in this order:"; for(auto &a: topo) cout << " " << a; cout << ".\n\n"; } return 0; }
int main(){ string input; while(cin>>input){ char c1 = input[0], c2 = input[2]; adjacency[c1].push_back(c2); } for(int i = 65; i < 91; i++){ to_print = false; complete.clear(); visited.clear(); char terminal = ';'; char start = i; if(!visited[start]){ if(cycle_found(start)&&to_print){ incycle.push_back(start); //cout<<start<<' '; break; } } } sort(incycle.begin(), incycle.end()); for(int i = 0; i < incycle.size(); i++){ cout<<incycle[i]<<' '; } }
int main(){ cout << setprecision(6)<<fixed; int t; cin >> t; set<int> s; map<int, int> convert; while(t--){ dm.clear(); dc.clear(); s.clear(); convert.clear(); cin >> n; double f, fa; for(int k=0;k<n;k++){ f=(double)k/(double)(n-1.0); fa=f; alpha[k]=0; for(int i=0;i<1000;i++){ alpha[k] +=fa; fa *=f; } } for(int k=0;k<(n*n);k++){ f=(double)k/(double)((n*n)); fa=f; beta[k]=0; for(int i=0;i<1000;i++){ beta[k] +=fa; fa *=f; } } for(int i=0;i<n;i++){ cin >> a[i]; s.insert(a[i]); } int p = 0; for(auto k: s){ if(convert.find(k) == convert.end()){ convert[k] = p; } p++; } int m=0; for(int i=0;i<n;i++){ a[i] = convert[a[i]]; m = setm(m,i,a[i]); } cout<<"Monty "<<M(m)<<" Carlos "<<C(m)<<endl; } }
void solve(int start, string &s, vector<string> &words) { //m stores info, m1 stores current info unordered_map<string, int>::iterator it; int p1 = start, p2 = start, len = words[0].length(), cur = 0; m1.clear(); while(p2 + len - 1 < s.length()) { while(cur != m.size() && p2 + len - 1 < s.length()) { string tmp = s.substr(p2, len); it = m.find(tmp); if(it == m.end()) { p2 += len; p1 = p2; cur = 0; m1.clear(); continue; } else if(it->second == m1[tmp]) { string tmp2 = ""; while(p1 != p2 && tmp2 != tmp) { tmp2 = s.substr(p1, len); if(m1.find(tmp2) != m1.end()) { if(m1[tmp2] == m[tmp2]) cur--; m1[tmp2]--; } p1 += len; } continue; } m1[tmp]++; if(it->second == m1[tmp]) cur++; p2 += len; } while(cur == m.size() && p1 <= p2) { ans.push_back(p1); string tmp = s.substr(p1, len); it = m1.find(tmp); if(it == m1.end()) { p1 += len; continue; } it->second--; if(it->second < m[tmp]) cur--; p1 += len; } } }
int maxPathSum(TreeNode *root){ if(root == NULL) return 0; pathSum.clear(); nodeSum.clear(); dfs(root); return dfsMax(root); }
void gao_TF_IDF(char * dim_items_txt){ fstream item_values_file(dim_items_txt); // for item's value int tot = 0, now = 0; // get item's value vector -------- LL item, cat; string values_string; double st = clock(); while(item_values_file >> item >> cat >> values_string){ assert(item < M); if (now++ % SHOW == 0) cerr<<"now:\t"<<now<<"\titem:\t"<<item<<"\tcat\t"<<cat<<"\tvs\t"<<values_string<<endl; vector<LL> values; stringstream ss(values_string); LL val; char douhao; while(ss >> val){ ss >> douhao; assert(douhao == ',' || douhao == '\n'); values.push_back(val); item_value_times[item][val]++; } if ((now - 1) % SHOW == 0){ for (int i = 0; i < values.size(); i++) cerr<<" "<<values[i]; cerr<<"\n"; } sort(values.begin(), values.end()); //values.erase(unique(values.begin(), values.end()), values.end()); int sz = unique(values.begin(), values.end()) - values.begin(); for (int i = 0; i < sz; i++){ // must unique for idf value_times[values[i]]++; } item_values[item] = values; item_cat[item] = cat; cat_items[cat].push_back(item); tot++; } now = 0; for (unordered_map<LL, vector<LL> >::iterator it = item_values.begin(); it != item_values.end(); it++){ LL item = it->first; vector<LL> & v = it->second; if (now++ % SHOW == 0) cerr<<"now:\t"<<now<<"\titem:\t"<<item<<"\tvaluesize:\t"<<v.size()<<endl; vector<PDL> res; sort(v.begin(), v.end()); int sz = unique(v.begin(), v.end()) - v.begin(); int words = v.size(); for (int i = 0; i < sz; i++){ LL val = v[i]; double tf = item_value_times[item][val] * 1.0 / words; double idf = log(tot * 1.0 / (1 + value_times[val])); res.push_back(PDL(tf * idf, val)); if ((now - 1) % SHOW == 0) { cerr<<"tf-idf = "<<tf*idf<<"\tval = "<<val<<endl; } } item_vector[item] = res; item_vector_len[item] = len(res); } cout<<"get item's vector over, time use:\t"<<(clock() - st) / CLOCKS_PER_SEC<<"\n"; item_value_times.clear(); value_times.clear(); }
UndirectedGraphNode *cloneGraph(UndirectedGraphNode *node) { if (node == NULL) return NULL; dfs(node); visit.clear(); dfs2(node); visit.clear(); UndirectedGraphNode * result = node->neighbors[(int)node->neighbors.size() - 1]; dfs3(node); return result; }
bool canCross(vector<int> &stones) { if (stones.size() == 1) return true; if (stones[1] - stones[0] != 1) return false; s.clear(), m.clear(); for (int i = 0; i < stones.size(); i++) s[stones[i]] = i; return helper(stones, 1, 1); }
/** Initialize your data structure here. */ AllOne() { Str2Num.clear(); Num2Strs.clear(); Num2Iter.clear(); ListNum.clear(); ListNum.push_back(0); Num2Iter[0] = ListNum.begin(); }
void StatsSender::SendStats(unordered_map<unsigned int, unsigned __int64> pickedItems, unordered_map<int, int> timers){ _pickedItems = pickedItems; _timers = timers; pickedItems.clear(); timers.clear(); HANDLE h = CreateThread(NULL, 0, StaticThreadStart2, (void*) this, 0, 0); }
int main() { int tests; int citiesN; int relationsN; int paths; string name; cin >> tests; for (int t = 0; t < tests; t++) { cityId.clear(); graph.clear(); cin >> citiesN; for(int c = 1; c <= citiesN; c++) { distances[c] = infinity; emptyDistances[c] = infinity; city city; cin >> city.name; graph[c] = city; cityId[city.name] = c; cin >> relationsN; for(int r = 0; r < relationsN; r++) { way way1; cin >> way1.destination >> way1.cost; graph[c].adjacent.push_back(way1); way way2 = way1; way2.destination = c; graph[way2.destination].adjacent.push_back(way2); } } cin >> paths; for (int p = 0; p < paths; p++) { string source, destination; cin >> source >> destination; distances = emptyDistances; fill(visited.begin(), visited.end(), false); dijkstra(cityId[source], cityId[destination]); cout << distances[cityId[destination]] << endl; } } return 0; }
int main() { // freopen("in.txt","r",stdin); string name,party,club; char ins[100],*ptr; int TC,tmp,ans; TC = atoi(gets(ins)); gets(ins); while(TC--) { name_set.clear(); party_set.clear(); club_set.clear(); memset(graph,0,sizeof(graph)); N = 1; while(gets(ins) && strlen(ins)) { ptr = strtok(ins," "); name = string(ptr); ptr = strtok(NULL," "); party = string(ptr); graph[get(name_set,name)][get(party_set,party)] = 1; while(ptr = strtok(NULL," ")) { club = string(ptr); graph[source()][get(club_set,club)] = 1; graph[get(club_set,club)][get(name_set,name)] = 1; } } tmp = (club_set.size() - 1) / 2; for(unordered_map<string,int>::iterator it = party_set.begin();it != party_set.end();it++) graph[it->second][target()] = tmp; ans = 0; visited.reset(); while(tmp = maxflow(source(),INT_MAX)) { ans += tmp; visited.reset(); } if(ans != club_set.size()) printf("Impossible.\n"); else for(unordered_map<string,int>::iterator it_name = name_set.begin();it_name != name_set.end();it_name++) for(unordered_map<string,int>::iterator it_club = club_set.begin();it_club != club_set.end();it_club++) if(graph[it_name->second][it_club->second]) { printf("%s %s\n",(it_name->first).c_str(),(it_club->first).c_str()); break; } if(TC) printf("\n"); } return 0; }
int main() { ios_base::sync_with_stdio(false); bool first = true; int n; while (cin >> n) { if (first) first = false; else cout << '\n'; Buys buy_orders(buy_cmp); Sells sell_orders(sell_cmp); for (auto i = 1; i <= n; ++i) { string cmd; cin >> cmd; if (cmd[0] == 'B') process_incoming(buy_orders, sell_orders, i); else if (cmd[0] == 'S') process_incoming(sell_orders, buy_orders, i); else // cancel order { int ci; cin >> ci; if (!gone.count(ci)) { if (b_seq2iter.count(ci)) { auto &it = b_seq2iter[ci]; price2size[it->price] -= it->size; buy_orders.erase(it); } else { auto &it = s_seq2iter[ci]; price2size[it->price] -= it->size; sell_orders.erase(it); } gone.insert(ci); } } print_quote(buy_orders, sell_orders); } price2size.clear(); b_seq2iter.clear(); s_seq2iter.clear(); gone.clear(); } return 0; }
int minMalwareSpread(vector<vector<int>>& graph, vector<int>& initial) { int n = graph.size(); parent.clear(); count.clear(); for(int i = 0; i < n; ++i) { parent[i] = i; count[i] = 1; } vector<int> visited(n, false); for(int i = 0; i < n; ++i) { for(int j = 0; j < n; ++j) { if(graph[i][j]) { int pi = findParent(i); int pj = findParent(j); if(pi != pj) { parent[pi] = pj; count[pj] += count[pi]; } } } } sort(initial.begin(), initial.end()); map<int, vector<int>> m; for(int i : initial) { m[findParent(i)].push_back(i); } int minCount = 0; int minIdx = initial[0]; for(const auto& p : m) { if(p.second.size() == 1) { if(count[p.first] > minCount) { minCount = count[p.first]; minIdx = p.second[0]; } } } return minIdx; }
/* * Main method to call the prefix generation * @Params A - Vector of strings */ vector<string> Solution::prefix(vector<string> &A) { // create a empty vector for results vector<string> result; // clear the global hashmap res.clear(); // return empty vector in case A is empty if(A.size() == 0) return result; // Generate the prefix tree Node* Tree = new Node("*"); for(int i = 0; i < A.size(); i++) { Tree->insertChild(A[i]); } // Traverse the tree to generate hashmap // Not needed if the order of prefix isn't important traverse(Tree, ""); // generate ordered result from hashmap for(int i = 0; i < A.size(); i++) { result.push_back(res[A[i]]); } return result; }
// Does one scan iteration. Returns a tuple containing the total number of // iterations done and left to do for the current scan. static PyObject *py_iter(PyObject *self, PyObject *args) { static int cur_iter; if (!cur_iter) cg_idle_mem_stat.clear(); long start_pfn = cur_iter * iter_span; long end_pfn = start_pfn + iter_span; if (end_pfn >= END_PFN) end_pfn = END_PFN; int iters_left = (END_PFN - end_pfn + iter_span - 1) / iter_span; cur_iter++; try { open_files(); count_idle_pages(start_pfn, end_pfn); set_idle_pages(start_pfn, end_pfn); } catch (error &e) { e.set_py_err(); return NULL; } PyObject *ret = Py_BuildValue("(ii)", cur_iter, iters_left); if (!ret) return PyErr_NoMemory(); if (iters_left == 0) cur_iter = 0; return ret; }
const vector<ProfilerDataPoint>& ProfilerGetAccumulatedStatistics() { static vector<ProfilerDataPoint> statistics; static unordered_map<DataPointKey, size_t> index; statistics.clear(); index.clear(); for (const auto& dataPoint : profileData) { auto key = DataPointKey { dataPoint.filename, dataPoint.line }; auto indexEntryIter = index.find(key); if (indexEntryIter == index.end()) { index[key] = statistics.size(); statistics.push_back(dataPoint); } else { auto& accumulatedStatistics = statistics[indexEntryIter->second]; assert(accumulatedStatistics.filename == dataPoint.filename); assert(accumulatedStatistics.line == dataPoint.line); assert(accumulatedStatistics.id == dataPoint.id); accumulatedStatistics.duration += dataPoint.duration; accumulatedStatistics.hitCount += dataPoint.hitCount; } } return statistics; }
/*Inititalize an LRU cache with size N */ LRUCache::LRUCache(int N) { ::cap = N; head = NULL; last = NULL; m.clear(); }
// discrete-logarithm, finding y for equation k = x^y % mod int discrete_logarithm(int x, int mod, int k) { if (mod == 1) return 0; int s = 1, g; for (int i = 0; i < 64; ++i) { if (s == k) return i; s = (1ll * s * x) % mod; } while ((g = gcd(x, mod)) != 1) { if (k % g) return -1; mod /= g; } static unordered_map<int, int> M; M.clear(); int q = int(sqrt(double(euler(mod)))) + 1; // mod-1 is also okay for (int i = 0, b = 1; i < q; ++i) { if (M.find(b) == M.end()) M[b] = i; b = (1ll * b * x) % mod; } int p = fpow(x, q, mod); for (int i = 0, b = 1; i <= q; ++i) { int v = (1ll * k * inverse(b, mod)) % mod; if (M.find(v) != M.end()) { int y = i * q + M[v]; if (y >= 64) return y; } b = (1ll * b * p) % mod; } return -1; }
int main(void){ for(int g, p; scanf("%d %d", &p, &g) == 2; ){ char comp[32], word[32]; m.clear(); for(int v1, v2; p-- && scanf("%s %d.%d", word, &v1, &v2) == 3; ) m[word] = v1*10 + v2; for(int gn = 0, v; gn++ < g; ){ int correct, sum = 0; while(true){ scanf("%s %s", word, comp); sum += m[word]; if(*comp == '+') continue; scanf("%d", &v); v *= 10; if(*comp == '<'){ if(*(comp + 1) == '=') correct = sum <= v; else correct = sum < v; } else if(*comp == '>'){ if(*(comp + 1) == '=') correct = sum >= v; else correct = sum > v; } else correct = sum == v; printf("Guess #%d was %s.\n", gn, correct ? "correct" : "incorrect"); sum = 0; break; } } } return 0; }
~PartFileCollection() { for (auto it = files.begin(); it != files.end(); ++it) { delete it->second; } files.clear(); }
int main() { /* #ifndef ONLINE_JUDGE freopen ("in.txt" , "r" , stdin); freopen ("out.txt" , "w" , stdout); #endif */ int n, m; while(cin>>n>>m) { hasht.clear(), L.clear(); for(int i=n;i>=1;i--) L.push_front(i), hasht[i]=L.begin(); for(int i=0;i<m;i++) { int x, y;string ins; cin>>ins>>x>>y; if(ins=="A") MoveLeft(x, y); else MoveRight(x, y); } for(auto e: L) cout<<e<<" "; cout<<endl; } return 0; }
~PartFile() { for (auto it = parts.begin(); it != parts.end(); ++it) { delete it->second; } parts.clear(); }
int main(){ int ts;cin>>ts; for(int i=1;i<=ts;i++){ cout<<"Case #"<<i<<":\n"; id.clear(); m.clear(); // cout<<id.size()<<" "<<m.size()<<endl; for(int i=0;i<10;i++){ string add;cin>>add; int n;cin>>n; int id=GI(add); m[id]+=n; } int mx=0; for(auto i:m){ mx=max(mx,i.Y); } vector<pair<int,string>> anss; for(auto i:m){ if(i.Y==mx){ auto rt=GN(i.X); anss.push_back({rt.Y,rt.X}); } } sort(anss.begin(),anss.end()); for(auto i:anss){ cout<<i.Y<<endl; } } }
int solution(vector<int> &A){ int res = 0; if (A.size() == 0) { return res; } n = 0; dict.clear(); for (int i = 0; i < A.size(); ++ i) { if (dict.find(A[i]) == dict.end()) dict[A[i]] = n ++; if (i == 0) { s = dict[A[i]]; }else if(i == A.size() - 1){ t = dict[A[i]]; } } init(); for (int i = 0; i < A.size() - 1; ++ i) { addedge(dict[A[i]], dict[A[i + 1]], 1); addedge(dict[A[i + 1]], dict[A[i]], 1); } if (s == t) { return 1; } dijk(); res = dist[t] + 1; return res; }
LRUCache(int capacity) { size = capacity; mem.resize(capacity, 0); addr.clear(), time.clear(); memIdx = 0; miss = 0; }
float lof_storage::collect_lrds_from_neighbors( const vector<pair<string, float> >& neighbors, unordered_map<string, float>& neighbor_lrd) const { if (neighbors.empty()) { return numeric_limits<float>::infinity(); } // collect lrd values of the nearest neighbors neighbor_lrd.clear(); for (size_t i = 0; i < neighbors.size(); ++i) { neighbor_lrd[neighbors[i].first] = get_lrd(neighbors[i].first); } // return lrd of the query float sum_reachability = 0; for (size_t i = 0; i < neighbors.size(); ++i) { sum_reachability += max(neighbors[i].second, get_kdist(neighbors[i].first)); } if (sum_reachability == 0) { return numeric_limits<float>::infinity(); } return neighbors.size() / sum_reachability; }
int main() { int T; scanf("%d",&T); while (T --) { scanf("%d",&n); int f, s, m = 0; dict.clear(); memset(vis, 0, sizeof(vis)); for (int i = 0; i < n; ++ i) { scanf("%d%d",&f,&s); if (dict.find(f) == dict.end() || dict[f].find(s) == dict[f].end()) { //pnt[m].first = f; //pnt[m].second = s; pnts[m].p.first = f; pnts[m].p.second = s; pnts[m].idx = i + 1; ++ m; dict[f].insert(s); } } n = m; ans = 0; covexhull(); if (T) { puts(""); } } return 0; }
int main() { int N; make_pattern(1, vector<int>(10)); while (cin >> N, N > 0) { vector<int> m_cnt(10); for (int i = 0; i < N; i++) { int m; cin >> m; m_cnt[m]++; } int res = 0; for (int i = 1; i <= 5; i++) { int mini = min(m_cnt[i], m_cnt[10 - i]); if (i == 5) mini /= 2; res += mini; m_cnt[i] -= mini; m_cnt[10 - i] -= mini; } mem.clear(); res += solve(m_cnt); cout << res << endl; } return 0; }
void TradeList2TradeMap(list<TradeField*> &tradeList, unordered_map<string, TradeField*> &tradeMap) { // 只在这个函数中new和delete应当没有问题 for (unordered_map<string, TradeField*>::iterator it = tradeMap.begin(); it != tradeMap.end(); ++it) { TradeField* pNewField = it->second; delete[] pNewField; } tradeMap.clear(); // 将多个合约拼接成 for (list<TradeField*>::iterator it = tradeList.begin(); it != tradeList.end(); ++it) { TradeField* pField = *it; unordered_map<string, TradeField*>::iterator it2 = tradeMap.find(pField->ID); if (it2 == tradeMap.end()) { TradeField* pNewField = new TradeField; memcpy(pNewField, pField, sizeof(TradeField)); tradeMap[pField->ID] = pNewField; } else { TradeField* pNewField = it2->second; pNewField->Price = pField->Price; pNewField->Qty += pField->Qty; } } }