服务部署

//write code here
vector<vector<vector<int>>> dp(countOfApp + 1,vector<vector<int>>(disk+1,vector<int>(mem+1)));
    for(int i = 1; i <= countOfApp; i++){
        for(int j = disk; j > 0; j--){
            for(int k = mem; k > 0; k--){
                if(j >= disks[i-1] && k >= mems[i-1]){
                    dp[i][j][k] = max(dp[i - 1][j][k],dp[i - 1][j - disks[i-1]][k - mems[i-1]]+ users[i-1]);
                }else{
                    dp[i][j][k] = dp[i - 1][j][k];
                }
            }
        }
    }
	return dp[countOfApp][disk][mem];

import java.io.*;
import java.util.*;
 
/**
 * Welcome to vivo !
 */
 
public class Main {
 
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String inputStr = br.readLine();
        String[] input = inputStr.split(" ");
        int totalDisk = Integer.parseInt(input[0]);
        int totalMemory = Integer.parseInt(input[1]);
        List<Service> services = parseServices(input[2].split("#"));
        int output = solution(totalDisk, totalMemory, services);
        System.out.println(output);
    }
 
    private static int solution(int totalDisk, int totalMemory, List<Service> services) {
 
        // TODO Write your code here
        int len = services.size();
        int[][][] dp = new int[len + 1][totalDisk + 1][totalMemory + 1];
           for(int i = 1; i <= len; i++)
                 for(int j = totalDisk; j > 0; j--)
                     for(int k = totalMemory; k > 0; k--){
           if(j >= services.get(i - 1).getDisk() && k >= services.get(i - 1).getMemory()){
                    dp[i][j][k] = Math.max(dp[i - 1][j][k],
                    dp[i - 1][j - services.get(i - 1).getDisk()][k - services.get(i - 1).getMemory()]
                    + services.get(i - 1).getusers());
           }else{
                    dp[i][j][k] = dp[i - 1][j][k];
           }
        }
        return dp[len][totalDisk][totalMemory];
    }
 
    private static List<Service> parseServices(String[] strArr) {
        if (strArr == null || strArr.length == 0) {
            return new ArrayList<Service>(0);
        }
        List<Service> services = new ArrayList<>(strArr.length);
        for (int i = 0; i < strArr.length; i++) {
            String[] serviceArr = strArr[i].split(",");
            int disk = Integer.parseInt(serviceArr[0]);
            int memory = Integer.parseInt(serviceArr[1]);
            int users = Integer.parseInt(serviceArr[2]);
            services.add(new Service(disk, memory, users));
        }
        return services;
    }
 
    static class Service {
        private int disk;
 
        private int memory;
 
        private int users;
 
        public Service(int disk, int memory, int users) {
            this.disk = disk;
            this.memory = memory;
            this.users = users;
        }
 
        public int getDisk() {
            return disk;
        }
 
        public void setDisk(int disk) {
            this.disk = disk;
        }
 
        public int getMemory() {
            return memory;
        }
 
        public void setMemory(int memory) {
            this.memory = memory;
        }
 
        public int getusers() {
            return users;
        }
 
        public void setusers(int users) {
            this.users = users;
        }
    }
}

private static int solution(int totalDisk, int totalMemory, List<Service> services) {
    // TODO Write your code here
    // 三维背包问题
    int n = services.size();
    int[][][] dp = new int[n + 1][totalDisk + 1][totalMemory + 1];
    for(int i = 1; i <= n; i++){
        for(int j = totalDisk; j > 0; j--){
            for(int k = totalMemory; k > 0; k--){
                if(j >= services.get(i - 1).getDisk() && k >= services.get(i - 1).getMemory()){
                    // 磁盘空间和内存还够，选择第i个应用程序或不选择第i个应用程序
                    dp[i][j][k] = Math.max(dp[i - 1][j][k],
                                           dp[i - 1][j - services.get(i - 1).getDisk()][k - services.get(i - 1).getMemory()]
                                           + services.get(i - 1).getusers());
                }else{
                    // 磁盘空间不够
                    dp[i][j][k] = dp[i - 1][j][k];
                }
            }
        }
    }
    return dp[n][totalDisk][totalMemory];
}

#include "stdio.h"
#include <stdlib.h>
#include "string.h"
/*
* Welcome to vivo !
*/

int  make (int *a,int b)
{
    int i,j=0;
    int c;
    for (i=0;i<b;i++)
    {
        if (a[i]!=-1) 
        {
            c=a[i];
            j=i;
            break;
        }
    }
    
    for (i=0;i<b;i++)
    {
        if (c>a[i] && a[i]>0) 
        {
            c=a[i];
            j=i;
        }
    }
    return j;
}

int solution(int countOfApp, int disk, int mem){

    int i;
    int Disk=0,Mem=0,User=0;
    for (i=0;i<countOfApp;i++)
    {
        if (disks[i]<=disk && mems[i]<=mem)
        {
        Disk=Disk+disks[i];
        Mem =Mem+mems[i];
        User=User+users[i];            
        }

    }
    for (i=0;i<countOfApp;i++)
    {
        if (Disk<=disk && Mem<=mem) return User;
        else 
        {
         int min= make(users,countOfApp);
         
         Disk=Disk-disks[min];
         Mem=Mem-mems[min];
         User=User-users[min];
         users[min]=-1;   
        }        
    }

}

import java.io.*;
import java.util.*;
public class Main {
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String inputStr = br.readLine();
        String[] input = inputStr.split(" ");
        int totalDisk = Integer.parseInt(input[0]);
        int totalMemory = Integer.parseInt(input[1]);
        List<Service> services = parseServices(input[2].split("#"));
        int output = solution(totalDisk, totalMemory, services);
        System.out.println(output);
    }
    
    // -------------------------------------------------------------------------------------
    private static int solution(int totalDisk, int totalMemory, List<Service> services) {
        Collections.sort(services, new Comparator<Service>(){  // 按照用户数，从大到小排序
			@Override
			public int compare(Service s1, Service s2) {
				if(s2.users > s1.users) {
					return 1;
				}
				return -1;
			}
        });
        int sum = 0;                                           // 单台服务器能承载的最大用户数
        for(Service it : services){                            // 从用户数最大的应用程序开始遍历
            if(totalDisk>=it.disk && totalMemory>=it.memory){  // 同时满足所需磁盘空间和内存时
                sum += it.users;                               // 累计用户数
                totalDisk -= it.disk;
                totalMemory -= it.memory;
            }
        }
        return sum;
    }
    // -------------------------------------------------------------------------------------
    
    private static List<Service> parseServices(String[] strArr) {
        if (strArr == null || strArr.length == 0) {
            return new ArrayList<Service>(0);
        }
        List<Service> services = new ArrayList<>(strArr.length);
        for (int i = 0; i < strArr.length; i++) {
            String[] serviceArr = strArr[i].split(",");
            int disk = Integer.parseInt(serviceArr[0]);
            int memory = Integer.parseInt(serviceArr[1]);
            int users = Integer.parseInt(serviceArr[2]);
            services.add(new Service(disk, memory, users));
        }
        return services;
    }

    static class Service {
        private int disk;

        private int memory;

        private int users;

        public Service(int disk, int memory, int users) {
            this.disk = disk;
            this.memory = memory;
            this.users = users;
        }

        public int getDisk() {
            return disk;
        }

        public void setDisk(int disk) {
            this.disk = disk;
        }

        public int getMemory() {
            return memory;
        }

        public void setMemory(int memory) {
            this.memory = memory;
        }

        public int getusers() {
            return users;
        }

        public void setusers(int users) {
            this.users = users;
        }
    }
}

for(int i = 0; i < countOfApp; i++){
        for(int j = disk; j >=  disks[i]; j--)
            for(int k = mem; k >= mems[i]; k--){
                dp[j][k] = max(dp[j][k],dp[j-disks[i]][k-mems[i]]+users[i]);            
            }               
    }
    return dp[disk][mem];
    

function solution(disk, mem, apps) {

    // TODO Write your code here
    let a=disk
    let b=mem
    var grid=[]
    let temp=apps
    for(let i=0;i<temp.length;i++){
        let item=temp[i].split(',').map(Number)
        grid.push(item)
    }
    let dp=[]
    for(let i=0;i<=a;i++){
        dp[i]=[]
        for(let j=0;j<=b;j++){
            dp[i][j]=0
        }
    }
    let N=grid.length
    for(let k=0;k<N;k++){
        for(let i=a;i>=grid[k][0];i--){
            for(let j=b;j>=grid[k][1];j--){
                if(i>=grid[k][0] && j>=grid[k][1]){
                    dp[i][j]=Math.max(dp[i][j],dp[i-grid[k][0]][j-grid[k][1]]+grid[k][2])
                }
            }
        }
    }
    return(dp[a][b])
}

#!/usr/bin/python
# -*- coding: utf-8 -*-
  
'''
Welcome to vivo !
'''
 
def solution(total_disk,total_memory,app_list):
     
    disks=[]
    mems=[]
    users=[]
    for x in app_list:
        disks.append(x[0])
        mems.append(x[1])
        users.append(x[2])
        n = len(app_list)
    dp = [[[0]*(mem+1) for _ in range(disk+1)] for _ in range(n+1)]
    for i in range(1,n+1):
        for j in range(1,disk+1):
            for k in range(1,mem+1):
                if j-disks[i-1]>=0 and k-mems[i-1]>=0:
                    dp[i][j][k] = max(dp[i - 1][j][k],dp[i - 1][j - disks[i-1]][k - mems[i-1]]+ users[i-1])
                else:
                    dp[i][j][k] = dp[i-1][j][k] #不选
    return dp[-1][-1][-1]
 
if __name__ == "__main__":
     
    input1 = input()
    disk = int(input1.split()[0])
    mem = int(input1.split()[1])
    input2 = input1.split()[2]
    app_list = [[int(j) for j in i.split(',')] for i in input2.split('#')]
    print(solution(disk,mem,app_list))