Example #1
0
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));
}
Example #2
0
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;
}
Example #3
0
    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);
            }
        }
    }
Example #4
0
int ask(int s, int t)
{
    st.clear();
    dfs(s, t, 0ll);
    return st.size();
}
Example #5
0
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();
}
Example #6
0
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);



    }
Example #7
0
File: calc.cpp Project: hsk/docs
 GC() {
   frame_list.push_front(&frame);
   heap_list.clear();
   heap_num = 0;
   heap_max = 8;
 }
Example #8
0
File: 193.cpp Project: paulot/uva
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();
}
Example #10
0
void init_lookup_table() { vis.clear(); }
Example #11
0
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;
		}
	}
}
Example #12
0
//----------------------------------------------------------------------------
void VETMesh::GetTriangles (set<Triangle>& rkTSet) const
{
    rkTSet.clear();
    for (MTCIter pkT = m_kTMap.begin(); pkT != m_kTMap.end(); pkT++)
        rkTSet.insert(pkT->first);
}
Example #13
0
//----------------------------------------------------------------------------
void VETMesh::GetEdges (set<Edge>& rkESet) const
{
    rkESet.clear();
    for (MECIter pkE = m_kEMap.begin(); pkE != m_kEMap.end(); pkE++)
        rkESet.insert(pkE->first);
}
Example #14
0
//----------------------------------------------------------------------------
void VETMesh::GetVertices (set<int>& rkVSet) const
{
    rkVSet.clear();
    for (MVCIter pkV = m_kVMap.begin(); pkV != m_kVMap.end(); pkV++)
        rkVSet.insert(pkV->first);
}
Example #15
0
 set<Func> get(Func func) {
   funcs.clear();
   func.accept(this);
   return funcs;
 }
Example #16
0
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;
}
Example #17
0
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;
    }
}
Example #19
0
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;

}
Example #20
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);
  }

}
Example #22
0
 void recover_removed_vertices() {
     m_stRemovedVertexIds.clear();
 }
Example #23
0
// 读方案
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;
}
Example #25
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();
}
Example #26
0
		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;
		}
Example #27
0
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;

}
Example #28
0
 size_t count(Expr expr) {
   indexVars.clear();
   expr.accept(this);
   return indexVars.size();
 }
Example #29
0
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;
}