秋招突击——算法训练——8/1——用友集团笔试

news2024/11/24 19:36:01

文章目录

    • 引言
    • 正文
      • 小友的生产线
        • 个人实现
        • 参考实现
      • 小友策划游戏人物
        • 个人实现
        • 参考实现
      • 最佳工作任务安排
        • 个人实现
        • 参考实现
      • 大众评分最高的一次旅程
    • 总结

引言

  • 今天晚上七点钟到九点钟是用友集团的笔试,作为今天算法练习的主要内容!具体怎么样,晚上再说喽!

正文

小友的生产线

  • 小友设计了一条新的生产线,在该条生产线上共有0-n种工序。每种工序之间可能存在上下游关系,如果一种工序没有下游工序,则为终点工序。如果一种工序其所有可能下游工序均可到达终点工序,则称该工序为合规工序。

  • 给你一个有向图,其中有n个节点,表示不同种工序,以及不同工序之间的关系,请计算该条生产线中,所有的合规工序,并按照升序排列。

  • 注意:终点工序无下游工序,默认为合规工序。

输入描述

  • 第一行输入正整数n,表示共有n个工序节点;

  • 接下来n行,每行有j(1<=j<n)个数,表示工序节点i与其余j个工序节点上下游关系。

  • 注意:若工序节点i为终点工序,则j=1,且数值为-1

输出描述

  • 输出一个数组,用来表示所有的合规工序,并按照升序排列

补充说明

● n == graph.length
● 1 <= n <= 1040 <= n[i].length <= n
● -1 <= n[i][j] <= n - 1
● n[i] 按严格递增顺序排列
● 图中可能包含自环

示例 1

  • 输入
5
1 2 3 4
1 2
3 4
0 4
-1
  • 输出
4

说明

  • 只有工序4是终点工序,即为合规工序

示例 2

  • 输入
7
1 2
2 3
5
0
5
-1
-1
  • 输出
 2 4 5 6

说明

工序5和6为终点工序,即为合规工序 工序2和4开始的所有下游工序最终都指向终点工序,按照升序排列最终结果为2,4,5,6

个人实现
  • 这道题我是单纯使用回溯实现的,个人看来就是判定没有给节点的所有可能路径,是否可能会成环,如果会成环,那就是不可能是合理工序,如果所有可能路径都不会成环,那就是合理工序。
  • 种类使用回溯实现的,具体如下
import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    static boolean[] visited;
    static boolean[][] matrix;
    static Set<Integer> set;
    static List<Integer> res;

    static boolean dfs(int curIdx){
        for(int i = 0;i < matrix[0].length;i ++){
            // 判断是否存在路径
            if(matrix[curIdx][i]){
                // 存在成环路径,直接返回
                if (visited[curIdx] || visited[i]) return false;
                // 存在路径,并且i是终止节点情况,直接跳过
                if(set.contains(i)) continue;
                // 存在路径,并且i不是终点的情况,需要递归访问
                visited[i] = true;
                if(!dfs(i))  return false;
                visited[i] = false;
            }
        }
        return true;
    }

    public static void main(String[] args) {
        set = new HashSet<>();
        res = new ArrayList<>();

        Scanner in = new Scanner(System.in);
        int count = in.nextInt();
        visited = new boolean[count];
        matrix = new boolean[count][count];
        for(int i = 0;i <= count;i ++){
            String line = in.nextLine();
            if(i == 0) continue;
            if( line.isEmpty())  set.add(i);
            Scanner lineScn = new Scanner(line);
            while(lineScn.hasNextInt()){
                int a = lineScn.nextInt();
                if(a == -1){
                    set.add(i - 1);
                }else{
                    matrix[i - 1][a] = true;
                }
            }
            lineScn.close();
        }



        // 遍历每一个元素
        for (int i = 0;i < count ;i ++){
            if(set.contains(i)) continue;
            //visited[i] = true;
            if(dfs(i)) set.add(i);
            Arrays.fill(visited,false);
            //visited[i] = false;
        }

        for(int x : set){
            res.add(x);
        }
        Collections.sort(res);
        for(int x : res) System.out.print(x + " ");

    }
}
  • 上述代码只能通过百分之四十的样例,然后剩下的怎么调节,都过不去了,这里专门复习一下,看一下一般来说怎么做的!
参考实现
  • 修改如下,正常的回溯我都想了很久,正常不应该是这样的,确定了回溯的迭代条件,以及终止条件就可以直接上模板了,不应该这样的!
  • 我的方法是针对无向图的环的检测,针对有向图的检测会出现问题的,这里还是建立使用三个状态来检测有向图的环,具体如下!
  • 三种状态
    • 0表示未访问
    • 1表示正在访问
    • 2表示已经访问,处理过当前节点,当前节点后续是不存在环的,直接跳过就行了!
boolean isCyclicUtil(int v,int[] visited){
	// 当前路径下确实存在环
	if(visited[v] == 1)	return true;

	// 检测是否已经是访问过的点
	if(visited[v] == 2)	return false;
	
	visited[v] = 1;
	for(int neighbour:adj.get(v)){
		if(isCyclicUtli(neighbour,vivited)){
			return true;
		}
	}
	visited[v] = 2;
	return false;
}

public boolean isCyclic() {
        int[] visited = new int[V];

        for (int i = 0; i < V; i++) {
            if (isCyclicUtil(i, visited)) {
                return true;
            }
        }

        return false;
    }

三个状态,11成环,22非环,12中间是循环

小友策划游戏人物

  • 小友是一个游戏策划,他计划设计一个新人物,该人物的攻击模式较为特殊:他的附加攻击力可以拆分为n份(n>=2),这n份的乘积作为最终伤害值。游戏总监认为该人物过于超模(过于强大),要求对其附加攻击力增加上限限制。
  • 现在给你最终伤害值的上限和该人物的附加攻击力,请判断该人物的实际最终伤害值是否会超出给出的最终伤害值上限。
  • 输入描述
输入两个数值,第一个数值为最终伤害值上限,第二个数值为该人物的附加攻击力。
例如:2920 22
2920为最终伤害值的上限
22为该人物的附加攻击力
  • 输出描述
输入true或者false
true表示超出上限
false表示未超出上限
  • 补充说明
最终伤害值上限不会超过int最大值

示例一

  • 输入
1 2
  • 输出
false
  • 说明
最终伤害上限1
附加攻击力2
2=1+1
1*1=1
所以未超过上限
个人实现
  • 我用的方法应该是有问题的,是拆成尽可能大的两个数字的乘积,然后在计算最大值,具体如下
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int maxV = in.nextInt();
        int att = in.nextInt();
        long maxAtt = 0;
        for(int i = 2;i <= att;i ++){
            long tempAtt = (long) (Math.pow(i, (double) att / i) * (att % i));
            maxAtt = Math.max(maxAtt,tempAtt);
        }

        System.out.println(maxAtt > maxV);
    }
}
  • 这个题目还是要想想使用动态规划怎么做
参考实现
  • 之前学了那么久的闫氏DP分析法,这里得想想看怎么弄分析,从集合的角度出发!这道题目对于任意的数字都可以分成两个数字,然后划分点是从第一个点往后遍历到最终的结果,具体如下图
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int maxV = in.nextInt();
        int att = in.nextInt();

        int[] dp = new int[att + 1];
        dp[0] = 0;
        dp[1] = 0;
        dp[2] = 1;

        for(int i = 2;i <= att;i ++){
            for(int j = 1;j < i;j ++){
                dp[i] = Math.max(dp[i],
                            Math.max(j * (i - j),
                                Math.max(dp[j] * dp[i - j],
                                    Math.max(j * dp[i - j],dp[j] * (i - j)))));
            }
        }
        System.out.println(dp[att]);
    }
}

在这里插入图片描述

最佳工作任务安排

  • 小友所在的部门在进行一系列复杂的开发项目。为了优化开发流程,部门要求工程师在不同的任务之间切换。每个任务有不同的执行时间,有些任务因为各种原因无法进行(标记为-1)。工程师可以在规定的跳跃范围内从一个任务跳到另一个任务,但每次执行任务需要消耗相应的时间。
  • 你的目标是找到一个从任务列表开头到结尾的执行顺序,使得总执行时间最小。如果存在多个总执行时间相同的顺序,返回按索引值更小优先的顺序。如果无法到达最后一个任务,返回一个空数组。

规则

1.输入一个整数数组 tasks 表示任务执行时间,长度为 n。
2.输入一个整数 maxStep 表示单次切换任务的最大切换长度。
3.你从任务列表的第一个任务开始(tasks[0] 不是 -1)。
4.从任务 i 切换到任务 j,消耗的时间为 tasks[j]5.如果你当前位于任务 i,你只能跳到任务 i + k(满足 i + k <= n),其中 k 在范围 [1, maxStep] 内。
6.返回一个整数数组,包含你访问的任务索引顺序,使得总执行时间最小。如果存在多个总执行时间相同的顺序,返回索引值更小的顺序。

排序说明

如果存在多个总执行时间相同的顺序:
假设方案 p1 = [Pa1, Pa2, ..., Pax] 和方案 p2 = [Pb1, Pb2, ..., Pbx]。
如果在两个方案中第一个不同的索引 j 处,Pa[j] 小于 Pb[j],则选择方案 p1。
如果所有索引都相同,但任务切换次数不同,则选择任务切换次数较少的一个方案。
提示:注意排序规则,如 1-2-3-4-51-4-5 , 假设两个方案所消耗的时间成本相同, 那么前面的方案更优。

输入描述

整数 N,代表任务 tasks 的长度
长度为 N 的数组 tasks 的各个元素
整数 M,代表每次切换任务的最大跳跃长度

输出描述

输出数组,代表总执行时间最短,并且索引值最小的执行方案

补充说明

1 <= tasks.length <= 1000
-1 <= tasks[i] <= 100
tasks[0] != -1
1 <= maxStep <= 100

示例 1

输入

5
1 2 4 -1 2
2

输出

1 3 5
个人实现
  • 我单纯使用回溯实现的,因为我知道如果使用用DP只能求出来对应最大值,但是没有办法求出来具体路径,如果要求出来具体的路径,还是得使用回溯,所以,为了节省时间,直接写了两边回溯!
  • 中间本来想改成优先队列的,后来没时间改,就冲写了一个,原来的优先队列有没闪,下面是考试中的原来的代码,还没来及的复制上去!
import java.sql.Array;
import java.util.ArrayList;
import java.util.List;
import java.util.PriorityQueue;
import java.util.Scanner;

public class Main {
    static int[] task;
    static PriorityQueue<List<Integer>> pq;
    static List<Integer> list;
    static List<Integer> res;
    static int maxV = 0;
    static int skipLen ;


    static void dfs(int curIdx ){
        if(curIdx < task.length && task[curIdx] == -1) return ;
        if(curIdx == task.length){
            int sum = 0;
            for(int i =0;i < list.size() - 1;i ++) sum += task[i];
            maxV = Math.max(maxV,sum);
        }

        // 遍历当前路径下的所有的步骤
        for (int i = 1; i <= skipLen && (curIdx + i) <= task.length;i ++ ){
            list.add(curIdx + i);
            dfs(curIdx + i);
            list.remove(list.size() - 1);
        }
    }
    static void dfs2(int curIdx ){
        if(curIdx < task.length && task[curIdx] == -1) return ;
        if(curIdx == task.length){
            int sum = 0;
            for(int i =0;i < list.size() - 1;i ++) sum += task[i];
            //System.out.println(sum);
            if(sum == maxV){
                if(res == null) res = list;
                else if(res.size() > list.size())  res = new ArrayList<>(list);
            }
        }

        // 遍历当前路径下的所有的步骤
        for (int i = 1; i <= skipLen && (curIdx + i) <= task.length;i ++ ){
            list.add(curIdx + i);
            dfs2(curIdx + i);
            list.remove(list.size() - 1);
        }
    }

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int count = in.nextInt();
        task = new int[count];
        for(int i = 0;i < count;i ++)   task[i] = in.nextInt();
        skipLen = in.nextInt();

        pq = new PriorityQueue<>((List<Integer> a,List<Integer> b)->{
            int sumA = 0;
            for(int x:a) sumA += x;
            int sumB = 0;
            for(int x:b) sumB += x;
            return Integer.compare(sumA,sumB);
        });
        list = new ArrayList<>();

        dfs(0);

        dfs2(0);

        if(res == null)
            System.out.println("[]");
        else{
            System.out.println("1 ");
            for(int i = 0;i < res.size();i ++)
                System.out.print(res.get(i) + 1 + " ");
        }

//        if(!pq.isEmpty())
//            for(int i = 0;i < pq.peek().size();i ++)
//                System.out.print(pq.peek().get(i) + " ");
//        else
//            System.out.println("[]");
    }
}
参考实现
  • 下述代码使用的是回溯和动态规划
  • 下面是使用了两个数组,一个是用来实现动态规划,还有一个是用来记录路径的!
  • 这道题感觉很像leetcode上面的青蛙跳,对应链接。
    在这里插入图片描述
    参考实现

还是最后一个状态为目标进行分析,假设可以跳跃K步,然后最后一步有几种可能

f[k] = x[k] + f[k - i] ,i从零到k
  • 然后选取上述值的最大值,如果f[k]是-1,中间就是断层的。
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // 读取输入
        int N = scanner.nextInt();
        int[] task = new int[N];
        for (int i = 0; i < N; i++) {
            task[i] = scanner.nextInt();
        }
        int M = scanner.nextInt();
        
        // 初始化 dp 数组
        final int INF = Integer.MAX_VALUE; // 使用 Integer.MAX_VALUE 代替 inf
        int[] f = new int[N];
        Arrays.fill(f, INF);
        f[0] = 0;
        
        int[] fm = new int[N];
        Arrays.fill(fm, -1);
        
        // 动态规划
        for (int i = 1; i < N; i++) {
            if (task[i] == -1) continue;
            for (int k = 1; k <= M; k++) {
                if (i - k < 0) break;
                if (f[i - k] + task[i] < f[i] && task[i - k] != -1) {
                    f[i] = f[i - k] + task[i];
                    fm[i] = i - k;
                }
            }
        }
        
        // 回溯找到路径
        List<Integer> res = new ArrayList<>();
        int index = N - 1;
        while (true) {
            if (index == 0) {
                res.add(1);
                break;
            }
            res.add(index + 1);
            index = fm[index];
        }
        
        // 输出结果
        Collections.reverse(res); // 反转列表以从起点到终点
        for (int r : res) {
            System.out.print(r + " ");
        }
        
        scanner.close();
    }
}

大众评分最高的一次旅程

在这里插入图片描述

总结

  • 很难受,今天的题目偏难,不过能够写出来三道题,然后第三道题写完了,没来得及复制上去,好可惜!
  • 不过今天也反应出来很多问题,就是我的笔试能力还是不够!代码写的太慢了,尤其是回溯!
  • 最后一题,我连题目都没有见到,就不放在这里了!跳过了!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/1972585.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

MinIO DataPod:百亿亿次级计算的参考架构

现代企业通过其数据来定义自己。这需要用于 AI/ML 的数据基础设施&#xff0c;以及作为现代数据湖基础的数据基础设施&#xff0c;该数据基础设施能够支持商业智能、数据分析和数据科学。如果他们落后、起步或使用 AI 获得高级见解&#xff0c;则情况确实如此。在可预见的未来&…

又一个GPT4级的模型免费了?MiniMax史诗级更新

又有一个超性价比的国产大模型出现了&#xff01;这里是智匠AI&#xff0c;MiniMax刚刚对他们的主力模型abab6.5s&#xff0c;进行了大幅降价&#xff0c;输入和输出成本都达到了1元/百万tokens。我们今天就来进行评测这款abab6.5s。 abab6.5s在文科任务、内容理解、文字生成及…

WebKit引擎:探索现代网页渲染的幕后魔法!

WebKit 是一个开源的浏览器引擎&#xff0c;它负责解析和渲染网页内容&#xff0c;包括HTML、CSS和JavaScript。WebKit的工作流程涵盖了加载资源、解析文档、应用样式、布局渲染树等一系列步骤&#xff0c;最终将网页内容呈现在用户的屏幕上。 WebKit简介 WebKit是一个开源的浏…

Python在气象与海洋中的应用

Python是功能强大、免费、开源&#xff0c;实现面向对象的编程语言&#xff0c;能够在不同操作系统和平台使用&#xff0c;简洁的语法和解释性语言使其成为理想的脚本语言。除了标准库&#xff0c;还有丰富的第三方库&#xff0c;并且能够把用其他语言&#xff08;C/C、Fortran…

Python SyntaxError: unexpected EOF while parsing

Python SyntaxError: unexpected EOF while parsing 在Python编程中&#xff0c;SyntaxError: unexpected EOF while parsing是一个常见的错误&#xff0c;通常发生在Python解释器在源代码中找到意外的文件结尾&#xff08;EOF&#xff0c;即End Of File&#xff09;时。这个错…

大模型LLM关键技术手段

大语言模型&#xff08;LLM&#xff09;是人工智能领域的一个突破性进展&#xff0c;它通过多种技术手段实现对自然语言的理解和生成。用比较通俗的话来列举一些我认为比较关键的技术手段&#xff1a; 深度学习技术&#xff1a;就像我们通过不断学习来掌握知识一样&#xff0c;…

SRM供应商管理系统有哪些实际用处?

随着供应商数量的不断增加&#xff0c;订单处理的复杂性与日俱增&#xff0c;传统的采购模式让订单的生成、跟踪到交货的每一个环节都可能成为潜在的瓶颈。在这样的背景下&#xff0c;SRM供应商管理系统的出现&#xff0c;为采购商提供了一个全面、高效的解决方案。 我想以真实…

白盒测试基础与实践:Python示例及流程图设计

文章目录 前言一、白盒测试是什么&#xff1f;主要特点常用方法优点缺点 二、白盒测试常用技术语句覆盖判定覆盖条件覆盖判定/条件覆盖条件组合覆盖路径覆盖 三、程序流程图设计四、测试用例设计1. 基本路径法2. 语句覆盖3. 判断覆盖4. 条件覆盖5. 判断/条件覆盖6. 条件组合覆盖…

【传知代码】基于图的去中心化社会推荐过滤器(论文复现)

在当今信息爆炸的时代&#xff0c;社交媒体和数字平台已经成为我们获取信息、交流观点以及发现新内容的主要途径。然而&#xff0c;随着内容数量的剧增&#xff0c;用户面临着信息过载和质量参差不齐的挑战。为了解决这一问题&#xff0c;基于图的去中心化社会推荐过滤器应运而…

AIR 调用 Python 脚本的解决方案

1. 问题背景 在 AIR 1.5 中&#xff0c;无法直接调用系统命令或运行可执行文件&#xff08;如 Python 解释器&#xff09;。 2. 解决方案 由于安全限制&#xff0c;AIR 应用程序无法直接调用系统命令或运行可执行文件。因此&#xff0c;以下解决方案仅适用于能够共享详细信息…

【传知代码】LAD-GNN标签注意蒸馏(论文复现)

近年来&#xff0c;随着图神经网络&#xff08;GNN&#xff09;在各种复杂网络数据中的广泛应用&#xff0c;如何提升其在大规模图上的效率和性能成为了研究的热点之一。在这个背景下&#xff0c;标签注意蒸馏&#xff08;Label Attention Distillation&#xff0c;简称LAD&…

分包—小程序太大,上传不上去,采用分包处理方式

在 app.json 中配置 subpackages 字段来定义分包。创建分包目录如左边红框。例如&#xff1a;

[Meachines] [Easy] Mirai Raspberry树莓派默认用户登录+USB挂载文件读取

信息收集 IP AddressOpening Ports10.10.10.48TCP:22,53,80,1276,32400,32469 $ nmap -p- 10.10.10.48 --min-rate 1000 -sC -sV PORT STATE SERVICE VERSION 22/tcp open ssh OpenSSH 6.7p1 Debian 5deb8u3 (protocol 2.0) | ssh-hostkey: | 1024 aa:ef:5c:…

vue-cli3脚手架详细讲解 基于webpack

1.安装vue3:新建一个文件夹&#xff0c;进入该文件夹下&#xff0c;执行 vue create ( 项目名称) , 如下图&#xff1a; vuecli3为项目名称&#xff0c;进入下一步&#xff0c; 我们选择第3个&#xff0c;进入下一步 这里要我们选择一个配置&#xff0c;按住上下键进行调转&a…

240802-Python代码混淆及加密的一些工具

1. 有哪些开源免费的工具&#xff0c;可以对Python代码加密 加密Python代码可以通过多种方法实现&#xff0c;尽管这些方法主要是为了保护代码不被轻易阅读或修改&#xff0c;但无法完全防止逆向工程。以下是一些开源免费的工具和方法&#xff0c;可以用于加密Python代码&…

聊聊ChatGLM-6B的源码分析

基于ChatGLM-6B第一版&#xff0c;要注意还有ChatGLM2-6B以及ChatGLM3-6B PrefixEncoder 作用&#xff1a;在微调时&#xff08;以P-Tuning V2为例&#xff09;&#xff0c;方法训练时冻结模型的全部参数&#xff0c;只激活PrefixEncoder的参数。 其源码如下&#xff0c;整体来…

Python数值计算(16)——Hermite插值

1. 概述 不管是前面介绍到拉格朗日插值还是牛顿插值&#xff0c;拟合的函数比线性插值更加“优秀”&#xff0c;即它们都是连续可导的&#xff0c;但是&#xff0c;有时拟合还有这样的要求&#xff0c;就是除了在给定点处的函数值要相等外&#xff0c;还要求在这些指定点处的导…

fastjson-小于1.2.47绕过

参考视频&#xff1a;fastjson反序列化漏洞3-<1.2.47绕过_哔哩哔哩_bilibili 分析版本 fastjson1.2.24 JDK 8u141 分析流程 分析fastjson1.2.25更新的源码&#xff0c;用JsonBcel链跟进 先看修改的地方 fastjson1.2.24 if (key JSON.DEFAULT_TYPE_KEY && !…

鸿蒙(API 12 Beta2版)NDK开发【JSVM-API简介】

JSVM-API简介 场景介绍 HarmonyOS JSVM-API是基于标准JS引擎提供的一套稳定的ABI&#xff0c;为开发者提供了较为完整的JS引擎能力&#xff0c;包括创建和销毁引擎&#xff0c;执行JS代码&#xff0c;JS/C交互等关键能力。 通过JSVM-API&#xff0c;开发者可以在应用运行期间…