deque | Extremely fast double-ended queue implementation

packaged_task needs to be able to call SumUp::operator() so that needs to be public not private:

There're no find in std::stack, but you can use std::deque, which provides the same functionality. Use push_back() for push() and pop_back() for pop(). std::vector also provides such functionalities.

Example code:

Yes, std::transform:

The variable here is simply whether std::deque requires its element type to be complete when it is instantiated. (Of course it must be complete when certain member functions are instantiated, but that’s separate.) If it does, you end up needing your value_type before it’s declared, which produces the error observed. C++17 requires that std::vector support incomplete types, but says nothing about std::deque, which is why this varies per standard library.

self.model.predict(state) will return a tensor of shape of (1, 2) containing the estimated Q values for each action (in cartpole the action space is {0,1}). As you know the Q value is a measure of the expected reward.

By setting self.model.predict(state)[0][action] = target (where target is the expected sum of rewards) it is creating a target Q value on which to train the model. By then calling model.fit(state, train_target) it is using the target Q value to train said model to approximate better Q values for each state.

I don't understand why you are saying that the loss becomes 0: the target is set to the discounted sum of rewards plus the current reward

You're adding a type to your list, not an instance of the type. What you're doing is essentially the same as this:

Is it because I have structured the function to not take a list as an input?

No. This may be confusing, but on LeetCode the raw list representation of the input is translated to an instance of TreeNode before your function is called. So you should never have to deal with this list structure. It is merely the common input format that LeetCode uses across the different programming languages. But the conversion to the target language's data structure is done for you before your implementation is called.

Your code produces an error on the first call of queue.append because of this line:

This won't be a full proof, you can read "A Note on Finding Shortest Path Trees" (Aaron Kershenbaum, 1981, https://doi.org/10.1002/net.3230110410) if you want that. An other source you may find interesting is "Properties of Labeling Methods for Determining Shortest Path Trees".

The intuitive reason why this algorithm can go bad is that a node in set M0 is pulled out from it again to be re-examined later if an edge that points to it is found. That already sounds quadratic because there could be |V|-1 edges pointing to it, so every node could potentially be "resurrected" that many times, but it's even worse: that effect is self-amplifying because every time a node is "resurrected" in that way, the edges outgoing from that node can cause more resurrections, and so on. In a full proof, some care must be taken with the edge weights, to ensure that enough of those "resurrections" can actually happen, because they are conditional, so [Kershenbaum 1981] presents a way to build an actual example on which Pape's algorithm requires an exponential number of steps.

By the way, in the same paper the author says:

I have used this algorithm to find routes in very large, very sparse real networks (thousands of nodes and average nodal degree between 2 and 3) with a variety of length functions (generally distance-related) and have found it to outperform all others.

(but since no one uses this algorithm, there are not many available benchmarks, except this one in which Pape's algorithm does not compare so favourably)

In contrast, triggering the exponential behaviour requires a combination of a high degree, a particular order of edges in the adjacency list, and unusual edge weights. Some mitigations are mentioned, for example sorting the adjacency lists by weight before running the running the algorithm.

I could not find any real source on this, and don't expect it to exist, after all you would not have to defend not-using some unusual algorithm that has strange properties to boot. There is the exponential worst case (though on closer inspection it seems unlikely to be triggered by accident, and anyway the Simplex algorithm has an exponential worse case, and it is used a lot), it is relatively unknown, and the only available actual benchmark casts doubt on the claim that the algorithm is "usually efficient" (though I will note they used a degree of 4, which still seems low, but it is definitely higher than the "between 2 and 3" used in the claim that the algorithm is efficient). Also, it should not be expected that Pape's algorithm will perform well on dense graphs in general, even if the exponential behaviour is not triggered.

In