Minimum number of palindromes required to express N as a sum | Set 1

Given a number N, we have to find the minimum number of palindromes required to express N as a sum of them. 
Examples:

Input: N = 11 
Output: 1 
11 is itself a palindrome.
Input: N = 65 
Output: 3 
65 can be expressed as a sum of three palindromes (55, 9, 1).

Approach:
We can use Dynamic Programming to solve this problem. The idea is to first generate all the palindromes up to N in a sorted fashion, and then we can treat this problem as a variation of the subset sum problem, where we have to find the size of the smallest subset such that its sum is N.
Below is the implementation of above approach:

CPP

// C++ implementation of above approach
#include <bits/stdc++.h>
using namespace std;

// Declaring the DP table as global variable
vector<vector<long long> > dp;


// A utility for creating palindrome
int createPalindrome(int input, bool isOdd)
{
    int n = input;
    int palin = input;

    // checks if number of digits is odd or even
    // if odd then neglect the last digit of input in
    // finding reverse as in case of odd number of
    // digits middle element occur once
    if (isOdd)
        n /= 10;

    // Creates palindrome by just appending reverse
    // of number to itself
    while (n > 0) {
        palin = palin * 10 + (n % 10);
        n /= 10;
    }

    return palin;
}

// Function to generate palindromes
vector<int> generatePalindromes(int N)
{
    vector<int> palindromes;
    int number;

    // Run two times for odd and even length palindromes
    for (int j = 0; j < 2; j++) {
        // Creates palindrome numbers with first half as i.
        // Value of j decides whether we need an odd length
        // or even length palindrome.
        int i = 1;
        while ((number = createPalindrome(i++, j)) <= N)
            palindromes.push_back(number);
    }

    return palindromes;
}

// Function to find the minimum
// number of elements in a sorted
// array A[i..j] such that their sum is N
long long minimumSubsetSize(vector<int>& A, int i, int j, int N)
{
    if (!N)
        return 0;

    if (i > j || A[i] > N)
        return INT_MAX;

    if (dp[i][N])
        return dp[i][N];

    dp[i][N] = min(1 + minimumSubsetSize(A, i + 1, j,
                                         N - A[i]),
                   minimumSubsetSize(A, i + 1, j, N));

    return dp[i][N];
}

// Function to find the minimum
// number of palindromes that N
// can be expressed as a sum of
int minimumNoOfPalindromes(int N)
{
    // Getting the list of all palindromes upto N
    vector<int> palindromes = generatePalindromes(N);

    // Sorting the list of palindromes
    sort(palindromes.begin(), palindromes.end());

    // Initializing the DP table
    dp = vector<vector<long long> >(palindromes.size(),
                                    vector<long long>(N + 1, 0));

    // Returning the required value
    return minimumSubsetSize(palindromes, 0,
                             palindromes.size() - 1, N);
}

// Driver code
int main()
{
    int N = 65;
    cout << minimumNoOfPalindromes(N);
    return 0;
}

Java

/*package whatever //do not write package name here */

import java.io.*;
import java.util.*;

class GFG {
  // Java implementation of above approach

  // Declaring the DP table as global variable
  static long[][] dp;


  // A utility for creating palindrome
  static int createPalindrome(int input, int isOdd)
  {
    int n = input;
    int palin = input;

    // checks if number of digits is odd or even
    // if odd then neglect the last digit of input in
    // finding reverse as in case of odd number of
    // digits middle element occur once
    if (isOdd > 0)
      n /= 10;

    // Creates palindrome by just appending reverse
    // of number to itself
    while (n > 0) {
      palin = palin * 10 + (n % 10);
      n /= 10;
    }

    return palin;
  }

  // Function to generate palindromes
  static ArrayList<Integer> generatePalindromes(int N)
  {
    ArrayList<Integer> palindromes = new ArrayList<>();
    int number;

    // Run two times for odd and even length palindromes
    for (int j = 0; j < 2; j++) {
      // Creates palindrome numbers with first half as i.
      // Value of j decides whether we need an odd length
      // or even length palindrome.
      int i = 1;
      while ((number = createPalindrome(i++, j)) <= N)
        palindromes.add(number);
    }

    return palindromes;
  }

  // Function to find the minimum
  // number of elements in a sorted
  // array A[i..j] such that their sum is N
  static long minimumSubsetSize(ArrayList<Integer> A, int i, int j, int N)
  {
    if (N == 0)
      return 0;

    if (i > j || A.get(i) > N)
      return Integer.MAX_VALUE;

    if (dp[i][N] > 0)
      return dp[i][N];

    dp[i][N] = Math.min(1 + minimumSubsetSize(A, i + 1, j,
                                              N - A.get(i)),
                        minimumSubsetSize(A, i + 1, j, N));

    return dp[i][N];
  }

  // Function to find the minimum
  // number of palindromes that N
  // can be expressed as a sum of
  static int minimumNoOfPalindromes(int N)
  {
    // Getting the list of all palindromes upto N
    ArrayList<Integer> palindromes = generatePalindromes(N);

    // Sorting the list of palindromes
    Collections.sort(palindromes);

    // Initializing the DP table
    dp = new long [palindromes.size()][N + 1];



    // Returning the required value
    return (int)minimumSubsetSize(palindromes, 0,
                                  palindromes.size() - 1, N);
  }

  // Driver Code
  public static void main(String args[])
  {
    int N = 65;
    System.out.println(minimumNoOfPalindromes(N));
  }
}

// This code is contributed by shinjanpatra.

Python3

# Python3 implementation of above approach

# Declaring the DP table as global variable
dp = [[0 for i in range(1000)] for i in range(1000)]

# A utility for creating palindrome
def createPalindrome(input, isOdd):

    n = input
    palin = input

    # checks if number of digits is odd or even
    # if odd then neglect the last digit of input in
    # finding reverse as in case of odd number of
    # digits middle element occur once
    if (isOdd):
        n //= 10

    # Creates palindrome by just appending reverse
    # of number to itself
    while (n > 0):
        palin = palin * 10 + (n % 10)
        n //= 10

    return palin

# Function to generate palindromes
def generatePalindromes(N):

    palindromes = []
    number = 0

    # Run two times for odd and even length palindromes
    for j in range(2):

        # Creates palindrome numbers with first half as i.
        # Value of j decides whether we need an odd length
        # or even length palindrome.
        i = 1
        number = createPalindrome(i, j)
        while number <= N:
            number = createPalindrome(i, j)
            palindromes.append(number)
            i += 1

    return palindromes

# Function to find the minimum
# number of elements in a sorted
# array A[i..j] such that their sum is N
def minimumSubsetSize(A, i, j, N):

    if (not N):
        return 0

    if (i > j or A[i] > N):
        return 10**9

    if (dp[i][N]):
        return dp[i][N]

    dp[i][N] = min(1 + minimumSubsetSize(A, i + 1, j, N - A[i]),
                    minimumSubsetSize(A, i + 1, j, N))

    return dp[i][N]

# Function to find the minimum
# number of palindromes that N
# can be expressed as a sum of
def minimumNoOfPalindromes(N):

    # Getting the list of all palindromes upto N
    palindromes = generatePalindromes(N)

    # Sorting the list of palindromes
    palindromes = sorted(palindromes)

    # Returning the required value
    return minimumSubsetSize(palindromes, 0, len(palindromes) - 1, N)

# Driver code
N = 65
print(minimumNoOfPalindromes(N))

# This code is contributed by mohit kumar 29

C#

// C# program to implement the approach
using System;
using System.Collections.Generic;

class GFG {

  // Declaring the DP table as global variable
  static long[, ] dp;

  // A utility for creating palindrome
  static int createPalindrome(int input, int isOdd)
  {
    int n = input;
    int palin = input;

    // checks if number of digits is odd or even
    // if odd then neglect the last digit of input in
    // finding reverse as in case of odd number of
    // digits middle element occur once
    if (isOdd > 0)
      n /= 10;

    // Creates palindrome by just appending reverse
    // of number to itself
    while (n > 0) {
      palin = palin * 10 + (n % 10);
      n /= 10;
    }

    return palin;
  }

  // Function to generate palindromes
  static List<int> generatePalindromes(int N)
  {
    List<int> palindromes = new List<int>();
    int number;

    // Run two times for odd and even length palindromes
    for (int j = 0; j < 2; j++) {
      // Creates palindrome numbers with first half as
      // i. Value of j decides whether we need an odd
      // length or even length palindrome.
      int i = 1;
      while ((number = createPalindrome(i++, j)) <= N)
        palindromes.Add(number);
    }

    return palindromes;
  }

  // Function to find the minimum
  // number of elements in a sorted
  // array A[i..j] such that their sum is N
  static long minimumSubsetSize(List<int> A, int i, int j,
                                int N)
  {
    if (N == 0)
      return 0;

    if (i > j || A[i] > N)
      return Int32.MaxValue;

    if (dp[i, N] > 0)
      return dp[i, N];

    dp[i, N] = Math.Min(
      1 + minimumSubsetSize(A, i + 1, j, N - A[i]),
      minimumSubsetSize(A, i + 1, j, N));

    return dp[i, N];
  }

  // Function to find the minimum
  // number of palindromes that N
  // can be expressed as a sum of
  static int minimumNoOfPalindromes(int N)
  {
    // Getting the list of all palindromes upto N
    List<int> palindromes = generatePalindromes(N);

    // Sorting the list of palindromes
    palindromes.Sort();

    // Initializing the DP table
    dp = new long[palindromes.Count, N + 1];

    // Returning the required value
    return (int)minimumSubsetSize(
      palindromes, 0, palindromes.Count - 1, N);
  }

  // Driver Code
  public static void Main(string[] args)
  {
    int N = 65;
    Console.WriteLine(minimumNoOfPalindromes(N));
  }
}

// This code is contributed by phasing17.

Javascript

<script>

// JavaScript implementation of above approach

// Declaring the DP table as global variable
let dp = new Array(1000);
for(let i = 0; i < 1000; i++)
{
    dp[i] = new Array(1000).fill(0);
}

// A utility for creating palindrome
function createPalindrome(input, isOdd){

    let n = input
    let palin = input

    // checks if number of digits is odd or even
    // if odd then neglect the last digit of input in
    // finding reverse as in case of odd number of
    // digits middle element occur once
    if (isOdd)
        n = Math.floor(n /10)

    // Creates palindrome by just pushing reverse
    // of number to itself
    while (n > 0){
        palin = palin * 10 + (n % 10)
        n = Math.floor(n /10)
    }

    return palin
}

// Function to generate palindromes
function generatePalindromes(N){

    let palindromes = []
    let number = 0

    // Run two times for odd and even length palindromes
    for(let j = 0; j < 2; j++)
    {

        // Creates palindrome numbers with first half as i.
        // Value of j decides whether we need an odd length
        // or even length palindrome.
        let i = 1
        number = createPalindrome(i, j)
        while(number <= N){
            number = createPalindrome(i, j)
            palindromes.push(number)
            i += 1
        }
    }

    return palindromes
}

// Function to find the minimum
// number of elements in a sorted
// array A[i..j] such that their sum is N
function minimumSubsetSize(A, i, j, N){

    if (N == 0)
        return 0

    if (i > j || A[i] > N)
        return Math.pow(10,9)

    if (dp[i][N])
        return dp[i][N]

    dp[i][N] = Math.min(1 + minimumSubsetSize(A, i + 1, j, N - A[i]),
                    minimumSubsetSize(A, i + 1, j, N))

    return dp[i][N]
}

// Function to find the minimum
// number of palindromes that N
// can be expressed as a sum of
function minimumNoOfPalindromes(N){

    // Getting the list of all palindromes upto N
    let palindromes = generatePalindromes(N)

    // Sorting the list of palindromes
    palindromes.sort((a,b)=>a-b)

    // Returning the required value
    return minimumSubsetSize(palindromes, 0, palindromes.length - 1, N)
}

// Driver code
let N = 65
document.write(minimumNoOfPalindromes(N),"</br>")

// This code is contributed by shinjanpatra

</script>

Output:

3