Because iterative DP is faster. And recursive DP would cause Maximum call stack size exceeded sometimes.

Recursive dp is easier because you need not worry whether the value needed for the subproblems have been computed before or not. The value required, if computed before gets returned. If not computed, it will get computed and returned.

I don't know about others but I often find iterative dp easier to visualize.

Because...it is very hard to pass using a recursive DP solution in Python

I prefer recursive dp as it is easier to imagine for me and rarely there's a problem that needs iterative instead. Iterative is faster

Unless need data structure or mathematical optimization, I never use iterative dp. I also recommend beginners to do the same.

I guess iterative dp is faster and possibly more memory-efficient depending on how it's coded, but that's rarely an issue.

I use iterative dp basically always. It's just more intuitive for me.

Don't fall into the trap of IGMs and GMs saying that iterative DP is faster. Everybody does it because it looks cool. I want my code to look cool that is why I use iterative DP. I don't want to look like a noob who can't visualize iterative DP and is stuck on recursive approach.

I always use recursive DP if the problem accepts such solutions. It's way easier to debug and you always respect some kind of template.

https://usaco.guide/CPH.pdf#page=75 2nd paragraph

It depends on the situation. Ie sometimes the problem calls for DP on a tree, in which recursive DP is much more convenient. Usually, experienced programmers will go for whatever is easier to implement in a given problem.

One problem with recursive DP is if the calls get very deep. I find that for example, a DFS on 50 million nodes often times out, and am not sure why. I suspect that the constant factor gets large when the stack size is large due to cache reasons.

I prefer iterative dp for two reasons:

1. I am more comfortable in debugging it.
2. I can do memory optimisation with iterative dp.

There are two ways to write iterative dp, pull dp and push dp:

vector dp(n + 2, 0ll);
dp[1] = 1;

// push
for (int i = 1; i < n; i++) {
    dp[i+1] += dp[i];
    dp[i+2] += dp[i];
}

// pull
for (int i = 2; i <= n; i++) {
    dp[i] = dp[i-1] + dp[i-2];
}

push DP is much harder to visualize for me, but pull dp looks exactly like recursive, except you need to write out base cases, which is a bit tedious (that's why I usually write recursive first).

Example, as you can see it hardly differs except the base cases:

    // recursive
    vector memo(w+1, vector<int>(h+1, -1));
    auto dp = [&](auto& dp, int i, int open)->ll {
        if (i == 0) return open == 0;
        if (open == 0 && i != w) return 0ll;
        if (memo[i][open] != -1) return memo[i][open];
 
        ll res = 0;
        for (int prev = 0; prev + open <= h; prev++) {
            res += (ll)dp(dp, i-1, prev)
                * choose(h - prev, open) % mod;
            res %= mod;
        }
        return memo[i][open] = res;
    };

    // pull iterative
    vector dp(w+1, vector<ll>(h+1, 0));
    for (int open = 0; open <= h; open++)
        dp[0][open] = open == 0;
 
    for (int i = 1; i <= w; i++) {
        for (int open = 0; open <= h; open++) {
            if (open == 0 && i != w) {
                continue;
            }
            for (int prev = 0; prev + open <= h; prev++) {
                dp[i][open] += dp[i-1][prev] * choose(h - prev, open) % mod;
            }
            dp[i][open]%=mod;
        }
    }

Another reason of using iterative DP is the ease of debugging. I myself find debugging a recursive DP implementation specifically, or any recursive function generally, quite horrendous. Iterative DP is easier to debug since you're literally calculating values from the bottom up, hence you can keep track of the current result; while in recursive DP you'll be lead to a seemingly random state whose value hasn't been calculated yet and jumping from state to state almost indefinitely.

That being said, I still use recursive DP 80% of the time because of it's simpler thinking process. Recursive DP functions look almost the same as each other, you can immediately start implementing it like a no brainer and it would highly likely be correct if your recurring formula is also correct. Once you've came up with a recurrence, with recursive DP you'll only need to specify the base cases while for iterative DP you also have to additionally determine the looping order of calculating. Determining this is sometimes not very trivial or straight up impossible, for instance Knapsack DP.

To the experts, I have an additional question. Is recursive dp more time-consuming than iterative dp? if yes, what is the reason?

i personally use iterative dp, because i realized recursive and iterative dp are the same except for looping order which is (nearly) always easy to find out [idk any cases where its hard, but maybe they exist] and iterative allows for optimizations, while recursive doesnt.

Why would i use recursive is the real question

I think its more of a habit thing , first someone tells you its fast , then you start doing it , then it becomes easier, personally I have never written recursive dp and when I tried it I found iterative dp way more intuitive and easier.

I don't like recursion unless it's dfs

Depends on the problems. Sometimes I use recursive dp because it can be nicely implemented. Sometimes iterative dp is harder. When transitions are too complex, the only choice is recursive dp.

it is faster and better memory but it is hard i think the recurive one is much more easier so if it fits in recursive solution do it if not apply iterative. experienced programmers do it because it is cooler; if recursive solution work do it without thinking