Imprima todas las posibles subsecuencias de longitud K de los primeros N números naturales con suma N

Dados dos enteros positivos N y K , la tarea es imprimir todas las subsecuencias posibles de longitud K a partir de los primeros N números naturales cuya suma de elementos sea igual a N .

Ejemplos:

Entrada: N = 5, K = 3 
Salida: { {1, 1, 3}, {1, 2, 2}, {1, 3, 1}, {2, 1, 2}, {2, 2, 1 }, {3, 1, 1} } 
Explicación: 
1 + 1 + 3 = N(= 5) y la longitud es K(= 3) 
1 + 2 + 2 = N(= 5) y la longitud es K(= 3) 
1 + 3 + 1 = N(= 5) y la longitud es K(= 3) 
2 + 1 + 2 = N(= 5) y la longitud es K(= 3) 
2 + 2 + 1 = N(= 5) y la longitud es K(= 3) 
3 + 1 + 1 = N(= 5) y la longitud es K(= 3)

Entrada: N = 3, K = 3 
Salida: { {1, 1, 1} }

Enfoque: El problema se puede resolver utilizando la técnica de retroceso . A continuación se muestra la relación de recurrencia:

Siga los pasos a continuación para resolver el problema:

• Inicialice una array 2D , digamos, res[][] para almacenar todas las posibles subsecuencias de longitud K cuya suma sea igual a N .
• Utilice la relación de recurrencia anterior y encuentre todas las subsecuencias posibles de longitud K cuya suma sea igual a N .
• Finalmente, imprima la array res[][] .

A continuación se muestra la implementación del enfoque anterior:

// C++ program to implement
// the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to print all subsequences of length
// K from N natural numbers whose sum equal to N
void findSub(vector<vector<int> >& res, int sum,
             int K, int N, vector<int>& temp)
{
 
    // Base case
    if (K == 0 && sum == 0) {
        res.push_back(temp);
        return;
    }
    if (sum <= 0 || K <= 0) {
        return;
    }
 
    // Iterate over the range [1, N]
    for (int i = 1; i <= N; i++) {
 
        // Insert i into temp
        temp.push_back(i);
        findSub(res, sum - i, K - 1, N, temp);
 
        // Pop i from temp
        temp.pop_back();
    }
}
 
// Utility function to print all subsequences
// of length K with sum equal to N
void UtilPrintSubsequncesOfKSumN(int N, int K)
{
 
    // Store all subsequences of length K
    // from N natural numbers
    vector<vector<int> > res;
 
    // Store current subsequence of
    // length K from N natural numbers
    vector<int> temp;
 
    findSub(res, N, K, N, temp);
 
    // Stores total count
    // of subsequences
    int sz = res.size();
 
    // Print all subsequences
    cout << "{ ";
 
    // Traverse all subsequences
    for (int i = 0; i < sz; i++) {
 
        cout << "{ ";
 
        // Print current subsequence
        for (int j = 0; j < K; j++) {
 
            // If current element is last
            // element of subsequence
            if (j == K - 1)
                cout << res[i][j] << " ";
            else
                cout << res[i][j] << ", ";
        }
 
        // If current subsequence is last
        // subsequence from n natural numbers
        if (i == sz - 1)
            cout << "}";
        else
            cout << "}, ";
    }
    cout << " }";
}
 
// Driver Code
int main()
{
 
    int N = 4;
    int K = 2;
    UtilPrintSubsequncesOfKSumN(N, K);
}

// Java program to implement
// the above approach
import java.io.*;
import java.util.*;
import java.util.stream.Collectors;
 
class GFG {
 
  // Function to print all subsequences of length
  // K from N natural numbers whose sum equal to N
  static void findSub(List<List<Integer> > res, int sum,
                      int K, int N, List<Integer> temp)
  {
 
    // Base case
    if (K == 0 && sum == 0) {
      List<Integer> newList = temp.stream().collect(
        Collectors.toList());
      res.add(newList);
      return;
    }
    if (sum <= 0 || K <= 0) {
      return;
    }
 
    // Iterate over the range [1, N]
    for (int i = 1; i <= N; i++) {
 
      // Insert i into temp
      temp.add(i);
      findSub(res, sum - i, K - 1, N, temp);
 
      // Pop i from temp
      temp.remove(temp.size() - 1);
    }
  }
 
  // Utility function to print all subsequences
  // of length K with sum equal to N
  static void UtilPrintSubsequncesOfKSumN(int N, int K)
  {
 
    // Store all subsequences of length K
    // from N natural numbers
    @SuppressWarnings("unchecked")
    List<List<Integer> > res = new ArrayList();
 
    // Store current subsequence of
    // length K from N natural numbers
    @SuppressWarnings("unchecked")
    List<Integer> temp = new ArrayList();
 
    findSub(res, N, K, N, temp);
 
    // Stores total count
    // of subsequences
    int sz = res.size();
 
    // Print all subsequences
    System.out.print("{ ");
 
    // Traverse all subsequences
    for (int i = 0; i < sz; i++) {
 
      System.out.print("{ ");
 
      // Print current subsequence
      for (int j = 0; j < K; j++) {
 
        // If current element is last
        // element of subsequence
        if (j == K - 1)
          System.out.print(res.get(i).get(j)
                           + " ");
        else
          System.out.print(res.get(i).get(j)
                           + ", ");
      }
 
      // If current subsequence is last
      // subsequence from n natural numbers
      if (i == sz - 1)
        System.out.print("}");
      else
        System.out.print("}, ");
    }
    System.out.print(" }");
  }
 
  // Driver code
  public static void main(String[] args)
  {
    int N = 4;
    int K = 2;
    UtilPrintSubsequncesOfKSumN(N, K);
  }
}
 
// This code is contributed by jithin.

# Python program to implement
# the above approach
 
 
# Function to print all subsequences of length
# K from N natural numbers whose sum equal to N
def findSub(res,sum,K,N,temp):
 
    # Base case
    if (K == 0 and sum == 0):
        res.append(temp[:])
        return
 
    if (sum <= 0 or K <= 0):
        return
 
    # Iterate over the range [1, N]
    for i in range(1,N):
 
        # Insert i into temp
        temp.append(i)
        findSub(res, sum - i, K - 1, N, temp)
 
        # Pop i from temp
        temp.pop()
 
# Utility function to print all subsequences
# of length K with sum equal to N
def UtilPrintSubsequncesOfKSumN(N, K):
 
    # Store all subsequences of length K
    # from N natural numbers
    res = []
 
    # Store current subsequence of
    # length K from N natural numbers
    temp = []
 
    findSub(res, N, K, N, temp)
     
    # # Stores total count
    # # of subsequences
    sz = len(res)
 
    # Print all subsequences
    print("{",end=" ")
 
    # Traverse all subsequences
    for i in range(sz):
 
        print("{",end=" ")
 
        # Print current subsequence
        for j in range(K):
 
            # If current element is last
            # element of subsequence
            if (j == K - 1):
                print(res[i][j],end=" ")
            else:
                print(res[i][j],end = ", ")
 
        # If current subsequence is last
        # subsequence from n natural numbers
        if (i == sz - 1):
            print("}",end="")
        else:
            print("},",end =" ")
    print(" }")
 
# Driver Code
N = 4
K = 2
UtilPrintSubsequncesOfKSumN(N, K)
 
# This code is contributed by shinjanpatra

{ { 1, 3 }, { 2, 2 }, { 3, 1 } }

Complejidad Temporal: O(2 ^N )  
Espacio Auxiliar: O(X), donde X denota el conteo de subsecuencias de longitud K cuya suma es N