Logic behind including / excluding current element in recursive approach - algorithm

Question

I'm studying DP nowadays however I've run into previously some examples like subset sum or as shown in this question coin change problem that their solutions call recursive cases both including the current element and excluding the current element. Yet, I've genuinely difficulty in comprehending what/why it's real reason by doing this approach. I cannot get the underneath logic behind of it. I don't want to memorize or to say "humm, okay, keep in mind it, there is an approach" like that styles.
class Util
{
// Function to find the total number of distinct ways to get
// change of N from unlimited supply of coins in set S
public static int count(int[] S, int n, int N)
{
// if total is 0, return 1 (solution found)
if (N == 0) {
return 1;
}
// return 0 (solution do not exist) if total become negative or
// no elements are left
if (N < 0 || n < 0) {
return 0;
}
// Case 1. include current coin S[n] in solution and recurse
// with remaining change (N - S[n]) with same number of coins
int incl = count(S, n, N - S[n]);
// Case 2. exclude current coin S[n] from solution and recurse
// for remaining coins (n - 1)
int excl = count(S, n - 1, N);
// return total ways by including or excluding current coin
return incl + excl;
}
// Coin Change Problem
public static void main(String[] args)
{
// n coins of given denominations
int[] S = { 1, 2, 3 };
// Total Change required
int N = 4;
System.out.print("Total number of ways to get desired change is "
+ count(S, S.length - 1, N));
}
}
I don't want to skip the parts superficially since recurrence formulas are really play leading role for dynamic programming.

Answer 1

At each recursion you want to explore both cases:
one more coin of type n is used
you are done with coin type n and proceed to the next coin type
The remaining task is handled in both cases by a recursive call.
By the way, this solution has nothing to do with dynamic programming.
In the common powerset problem, given (1 2 3) we are asked to generate ((1 2 3) (1 2) (1 3) (1) (2 3) (2) (3) ()). We can use this with and without technique to generate the result.
+---+ +---------------------------+ +--------------------------------------------+
| +-with----> ((1 2 3) (1 2) (1 3) (1)) | | |
| 1 | | +-----> ((1 2 3) (1 2) (1 3) (1) (2 3) (2) (3) ()) |
| +-without-> ((2 3) (2) (3) ()) | | |
+-^-+ +---------------------------+ +--------------------------------------------+
|
+-------------------------------------------+
|
+---+ +-------------+ +-----------+--------+
| +-with------> ((2 3) (2)) | | |
| 2 | | +---> ((2 3) (2) (3) ()) |
| +-without---> ((3) ()) | | |
+-^-+ +-------------+ +--------------------+
|
+--------------------------------+
|
+---+ +-----+ +------+--------+
| +-with------> (3) | | |
| 3 | | +-----> ((3) ()) |
| +-without---> () | | |
+-^-+ +-----+ +---------------+
|
|
+-+-+
|() |
| | <- base case
+---+