Is Dijkstra's algorithm dynamic programming?

All implementation of Dijkstra's algorithms I have seen do not have a recursive function

Recursion gives us a stack. But we don't need a stack here. We need a priority queue. The efficient way to implement Dijkstra's algorithm uses a heap (stl priority_queue in c++).

but I have also read that by definition dynamic programming is an algorithm with a recursive function and "memory" of things already calculated.

Dynamic Programming need not be written in a recursive way though most people prefer to write it in a recursive way.

For example:

int dp[MAX]={-1,-1,...};
find fibonacci(int n){
   if(n <= 1) return n;
   if(dp[n]!=-1) return dp[n];
   return dp[n]=fibonacci(n-1)+fibonacci(n-2);
}

is a recursive implementation of DP

and

int dp[MAX]={0,1,-1,-1,-1,..};
int lastFound = 1;
int fibonacci(int n){
    for(int i=lastFound+1;i<=n;i++){
       dp[i]=dp[i-1]+dp[i-2];
    }
    return dp[n];
}

is an iterative way of writing it to save stack memory.

Remember that any algorithm

1. that does not recalculate the result that is already found and

2. uses the existing result to find the required result

can be called as a DP. Even using BFS to find the shortest path in an unweighted graph can be considered as DP in a way as it passes the above 2 conditions.

So is Dijkstra's algorithm with a loop qualified as dynamic programming?

Dijkstra is DP!

Or in order to qualify as dynamic algorithm I have to change a loop into a recursive function.

No

There is a paper about it entitled "Dijkstra’s algorithm revisited: the dynamic programming connexion" by Moshe Sniedovich. http://matwbn.icm.edu.pl/ksiazki/cc/cc35/cc3536.pdf

The paper claim that Dijkstra’s algorithm is strongly inspired by Bellman’s Principle of Optimality and that both conceptually and technically it constitutes a dynamic programming successive approximation procedure par excellence.

Dijkstra's Algorithm is like a water filling algorithm. At each step it chooses local minima that's the reason why many consider it as Greedy Algorithm. If you will try this same algorithm with choosing any arbitrary path not the local minima, then you will come to know that it's still working. Choosing a local minima is just because of filling water optimally as I mentioned earlier that it's like water filling algorithm. So, the main concept behind Dijkstra's Algorithm is to store the previous result to predict the upcoming result and that is what Dynamic Approach is.

For more details refer below link

Why does Dijkstra's algorithm work?

I had the same question after reading CLRS for college. If you are studying purely for class/tech interviews, CLRS labels Dijkstra's as a greedy algorithm and Bellman-Ford as a dynamic programming algorithm based upon all the reasons listed by commenters above.

IMO, It's more important to understand why Dijkstra's is the classic greedy algorithm example than why it is not a dynamic algorithm even though it has some dynamic programming like logic.

Once you understand how Dijkstra's work and why its runtime is better in most cases than Bellman-Ford's, than approach Bellman-Ford. Try to understand why if a graph has a negative edge weight we can use BF and the dynamic programming part will make sense.

I think sometimes CLRS/Youtube throws out these definitions and we try to fit these algorithms into these label buckets. I also think the slides for CLRS don't do a great job of explaining the reason we are learning certain algos versus others and their similarities. You really have to spend a lot of time piecing it all together yourself.

Botton line is that academically, Dijkstra's Single Source Shortest Path Algorithm is the classic greedy algorithm students learn and do not confuse it with Dynamic Programming Algos like Bellman-Ford.