Динамическое программирование

public class Solution {
     static BufferedReader in;
     static StringTokenizer st;
 
 
 static String next() throws IOException {
  if (st == null || !st.hasMoreTokens()) 
  {
      String line = in.readLine();
      if (line == null)
          return null;
      st = new StringTokenizer(line);
  }
  return st.nextToken();
}
 
 public static void main(String[] args) {
      try {
          boolean tack = false;
       in = new BufferedReader(new FileReader("input.txt"));
       PrintWriter out = new PrintWriter(new FileWriter("output.txt"));
       int n = Integer.parseInt(next());
       int m = Integer.parseInt(next());
       int d = Integer.parseInt(next());
       int[] l = new int[n];
       for (int i = 0; i < n; i++)
          l[i] = Integer.parseInt(next());
       
       int space = 0,next_i = 0,next_j=0,next_k=0;
       int[][][] mas = new int[n + 1][m + 1][d];
       
       for (int i = 0; i < n; i++) 
       {
          for (int j = 0; j < m; j++) 
          {
              for (int k = 0; k < d; k++) 
              {
                  space = l[i];
                  next_i = i + 1;
                  next_j = j;
                  next_k = k + space;
          
                  if (need_space > d)
                      continue;
          
                  if (next_k > d) 
                  {
                      next_j++;
                      next_k = space;
                  }
          
                  if (next_k == d) 
                  {
                      next_j++;
                      next_k = 0;
                  }
          
                  if (next_i > n || next_j > m || next_k >= d)
                      continue;
          
                  if (mas[next_i][next_j][next_k] < mas[i][j][k] + 1)
                      mas[next_i][next_j][next_k] = mas[i][j][k] + 1;
 
              }
          }
       }
       
       int res = 0;
       for (int i = 0; i < n + 1; i++)
          for (int j = 0; j < m + 1; j++)
              for (int k = 0; k < d; k++)
                  res = Math.max(res, mas[i][j][k]);
 
       out.println(res);
       out.close();
      } catch (IOException e) {
       
      }
    }
 
}

static void MaxN(int count, int d, int[] musicLength, int cIndex, int restD, int max) {
        if (count == 0) {
            if (musicLength[musicLength.length - 1] < max)
                musicLength[musicLength.length - 1] = max;
            return;
        }
        for (int index = cIndex, rD = restD; index < musicLength.length; index++) {
            if (musicLength[index] <= rD)
                MaxN(count, d, musicLength, index + 1, rD - musicLength[index], max + 1);
            else
                MaxN(count - 1, d, musicLength, index, d, max);
            MaxN(count, d, musicLength, index + 1, rD, max);
        }
    }
    public static void main(final String[] args) {
        int M /*число кассет*/ = 4;
        int D /*длительность звучания */ = 6;
        int N /*Число песен*/ = 8;
        int[] musicLength = {4, 2, 4, 2, 6, 6, 4, 2,/*последний элемент ответ*/ 0};
 
        MaxN(M, D, musicLength, 0, D, 0);
        System.out.println(musicLength[musicLength.length - 1]);
    }

import java.io.*;
import java.util.*;
 
public class Main {
 
    public static void main(String[] args) {
        int N = 0, M = 0, D = 0;
        int[] musicLength = null;
        int[][] table = null;
 
        try (Scanner sc = new Scanner(new File("input.txt"))) {
 
            M = sc.nextInt();
            D = sc.nextInt();
            N = sc.nextInt();
            musicLength = new int[N + 1];
            table = new int[N + 1][M * D + 1];
 
            for (int i = 1; i <= N; i++)
                musicLength[i] = sc.nextInt();
        } catch (FileNotFoundException ex) {
        }
 
        for (int i = 1; i <= N; i++)
            for (int j = 1, val = 1; j <= M * D; j++, val = (val + 1 > D) ? 1 : val + 1)
                if (musicLength[i] <= val)
                    table[i][j] = Math.max(table[i - 1][j], table[i - 1][j - musicLength[i]] + 1);
                else
                    table[i][j] = Math.max(table[i][j - 1], table[i - 1][j]);
 
        try (PrintWriter pw = new PrintWriter(new File("output.txt"))) {
            pw.println(table[N][M * D]);
        } catch (FileNotFoundException ex) {
        }
 
    }
}