C++ Blocks::size方法代码示例

void simplifyPFBlock(const Edges& toUnlink, const PFBlock& block, Blocks& simplifiedBlocks, Nodes& history) {
  // take a block, unlink some of the edges and
  // create smaller blocks or a simplified blocks
  // or if nothing has changed take a copy of the original block
  if (toUnlink.size() == 0) {
    // no change needed, just make a copy of block
    PFBlock newblock(block.elementIds(), block.edges(), simplifiedBlocks.size(), 's');  // will copy edges and ids
    PDebug::write("Made {}", newblock);
    auto id = newblock.id();
    simplifiedBlocks.emplace(id, std::move(newblock));
    // update history
    makeHistoryLinks(block.elementIds(), {id}, history);
  } else {
    Edges modifiedEdges;
    for (auto edge : block.edges()) {  // copying edges
      Edge e = edge.second;
      if (toUnlink.find(edge.first) != toUnlink.end()) {
        e.setLinked(false);
      }
      modifiedEdges.emplace(e.key(), e);
    }
    // create new blocks and add into simplifiedBlocks
    buildPFBlocks(block.elementIds(), modifiedEdges, 's', simplifiedBlocks, history);
  }
}

void PFReconstructor::reconstruct() {
  // TODO sort m_blocks

  // simplify the blocks by editing the links
  // each track will end up linked to at most one hcal

  // sort the blocks by id to ensure match with python
  std::vector<IdType> blockids;
  std::vector<IdType> newblockids;

  Ids ids = m_pfEvent.mergedElementIds();

  // create the blocks of linked ids
  auto bBuilder = PFBlockBuilder(ids, m_pfEvent);
  m_blocks = bBuilder.blocks();

  for (const auto& b : m_blocks) {
    blockids.push_back(b.first);
  }
#if WITHSORT
  std::sort(blockids.begin(), blockids.end());
#endif
  // go through each block and see if it can be simplified
  // in some cases it will end up being split into smaller blocks
  // Note that the old block will be marked as disactivated
  for (auto bid : blockids) {
    // std::cout<<Id::pretty(bid)<< ":" << bid <<std::endl;
    Blocks newBlocks = simplifyBlock(bid);
    if (newBlocks.size() > 0) {
      for (auto& b : newBlocks) {
        IdType id = b.first;
        m_blocks.emplace(id, std::move(b.second));
        newblockids.push_back(b.first);
      }
    }
  }
  blockids.insert(std::end(blockids), std::begin(newblockids), std::end(newblockids));

  for (auto bid : blockids) {
    PFBlock& block = m_blocks.at(bid);
    if (block.isActive()) {  // when blocks are split the original gets deactivated
      PDebug::write("Processing {}", block);
      reconstructBlock(block);
    }
  }
  if (m_unused.size() > 0) {
    PDebug::write("unused elements ");
    for (auto u : m_unused)
      PDebug::write("{},", u);
    // TODO warning message
  }
}

// This is the core solution
bool Board::RecursiveSetBlock(Blocks &bs, size_t block_index)
{
    Block* block = bs[block_index];

    size_t xmax = width - block->width;
    size_t ymax = height - block->height;

    for (size_t x = 0; x <= xmax; x++)
    {
        for (size_t y = 0; y <= ymax; y++)
        {
            // if there is a place for block, process.
            if (SetBlock(block, x, y))
            {
                // If the block is the last one, solution found.
                if (block_index == bs.size() - 1)
                {
                    cout << "Step: Put block " << block_index << " at [" << x << ", " << y << "]" << endl;
                    block->Print(width, height, x, y, "Block " + to_string(block_index));
                    return true;
                }

                // If not the last one, process other blocks.
                if (RecursiveSetBlock(bs, block_index + 1))
                {
                    // If all other blocks are positioned correctly, solution found.
                    cout << "Step: Put block " << block_index << " at [" << x << ", " << y << "]" << endl;
                    block->Print(width, height, x, y, "Block " + to_string(block_index));
                    return true;
                }
                else
                {
                    // If not able to found a solution for other blocks, rollback current block,
                    // and continually find next available position for current block.
                    ClearBlock(block, x, y);
                    continue;
                }
            }
        }
    }

    return false;
}