算法的最坏情况复杂度

Question

void my_algo(const std::vector<unsigned int>& lp, const std::vector<unsigned int>& lm, std::vector<int>& aff) {

  std::vector<std::pair<unsigned int, unsigned int> > m_index;
  for (unsigned int i = 0; i < m_lengths.size(); i++)
    m_index.push_back(std::make_pair(m_lenghts[i], i));

  std::vector<std::pair<unsigned int, unsigned int> > p_index;
  for (unsigned int i = 0; i < p_lengths.size(); i++)
    p_index.push_back(std::make_pair(p_lenghts[i], i));

  std::make_heap(p_index.begin(), p_index.end());
  std::make_heap(m_index.begin(), m_index.end());

  for (unsigned int i = 0; i < m_lengths.size(); i++) {

    std::pop_heap(m_index.begin(), m_index.end());
    std::pair<unsigned int, unsigned int> m_root = m_index.back();
    m_index.pop_back();

    std::pop_heap(p_index.begin(), p_index.end());
    std::pair<unsigned int, unsigned int> p_root = p_index.back();
    p_index.pop_back();

    if (p_root.first >= m_root.first) {
      aff.at(m_root.second) = p_root.second;

      p_root.first -= m_root.first;
    }
    else{
      aff.at(m_root.second) = -1;
    }

    p_index.push_back(root_p);
    std::push_heap(p_index.begin(), p_index.end());
  }
}

I would like to analyze the worst case complexity of my algorithm, but I am not sure where to start. Suppose the length of lp is n and the length of lm is m. The complexity of the two first for loop are quite easy but I am not sure about the third one. Can you help with the worst case complexity of the algorithm?

I think third for loop might be in 2 m log(m), but I am really not sure of what I am saying. Could you explain step by step how to analyse the last for loop?

Answer 1

The first loop and make_heap has complexity O(m) . The second loop and make_heap has complexity O(n) .

Now the third loop has m iterations, each of which does 1 m_index heap operation, and 2 p_index heap operations. Heap pop/push operations have cost logarithmic in number of elements. Thus the cost is O(m (log(m)+log(n) ) . If m>=n then this is O(m log(m)) .

Note that you can slightly improve your solution, by only pop'ing and push'ing p_root if it is actually altered.

Instead of std::make_heap , std::pop_heap and std::push_heap over a std::vector , you can also directly use std::priority_queue instead.