我的hw，kepa

第一题

第二题

class T2 {
     
    public static void main(String[] args) {
     
        Scanner sc = new Scanner(System.in);
        1.任务队列
        String[] ss1 = sc.nextLine().split(",");
        2.保存任务间依赖
        String[] ss2 = sc.nextLine().split(",");
        3.list保存任务序号，及其所需的执行时间
        LinkedList<String[]> list = new LinkedList<>();
        4.set 保存已经执行的任务
        HashSet<String> set = new HashSet<>();
        map 保存任务名、依赖列表
        HashMap<String, ArrayList<String>> map = new HashMap<>();
        for (String s : ss2) {
     
            String[] arr = s.split("->");
            把arr[0] 的依赖 依次放入队列
            ArrayList<String> ls = map.getOrDefault(arr[0], new ArrayList<>());
            ls.add(arr[1]);
            map.put(arr[0],ls);
        }
        StringBuilder builder = new StringBuilder();
        int[] res=new int[ss1.length];
        int sum_time=0;
        
for循环，本次循环保存在res数组的任务执行时间是 1.没有依赖的任务  2.有依赖，但是依赖在该任务A之前就都执行了 
        for (int i = 0; i < ss1.length; i++) {
     
            1.依次取出任务队列中的 元素
            String s=ss1[i];
            2.找出此任务的 依赖队列
            ArrayList<String> arrayList = map.get(String.valueOf(i));
 1.flag 标志问题
            boolean flag=true;
            3.若依赖不为空
            if (arrayList!=null){
     
                for (int j = 0; j < arrayList.size(); j++) {
     
                    1.取出 依赖项列表
                    String s1 = arrayList.get(j);
                   2.如果set中有，说明依赖已经执行，删除即可，j--,是因为后边的数组元素 会向前移动
                    if (set.contains(s1)){
     
                        arrayList.remove(j);
                        j--;
                    3.说明 set中还没有，依赖还没执行
                    }else {
     
                        flag=false;
                        break;
                    }
                }
            }
   2.时间计算问题
            4.若当前 任务 没有依赖，或者依赖都执行完了
            if (flag){
     
                1. 计算当前元素的 时间总和
                sum_time+=Integer.parseInt(s);
                2. 存入set，说明当前任务已经执行完成
                set.add(String.valueOf(i));
                3.记录当前任务的执行时间
                res[i]=sum_time;
                
            5.若当前任务的依赖还没执行完，则存入list
            }else {
     
                1.当前任务序号 和 执行该任务所需时间
                String[] arr={
     String.valueOf(i),s};
                list.addLast(arr);
            }
        }
        
while循环.list 保存了还没有执行的任务A的序列号，及其执行时间
        while (!list.isEmpty()){
     
            1.得到任务A的序列号，及执行该任务所需时间
            String[] ss = list.getFirst();
            2.找到任务A的依赖列表
            ArrayList<String> arrayList = map.get(ss[0]);
            boolean flag=true;
            3.当任务A的依赖不为空时
            if (arrayList!=null){
     
                1.遍历任务A的依赖，看看是否都执行完了
                for (int j = 0; j < arrayList.size(); j++) {
     
                    String s1 = arrayList.get(j);
                    1.某个依赖执行了，就删掉他
                    if (set.contains(s1)){
     
                        arrayList.remove(j);
                        j--;
                    2.任务A只要存在 没执行的依赖，flag就为false，跳出for循环
                    }else {
     
                        flag=false;
                        break;
                    }
                }
            }
            4.当任务A的依赖被执行完时
            if (flag){
     
                1.sum 加上任务A自己的执行时间
                sum_time+=Integer.parseInt(ss[1]);
                2.并记录已经执行的任务A的序列号
                set.add(ss[0]);
                3.把任务A的总执行时间保存
                res[Integer.parseInt(ss[0])]=sum_time;
            5.当任务A还无法执行时，把它放入队列最后
            }else {
     
                list.addLast(ss);
            }
            6.删除队头 的任务A
            list.removeFirst();
        }
        res存储了，个序列元素的执行时间
        for (int re : res) {
     
            builder.append(re).append(",");
        }
        builder.deleteCharAt(builder.length()-1);
        System.out.println(builder);
    }
}

第三题

第三题——DFS

class T3 {
     
    static int res;
    public static void main(String[] args) {
     
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
     
            int row = sc.nextInt();
            int col = sc.nextInt();
            int t = sc.nextInt();
            int[][] arr = new int[row][col];
            for (int i = 0; i < row; i++) {
     
                for (int j = 0; j < col; j++) {
     
                    arr[i][j] = sc.nextInt();
                }
            }
            res = -1;
            int sum = 0;
            dfs(arr, 0, 0, sum, t);
            System.out.println(res);
        }
    }
    private static void dfs ( int[][] arr, int r, int c, int sum, int t){
     
            1.每次进来都先加上当前格子的时间
            sum += arr[r][c];

            2.当到达最后1格时，且sum满足要求
            if (r == (arr.length - 1) && c == (arr[0].length - 1) && sum <= t) {
     
                对每种到达最后1格的方式，取最大的
                res = Math.max(sum, res);
            } else {
     
                if (sum <= t) {
     
                    1.向下 走1格
                    if (r + 1 < arr.length) {
     
                        dfs(arr, r + 1, c, sum, t);
                    }
                    2.向右走1格
                    if (c + 1 < arr[0].length) {
     
                        dfs(arr, r, c + 1, sum, t);
                    }
                }
                sum超过后就终止此 dfs分支
                else
                    return;
            }
        }

}