void WED_Select::GetSelectionSet(set<ISelectable *>& sel) const { sel.clear(); for (set<int>::const_iterator i = mSelected.begin(); i != mSelected.end(); ++i) sel.insert(FetchPeer(*i)); }
bool CreatePosTx(const CBlockIndex *pPrevIndex, CBlock *pBlock, set<CKeyID>&setCreateKey, CAccountViewCache &view, CTransactionDBCache &txCache, CScriptDBViewCache &scriptCache) { set<CKeyID> setKeyID; setKeyID.clear(); set<CAccount, CAccountComparator> setAcctInfo; { LOCK2(cs_main, pwalletMain->cs_wallet); if((unsigned int)(chainActive.Tip()->nHeight + 1) != pBlock->GetHeight()) return false; pwalletMain->GetKeys(setKeyID, true); // first:get keyID from pwalletMain if (setKeyID.empty()) { return ERRORMSG("CreatePosTx setKeyID empty"); } LogPrint("INFO","CreatePosTx block time:%d\n", pBlock->GetTime()); for(const auto &keyid:setKeyID) { //second:get account by keyID //find CAccount info by keyid if(setCreateKey.size()) { bool bfind = false; for(auto &item: setCreateKey){ if(item == keyid){ bfind = true; break; } } if (!bfind) continue; } CUserID userId = keyid; CAccount acctInfo; if (view.GetAccount(userId, acctInfo)) { // check acctInfo is or not allowed to mining , //available // LogPrint("miner", "account info:regid=%s keyid=%s ncoinday=%lld isMiner=%d\n", acctInfo.regID.ToString(), // acctInfo.keyID.ToString(), acctInfo.GetAccountPos(pBlock->nHeight), acctInfo.IsMiner(pBlock->nHeight)); if (acctInfo.IsRegister() && acctInfo.GetAccountPos(pBlock->GetHeight()) > 0 && acctInfo.IsMiner(pBlock->GetHeight())) { setAcctInfo.insert(std::move(acctInfo)); // LogPrint("miner", "miner account info:%s\n", acctInfo.ToString()); } } } } if (setAcctInfo.empty()) { setCreateKey.clear(); LogPrint("INFO", "CreatePosTx setSecureAcc empty"); return false; } uint64_t maxNonce = SysCfg().GetBlockMaxNonce(); //cacul times uint256 prevblockhash = pPrevIndex->GetBlockHash(); const uint256 targetHash = CBigNum().SetCompact(pBlock->GetBits()).getuint256(); //target hash difficult set<CAccount, CAccountComparator>::iterator iterAcct = setAcctInfo.begin(); for (;iterAcct!=setAcctInfo.end();++iterAcct) { //third: 根据不同的账户 ,去计算挖矿 CAccount &item = const_cast<CAccount&>(*iterAcct); uint64_t posacc = item.GetAccountPos(pBlock->GetHeight()); if (0 == posacc) { //have no pos LogPrint("ERROR", "CreatePosTx posacc zero\n"); continue; } LogPrint("miner", "miner account:%s\n", item.ToString()); // LogPrint("INFO", "target hash:%s\n", targetHash.ToString()); // LogPrint("INFO", "posacc:%d\n", posacc); uint256 adjusthash = GetAdjustHash(targetHash, posacc, pBlock->GetHeight()-1); //adjust nbits // LogPrint("INFO", "adjusthash:%s\n", adjusthash.ToString()); //need compute this block proofofwork struct PosTxInfo postxinfo; postxinfo.nVersion = pBlock->GetVersion(); postxinfo.hashPrevBlock = prevblockhash; postxinfo.hashMerkleRoot = item.GetHash(); postxinfo.nValues = item.llValues; postxinfo.nHeight = pBlock->GetHeight(); postxinfo.nFuel = pBlock->GetFuel(); postxinfo.nFuelRate = pBlock->GetFuelRate(); postxinfo.nTime = pBlock->GetTime(); //max(pPrevIndex->GetMedianTimePast() + 1, GetAdjustedTime()); unsigned int nNonce = 0; for (; nNonce < maxNonce; ++nNonce) { //循环的 更改随机数,计算curhash看是否满足 postxinfo.nNonce = nNonce; pBlock->SetNonce(nNonce); uint256 curhash = postxinfo.GetHash(); if (UintToArith256(curhash) <= UintToArith256(adjusthash)) { CRegID regid; if (pAccountViewTip->GetRegId(item.keyID, regid)) { CRewardTransaction *prtx = (CRewardTransaction *) pBlock->vptx[0].get(); prtx->account = regid; //存矿工的 账户ID prtx->nHeight = pPrevIndex->nHeight+1; pBlock->SetHashMerkleRoot(pBlock->BuildMerkleTree()); pBlock->SetHashPos(curhash); LogPrint("INFO", "find pos tx hash succeed: \n" " pos hash:%s \n" "adjust hash:%s \r\n", curhash.GetHex(), adjusthash.GetHex()); vector<unsigned char> vSign; if (pwalletMain->Sign(item.keyID, pBlock->SignatureHash(), vSign, item.MinerPKey.IsValid())) { LogPrint("INFO", "Create new block hash:%s\n", pBlock->GetHash().GetHex()); LogPrint("miner", "Miner account info:%s\n", item.ToString()); LogPrint("miner", "CreatePosTx block hash:%s, postxinfo:%s\n",pBlock->GetHash().GetHex(), postxinfo.ToString().c_str()); pBlock->SetSignature(vSign); return true; } else { LogPrint("ERROR", "sign fail\r\n"); } } else { LogPrint("ERROR", "GetKey fail or GetVec6 fail\r\n"); } } } } return false; }
void drillDown( boost::filesystem::path root, bool use_db, bool use_coll, bool oplogReplayLimit, bool top_level=false) { bool json_metadata = false; LOG(2) << "drillDown: " << root.string() << endl; // skip hidden files and directories if (root.leaf()[0] == '.' && root.leaf() != ".") return; if ( is_directory( root ) ) { boost::filesystem::directory_iterator end; boost::filesystem::directory_iterator i(root); boost::filesystem::path indexes; while ( i != end ) { boost::filesystem::path p = *i; i++; if (use_db) { if (boost::filesystem::is_directory(p)) { error() << "ERROR: root directory must be a dump of a single database" << endl; error() << " when specifying a db name with --db" << endl; printHelp(cout); return; } } if (use_coll) { if (boost::filesystem::is_directory(p) || i != end) { error() << "ERROR: root directory must be a dump of a single collection" << endl; error() << " when specifying a collection name with --collection" << endl; printHelp(cout); return; } } // don't insert oplog if (top_level && !use_db && p.leaf() == "oplog.bson") continue; if ( p.leaf() == "system.indexes.bson" ) { indexes = p; } else { drillDown(p, use_db, use_coll, oplogReplayLimit); } } if (!indexes.empty() && !json_metadata) { drillDown(indexes, use_db, use_coll, oplogReplayLimit); } return; } if ( endsWith( root.string().c_str() , ".metadata.json" ) ) { // Metadata files are handled when the corresponding .bson file is handled return; } if ( ! ( endsWith( root.string().c_str() , ".bson" ) || endsWith( root.string().c_str() , ".bin" ) ) ) { error() << "don't know what to do with file [" << root.string() << "]" << endl; return; } log() << root.string() << endl; if ( root.leaf() == "system.profile.bson" ) { log() << "\t skipping" << endl; return; } string ns; if (use_db) { ns += _db; } else { string dir = root.branch_path().string(); if ( dir.find( "/" ) == string::npos ) ns += dir; else ns += dir.substr( dir.find_last_of( "/" ) + 1 ); if ( ns.size() == 0 ) ns = "test"; } verify( ns.size() ); string oldCollName = root.leaf(); // Name of the collection that was dumped from oldCollName = oldCollName.substr( 0 , oldCollName.find_last_of( "." ) ); if (use_coll) { ns += "." + _coll; } else { ns += "." + oldCollName; } if (oplogReplayLimit) { error() << "The oplogLimit option cannot be used if " << "normal databases/collections exist in the dump directory." << endl; exit(EXIT_FAILURE); } log() << "\tgoing into namespace [" << ns << "]" << endl; if ( _drop ) { if (root.leaf() != "system.users.bson" ) { log() << "\t dropping" << endl; conn().dropCollection( ns ); } else { // Create map of the users currently in the DB BSONObj fields = BSON("user" << 1); scoped_ptr<DBClientCursor> cursor(conn().query(ns, Query(), 0, 0, &fields)); while (cursor->more()) { BSONObj user = cursor->next(); _users.insert(user["user"].String()); } } } BSONObj metadataObject; if (_restoreOptions || _restoreIndexes) { boost::filesystem::path metadataFile = (root.branch_path() / (oldCollName + ".metadata.json")); if (!boost::filesystem::exists(metadataFile.string())) { // This is fine because dumps from before 2.1 won't have a metadata file, just print a warning. // System collections shouldn't have metadata so don't warn if that file is missing. if (!startsWith(metadataFile.leaf(), "system.")) { log() << metadataFile.string() << " not found. Skipping." << endl; } } else { metadataObject = parseMetadataFile(metadataFile.string()); } } _curns = ns.c_str(); _curdb = NamespaceString(_curns).db; _curcoll = NamespaceString(_curns).coll; // If drop is not used, warn if the collection exists. if (!_drop) { scoped_ptr<DBClientCursor> cursor(conn().query(_curdb + ".system.namespaces", Query(BSON("name" << ns)))); if (cursor->more()) { // collection already exists show warning warning() << "Restoring to " << ns << " without dropping. Restored data " "will be inserted without raising errors; check your server log" << endl; } } if (_restoreOptions && metadataObject.hasField("options")) { // Try to create collection with given options createCollectionWithOptions(metadataObject["options"].Obj()); } processFile( root ); if (_drop && root.leaf() == "system.users.bson") { // Delete any users that used to exist but weren't in the dump file for (set<string>::iterator it = _users.begin(); it != _users.end(); ++it) { BSONObj userMatch = BSON("user" << *it); conn().remove(ns, Query(userMatch)); } _users.clear(); } if (_restoreIndexes && metadataObject.hasField("indexes")) { vector<BSONElement> indexes = metadataObject["indexes"].Array(); for (vector<BSONElement>::iterator it = indexes.begin(); it != indexes.end(); ++it) { createIndex((*it).Obj(), false); } } }
int ask(int s, int t) { st.clear(); dfs(s, t, 0ll); return st.size(); }
void ClassConfigInfo::getLegNStart(int leg, set<int> &sel) const { if (size_t(leg) < legNStart.size() && !legNStart[leg].empty()) sel.insert(legNStart[leg].begin(), legNStart[leg].end()); else sel.clear(); }
int main () { #ifdef hasibpc read("input.txt"); //write("output.txt"); #endif // hasibpc int kases; ll A, B, C; sf("%d", &kases); while(kases--) { sf("%d", &N); v.clear(); s.clear(); loop(i, N) { sf("%lld %lld %lld", &A, &B, &C); if( B == 0 ) { ll g = __gcd(A, C); //vdump(A); //vdump(C); //vdump(g); s.insert(MP(A/g, C/g)); } else { ll g1 = __gcd(A, B); ll g2 = __gcd(C, B); //vdump(g2); v.pb(MP(MP(A/g1, B/g1), MP(C/g2, B/g2)) ); } } sort(all(v)); //vdump(v); int mxCnt = SZ(s); int tmpCnt = 0; loop(i, SZ(v)) { if(i == 0) { tmpCnt = 1; } else { if(v[i].fr == v[i-1].fr) { if(v[i].sc != v[i-1].sc) { tmpCnt++; } } else { mxCnt = max(mxCnt, tmpCnt); tmpCnt = 1; } } } mxCnt = max(mxCnt, tmpCnt); pf("%d\n", mxCnt); }
GC() { frame_list.push_front(&frame); heap_list.clear(); heap_num = 0; heap_max = 8; }
void solve() { nodes.clear(); for (int i = 1; i <= n; i++) color[i] = plain; dfs(1); }
void init() { memset(node,'\0',sizeof(node)); memset(order,'\0',sizeof(order)); set_result.clear(); }
void init_lookup_table() { vis.clear(); }
void myGraph::subPathes(set<int> &preNodeSet, vector<vector<int>> &Edge_t, set<int>& nodeSet, vector<int> &nodeRanks) { float maxlength=-100000; int maxid=-1; vector<vector<vector<int>>> maxPath; bool haveHead=false; set<int> headSet, endSet; for(int i=0; i<Edge_t.size(); i++) { headSet.insert(Edge_t[i][0]); endSet.insert(Edge_t[i][1]); } for(set<int>::iterator it=nodeSet.begin(); it!=nodeSet.end(); it++) { int start=*it; if(headSet.find(start)!=headSet.end() && endSet.find(start)==endSet.end()) //a top node { int length; vector<vector<vector<int>>> path = getShortestPath(start, length, Edge_t); //edgeSet, nodeSet); if(length > maxlength) { maxlength = length; maxid = start; maxPath=path; } haveHead=true; } } if(!haveHead) for(set<int>::iterator it=nodeSet.begin(); it!=nodeSet.end(); it++) { int start=*it; { int length; vector<vector<vector<int>>> path = getShortestPath(start, length, Edge_t); //edgeSet[sid], nodeSet); if(length > maxlength) { maxlength = length; maxid = start; maxPath=path; } haveHead=true; } } //initial rank //get the rank by redo the shortest path search for the minimal span tree //Graph initG; vector<vector<int>> Edge_i=maxPath[0]; for(int k=0; k<Edge_i.size(); k++) { //if(Edge[k][0]==etemp[0] || Edge[k][1]==etemp[1]) //add_edge(maxPath[k][0], maxPath[k][1], 1, initG); Edge_i[k].push_back(1); } int length; vector<vector<vector<int>>> initPath = getShortestPath(maxid, length, Edge_i);//, edgeSet[sid], nodeSet); //iniPath should have rank info vector<int> nodeRanks_t(nodeRanks.size(),20000); nodeRanks_t[maxid]=0; for(int k=0; k<initPath[0].size(); k++) { int v=initPath[0][k][1], d=initPath[0][k][initPath[0][k].size()-1]; nodeRanks_t[v]=d; } if(initPath[0].size()!=Edge_i.size()) { //error } //reduce the searched graph Edge_t=maxPath[1]; for(int i=0; i<maxPath[0].size(); i++) { preNodeSet.insert(maxPath[0][i][0]); preNodeSet.insert(maxPath[0][i][1]); } if(preNodeSet.size()==nodeSet.size()) { nodeSet.clear(); } else { for(int i=0; i<Edge_t.size(); i++) { nodeSet.insert(Edge_t[i][0]); nodeSet.insert(Edge_t[i][1]); } } //reassign rank level to nodeRanks_t int markid=-1, markLevel=20000, dL=20000; for(int i=0; i<nodeRanks_t.size(); i++) { if(nodeRanks_t[i]!=20000 && nodeRanks[i]!=20000 && nodeRanks_t[i]!=nodeRanks[i]) { markid=i; dL = nodeRanks[i]-nodeRanks_t[i]; markLevel=nodeRanks_t[i]; } } if(markid>=0) for(int i=0; i<nodeRanks_t.size(); i++) { if(nodeRanks_t[i]!=20000) { nodeRanks_t[i]=nodeRanks_t[i] + dL; } } int negFlag=0; for(int i=0; i<nodeRanks.size(); i++) { if(nodeRanks[i]==20000 && nodeRanks_t[i]!=20000) { nodeRanks[i]=nodeRanks_t[i]; if(nodeRanks_t[i]<negFlag) { negFlag=nodeRanks_t[i]; } } } if( negFlag<0) { negFlag = -negFlag; for(int i=0; i<nodeRanks.size(); i++) { if(nodeRanks[i]!=20000) nodeRanks[i]= nodeRanks[i]+negFlag; } } }
//---------------------------------------------------------------------------- void VETMesh::GetTriangles (set<Triangle>& rkTSet) const { rkTSet.clear(); for (MTCIter pkT = m_kTMap.begin(); pkT != m_kTMap.end(); pkT++) rkTSet.insert(pkT->first); }
//---------------------------------------------------------------------------- void VETMesh::GetEdges (set<Edge>& rkESet) const { rkESet.clear(); for (MECIter pkE = m_kEMap.begin(); pkE != m_kEMap.end(); pkE++) rkESet.insert(pkE->first); }
//---------------------------------------------------------------------------- void VETMesh::GetVertices (set<int>& rkVSet) const { rkVSet.clear(); for (MVCIter pkV = m_kVMap.begin(); pkV != m_kVMap.end(); pkV++) rkVSet.insert(pkV->first); }
set<Func> get(Func func) { funcs.clear(); func.accept(this); return funcs; }
double solve() { queue<Node> q; vector<int> arr; Node node; UINT64 sum, k, t; int count, i, j, r, s, u, v; double w; string str, str2; visit.clear(); w = 0.0; sum = 0; count = 0; str = generateString(); for (i = 0; i < n; i++) { k = weights[i]; sum += a[k]; node.idx = i; node.w = k; str2 = str; str2[i] = '1'; node.str = str2; q.push(node); count++; } while (!q.empty()) { node = q.front(); q.pop(); i = node.idx; k = node.w; arr = node.parents; str = node.str; node.parents.push_back(i); for (j = 0; j < map[i].size(); j++) { s = map[i][j]; str2 = str; str2[s] = '1'; if (visit.find(str2) != visit.end()) continue; visit.insert(str2); t = k + weights[s]; sum += a[t]; count++; node.idx = s; node.w = t; node.str = str2; q.push(node); } node.parents.pop_back(); if (arr.size() > 0) { u = arr[ arr.size() - 1 ]; node.idx = u; node.w = k; arr.pop_back(); node.parents = arr; node.str = str; q.push(node); } } w = sum / (double)count; return w; }
int main() { int test_case; int n_elem; int max,temp; bool flags; state_t S; scanf("%d",&test_case); for( int i = 0; i < test_case; i++ ) { scanf("%d",&n_elem); for( int j = 0; j < n_elem; j++ ) { scanf("%d",&elem[j]); int_set.insert(elem[j]); } sort(elem,elem+n_elem); max = elem[n_elem-1]; flags = false; for( int j = 0; j < n_elem-1; j++ ) for( int k = j+1; (temp = elem[j]+elem[k] ) <= max; k++ ) { if( int_set.find(temp) != int_set.end() ) { printf("%d+%d=%d\n",elem[j],elem[k],temp); flags = true; } S.flags = 0; S.sum = temp; S.next = k+1; set_n(S.flags,j); set_n(S.flags,k); state.push(S); } while( state.empty() != true ) { state_t new_state; S = state.front(); state.pop(); for( int j = S.next; j < n_elem&& (temp = S.sum+elem[j]) <= max; j++ ) { new_state = S; set_n(new_state.flags,j); new_state.next = j+1; new_state.sum = temp; if( int_set.find( temp ) != int_set.end()) { print(new_state,n_elem,temp); flags = true; } state.push(new_state); } } if( flags == false ) printf("Can't find any equations.\n"); int_set.clear(); printf("\n"); } return 0; }
int main() { ios::sync_with_stdio(false); cin.tie(0); while (cin >> N) { AdjList.clear(); AdjList.resize(N + 2); visited.clear(); visited.resize(N + 2, false); heights.clear(); heights.resize(N + 2); best.clear(); worst.clear(); parent.clear(); parent.resize(N+2); for (int i = 0; i < N; i++) { cin >> num; while (num--) { int v; cin >> v; AdjList[i].push_back(--v); AdjList[v].push_back(i); } } max_height = 0; dfs(0, 0); fill(visited.begin(), visited.end(), false); parent.clear(); max_height = 0; dfs(furthest, 0); if (max_height % 2 == 0) for (int i = furthest; ; i = parent[i]) { if (heights[i] == max_height / 2) { best.push_back(i); break; } } else for (int i = furthest; ; i = parent[i]) if (heights[i] == (max_height + 1) / 2) { best.push_back(i); } else if (heights[i] == max_height / 2) { best.push_back(i); break; } sort(best.begin(), best.end()); for (int i = 0; i < best.size(); i++) { fill(visited.begin(), visited.end(), false); max_height = 0; dfs(best[i], 0); for (int j = 0; j < heights.size(); j++) if (heights[j] == max_height) worst.insert(j); } cout << "Best Roots :"; for (auto x : best) cout << ' ' << x + 1; cout << endl << "Worst Roots :"; for (auto x : worst) cout << ' ' << x + 1; cout << endl; } }
int main(){ freopen("in.txt","r",stdin); input.grabBuffer(); int a,b,e; for (int kk=1;true;++kk){ e=input.rInt(); if ( !e )return 0; int v=1; while(e-- ){ a=input.rInt(); b=input.rInt(); v=max(v,a); v=max(v,b); outarrow[a].push_back(b); outarrow[b].push_back(a); } memset( level,-1,sizeof(level)); memset( childrenCnt,0,sizeof(childrenCnt)); memset( isArtic,false,sizeof(isArtic) ); memset(vis,false,sizeof(vis)); for (int i=1;i<=v;++i){ //printf("%d %d %d\n",i,level[i],low[i]); if ( level[i]== -1 ){ level[i]=0; dfs(i); } } int tunnel=0; LL way=1; for (int i=1;i<=v;++i){ if ( isArtic[i] || vis[i] )continue; cnt=0; sset.clear(); DFS2(i); if( !sset.size() ){ if( cnt==1 ){ tunnel++; } else{ tunnel += 2; way *= (cnt*(cnt-1))/2; } }else if( sset.size()==1 ){ tunnel++; way *= cnt; } } printf("Case %d: %d %llu\n",kk,tunnel,way); for (int i=0;i<=v;++i){ outarrow[i].clear(); } } return 0; }
void recover_removed_edges() { m_stRemovedEdge.clear(); }
void constructCepts(vector < pair < set <int> , set <int> > > & ceptsInPhrase, set <int> & sourceNullWords, set <int> & targetNullWords, vector <string> & alignment, int eSize, int fSize) { ceptsInPhrase.clear(); sourceNullWords.clear(); targetNullWords.clear(); vector <int> align; std::map <int , vector <int> > sT; std::map <int , vector <int> > tS; std::set <int> eSide; std::set <int> fSide; std::set <int> :: iterator iter; std :: map <int , vector <int> > :: iterator iter2; std :: pair < set <int> , set <int> > cept; int src; int tgt; ceptsInPhrase.clear(); for (int j=0; j<alignment.size(); j+=2) { align.push_back(stringToInteger(alignment[j+1])); align.push_back(stringToInteger(alignment[j])); } for (int i = 0; i < align.size(); i+=2) { src = align[i]; tgt = align[i+1]; tS[tgt].push_back(src); sT[src].push_back(tgt); } for (int i = 0; i< fSize; i++) { if (sT.find(i) == sT.end()) { targetNullWords.insert(i); } } for (int i = 0; i< eSize; i++) { if (tS.find(i) == tS.end()) { sourceNullWords.insert(i); } } while (tS.size() != 0 && sT.size() != 0) { iter2 = tS.begin(); eSide.clear(); fSide.clear(); eSide.insert (iter2->first); getMeCepts(eSide, fSide, tS , sT); for (iter = eSide.begin(); iter != eSide.end(); iter++) { iter2 = tS.find(*iter); tS.erase(iter2); } for (iter = fSide.begin(); iter != fSide.end(); iter++) { iter2 = sT.find(*iter); sT.erase(iter2); } cept = make_pair (fSide , eSide); ceptsInPhrase.push_back(cept); } }
void recover_removed_vertices() { m_stRemovedVertexIds.clear(); }
// 读方案 void ReadOptions(LPCTSTR path) { CString strBuf; gzFile f = gzopen_w(path, "rb"); if (f == NULL) goto UseDefaultOptions; // 头部 char header[2]; gzread(f, header, sizeof(header)); if (header[0] != 'T' || header[1] != 'B') { gzclose(f); goto UseDefaultOptions; } g_optionsLock.Lock(); // 违规内容 ReadRegexTexts(f, g_keywords); // 屏蔽用户 ReadRegexTexts(f, g_blackList); // 信任用户 int intBuf; gzread(f, &intBuf, sizeof(int)); // 长度 for (int i = 0; i < intBuf; i++) { ReadText(f, strBuf); g_whiteList.insert(strBuf); } // 信任内容 ReadRegexTexts(f, g_whiteContent); gzread(f, &g_scanInterval, sizeof(int)); // 扫描间隔 gzread(f, &g_banID, sizeof(BOOL)); // 封ID gzread(f, &g_banDuration, sizeof(int)); // 封禁时长 BOOL banIP; gzread(f, &banIP, sizeof(BOOL)); // 封IP gzread(f, &g_banTrigCount, sizeof(int)); // 封禁违规次数 gzread(f, &g_onlyScanTitle, sizeof(BOOL)); // 只扫描标题 gzread(f, &g_deleteInterval, sizeof(float));// 删帖间隔 gzread(f, &g_confirm, sizeof(BOOL)); // 操作前提示 gzread(f, &g_scanPageCount, sizeof(int)); // 扫描最后页数 gzread(f, &g_briefLog, sizeof(BOOL)); // 只输出删帖封号 if (gzread(f, &g_delete, sizeof(BOOL)) != sizeof(BOOL)) // 删帖 g_delete = TRUE; if (gzread(f, &g_threadCount, sizeof(int)) != sizeof(int)) // 线程数 g_threadCount = 2; ReadText(f, g_banReason); // 封禁原因 if (!ReadText(f, g_imageDir)) // 违规图片目录 g_images.clear(); else ReadImages(g_imageDir); // 违规图片 if (gzread(f, &g_SSIMThreshold, sizeof(double)) != sizeof(double)) // 阈值 g_SSIMThreshold = 2.43; // 信任主题 g_trustedThread.clear(); if (gzread(f, &intBuf, sizeof(int)) == sizeof(int)) // 长度 for (int i = 0; i < intBuf; i++) { ReadText(f, strBuf); g_trustedThread.insert(strBuf); } if (gzread(f, &g_defriend, sizeof(BOOL)) != sizeof(BOOL)) // 拉黑 g_defriend = FALSE; if (gzread(f, &g_defriendTrigCount, sizeof(int)) != sizeof(int)) // 拉黑违规次数 g_defriendTrigCount = 5; if (gzread(f, &g_autoSaveLog, sizeof(BOOL)) != sizeof(BOOL)) // 自动保存日志 g_autoSaveLog = FALSE; g_optionsLock.Unlock(); gzclose(f); return; UseDefaultOptions: g_optionsLock.Lock(); g_keywords.clear(); // 违规内容 g_blackList.clear(); // 屏蔽用户 g_whiteList.clear(); // 信任用户 g_whiteContent.clear(); // 信任内容 g_scanInterval = 5; // 扫描间隔 g_banID = FALSE; // 封ID g_banDuration = 1; // 封禁时长 g_banTrigCount = 1; // 封禁违规次数 g_onlyScanTitle = FALSE; // 只扫描标题 g_deleteInterval = 2.0f; // 删帖间隔 g_confirm = TRUE; // 操作前提示 g_scanPageCount = 1; // 扫描最后页数 g_briefLog = FALSE; // 只输出删帖封号 g_delete = TRUE; // 删帖 g_threadCount = 2; // 线程数 g_banReason = _T(""); // 封禁原因 g_imageDir = _T(""); // 违规图片目录 g_images.clear(); // 违规图片 g_SSIMThreshold = 2.43; // 阈值 g_trustedThread.clear(); // 信任主题 g_defriend = FALSE; // 拉黑 g_defriendTrigCount = 5; // 拉黑违规次数 g_autoSaveLog = FALSE; // 自动保存日志 g_optionsLock.Unlock(); }
int main() { freopen(fname".in", "r", stdin); freopen(fname".out", "w", stdout); scanf("%d%d",&n,&m); for(i=1;i<=n;++i) { scanf("%d",&a[i]); if (a[i] == 1) a1[++a1[0]] = i; else if(a[i] == 2) a2[++a2[0]] = i; } for(i=1;i<=m;++i){ scanf("%d%d%d",&x,&y,&z); g[x].pb(mp(y,z)); g[y].pb(mp(x,z)); } if (a1[0] < a2[0]) { for (int i = 1; i <= a1[0]; i ++ ) { s.clear(); memset(d, -1, sizeof d); d[a1[i]] = 0; s.insert(mp(0, a1[i])); while (!s.empty()) { int v = s.begin() -> S; s.erase(s.begin()); for (int j = 0;j < g[v].size(); ++ j) { int to = g[v][j].F; int len = g[v][j].S; if (d[to] > d[v] + len || d[to] == -1) { s.erase(mp(d[to], to)); d[to] = d[v] + len; s.insert(mp(d[to], to)); } } } for (int j = 1; j <= a2[0]; ++ j) { if (d[a2[j]] != -1 && ans > d[a2[j]]) { ans = d[a2[j]]; x = a1[i], y = a2[j]; } } } } else { for (int i = 1; i <= a2[0]; i ++ ) { s.clear(); memset(d, -1, sizeof d); d[a2[i]] = 0; s.insert(mp(0, a2[i])); while (!s.empty()) { int v = s.begin() -> S; s.erase(s.begin()); for (int j = 0;j < g[v].size(); ++ j) { int to = g[v][j].F; int len = g[v][j].S; if (d[to] > d[v] + len || d[to] == -1) { s.erase(mp(d[to], to)); d[to] = d[v] + len; s.insert(mp(d[to], to)); } } } for (int j = 1; j <= a1[0]; ++ j) { if (d[a1[j]] != -1 && ans > d[a1[j]]) { ans = d[a1[j]]; x = a1[j], y = a2[i]; } } } } if (ans == 1000000000) cout << -1; else cout << x << " " << y << " " << ans; return 0; }
void ClassConfigInfo::getRaceNRes(int race, set<int> &sel) const { if (size_t(race) < raceNRes.size() && !raceNRes[race].empty()) sel.insert(raceNRes[race].begin(), raceNRes[race].end()); else sel.clear(); }
double find() { if (max_variants <= 0) return value; if (value < finder->best) finder->best = value; report(true); int i[3]; for(i[0] = 0; i[0] < finder->sub_division; ++i[0]) for(i[1] = 0; i[1] < finder->sub_division; ++i[1]) for(i[2] = 0; i[2] < finder->sub_division; ++i[2]) { Params p; for(int j = 0; j < 3; ++j) p.k[j] = (max.k[j] - min.k[j])/finder->sub_division*(i[j] + 0.5) + min.k[j]; finder->value(i[0], i[1], i[2]) = finder->checker.check2(p); } finder->clear_zones(); for(i[0] = 1; i[0] < finder->sub_division-1; ++i[0]) for(i[1] = 1; i[1] < finder->sub_division-1; ++i[1]) for(i[2] = 1; i[2] < finder->sub_division-1; ++i[2]) if (finder->is_local_minimum(i[0], i[1], i[2])) { Zone &z = finder->zone_for_value(i[0], i[1], i[2]); double &v = finder->value(i[0], i[1], i[2]); if (v < z.value) z.set(v, i); } for(i[0] = 0; i[0] < finder->zone_count; ++i[0]) for(i[1] = 0; i[1] < finder->zone_count; ++i[1]) for(i[2] = 0; i[2] < finder->zone_count; ++i[2]) { Zone &z = finder->zone(i[0], i[1], i[2]); if (!isinf(z.value)) { Entry sub; sub.finder = finder; sub.parent = this; sub.level = level + 1; sub.max_variants = max_variants/2; if (sub.max_variants < 1) sub.max_variants = 1; for(int j = 0; j < 3; ++j) { sub.min.k[j] = (max.k[j] - min.k[j])/finder->sub_division*(z.index[j] + 0.5 - finder->zone_size) + min.k[j]; sub.current.k[j] = (max.k[j] - min.k[j])/finder->sub_division*(z.index[j] + 0.5) + min.k[j]; sub.max.k[j] = (max.k[j] - min.k[j])/finder->sub_division*(z.index[j] + 0.5 + finder->zone_size) + min.k[j]; } sub.value = z.value; add_variant(sub); } } if (level < finder->max_level) { vector<Entry> v(variants.begin(), variants.end()); variants.clear(); for(vector<Entry>::iterator i = v.begin(); i != v.end(); ++i) { i->index = i - v.begin(); i->find(); variants.insert(*i); } } if (!variants.empty() && variants.begin()->value < value) { value = variants.begin()->value; current = variants.begin()->current; } if (value < finder->best) finder->best = value; report(false); return value; }
int main() { int k,i,ai,d,fd=99999999,fa=99999999; scanf("%d %d",&n,&k); //opt.resize(n); for(i=1; i<=n; i++) { scanf("%d",&a[i]); } for(i=1;i<=n;i++) { // cout<<"i = "<<i<<endl; if(opt[i]==true) { // cout<<"opt true\n"; continue; } else { // cout<<"opt false\n"; ai=a[i]; for(int j= i;j<=n;j++) { // cout<<"j = "<<j<<endl; if(i==j) continue; int temp=(a[j]-ai); // cout<<"temp = "<<temp<<endl; if(i==0) { dset.insert(temp); dcount[temp] = dcount[temp] + 1; continue; } if((((temp))%i)==0) { // cout<<"temp/j = "<<temp/j<<endl; dset.insert(temp/(j-i)); // cout<<"current counof "<<temp/(j-i) <<" = "<<dcount[temp/(j-i)]<<endl; dcount[temp/(j-i)] = dcount[temp/(j-i)] + 1; // cout<<"after counof "<<temp/(j-i) <<" = "<<dcount[temp/(j-i)]<<endl; } } // cout<<"first loop done\n"; for(int j= i;j>0;j--) { // cout<<"j = "<<j<<endl; if(j==i) continue; int temp=(ai-a[j]); // // cout<<"2 loop temp = "<<temp<<endl; if(j==0) { dset.insert(temp); dcount[temp] = dcount[temp] + 1; continue; } if(((temp)%i)==0) { // cout<<"inserting temp/(j-i)"<<temp/(j-i)<<endl; dset.insert(temp/(j-i)); dcount[temp/(j-i)] = dcount[temp/(j-i)] + 1; } } for (set<int>::iterator it=dset.begin(); it!=dset.end(); ++it) { // cout<<"came till set check;\n"; cout<<"The value of d = " <<(*it)<< " count "<<dcount[*it]<<endl; int req_changes = (n-dcount[*it]-1); cout<<"req_changes = "<<req_changes<<endl; if(req_changes>k) continue; else { int a0 = ai - (i-1)* (*it); if(a0<fa) { fa=a0; fd= (*it); cout<<"updating fa = "<<fa<<" fd = "<<fd<<endl; updateopt(a0, (*it)); } else if(a0 == fa) { if(fd> (*it)) { fd = (*it); cout<<"updating fa = "<<fa<<" fd = "<<fd<<endl; updateopt(a0, (*it)); } } } } dcount.clear(); dset.clear(); } } for(int i=1;i<=n;i++) printf("%d ",(fa+(i-1)*fd)); printf("\n"); return 0; }
size_t count(Expr expr) { indexVars.clear(); expr.accept(this); return indexVars.size(); }
int main() { ifstream in("desc.in"); in >> n >> k; factorize(n); //int brt = brute(n, 2); v = vector<long long> (T.begin(), T.end()); T.clear(); n = v.size(); for(int i = 0 ; i < n ; ++i) f[i + 1] = v[i]; v.clear(); for(int i = 1 ; i <= n ; ++i){ H[f[i]] = i; } for(int i = 1 ; i <= n ; ++i) DP[1][i] = 1; for(int i = 2 ; i <= n ; ++i) { for(int j = n ; j >= 1 ; --j) { DP[i][j] += DP[i][j + 1]; if(f[i] % f[j] == 0) { long long nxt = f[i] / f[j]; nxt = H[nxt]; DP[i][j] += DP[nxt][j]; } } } ofstream out("desc.out"); #define cout out cout << DP[n][2] << "\n"; int last = 2; while(last <= n) { if(f[n] % f[last]) { ++last; continue; } long long nxt = f[n] / f[last]; nxt = H[nxt]; if(DP[nxt][last] < k) { k -= DP[nxt][last]; ++last; } else { cout << f[last] << " "; n = nxt; } } return 0; }
/* returns a list of hashes, the receiving function must free it */ void generate_feedback(uint32_t current_oid, uint32_t best_oid) { /* generate feedback from this packet */ if(!advertise_hashes.empty()) { advertise_hashes.clear(); } uint32_t anchor = 0; if(last_advertised.find(current_oid) == last_advertised.end()) { anchor = (*last_match[current_oid])[best_oid]; } else if(last_advertised[current_oid]->find(best_oid) == last_advertised[current_oid]->end()) { anchor = (*last_match[current_oid])[best_oid]; } else { anchor = ((*last_match[current_oid])[best_oid] > (*last_advertised[current_oid])[best_oid]) ? (*last_match[current_oid])[best_oid] : (*last_advertised[current_oid])[best_oid]; } object_information *best_object = object_memory[best_oid]; if (anchor == best_object->hash_list.size()) return; bool object_changed = false, end_of_connection = false; list<uint64_t>::iterator best_it = best_object->hash_list.begin(); advance(best_it, anchor); uint32_t advertise_oid = best_oid; for(int i = 0; i < ADVERTISE_COUNT; i++) { best_it++; if(best_it == best_object->hash_list.end()) { /* the best object has ended */ if(best_object->next_oid_set == false) { /* no new object to go to, just break*/ break; } /* else there is a next object*/ object_changed = true; /* reset anchor for this new object */ anchor = 0; /* pick the new oid */ advertise_oid = best_object->next_oid; /* the new oid could have no hashes*/ while(object_memory[advertise_oid]->hash_list.empty()) { /* find the next oid */ if(!object_memory[advertise_oid]->next_oid_set) { /* reached end of connection, just exit */ end_of_connection = true; break; } advertise_oid = object_memory[advertise_oid]->next_oid; } if(end_of_connection) break; /* not end of connection, so you found a new oid, iterate * through it */ int next_oid_count = 0; for(list<uint64_t>::iterator adv_oid_it = object_memory[advertise_oid]->hash_list.begin(); adv_oid_it != object_memory[advertise_oid]->hash_list.end(); adv_oid_it++) { /* extract ADVERTISE_COUNT -i hashes from this*/ if (next_oid_count == ADVERTISE_COUNT -i) break; /* else */ advertise_hashes.insert(*adv_oid_it); next_oid_count ++; } /*advertisements done, just exit the for loop*/ break; } /* we have not reached the end of best_object, so just add the * next hash to advertise_hashes */ advertise_hashes.insert(*best_it); } /* update the current anchor value in last_advertised */ if(last_advertised.find(current_oid) == last_advertised.end()) { last_advertised[current_oid] = new map<uint32_t, uint32_t>; (*last_advertised[current_oid])[best_oid] = 0; } else if(last_advertised[current_oid]->find(best_oid) == last_advertised[current_oid]->end()) { (*last_advertised[current_oid])[best_oid] = 0; } (*last_advertised[current_oid])[best_oid] = anchor; if(object_changed) { last_advertised[current_oid]->erase(best_oid); last_match[current_oid]->erase(best_oid); (*hit_count[current_oid])[best_oid] = 0; } return; }