字节跳动9.22笔试

第一题 AC:
店铺离厕所最近距离
保存left厕所和right厕所的点,遍历一遍就可以了
代码没存

第二题:
动态规划 64.29%
做题
import java.util.Scanner;

public class Main {
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        int total = in.nextInt();
        for(int ll=0; ll<total; ll++){
            int n = in.nextInt();
            int m = in.nextInt();
            int[] a = new int[n];
            for(int i=0; i<n; i++){
                a[i] = in.nextInt();
            }
            int[][] result = new int[n][m+1];
            for(int j=0; j<=m; j++){
                result[0][j] = 0;
            }
            for(int i=1; i<n; i++){
                for(int j=0; j<=m; j++){
                    if( j - a[i-1] >= 0){
                       result[i][j] = max(result[i-1][j-a[i-1]] + 1, result[i-1][j]);
                    }else{
                        result[i][j] = result[i-1][j];
                    }
                }
            }
            for(int i=0; i<n; i++){
                System.out.print(i - result[i][m-a[i]]);
                System.out.print(" ");
            }
            System.out.println();
        }
    }

    public static int max(int a, int b){
        return a>b ? a : b;
    }
}
第三题 90%:
有向无环图
import java.util.*;

class Node{
    int val;
    LinkedList<Node> pre;
    LinkedList<Node> next;

    public Node(int _val){
        this.val = _val;
        pre = new LinkedList<>();
        next = new LinkedList<>();
    }
}

public class Main6 {
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        HashMap<Integer,Node> temp = new HashMap<>();
        ArrayList<Integer> result = new ArrayList<>();
        while(in.hasNextLine()){
            String line = in.nextLine();
            if(line.equals("")){
                break;
            }
            String[] ls = line.split(" ");
            int first = Integer.parseInt(ls[0]);
            Node la, prn;
            if(!temp.containsKey(first)){
                la = new Node(first);
                temp.put(first, la);
            }else{
                la = temp.get(first);
            }
            for(int i=1; i<ls.length; i++){
                int pr = Integer.parseInt(ls[i]);
                if(!temp.containsKey(pr)){
                    prn = new Node(pr);
                    temp.put(pr, prn);
                }else{
                    prn = temp.get(pr);
                }
                la.pre.add(prn);
                prn.next.add(la);
            }
        }
        Set<Integer> s = temp.keySet();
        int length = s.size();
        while(result.size() < length){
            int cur = -1;
            Iterator<Integer> it = s.iterator();
            while (it.hasNext()){
                int i = it.next();
                if(temp.get(i).pre.size() == 0 && (cur == -1 || i < cur)){
                    cur = i;
                }
            }
            if(cur == -1){
                System.out.println(-1);
                return;
            }else{
                result.add(cur);
                Node node = temp.get(cur);
                Iterator<Node> l = node.next.iterator();
                while (l.hasNext()){
                    Node next = l.next();
                    next.pre.remove(node);
                }
                temp.remove(node);
                s.remove(cur);
            }
        }
        Iterator<Integer> i = result.iterator();
        while (i.hasNext()){
            System.out.print(i.next() + " ");
        }
    }
}
第四题:
暴力解法 8%, 实在想不出
个人感觉可以用质数加因数分解优化一下
import java.util.Scanner;

public class Main7 {
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        int an = in.nextInt();
        int bn = in.nextInt();
        if(an==0){
            System.out.println(bn);
        }
        if(bn==0){
            System.out.println(an);
        }
        int result = 0;
        for(int k=1; k<=an+bn; k++){
            for(int ak=1; ak<k; ak++){
                int bk = k - ak;
                int as = an/ak;
                int bs = bn/bk;
                if(as == bs || (as == bs + 1 && an%ak == 0) || (bs == as + 1 && bs%bk == 0)){
                    result++;
                    break;
                }
            }
        }
        System.out.println(result);
    }
}


#笔试题目##字节跳动#
全部评论
第二题可能是空间复杂度太高了,我记得n<=1000   m<=1,000,000 ..  你的算法是O(nm)的空间复杂度
点赞 回复 分享
发布于 2019-09-22 10:22
不用动态规划吧,直接排完序从小到大加起来比较
点赞 回复 分享
发布于 2019-09-22 10:42
第三题是拓扑排序吗? 第四题我也是暴力8%,考完后推了一下,每一个k需要A和B的数量分配情况,假设这个k里面A数量为a,a~[1,k-1],实际上a不用遍历,是否满足是看m,n里面够不够分配,解两个不等式组就有个判断条件,满足a的下界<=上界就存在k,不满足则这样的k不存在。简单数据测了一下好像是对的? # input if n<m:     n,m=m,n #n>m # k cannot be 1, always could be n+m res=1 for k in range(2,n+m):     q,rem=divmod(n+m,k)     hb=min(n//q,int(k-m/(q+1)))     lb=max((math.ceil(n/(q+1)),math.ceil(k-m/q),(k+1)//2))     if hb>=lb:         res+=1 print(res)
点赞 回复 分享
发布于 2019-09-22 13:42

相关推荐

11-13 20:32
门头沟学院 Java
面向未来编程code:我没看到他咋急,他不就问你个问题。。。
点赞 评论 收藏
分享
1 4 评论
分享
牛客网
牛客企业服务