C++ bitset::reset方法代码示例

void bitsetDivide(std::bitset<N> x, std::bitset<N> y,
  std::bitset<N>& q, std::bitset<N>& r)
{
  if (y.none( )) {
    throw std::domain_error("division by zero undefined");
  }
  q.reset( );
  r.reset( );
  if (x.none( )) {
    return;
  }
  if (x == y) {
    q[0] = 1;
    return;
  }
  r = x;
  if (bitsetLt(x, y)) {
    return;
  }

  // count significant digits in divisor and dividend
  unsigned int sig_x;
  for (int i=N-1; i>=0; i--) {
    sig_x = i;
    if (x[i]) break;
  }
  unsigned int sig_y;
  for (int i=N-1; i>=0; i--) {
    sig_y = i;
    if (y[i]) break;
  }

  // align the divisor with the dividend
  unsigned int n = (sig_x - sig_y);
  y <<= n;

  // make sure the loop executes the right number of times
  n += 1;

  // long division algorithm, shift, and subtract
  while (n--)
  {
    // shift the quotient to the left
    if (bitsetLtEq(y, r))
    {
      // add a new digit to quotient
      q[n] = true;
      bitsetSubtract(r, y);
    }
    // shift the divisor to the right
    y >>= 1;
  }
}

void Sync::choose_threads(){
    int ref = -1;
    for (UINT ii=0; ii<num_threads; ii++){
        unsigned int i = (ii + rrcounter) % num_threads;
        if ( !t[i].ignore && !was_executed.test(i) ){
            ref = i;
            break;
        }
    }
    if (ref == -1){
        was_executed.reset();
        for (UINT ii=0; ii<num_threads; ii++){
            unsigned int i = (ii + rrcounter) % num_threads;
            if (!t[i].ignore){
                ref = i;
                break;
            }
        }
    }
    
    for (UINT i=0; i<num_threads; i++){
        t[i].is_active = !t[i].ignore && t[i].pc == t[ref].pc;
        if (t[i].is_active){
            was_executed.set(i);
        }
    }
    
    // Next
    rrcounter = (ref + 1) % num_threads;
}

template<size_t N> void fillSieveOfAtkin(std::bitset<N>& primes) {
    primes.reset();
    const size_t ROOT_MAX = static_cast<size_t>( sqrtf(N) );

    typedef unsigned long ulong;
    for (size_t x = 1; x < ROOT_MAX; x++) {
        for (size_t y = 1; y < ROOT_MAX; y++) {
            ulong x_2 = x * x; 
            ulong y_2 = y * y;

            ulong n = 4 * x_2 + y_2;
            ulong n_mod_12 = n % 12;            
            if (n <= N && (n_mod_12 == 1 || n_mod_12 == 5)) primes[n] = !primes[n];

            n = 3 * x_2 + y_2;
            if (n <= N && (n % 12) == 7) primes[n] = !primes[n];

            n = 3 * x_2 - y_2;           
            if (x > y && n <= N && (n % 12) == 11) primes[n] = !primes[n];
        }
    }
    
    for (size_t n = 5; n < ROOT_MAX; n++) {
        if (primes[n]) {
            ulong k = n * n;
            for (size_t j = k; j <= N; j += k) primes[j] = false;
        }
    }
    primes[2] = primes[3] = true;
}

void updateInput()
{
	pressed.reset();
	released.reset();

	while (al_get_next_event(keyboardEventQueue, &tempEvent)) {
		if (tempEvent.type == ALLEGRO_EVENT_KEY_DOWN) {
			pressed[tempEvent.keyboard.keycode] = 1;
			down[tempEvent.keyboard.keycode] = 1;
		}
		if (tempEvent.type == ALLEGRO_EVENT_KEY_UP) {
			released[tempEvent.keyboard.keycode] = 1;
			down[tempEvent.keyboard.keycode] = 0;
		}
	}
}

	void OnRehash(User*)
	{
		/* from m_sethost: use the same configured host character map if it exists */
		std::string hmap = ServerInstance->Config->ConfValue("hostname")->getString("charmap", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz.-_/0123456789");

		hostmap.reset();
		for (std::string::iterator n = hmap.begin(); n != hmap.end(); n++)
			hostmap.set(static_cast<unsigned char>(*n));
	}

void cal(int l, int r) {
	int *now = buf;
	int tot = cnt[l][r];
	if(tot != 0) return;
	if(l == r) {
		buf[tot++] = ch[s[l]];
		dp[l][r][cnt[l][r]++] = ch[s[l]];
		return ;
	}
	for(int i = l; i < r; i++) {
		cal(l, i); cal(i + 1, r);
	}
	vis.reset();
	for(int i = l; i < r; i++) {
		int *left = dp[l][i], *right = dp[i + 1][r];
		int tot1 = cnt[l][i], tot2 = cnt[i + 1][r];
		for(int j = 0; j != tot1; j++) {
			int cur = dp[l][i][j];
			int x = left[j];
			int st = 
				std::upper_bound(right, right + tot2, 5001 - x) - right;
			for(int k = 0; k != st; k++) {
				int y = right[k];
				if(y > x)  break;
				if(!vis[(x + y)])
					now[tot++] = (x + y);
				vis[(x + y)] = true;
			}
		}
	}
	for(int i = l; i < r; i++) {
		int *left = dp[l][i], *right = dp[i + 1][r];
		int tot1 = cnt[l][i], tot2 = cnt[i + 1][r];
		for(int k = 0; k != tot2; k++) {
			for(int j = 0; j < tot1; j++) {
				int x = left[j], y = right[k];
				if(x >= y) break;
				if(!vis[(y - x)])
					now[tot++] = (y - x);
				vis[(y - x)] = true;
			}
		}
	}
	std::sort(now, now + tot);
	tot = std::unique(now, now + tot) - now;
	int &cur = cnt[l][r];
	cur = 0;
	for(int i = 0; i < tot; i++) dp[l][r][cur++] = now[i];
}

  void rebuild()
  {
    p.reset();
    p.flip();

    p[0] = p[1] = 1;

    for ( size_t n=2; n < PRIMES; ++n )
      if ( p[n] ) {
        v.push_back(n);

        for ( size_t m=n<<1; m < PRIMES; m += n )
          p[m] = 0;
      }
  }

void bitsetMultiply(std::bitset<N>& x, const std::bitset<N>& y)
{
  std::bitset<N> tmp = x;
  x.reset( );

  // we want to minimize the number of times we shift and add
  if (tmp.count( ) < y.count( )) {
    for (int i=0; i < N; i++)
      if (tmp[i]) bitsetAdd(x, y << i);
  }
  else {
    for (int i=0; i < N; i++)
      if (y[i]) bitsetAdd(x, tmp << i);
  }
}

 bool _on_value_changed()
 {
     if(!_set.all())
         return false;
     _set.reset();
     switch(_operation)
     {
         case ADD:
             return output(_value0+_value1);
         case SUBTRACT:
             return output(_value0-_value1);
         case MULTIPLY:
             return output(_value0*_value1);
         case DIVIDE:
             return output(_value0/_value1);
     }
 }

int main(){
    // do you mind telling us in the problem statement
    // that there is more than one test case per input
    while(~scanf("%d%d",&N,&M)){
        V.clear();
        for(int i=1;i<=N;++i){
            scanf("%d",W+i);
            V.emplace_back(W[i]);
        }
        std::sort(all(V));
        V.erase(std::unique(all(V)),V.end());
        for(int i=1;i<=N;++i)
            W[i]=std::lower_bound(all(V),W[i])-V.begin();
        for(int i=1;i<=N;++i)
            adj[i].clear();
        for(int i=1,a,b;i<N;++i){
            scanf("%d%d",&a,&b);
            adj[a].emplace_back(b);
            adj[b].emplace_back(a);
        }
        dfs(1,-1);
        build();
        for(int i=0,a,b,l;i<M;++i){
            scanf("%d%d",&a,&b);
            l=lca(a,b);
            if(ein[b]<ein[a]) std::swap(a,b);
            if(a==l||b==l) qrys[i]={ein[a],ein[b],-1,i};
            else qrys[i]={eout[a],ein[b],l,i};
        }
        std::sort(qrys,qrys+M);
        vis.reset();
        memset(cnt,0,sizeof cnt);
        res=0;
        chk(tour[1]);
        for(int i=0,l=1,r=1;i<M;++i){
            while(r<qrys[i].r) chk(tour[++r]);
            while(l>qrys[i].l) chk(tour[--l]);
            while(r>qrys[i].r) chk(tour[r--]);   
            while(l<qrys[i].l) chk(tour[l++]);
            if(~qrys[i].lca) chk(qrys[i].lca);
            ans[qrys[i].i]=res;
            if(~qrys[i].lca) chk(qrys[i].lca);
        }
        for(int i=0;i<M;printf("%d\n",ans[i++]));
    }
}

int main()
{
	while(scanf("%d%d%d", &n, &m, &q) == 3 && n + m + q)
	{
		for(int i = 0; i < n; ++i)
			scanf("%d%d%d%d", &cir[i].x, &cir[i].y, &cir[i].z, r + i);
		for(int i = 0; i < m; ++i)
			scanf("%d%d%d%d", &lht[i].x, &lht[i].y, &lht[i].z, val + i);
		scanf("%d%d%d", &obj.x, &obj.y, &obj.z);
		for(int i = 0; i < n; ++i)
			cir[i] = cir[i] - obj;
		for(int i = 0; i < m; ++i)
		{
			lht[i] = lht[i] - obj;
			dis[i] = lht[i].mode();
			cnt[i].reset();
			for(int j = 0; j < n; ++j)
			{
				int sgn1 = sgn((lht[i] - cir[j]).mode() - r[j] * r[j]);
				int sgn2 = sgn(cir[j].mode() - r[j] * r[j]);
				if(sgn1 * sgn2 < 0
				|| sgn1 > 0 && sgn2 > 0 && lht[i].det(cir[j]).mode() < r[j] * r[j] * (LL)dis[i]
				&& lht[i].dot(lht[i] - cir[j]) > 0 && lht[i].dot(cir[j]) > 0)
					cnt[i].set(j);
			}
		}
		double ans = 0;
		for(int i = 0; i < 1 << m; ++i)
		{
			double value = 0;
			cost.reset();
			for(int j = 0; j < m; ++j)
				if((i >> j) & 1)
				{
					cost |= cnt[j];
					value += (double)val[j] / dis[j];
				}
			if((int)cost.count() <= q && ans < value)
				ans = value;
		}
		printf("%.10f\n", ans);
	}
	return 0;
}

// For correctness check out:
// "A Linear Sieve Algorithm for Finding Prime Numbers" 
void generate_sieve()
{
    sieve.flip(); // all bits are 1 now
    for (int i=2; i<n; ++i){
        if (sieve[i]){
            primes.push_back(i);
        }
        for (int k=0; k<(int)primes.size() && i*primes[k]<n; ++k){
            // For debug purposes: 
            // std::cout<<"i="<<i<<", k="<<k<<", "<<i*primes[k]<<std::endl;

            // We reset the bit of a composite number, until we find lowest
            // prime that divides i.
            sieve.reset(i*primes[k]);
            if (i%primes[k] == 0){
                break;
            }
        } 
    } 
}

BOOL CPEParser::AnalizeExport()
{
	//флаги наличия имени у функции (определяется заблаговременно, чтобы не было warning'а из-за goto).
	static std::bitset<0x10000> NamesFlags;
	NamesFlags.reset();

	//получить директорию экспорта
	PIMAGE_DATA_DIRECTORY pDataDirectory=mpImageOptionalHeader->DataDirectory+IMAGE_DIRECTORY_ENTRY_EXPORT;
	//если экспорта нет, закончить
	if(!pDataDirectory->VirtualAddress || pDataDirectory->Size<sizeof(IMAGE_EXPORT_DIRECTORY)) return TRUE;
	//считать дескриптор экспорта
	CYBER_ADDRESS DescriptorAddress=mSettings.BaseAddress+pDataDirectory->VirtualAddress;
	IMAGE_EXPORT_DIRECTORY Descriptor;
	try
	{
		mpMemory->Data(&Descriptor,DescriptorAddress,sizeof(IMAGE_EXPORT_DIRECTORY));
	}
	catch(CCyberMemoryPageFaultException)
	{
		goto error;
	}

	//создать список экспорта
	CImageListExports* pExportsList=new CImageListExports;
	//добавить его в список дополнительных объектов
	mpExtendMap->insert(std::make_pair(IMAGE_EXTEND_LIST_EXPORTS,pExportsList));
	//получить список функций
	std::list<CImageListExports::CExportFunction*>* pFunctionsList=pExportsList->GetList();

	//получить количество функций и имен
	UINT FunctionsCount=Descriptor.NumberOfFunctions;
	if(FunctionsCount>0x10000) goto error;
	UINT NamesCount=Descriptor.NumberOfNames;
	if(NamesCount>0x10000) goto error;
	//получить таблицы имен, адресов и ординалов
	CYBER_ADDRESS AddressTable=mSettings.BaseAddress+Descriptor.AddressOfFunctions;
	CYBER_ADDRESS NamesTable=mSettings.BaseAddress+Descriptor.AddressOfNames;
	CYBER_ADDRESS OrdinalsTable=mSettings.BaseAddress+Descriptor.AddressOfNameOrdinals;

	//цикл по именам
	for(UINT i=0;i<NamesCount;++i)
	{
		//считать имя, ординал, адрес и форвард функции
		LPSTR szName;
		LPSTR szForward;
		WORD Ordinal;
		CYBER_ADDRESS Address;
		//флаг форварда
		BOOL IsForward=FALSE;
		try
		{
			//считать имя
			szName=mpMemory->ReadASCIIZ(mSettings.BaseAddress+mpMemory->Dword(NamesTable+i*sizeof(DWORD)));
			//считать ординал
			Ordinal=mpMemory->Word(OrdinalsTable+i*sizeof(WORD));
			//считать адрес
			Address=mpMemory->Dword(AddressTable+Ordinal*sizeof(DWORD));

			//если адрес находится в пределах таблицы экспорта, значит, это форвард
			if(Address>=pDataDirectory->VirtualAddress && Address<pDataDirectory->VirtualAddress+pDataDirectory->Size)
				IsForward=TRUE;
			Address+=mSettings.BaseAddress;

			if(IsForward)
				//считать имя форвард-функции
				szForward=mpMemory->ReadASCIIZ(Address);
		}
		catch(CCyberMemoryPageFaultException)
		{
			goto error;
		}

		//указать флаг наличия имени
		NamesFlags[Ordinal]=true;

#ifdef UNICODE
		//преобразовать строки в Unicode
		UINT NameLength=strlen(szName)+1;
		LPTSTR szUnicodeName=new TCHAR[NameLength];
		MultiByteToWideChar(CP_ACP,0,szName,-1,szUnicodeName,NameLength);
		SafeDeleteMassive(szName);

		UINT ForwardLength;
		LPTSTR szUnicodeForward;
		if(IsForward)
		{
			ForwardLength=strlen(szForward)+1;
			szUnicodeForward=new TCHAR[ForwardLength];
			MultiByteToWideChar(CP_ACP,0,szForward,-1,szUnicodeForward,ForwardLength);
			SafeDeleteMassive(szForward);
		}
#define szName szUnicodeName
#define szForward szUnicodeForward
#endif

		//добавить функцию в список
		if(IsForward)
			pFunctionsList->push_back(new CImageListExports::CExportFunction(szName,Ordinal,szForward));
		else
			pFunctionsList->push_back(new CImageListExports::CExportFunction(szName,Ordinal,Address));
//.........这里部分代码省略.........

void OPKiller::reset() {
    opcodes_filter_.reset();
    target_opcodes_.clear();
    areas_filter_.reset();
    target_areas_.clear();
}