vector<vector<int>> subsetsWithDup(unordered_map<int, int>& mapNums) {
vector<vector<int>> ret = {{}};
vector<vector<int>> tret = {};
if(mapNums.size() == 0) return ret;
int count = (mapNums.begin())->second;
int nums = (mapNums.begin())->first;
mapNums.erase(mapNums.begin());
vector<vector<int>> tmp = subsetsWithDup(mapNums);
for(int i=0; i<count; i++) {
vector<int> t(i+1, nums);
tret.push_back(t);
}
for(auto t:tmp)
if(t.size()) ret.push_back(t);
for(auto tr:tret)
ret.push_back(tr);
for(auto tr : tret) {
for(auto t : tmp) {
if(!t.size()) continue;
vector<int> tt(tr.begin(), tr.end());
tt.insert(tt.begin(), t.begin(), t.end());
ret.push_back(tt);
}
}
return ret;
}
//更新记录
bool SqliteManager::UpdateData(sqlite3* MyDB, string tableName, unordered_map<string, string> paraInfoSTR, unordered_map<string, INT64> paraInfoINT, string condition) {
string strPara;
//字符串类型参数的拼接
unordered_map<string, string>::iterator itor1;
for (itor1 = paraInfoSTR.begin(); itor1 != paraInfoSTR.end(); itor1++)
{
strPara += itor1->first + "='" + itor1->second + "',";
}
//整型参数的拼接
unordered_map<string, INT64>::iterator itor2;
for (itor2 = paraInfoINT.begin(); itor2 != paraInfoINT.end(); itor2++)
{
char str[50];
sprintf(str, "%d", itor2->second);
string myStr(str);
strPara += itor2->first + "=" + myStr + ",";
}
//去掉最后一个逗号
strPara.erase(strPara.size() - 1, 1);
string sqlstr = "update " + tableName + " set " + strPara + " " + condition;//sql语句
//注册超时等待时间为1000ms
sqlite3_busy_timeout(MyDB, 1000);
//执行
char* errMsg;
int result = sqlite3_exec(MyDB, sqlstr.c_str(), NULL, NULL, &errMsg);
if (result != SQLITE_OK)
return false;
return true;
}
bool isTheSame2(unordered_map<char, int>&check, unordered_map<char, int>&record) {
for (auto it = check.begin(); it!=check.end(); it++){
if (it->second != record[it->first]) return false;
}
for (auto it = record.begin(); it!=record.end(); it++) {
if (it->second != check[it->first]) return false;
}
return true;
}
void RunThread2()
{
//int gameDiff = D2CLIENT_GetDifficulty();
int gameDiff = 1;
BnetData* pData = (*p_D2LAUNCH_BnData);
char* accountNameChar = pData->szAccountName;
char* charName = pData->szPlayerName; //GetCharName();
std::string accountNameCharString(accountNameChar);
std::string charNameCharString(charName);
string jsonData = "{\"data\":{\"AccountName\":\"" + accountNameCharString + "\",\"CharName\":\"" + charNameCharString + "\",";
jsonData += "\"GameDiff\":\"" + std::to_string(gameDiff) + "\",\"CompressedData\":[";
unordered_map<unsigned int, unsigned __int64>::const_iterator it;
for (it = _pickedItems.begin(); it != _pickedItems.end(); it++) {
jsonData += "{\"ItemKey\":\"" + std::to_string((*it).first) + "\", \"ItemValue\":\"" + std::to_string((*it).second) + "\"},";
}
if (_pickedItems.size() > 0) {
jsonData.pop_back(); // remove last ,
}
jsonData += "], \"Timers\":[";
unordered_map<int, int>::const_iterator it2;
for (it2 = _timers.begin(); it2 != _timers.end(); it2++) {
jsonData += "{\"LvlNo\":\"" + std::to_string((*it2).first) + "\", \"Time\":\"" + std::to_string((*it2).second) + "\"},";
}
if (_timers.size() > 0) {
jsonData.pop_back(); // remove last ,
}
jsonData += "]}}\n";
//_oldItems.clear();
//SetCharName(""); // will be reset in core loop the f**k is this
DWORD dwWrite, dwRead;
bool flg = WriteFile(hPipe, jsonData.c_str(), jsonData.size(), &dwWrite, NULL);
}
routing_table* setup(char routerName)
{
routing_table* ret = new routing_table();
ifstream infile;
infile.open(portFile);
if (infile.fail())complain("cannot open " + portFile);
string line;
while (!infile.eof())
{
getline(infile, line);
if (!line.empty())
{
int p = line.find("=", 0);
if (p<0)complain("malformed " + portFile);
ports.insert(pair<char, int>(line[0], atoi(line.substr(p + 1).c_str())));
}
}
infile.close();
infile.open(linkFile);
if (infile.fail())complain("cannot open " + linkFile);
while (!infile.eof())
{
getline(infile, line);
if (!line.empty() && tolower(line[0]) == tolower(routerName))
{
vector<string> output = split(line, ",");
int o, d;
unordered_map<char, int>::iterator i;
for (i = ports.begin(); i != ports.end(); i++)
{
if (tolower(i->first) == tolower(routerName))
{
o = i->second;
break;
}
}
if (i == ports.end())complain("bad configuration files");
for (i = ports.begin(); i != ports.end(); i++)
{
if (tolower(i->first) == tolower(output[1][0]))
{
d = i->second;
break;
}
}
if (i == ports.end())complain("bad configuration files");
ret->insert(routing_entry(output[1][0], atoi(output[2].c_str()), o, d));
}
}
infile.close();
return ret;
}
unordered_map<long,long> operator+(unordered_map<long,long> x,unordered_map<long,long>y)
{
unordered_map<long,long> result;
for(auto i=x.begin();i!=x.end();++i)
result[i->first]=x[i->first];
for(auto i=y.begin();i!=y.end();++i)
result[i->first]+=y[i->first];
return result;
}
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;
}
~trieNode() {
auto node = children.begin();
while(node != children.end()) {
delete node->second;
node = children.erase(node);
}
}
void VectorFactorsExtractor::Initialize(
int _numberOfLabels, int _numberOfFeatures,
int _numberOfCliques,
const unordered_map<int, unordered_set<int> >& cliquePossibleFeatures)
{
numberOfLabels = _numberOfLabels;
numberOfFeatures = _numberOfFeatures;
numberOfCliques = _numberOfCliques;
cliqueFeatureConverter.resize(numberOfCliques);
dimension = 2 * numberOfLabels + numberOfCliques;
// Iterate over cliques
int enumerator = 0;
for (auto cliqueIterator = cliquePossibleFeatures.begin();
cliqueIterator != cliquePossibleFeatures.end();
++cliqueIterator)
{
unordered_map<int, int> featureToPositionInVector;
const unordered_set<int>& possibleFeatures =
cliqueIterator->second;
// Find positions in vector for features in clique
for (auto featureIterator = possibleFeatures.begin();
featureIterator != possibleFeatures.end();
++featureIterator)
{
featureToPositionInVector[*featureIterator] =
dimension;
++dimension;
}
cliqueFeatureConverter[cliqueIterator->first] =
std::move(featureToPositionInVector);
++enumerator;
printf("\rEvaluated %d cliques", enumerator);
}
}
void printGraph(){
queue<node*> list;
list.push(&graph.at("Quinn"));
while(!list.empty()){
node*n = list.front();
list.pop();
for(node* n2 : n->neighbours){
if(n2->visited == false){
list.push(n2);
n2->depth=(n->depth+1);
n2->visited = true;
}
}
}
vector<string> vec;
for(auto ele = graph.begin(); ele != graph.end(); ++ele){
string s = "";
if(ele->second.depth < 0)
s = ele->first + " uncool";
else
s= ele->first + " " + to_string(ele->second.depth);
vec.push_back(s);
}
sort(vec.begin(),vec.end());
for(string ele : vec)
cout << ele <<endl;
}
int main()
{
freopen("mirror.in","r",stdin);
freopen("mirror.out","w",stdout);
READ(N), READ(M), READ(K);
for (int i=1;i<=K;i++)
{
int x, y;
READ(x), READ(y);
INS(x-1,y-1,SE), INS(x-1,y,SW), INS(x,y,NW), INS(x,y-1,NE);
}
for (int i=1;i<M;i++) INS(0,i,NE|NW), INS(N,i,SE|SW);
for (int i=1;i<N;i++) INS(i,0,NW|SW), INS(i,M,NE|SE);
INS(0,0,SW|NW|NE), INS(0,M,NW|NE|SE);
INS(N,0,NW|SW|SE), INS(N,M,SW|SE|NE);
for (unordered_map<long long,int>::iterator i=S.begin(); i!=S.end(); i++)
{
int x=i->fi/(M+1), y=i->fi%(M+1);
A[oA(x,y)].insert(oB(x,y));
B[oB(x,y)].insert(oA(x,y));
}
int X, Y, D;
char s[3];
scanf("%d%d%s",&X,&Y,s);
D=(s[0]=='N' && s[1]=='E'? NE: s[0]=='S' && s[1]=='E'? SE: s[0]=='S' && s[1]=='W'? SW: NW);
if (D==NW? GO(X-1,Y-1,D): D==NE? GO(X-1,Y,D): D==SE? GO(X,Y,D): GO(X,Y-1,D))
{
ans++, D=L(D,2);
D==NW? GO(X-1,Y-1,D): D==NE? GO(X-1,Y,D): D==SE? GO(X,Y,D): GO(X,Y-1,D);
}
printf("%lld\n",ans);
return 0;
}
void save_help_wanted(fstream& lbfile)
{
save_primitive<int>(lbfile, ai_detail::next_job_id);
save_primitive<int>(lbfile, jobs_board.size());
for (auto it = jobs_board.begin(); it != jobs_board.end(); ++it)
{
save_primitive<int>(lbfile, it->second.type);
save_primitive<int>(lbfile, it->second.job_id);
save_primitive<uint8_t>(lbfile, it->second.current_step);
save_primitive<int>(lbfile, it->second.assigned_to);
save_primitive<int>(lbfile, it->second.steps.size());
for (auto steps = it->second.steps.begin();
steps != it->second.steps.end(); ++steps)
{
save_primitive<int>(lbfile, steps->type);
save_primitive<int16_t>(lbfile, steps->target_x);
save_primitive<int16_t>(lbfile, steps->target_y);
save_primitive<uint8_t>(lbfile, steps->target_z);
save_primitive<int>(lbfile, steps->component_id);
save_primitive<bool>(lbfile, steps->requires_skill);
save_primitive<string>(lbfile, steps->skill_name);
save_primitive<int>(lbfile, steps->placeholder_structure_id);
save_primitive<char>(lbfile, steps->required_skill_difficulty);
}
}
}
void CSingleUser::CompareTradeMapAndEmit(unordered_map<string, TradeField*> &oldMap, unordered_map<string, TradeField*> &newMap)
{
for (unordered_map<string, TradeField*>::iterator it = newMap.begin(); it != newMap.end(); ++it)
{
TradeField* pNewField = it->second;
unordered_map<string, TradeField*>::iterator it2 = oldMap.find(pNewField->ID);
if (it2 == oldMap.end())
{
// 没找到,是新单
m_msgQueue->Input_Copy(ResponeType::ResponeType_OnRtnTrade, m_msgQueue, m_pClass, 0, 0, pNewField, sizeof(TradeField), nullptr, 0, nullptr, 0);
}
else
{
TradeField* pOldField = it2->second;
int Qty = pNewField->Qty - pOldField->Qty;
if (Qty > 0)
{
// 有变化的单
TradeField* pField = new TradeField;
memcpy(pField, pNewField, sizeof(TradeField));
pField->Qty = Qty;
m_msgQueue->Input_Copy(ResponeType::ResponeType_OnRtnTrade, m_msgQueue, m_pClass, 0, 0, pNewField, sizeof(TradeField), nullptr, 0, nullptr, 0);
delete[] pField;
}
}
}
}
~PartFile()
{
for (auto it = parts.begin(); it != parts.end(); ++it) {
delete it->second;
}
parts.clear();
}
~PartFileCollection()
{
for (auto it = files.begin(); it != files.end(); ++it) {
delete it->second;
}
files.clear();
}
void printMap(const unordered_map<string, int>& myMap)
{
for (auto iter = myMap.begin(); iter != myMap.end(); iter++) {
cout << iter->first << ": " << iter->second << endl;
}
cout << "-----" << endl;
}
//从构造好的树中挖掘频繁项集
void FPTree::mineTree(string &prefix, unordered_map<string,int> &frequent)
{
//头指针列表head中存储的实际是单频繁项。根据项值和计数值构造节点，插入到集合
//不同于建树时，此时是按照计数值从低到高顺序排序
vector<node> key_count;
for (auto iter = head.begin(); iter != head.end(); ++iter)
key_count.emplace_back(node(iter->first, iter->second->count));
sort(key_count.begin(), key_count.end(), node::comparer::less());
for (auto iter = key_count.begin(); iter != key_count.end(); ++iter)
{//对于每一个单频繁项
prefix.append(iter->key);
frequent.emplace(prefix + ')',iter->count); //发现一个频繁项
unordered_map<string, int> subdata;
//以当前单频繁项为尾，在树中上溯挖掘条件基，也就是在已出现prefix的情况下挖掘记录
findPrefixPath(iter->key, subdata);
FPTree subtree(eps);
subtree.create(subdata); //根据挖掘到的记录构造的子数据集创建子FP树，以用于挖掘更复杂的频繁项
if (!subtree.empty())
{//如果树不空，即存在更复杂的频繁项
prefix += ' ';//用于分隔记录项
subtree.mineTree(prefix, frequent); //继续递归挖掘
prefix.pop_back(); //删除空格
}
int index = prefix.rfind(' ');
if (index == string::npos) prefix.resize(1); //删除iter->key
else prefix.resize(index + 1);
}
}
int numSimilarGroups(vector<string>& A) {
int res = 0;
unordered_map<string,string> ancestors;
for(int i=0; i<A.size(); ++i)
{
auto lhs_anc_iter = ancestors.find(A[i]);
for(int j=i+1; j<A.size(); ++j)
{
if(isgroup(A[i], A[j]))
{
if (lhs_anc_iter!=ancestors.end()) {
group[lhs_anc_iter->second].insert(A[j]);
ancestors[A[j]]=lhs_anc_iter->second;
}
else {
auto rhs_anc_iter = ancestors.find(A[j]);
if (rhs_anc_iter!=ancestors.end()) {
group[rhs_anc_iter->second].insert(A[i]);
ancestors[A[i]]=rhs_anc_iter->second;
}
else {
group[A[i]].insert(A[j]);
ancestors[A[j]] = A[i];
}
}
}
}
if (group.find(A[i])==group.end() && ancestors.find(A[i]) == ancestors.end())
{
++res;
//output(A[i] + "\n");
}
}
// merge groups
int merge_cnt = 0;
while(group.size()>1) {
merge_cnt =0;
for(auto iter: group)
{
auto& vec = iter.second;
for(auto wd: vec)
{
if (mergegroup(iter.first, wd))
merge_cnt++;
}
}
for(auto iter=group.begin(); iter!=group.end();)
{
if(iter->second.empty()) iter = group.erase(iter);
else ++iter;
}
if(merge_cnt==0 )
break;
}
return res + group.size();
}
/**
* The basic destcutor that shall remove all the jobs
*/
virtual ~session_data_struct() {
//Just iterate through the map and delete all the jobs
//Note that there is no need to remove the jobs from mappings
for (auto iter = m_jobs.begin(); iter != m_jobs.end(); ++iter) {
delete iter->second;
}
}
/*
* Call a function (with signature void(entity *) on each
* entity.
*/
void for_each(std::function<void(entity *)> func)
{
for (auto it = entities.begin(); it != entities.end(); ++it)
{
func(&it->second);
}
}
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;
}
}
}
/*
every node has its own backoff value calculated by randomly picking a number between 0 and R
in each iteration of the loop, nodes backoff values are decremented
but cant decrement until channel is checked, can use a global flag for this
once a node reaches 0, it can begin transmission by setting the channel flag
other nodes wont decrement in this iteration is the flag is set
once that node is done with its transmitting, it resets channel flag and gets new random backoff
next iteration both can countdown since flag not set
need to simulate collisions? and count how many packets are properly transmitted
every time there is a collision need to do 2 things
R is doubled for every collision unless next value is specified in input file
1. increment global collision count by 1, this is the "total number of collisions"
2. increment local collision count of each colliding node. at end of simulation
the local collision counts are used to compute the variance in number of collisions across all nodes
need to be careful with orderering, dont decrement A if B is going to set flag in same iteration
*/
void decrement_all_backoffs(){
for(auto it = nodes.begin(); it != nodes.end(); ++it){
Node *gdbnode = it->second;
int gdbnodekey = it->first;
it->second->backoff--;
}
}
Move move() {
auto element = max_element(next_.begin(), next_.end(), [](const auto& a, const auto& b){
return a.second->n_ < b.second->n_;
});
return element->first;
}
void get_frame_stamps(unordered_map< uint64, Matrix4f>& map_rot_stamps, list< uint64>& list){
unordered_map< uint64, Matrix4f>::iterator it;
for (it = map_rot_stamps.begin(); it != map_rot_stamps.end(); it++) {
list.push_back(it->first);
}
list.sort();
}
void get_frame_idx_vector(unordered_map< int, Matrix4f>& mapRots, list< int>& list){
unordered_map< int, Matrix4f>::iterator it;
for (it = mapRots.begin(); it != mapRots.end(); it++) {
list.push_back(it->first);
}
list.sort();
}
int findStart(unordered_map<char, deque<int>>& map) {
int st = INT_MAX;
for (unordered_map<char, deque<int>>::iterator it = map.begin(); it != map.end(); ++it) {
st = min(st, it->second[0]);
}
return st;
}
void getResults(){
//calculate variances
double transmission_var, collision_var;
vector<int> trandata, coll_data;
for(auto it = nodes.begin(); it != nodes.end(); ++it){
trandata.push_back(it->second->transcount);
coll_data.push_back(it->second->collision_count);
}
transmission_var = calc_variance(trandata);
collision_var = calc_variance(coll_data);
ofstream outfile;
outfile.open("output.txt");
//printf("Channel Used: %ld\n", channel_utilization);
//printf("Channel Idle: %ld\n", channel_idle);
//printf("Channel collision time: %ld\n", collision_time);
double collis_perc = ((double) collision_time / (double) T) * 100.0;
//printf("Channel collision fraction: %f\n", collis_perc);
outfile << "Channel utilization: " << ((double) channel_utilization / (double) T) * 100.0 << "%\n";
outfile << "Channel idle fraction: " << ((double) channel_idle / (double) T) * 100.0 << "%\n";
outfile << "Total number of collisions: " << totalcollisions << "\n";
outfile << "Variance in number of successful transmissions: " << transmission_var << "\n";
outfile << "Variance in number of collisions: " << collision_var << "\n";
outfile.close();
//debugging functions to check calculations
printNodes();
//printData(trandata, "transmissions.txt");
//printData(coll_data, "collisions.txt");
}
bool check_loop_valid(vector< map< uint64_t, uint64_t> >& mapLoops,
unordered_map< uint64_t, Matrix4f>& rotStamps) {
//校验是不是rot中包含了loop对应的stamp
for (int i = 0; i < mapLoops.size(); i++) {
map< uint64_t, uint64_t> loop = mapLoops[i];
bool isFindStart = false, isFindEnd = false;
for (unordered_map< uint64_t, Matrix4f>::iterator it = rotStamps.begin();
it != rotStamps.end(); it++) {
if (it->first == loop.begin()->first) {
isFindStart = true;
}
if (it->first == loop.begin()->second) {
isFindEnd = true;
}
if (isFindStart && isFindEnd) {
break;
}
}
if (isFindStart && isFindEnd) {
} else {
cout << "error ... rot empty stamp not valid." << loop.begin()->first << " "
<< loop.begin()->second << endl;
return false;
}
}
return true;
}
void perm(vector<int> &vi) {
vector<int> path;
perm(vi, path, 0);
for(unordered_map<string, vector<int> >::iterator it = m.begin(); it != m.end(); it++) {
show((*it).second);
}
}
void Permonkey::Classify(unordered_map<string, vector<string>> objList){
pair<string, string> nameType;
for (auto i = objList.begin(); i != objList.end(); ++i){
for (int j = 0; j < i->second.size(); j++){
if (i->first == preference){
nameType.first = i->first;
nameType.second = i->second[j];
preferredObjects.emplace_back(nameType);
}
else{
if (i->first != "None"){
nameType.first = i->first;
nameType.second = i->second[j];
otherObjects.emplace_back(nameType);
}
else{
lastGoal.first = i->first;
lastGoal.second = i->second[j];
}
}
}
}
for (int i = 0; i < 3; i++)
ChooseGoals();
for (int i = 0; i < goals.size(); i++){
//cout << goals[i].first << " : " << goals[i].second << endl;
}
}
