牛客网刷题笔记（一）

1.牛牛找工作

题目描述

为了找到自己满意的工作，牛牛收集了每种工作的难度和报酬。牛牛选工作的标准是在难度不超过自身能力值的情况下，牛牛选择报酬最高的工作。在牛牛选定了自己的工作后，牛牛的小伙伴们来找牛牛帮忙选工作，牛牛依然使用自己的标准来帮助小伙伴们。牛牛的小伙伴太多了，于是他只好把这个任务交给了你。

输入描述:

每个输入包含一个测试用例。
每个测试用例的第一行包含两个正整数，分别表示工作的数量N(N<=100000)和小伙伴的数量M(M<=100000)。
接下来的N行每行包含两个正整数，分别表示该项工作的难度Di(Di<=1000000000)和报酬Pi(Pi<=1000000000)。
接下来的一行包含M个正整数，分别表示M个小伙伴的能力值Ai(Ai<=1000000000)。
保证不存在两项工作的报酬相同。

输出描述:

对于每个小伙伴，在单独的一行输出一个正整数表示他能得到的最高报酬。一个工作可以被多个人选择。

示例1

输入

3 3 
1 100 
10 1000 
1000000000 1001 
9 10 1000000000

输出

100 
1000 
1001

解题思路：

首先考虑最简单的解法，直接暴力枚举

import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int Number = in.nextInt();
        int Member = in.nextInt();

        ArrayList<Job> jobs = new ArrayList<>(Number);
        for (int i = 0; i < Number; i++) {
            Job job = new Job(in.nextInt(), in.nextInt());
            jobs.add(job);
        }
        int[] members = new int[Member];
        for (int i = 0; i < Member; i++) {
            members[i] = in.nextInt();
        }

        //排序，按照报酬从大到小排序
        Collections.sort(jobs);

        for (int i = 0; i < Member; i++) {
            for (Job job : jobs) {
                if (job.getDi() <= members[i]) {
                    System.out.println(job.getPi());
                    break;
                }
            }
        }
    }
}
//定义一个工作对象
class Job implements Comparable{
    private int Di;
    private int Pi;

    public Job(int di, int pi) {
        Di = di;
        Pi = pi;
    }

    public int getDi() {
        return Di;
    }

    public void setDi(int di) {
        Di = di;
    }

    public int getPi() {
        return Pi;
    }

    public void setPi(int pi) {
        Pi = pi;
    }

    @Override
    public int compareTo(Object o) {
        Job job2 = (Job) o;
        return Integer.compare(this.Pi, job2.Pi) * -1;
    }

    @Override
    public String toString() {
        return "Job{" +
                "Di=" + Di +
                ", Pi=" + Pi +
                '}';
    }
}

果然超时了，换个思路，

由于相同难度的工作相当于只选择报酬最高的，因此使用map记录难度和不超过该难度的最大报酬，将人的能力也插入到这张map中，如果已存在，那么不插入，不存在的话先设置为0。对map进行排序（可以使用treeMap就不需要排序）。最后，遍历map，从小到大，使得能力值对应的报酬最大化。

import java.util.*;

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

        Map<Integer, Integer> treeMap = new TreeMap<>();

        //把工作和报酬放到map中
        for (int i = 0; i < number; i++) {
            int Di = in.nextInt();
            int Pi = in.nextInt();
            if (treeMap.containsKey(Di)) {
                if (Pi > treeMap.get(Di)) {
                    treeMap.put(Di, Pi);
                }
            } else {
                treeMap.put(Di, Pi);
            }
        }



        int[] members = new int[member];

        //把小伙伴的能力值也放进去
        for (int i = 0; i < member; i++) {
            int Vi = in.nextInt();
            members[i] = Vi;
            //如果原map里面没有，设置为0
            if (!treeMap.containsKey(Vi)) {
                treeMap.put(Vi, 0);
            }
        }

//        System.out.println(treeMap.toString());

        //从小到大更新treeMap
        int tmp = 0;
        for (Map.Entry<Integer, Integer> entry : treeMap.entrySet()) {
            //如果薪酬小于比它难度简单的工作，则更新薪酬
            if (entry.getValue() < tmp) {
                entry.setValue(tmp);
            }
            tmp = entry.getValue();
        }


//        System.out.println(treeMap.toString());
        //输出结果
        for (int i = 0; i < member; i++) {
            System.out.println(treeMap.get(members[i]));
        }
        
    }
}

2.被3整除

题目描述

小Q得到一个神奇的数列: 1, 12, 123,…12345678910,1234567891011…。

并且小Q对于能否被3整除这个性质很感兴趣。

小Q现在希望你能帮他计算一下从数列的第l个到第r个(包含端点)有多少个数可以被3整除。

输入描述:

输入包括两个整数l和r(1 <= l <= r <= 1e9), 表示要求解的区间两端。

输出描述:

输出一个整数, 表示区间内能被3整除的数字个数。

示例1

输入

2 5

输出

3

说明

12, 123, 1234, 12345...
其中12, 123, 12345能被3整除。

解题思路：

被3整除的数都有一个性质，那就是所有位置上的值加起来仍然能够被3整除，那么只需要计算加和就可以

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        long left = in.nextInt();
        long right = in.nextInt();

        long number = 0;

        long sub = 0;
        //第几个数就是多少个自然数的组合
        
        //注意！利用逐个数字用等差数列公式求和的方法没有错误，
        // 但是关键的是利用的类型不能是int,因为可能中途求和的结果会超出 int 类型的最大长度，使用long 就可以通过所有测试用例。
        for (long i = left; i <= right; i++) {
            sub = i * (1 + i) / 2;
            if (sub % 3 == 0) {
                number++;
            }
        }
        System.out.println(number);
    }
}

3.安置路灯

题目描述

小Q正在给一条长度为n的道路设计路灯安置方案。

为了让问题更简单,小Q把道路视为n个方格,需要照亮的地方用’.'表示, 不需要照亮的障碍物格子用’X’表示。

小Q现在要在道路上设置一些路灯, 对于安置在pos位置的路灯, 这盏路灯可以照亮pos - 1, pos, pos + 1这三个位置。

小Q希望能安置尽量少的路灯照亮所有’.'区域, 希望你能帮他计算一下最少需要多少盏路灯。

输入描述:

输入的第一行包含一个正整数t(1 <= t <= 1000), 表示测试用例数
接下来每两行一个测试数据, 第一行一个正整数n(1 <= n <= 1000),表示道路的长度。
第二行一个字符串s表示道路的构造,只包含'.'和'X'。

输出描述:

对于每个测试用例, 输出一个正整数表示最少需要多少盏路灯。

示例1

输入

2
3
.X.
11
...XX....XX

输出

1
3

解题思路：

这道题比较简单，直接暴力求解，从最左边开始，每有一个“.”就在它的右边一格放一个路灯，然后右移三位，否则向后走一格，看下一个位置

import java.util.ArrayList;
import java.util.Scanner;

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

        ArrayList<String> roads = new ArrayList<>(testNumber);

        for (int i = 0; i < testNumber; i++) {
            int length = in.nextInt();
            roads.add(in.next());
        }

        for (String road : roads) {
            char[] roadChars = road.toCharArray();
            int flag = 0;
            int count = 0;

            while (flag < roadChars.length) {
                //如果当前为“.”，那么放一个路灯能照亮三格，右移三位，否则右移一位
                if (roadChars[flag] == '.') {
                    count++;
                    flag += 3;
                } else {
                    flag += 1;
                }
            }
            System.out.println(count);
        }
    }
}