广联达笔试 2020 7 29

最新推荐文章于 2023-02-19 22:46:35 发布

Bears9

最新推荐文章于 2023-02-19 22:46:35 发布

阅读量2.6k

点赞数 4

分类专栏：笔试

本文链接：https://blog.csdn.net/DaDaguai001/article/details/107728719

版权

笔试专栏收录该内容

3 篇文章 0 订阅

订阅专栏

第一题

杰夫非常喜欢种草，他自己有一片草地，为了方便起见，我们把这片草地看成一行从左到右，并且第 i 个位置的草的高度是hi。
杰夫在商店中购买了m瓶魔法药剂，每瓶魔法药剂可以让一株草长高x，杰夫希望每次都能有针对性的使用药剂，也就是让当前长得最矮的小草尽量高，现在杰夫想请你告诉他在使用了m瓶魔法药剂之后，最矮的小草在这种情况下最高能到多少。

输入描述
第一行三个整数n, m, x分别表示小草的个数，魔法药剂的个数以及每瓶魔法药剂让小草长高的高度。(1≤n,m,x≤1e5)
第二行n个整数分别表示第i株小草的高度ai。(1≤ai≤1e9)

输出描述
使用了m瓶药剂之后最矮的小草的最高高度。

样例
输入
3 2 3
3 3 7
输出
6

代码

package 广联达;

import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;

public class Question1 {

    public static void main(String[] args) {
        Queue<Integer> q = new PriorityQueue<>();
        Scanner sc = new Scanner( System.in );
        int n,m,x;
        n = sc.nextInt();//n 小草的个数
        m = sc.nextInt();//m 瓶药剂
        x = sc.nextInt();//x 长高的高度
        int temp;
        for( int i = 0 ; i < n ; i ++ ){
            temp = sc.nextInt();
            q.add( temp );
        }

        for( int i = 0 ; i < m ; i ++ ){
            temp = q.poll() + x;
            q.add( temp );
        }
        System.out.println( q.poll() );
    }
}

第二题

我们希望一个序列中的元素是各不相同的，但是理想和现实往往是有差距的。现在给出一个序列A，其中难免有些相同的元素，
现在提供了一种变化方式，使得经过若干次操作后一定可以得到一个元素各不相同的序列。

这个操作是这样的，令x为序列中最小的有重复的数字，你需要删除序列左数第一个x，并把第二个x替换为2*x。

请你输出最终的序列。

例如原序列是[2,2,1,1,1],一次变换后变为[2,2,2,1]，两次变换后变为[4,2,1]，变换结束

输入描述
输入第一行包含一个正整数n，表示序列的长度为n。(1<=n<=50000)

第二行有n个整数，初始序列中的元素。(1<=a_i<=10^8)

输出描述
输出包含若干个整数，即最终变换之后的结果。

样例
输入
5
2 2 1 1 1
输出
4 2 1

代码：不知道代码的是否能AC，没得测了...仅记录，提供思路。现在知道了，我自己写的代码没有考虑，原数组的顺序，这个也简单，用map记录一下就行了。

package 广联达;

import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;
import java.util.Vector;

public class Question2 {

    //优先级队列
    public static Queue<Integer> q = new PriorityQueue<>();
    //优先级队列
    public static Vector<Integer> v = new Vector<>();

    使用自定义的队列，使其降序排列
    //public int compare(Integer e1, Integer e2) {
    //    return e2 - e1;
    //}

    //判断队列中的前两个数字是否相等
    public static boolean judge(){
        //如果此时数量不足，那么将优先级队列中的数直接给vector
        if( q.size() < 2 ){
            return false;
        }
        else{
            //如果此时优先级队列中的值大于1
            int first = q.poll();
            int second = q.peek();
            //这里少抛出一次
            q.add( first );
            //如果相等才进行自我合并
            if( first == second ){
                return true;
            }
            return false;
        }
    }
    public static void main(String[] args) {
        /**
         * 解题的想法，找一个可变的容器，并且其内部会自动排序
         * 那么想到了优先级队列，因为时间复杂度允许，1s,优先级队列的时间复杂度是nlogn(不超过80000就行)
         */
        Scanner sc = new Scanner( System.in );
        //n个数
        int n = sc.nextInt();
        int temp;
        for( int i = 0 ; i < n ; i ++ ){
            temp = sc.nextInt();
            q.add( temp );
        }

        //用来进行合并的两个数
        int first,second;
        while ( !q.isEmpty() ){
            //进行判断，看是否是进行合并还是进行 “ 转移 ”
            //如果返回true,说明能进行合并
            if( judge() ){
                first = q.poll();
                second = q.poll();
                q.add( first * 2 );
            }
            else{
                v.add( q.poll() );
            }
        }
        //输出vector
        System.out.print( v.get(0) );
        for( int i = 1 ; i < v.size() ; i ++ ){
            System.out.print( " " + v.get( i ) );
        }
    }
}


//第二种解法
//来自 https://www.nowcoder.com/discuss/462425?type=all&order=time&pos=&page=1&channel=666&source_id=search_all
public class Question222 {
    public static void setAdd(Set<Integer> set, Integer i) {
        //如果已经有这个数了，那么将其移除，再乘以2
        if (!set.add(i)) {
            set.remove(i);
            setAdd(set, i << 1);
        }
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        Integer[] array = new Integer[n];
        for (int i = 0; i < array.length; i++) {
            array[i] = scanner.nextInt();
        }
        //前面都是进行正常的输入
        LinkedHashSet<Integer> res = new LinkedHashSet<>();
        for (int i = 0; i < array.length; i++) {
            //挨个放入，如果已经有这个数字了，那么进行移除，并且乘以2
            setAdd(res, array[i]);
        }
        //后面进行正常的输出
        Iterator<Integer> iterator = res.iterator();
        while (iterator.hasNext()) {
            System.out.print(iterator.next());
            if (iterator.hasNext()) System.out.print(" ");
        }
    }

}