Take two inputs from user:

N - #items
B - budget.

There are S items, each with some price value, out of which user needs to select N items in such a way that total bill does not exceed B. The program should print all such combination of N products.

To solve this problem, we can use the concept of recursion and backtracking.

Here's the step-by-step approach to solve the problem:

1. Take two inputs from the user: N (the number of items to be selected) and B (the budget).
2. Create a list to store the prices of the S items.
3. Sort the list of prices in ascending order.
4. Create an empty list to store the selected items.
5. Call the recursive function with the following parameters: index (0 initially), N, B, the list of prices, and the list of selected items.
6. In the recursive function:
a. Check if the number of items selected is equal to N. If so, print the selected items and return.
b. Check if the index is greater than or equal to the length of the price list. If so, return.
c. Check if the current price is greater than the remaining budget. If so, return.
d. Add the current price to the selected items list.
e. Call the recursive function again with the updated parameters:
- Increment the index by 1.
- Decrement N by 1.
- Subtract the current price from the remaining budget.
- Pass the updated lists of prices and selected items.
f. Remove the last added item from the selected items list and call the recursive function again without selecting the current item:
- Increment the index by 1.
- Maintain the value of N and B.
- Pass the original lists of prices and selected items.
7. Call the recursive function with the initial parameters (index = 0, N, B, price list, and an empty list of selected items).

Here's the algorithm implementation in Python:

```python
def find_combinations(index, N, B, prices, selected_items):
if N == 0:
print(selected_items)
return

if index >= len(prices):
return

if prices[index] > B:
return

selected_items.append(prices[index])
find_combinations(index + 1, N - 1, B - prices[index], prices, selected_items)
selected_items.pop()
find_combinations(index + 1, N, B, prices, selected_items)

N = int(input("Enter the number of items to be selected: "))
B = float(input("Enter the budget amount: "))

S = int(input("Enter the total number of items: "))
prices = []
for i in range(S):
price = float(input(f"Enter the price of item {i + 1}: "))
prices.append(price)

prices.sort()

selected_items = []
find_combinations(0, N, B, prices, selected_items)
```

By following the above algorithm, the program will print all the combinations of N items whose total price does not exceed the budget B.