长度为a，b和c的最大段数

给定正整数N，找到可以由N形成的长度为a，b和c的最大片段数。
例子 ：

Input : N = 7, a = 5, b, = 2, c = 5 
Output : 2 
N can be divided into 2 segments of lengths
2 and 5. For the second example,

Input : N = 17, a = 2, b = 1, c = 3 
Output : 17 
N can be divided into 17 segments of 1 or 8 
segments of 2 and 1 segment of 1. But 17 segments
of 1 is greater than 9 segments of 2 and 1.  

方法：使用的方法是动态编程。基本dp ₀将为0，因为最初它没有任何分段。之后，从1迭代到n，并针对dp _{i + a} ，dp _{i + b}和dp _{i + c}这3种状态的每_一个，存储通过使用或不使用a，b或c获得的最大值部分。
要处理的三个州是：

dp_i+a=max(dp_i+1, dp_i+a); 
dp_i+b=max(dp_i+1, dp_i+b); 
dp_i+c=max(dp_i+1, dp_i+c);

下面是上述想法的实现：

C++

// C++ implementation to divide N into
// maximum number of segments
// of length a, b and c
#include 
using namespace std;
 
// function to find the maximum
// number of segments
int maximumSegments(int n, int a,
                    int b, int c)
{
    // stores the maximum number of
    // segments each index can have
    int dp[n + 1];
     
    // initialize with -1
    memset(dp, -1, sizeof(dp));
 
    // 0th index will have 0 segments
    // base case
    dp[0] = 0;
 
    // traverse for all possible
    // segments till n
    for (int i = 0; i < n; i++)
    {
        if (dp[i] != -1) {
             
            // conditions
        if(i + a <= n )    //avoid buffer overflow
                dp[i + a] = max(dp[i] + 1,
                            dp[i + a]);
                             
        if(i + b <= n ) //avoid buffer overflow
                dp[i + b] = max(dp[i] + 1,
                            dp[i + b]);
                             
        if(i + c <= n )    //avoid buffer overflow
                dp[i + c] = max(dp[i] + 1,
                            dp[i + c]);
        }
    }
    return dp[n];
}
 
// Driver code
int main()
{
    int n = 7, a = 5, b = 2, c = 5;
    cout << maximumSegments(n, a, b, c);
    return 0;
}

Java

// Java implementation to divide N into
// maximum number of segments
// of length a, b and c
import java.util.*;
 
class GFG
{
     
    // function to find the maximum
    // number of segments
    static int maximumSegments(int n, int a,
                            int b, int c)
    {
        // stores the maximum number of
        // segments each index can have
        int dp[] = new int[n + 10];
 
        // initialize with -1
        Arrays.fill(dp, -1);
 
        // 0th index will have 0 segments
        // base case
        dp[0] = 0;
 
        // traverse for all possible
        // segments till n
        for (int i = 0; i < n; i++)
        {
            if (dp[i] != -1)
            {
 
                // conditions
                if(i + a <= n )    //avoid buffer overflow
                dp[i + a] = Math.max(dp[i] + 1,
                                    dp[i + a]);
                                     
                if(i + b <= n )    //avoid buffer overflow
                dp[i + b] = Math.max(dp[i] + 1,    
                                    dp[i + b]);
                                     
                if(i + c <= n )    //avoid buffer overflow
                dp[i + c] = Math.max(dp[i] + 1,
                                    dp[i + c]);
            }
        }
        return dp[n];
    }
 
    // Driver code
    public static void main(String arg[])
    {
        int n = 7, a = 5, b = 2, c = 5;
        System.out.print(maximumSegments(n, a, b, c));
    }
}
 
// This code is contributed by Anant Agarwal.

Python3

# Python implementation
# to divide N into maximum
# number of segments of
# length a, b and c
 
# function to find
# the maximum number
# of segments
def maximumSegments(n, a, b, c) :
 
    # stores the maximum
    # number of segments
    # each index can have
    dp = [-1] * (n + 10)
 
    # 0th index will have
    # 0 segments base case
    dp[0] = 0
 
    # traverse for all possible
    # segments till n
    for i in range(0, n) :
     
        if (dp[i] != -1) :
         
            # conditions
            if(i + a <= n ): # avoid buffer overflow   
                dp[i + a] = max(dp[i] + 1,
                            dp[i + a])
                             
            if(i + b <= n ): # avoid buffer overflow   
                dp[i + b] = max(dp[i] + 1,
                            dp[i + b])
                             
            if(i + c <= n ): # avoid buffer overflow   
                dp[i + c] = max(dp[i] + 1,
                            dp[i + c])
 
    return dp[n]
 
# Driver code
n = 7
a = 5
b = 2
c = 5
print (maximumSegments(n, a,
                    b, c))
 
# This code is contributed by
# Manish Shaw(manishshaw1)

C#

// C# implementation to divide N into
// maximum number of segments
// of length a, b and c
using System;
 
class GFG
{
     
    // function to find the maximum
    // number of segments
    static int maximumSegments(int n, int a,
                            int b, int c)
    {
        // stores the maximum number of
        // segments each index can have
        int []dp = new int[n + 10];
 
        // initialize with -1
        for(int i = 0; i < n + 10; i++)
        dp[i]= -1;
         
 
        // 0th index will have 0 segments
        // base case
        dp[0] = 0;
 
        // traverse for all possible
        // segments till n
        for (int i = 0; i < n; i++)
        {
            if (dp[i] != -1)
            {
 
                // conditions
                if(i + a <= n )    // avoid buffer overflow
                dp[i + a] = Math.Max(dp[i] + 1,
                                    dp[i + a]);
                                     
                if(i + b <= n )    // avoid buffer overflow
                dp[i + b] = Math.Max(dp[i] + 1,
                                    dp[i + b]);
                                     
                if(i + c <= n )    // avoid buffer overflow
                dp[i + c] = Math.Max(dp[i] + 1,
                                    dp[i + c]);
            }
        }
        return dp[n];
    }
 
    // Driver code
    public static void Main()
    {
        int n = 7, a = 5, b = 2, c = 5;
        Console.Write(maximumSegments(n, a, b, c));
    }
}
 
// This code is contributed by nitin mittal

Javascript

// JavaScript program implementation to divide N into
// maximum number of segments
// of length a, b and c
 
    // function to find the maximum
    // number of segments
    function maximumSegments(n, a, b, c)
    {
        // stores the maximum number of
        // segments each index can have
        let dp = [];
   
        // initialize with -1
        for(let i = 0; i < n + 10; i++)
        dp[i]= -1;
   
        // 0th index will have 0 segments
        // base case
        dp[0] = 0;
   
        // traverse for all possible
        // segments till n
        for (let i = 0; i < n; i++)
        {
            if (dp[i] != -1)
            {
   
                // conditions
                if(i + a <= n )    //avoid buffer overflow
                dp[i + a] = Math.max(dp[i] + 1,
                                    dp[i + a]);
                                       
                if(i + b <= n )    //avoid buffer overflow
                dp[i + b] = Math.max(dp[i] + 1,    
                                    dp[i + b]);
                                       
                if(i + c <= n )    //avoid buffer overflow
                dp[i + c] = Math.max(dp[i] + 1,
                                    dp[i + c]);
            }
        }
        return dp[n];
    }
   
 
// Driver Code
 
        let n = 7, a = 5, b = 2, c = 5;
        document.write(maximumSegments(n, a, b, c));
 
// This code is contributed by susmitakundugoaldanga.

输出 ：

2

时间复杂度：O(n)