GPU算力，判定S是否是L的有效子串，简易内存池 java

GPU算力---100%

一、题目描述：
为了充分发挥GPU算力，
需要尽可能多的将任务交给GPU执行，
现在有一个任务数组，
数组元素表示在这1s内新增的任务个数，
且每秒都有新增任务，
假设GPU最多一次执行n个任务，
一次执行耗时1s，
在保证GPU不空闲的情况下，最少需要多长时间执行完成。

二、输入描述
第一个参数为GPU最多执行的任务个数
取值范围1~10000
第二个参数为任务数组的长度
取值范围1~10000
第三个参数为任务数组
数字范围1~10000

三、输出描述
执行完所有任务需要多少秒

四、示例1
输入
————————————————
 3
5
1 2 3 4 5

输出
6

说明
一次最多执行3个任务，最少耗时6s

六、Java

import java.util.Scanner;

public class Main0005 {
    public static void main(String[] args) {
        try (Scanner scanner = new Scanner(System.in)) {
            int n = scanner.nextInt();
            int len = scanner.nextInt();
            int[] jobCount = new int[len];
            for (int i = 0; i < len; i++) {
                jobCount[i] = scanner.nextInt();
            }
        solution(n, jobCount);
        }
    }
    
    private static void solution(int n, int[] jobCount) {
        int time = 0;
        int remaining = 0;
        for (int count : jobCount) {
            if (count + remaining > n) {
                remaining = count + remaining - n;
            } else {
                remaining = 0;
            }
            time++;
        }
        time += remaining / n;
        if (remaining % n > 0) {
            time++;
        }
        System.out.println(time);
    }
}

原文链接：https://blog.csdn.net/qq_42149894/article/details/125528295

判定S是否是L的有效子串----60%

题目描述
输入两个字符串S和L，都只包含英文小写字母。S长度<=100，L长度<=500,000。
判定S是否是L的有效子串。
判定规则：
S中的每个字符在L中都能找到（可以不连续），且S在Ｌ中字符的前后顺序与S中顺序要保持一致。
（例如，S=”ace”是L=”abcde”的一个子序列且有效字符是a、c、e，而”aec”不是有效子序列，且有效字符只有a、e）

输入描述
输入两个字符串S和L，都只包含英文小写字母。S长度<=100，L长度<=500,000。
先输入S，再输入L，每个字符串占一行。

输出描述
S串最后一个有效字符在L中的位置。（首位从0开始计算，无有效字符返回-1）

示例1 输入输出示例仅供调试，后台判题数据一般不包含示例
输入
ace
abcde
输出
4
示例2 输入输出示例仅供调试，后台判题数据一般不包含示例
输入
fgh
abcde
输出
-1
———————————————— 
原文链接：https://blog.csdn.net/Ghost_199503/article/details/125386454

https://blog.csdn.net/qq_34465338/article/details/125249988

public class zifuchuanxuliepanding {
 
    public static void main(String[] args) {
 
        Scanner sc = new Scanner(System.in);
 
        String S = sc.nextLine();
        String L = sc.nextLine();
 
        int n = 0;
        int m = 0;
 
        while (m<L.length() && n<S.length()){
            if(S.charAt(n)==L.charAt(m)){
                n++;
            }
            m++;
        }
 
        if(n==S.length()){
            System.out.println(m-1);
        }else {
            System.out.println(-1);
        }
 
    }
}

简易内存池 ===100%

请实现一个简易内存池,根据请求命令完成内存分配和释放。
内存池支持两种操作命令，REQUEST和RELEASE，其格式为：
REQUEST=请求的内存大小 表示请求分配指定大小内存，如果分配成功，返回分配到的内存首地址；如果内存不足，或指定的大小为0，则输出error。
RELEASE=释放的内存首地址 表示释放掉之前分配的内存，释放成功无需输出，如果释放不存在的首地址则输出error。
注意：
1.内存池总大小为100字节。
2.内存池地址分配必须是连续内存，并优先从低地址分配。
3.内存释放后可被再次分配，已释放的内存在空闲时不能被二次释放。
4.不会释放已申请的内存块的中间地址。
5.释放操作只是针对首地址所对应的单个内存块进行操作，不会影响其它内存块。
解答要求
时间限制: 1000ms, 内存限制: 256MB
首行为整数 N , 表示操作命令的个数，取值范围：0 < N <= 100。
接下来的N行, 每行将给出一个操作命令，操作命令和参数之间用 “=”分割。

输入输出

样例1：
2
REQUEST=10
REQUEST=20
输出样例1：
0
10
1.
2.
3.
4.
5.
6.
7.
样例2：
5
REQUEST=10
REQUEST=20
RELEASE=0
REQUEST=20
REQUEST=10
输出样例2：
0
10
30
0

提示说明：
第一条指令，申请地址0~9的10个字节内存，返回首地址0
第二条指令，申请地址10~29的20字节内存，返回首地址10
第三条指令，释放首地址为0的内存申请，0~9地址内存被释放，变为空闲，释放成功，无需输出
第四条指令，申请20字节内存，09地址内存连续空间不足20字节，往后查找到3049地址，返回首地址30
第五条指令，申请10字节，0~9地址内存空间足够，返回首地址0

import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.TreeMap;

class Solution {
    static class AllocatedMemory {
        private TreeMap<Integer, Integer> hasAllocated;
        private int ADDRESS_DEFAULT_HEAD = 0;
        private int ADDRESS_DEFAULT_END = 100;
        AllocatedMemory() {
            hasAllocated = new TreeMap<>();
        }

        String request(int size) {
            int addressHead = ADDRESS_DEFAULT_HEAD;
            if (size <= 0 || size > 100) {
                return "error";
            }
            if (hasAllocated.isEmpty()) {
                hasAllocated.put(ADDRESS_DEFAULT_HEAD, size);
            } else {
                List<Integer> headList = new ArrayList<>(hasAllocated.keySet());
                for (int i=0; i<headList.size(); i++) {
                    if (headList.get(i) - addressHead >= size) {
                        hasAllocated.put(addressHead, addressHead + size);
                    } else {
                        addressHead = hasAllocated.get(headList.get(i));
                    }
                }
                if (size <= ADDRESS_DEFAULT_END - addressHead) {
                    hasAllocated.put(addressHead, addressHead + size);
                } else {
                    return "error";
                }
            }
            return String.valueOf(addressHead);
        }

        boolean release(int startAddress) {
            if (hasAllocated.containsKey(startAddress)) {
                hasAllocated.remove(startAddress);
                return true;
            }
            return false;
        }

        public static void main(String[] args) {
            Solution.AllocatedMemory allocatedMemory =
                    new Solution.AllocatedMemory();
            Scanner cin = new Scanner(System.in, StandardCharsets.UTF_8.name());
            int line = Integer.parseInt(cin.nextLine());
            String[][] ins = new String[line][2];
            for (int i=0; i<line; i++) {
                ins[i] = cin.nextLine().split("=");
                if (ins[i][0].startsWith("REQUEST")) {
                    System.out.println(allocatedMemory.request(Integer.parseInt(ins[i][1])));
                } else {
                    boolean ret =
                            allocatedMemory.release(Integer.parseInt(ins[i][1]));
                    if (!ret) {
                        System.out.println("error");
                    }
                }
            }

            cin.close();
        }
    }
}

https://blog.51cto.com/u_15127575/3271270