网易

1. 找工作

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

思路：暴力法超时， 用HashMap存储

import java.util.*;
 
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int m = scanner.nextInt();
        int[] t = new int[n + m];
        HashMap<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < n; i++) {
            t[i] = scanner.nextInt();
            map.put(t[i], scanner.nextInt());
        }
        int[] t2 = new int[m];
        for (int i = 0; i < m; i++) {
            t[n+i]=scanner.nextInt();
            t2[i] = t[n+i];
        }
        scanner.close();
        Arrays.sort(t);
        
        int max = 0;
        for (int i = 0; i < n + m; i++) {
            max = Math.max(map.getOrDefault(t[i],0),max);
            map.put(t[i],max);
        }

        for (int i = 0; i < m; i++) System.out.println(map.get(t2[i]));
    }
}

　　

2. 数对

牛牛以前在老师那里得到了一个正整数数对(x, y), 牛牛忘记他们具体是多少了。

但是牛牛记得老师告诉过他x和y均不大于n, 并且x除以y的余数大于等于k。

牛牛希望你能帮他计算一共有多少个可能的数对。

思路：y确定时候 x可以取2种

• 第一种　　k,k+1,k+2...,y-1;　　y+k,y+k+1,...,2y-1;    ...　　...my-1; 
• 第二种 　　my+k,my+k+1,..., my+k+t=n

第一种共（n/y）组，每组从 my+k 到 （m+1）y-1,即每组 y-k个；  共 （n/y)*([(m+1）y-1]  -  [my+k ] +1) = (n/y)*(y- k)

第二种当 n%y数大于等于k时候存在，共 n%y - （k-1）个， 即 Math.max(0, n%y - k+1）

import java.util.*;
 
/**
 * @author zzm
 * @data 2020/5/23 17:09
 */
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        long n = scanner.nextInt();
        long k = scanner.nextInt();
        long res = 0;
        if(k==0) {
            System.out.println(n*n);
            return;
        }
        for (long y = k+1; y <= n; y++) {
            //y确定时候 x可以取 （n/y）组，每组从 my+k 到 （m+1）y-1,即每组 y-k个
            res += (n/y)*(y-k) + Math.max(0,n%y-k+1);
        }
        System.out.println(res);
    }
}

　　

3. 被3整除

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

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

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

输入描述:

输入包括两个整数l和r(1 <= l <= r <= 1e9), 表示要求解的区间两端。
思路：每相邻三个数中有两个可以被整除

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()){

            int l = scanner.nextInt();
            int r = scanner.nextInt();
            System.out.println(cal(r)-cal(l-1));
        }
        scanner.close();
    }

    private static int cal(int num) {
        int res = num / 3 * 2;
        res += (num % 3 == 2) ? 1 : 0;
        return res;
    }
}

4. 最大矩阵重叠数

平面内有n个矩形, 第i个矩形的左下角坐标为(x1[i], y1[i]), 右上角坐标为(x2[i], y2[i])。

如果两个或者多个矩形有公共区域则认为它们是相互重叠的(不考虑边界和角落)。

请你计算出平面内重叠矩形数量最多的地方,有多少个矩形相互重叠。

输入描述:

输入包括五行。
第一行包括一个整数n(2 <= n <= 50), 表示矩形的个数。
第二行包括n个整数x1[i](-10^9 <= x1[i] <= 10^9),表示左下角的横坐标。
第三行包括n个整数y1[i](-10^9 <= y1[i] <= 10^9),表示左下角的纵坐标。
第四行包括n个整数x2[i](-10^9 <= x2[i] <= 10^9),表示右上角的横坐标。
第五行包括n个整数y2[i](-10^9 <= y2[i] <= 10^9),表示右上角的纵坐标。
思路： A分别和B  C重叠，但是B  C不重叠的时候只算2个而不是3个
遍历判断 ：重叠区域必为一矩形， 重叠区域的四个顶点都为输入矩形的顶点。  判断包含某个顶点的最大矩形数

import java.util.*;
import static java.lang.Math.*;
/**
 * @author zzm
 * @data 2020/5/23 17:34
 */
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int[] x1 = new int[n];
        int[] y1 = new int[n];
        int[] x2 = new int[n];
        int[] y2 = new int[n];
        for (int i = 0; i < n; i++) x1[i] = scanner.nextInt();
        for (int i = 0; i < n; i++) y1[i] = scanner.nextInt();
        for (int i = 0; i < n; i++) x2[i] = scanner.nextInt();
        for (int i = 0; i < n; i++) y2[i] = scanner.nextInt();
        scanner.close();

        ArrayList<Integer> X = new ArrayList<>();
        Arrays.stream(x1).forEach(a -> X.add(a));
        Arrays.stream(x2).forEach(a -> X.add(a));

        ArrayList<Integer> Y = new ArrayList<>();
        Arrays.stream(y1).forEach(a -> Y.add(a));
        Arrays.stream(y2).forEach(a -> Y.add(a));

        int res = 1;

        for (int x : X) {
            for (int y : Y) {
                int now = 0;
                for (int i = 0; i < n; i++) {
                    if (x < x2[i] && x >= x1[i] && y < y2[i] && y >= y1[i]) now++;
                }
                res = Math.max(res, now);
            }
        }
        System.out.println(res);
    }
}

5. 上学的最晚时间

牛牛总是睡过头，所以他定了很多闹钟，只有在闹钟响的时候他才会醒过来并且决定起不起床。从他起床算起他需要X分钟到达教室，上课时间为当天的A时B分，请问他最晚可以什么时间起床

输入描述:

每个输入包含一个测试用例。
每个测试用例的第一行包含一个正整数，表示闹钟的数量N(N<=100)。
接下来的N行每行包含两个整数，表示这个闹钟响起的时间为Hi(0<=A<24)时Mi(0<=B<60)分。
接下来的一行包含一个整数，表示从起床算起他需要X(0<=X<=100)分钟到达教室。
接下来的一行包含两个整数，表示上课时间为A(0<=A<24)时B(0<=B<60)分。
数据保证至少有一个闹钟可以让牛牛及时到达教室。

输出描述:

输出两个整数表示牛牛最晚起床时间。

import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;

/**
 * @author zzm
 * @data 2020/5/23 18:12
 */
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int[][] clocks = new int[n][2];
        for (int i = 0; i < n; i++) {
            clocks[i][0] = scanner.nextInt();
            clocks[i][1] = scanner.nextInt();
        }
        int totle = scanner.nextInt();
        int h = scanner.nextInt();
        int m = scanner.nextInt();
        Arrays.sort(clocks, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                if(o1[0]==o2[0]) return o2[1]-o1[1];
                else return o2[0]-o1[0];
            }
        });

        for (int i = 0; i < n; i++) {
            if (helper(clocks[i][0], clocks[i][1], h, m) >= totle) {
                System.out.println(clocks[i][0] + " " + clocks[i][1]);
                break;
            }
        }
    }

    private static int helper(int h1, int m1, int h2, int m2) {
            return (h2 - h1) * 60 + (m2 - m1);
    }
}

6. 背包问题

牛牛准备参加学校组织的春游, 出发前牛牛准备往背包里装入一些零食, 牛牛的背包容量为w。

牛牛家里一共有n袋零食, 第i袋零食体积为v[i]。

牛牛想知道在总体积不超过背包容量的情况下,他一共有多少种零食放法(总体积为0也算一种放法)。

输入描述:

输入包括两行
第一行为两个正整数n和w(1 <= n <= 30, 1 <= w <= 2 * 10^9),表示零食的数量和背包的容量。
第二行n个正整数v[i](0 <= v[i] <= 10^9),表示每袋零食的体积。

输出描述:

输出一个正整数, 表示牛牛一共有多少种零食放法。
思路：此题背包容量过大，不能用动态规划

import java.util.*;

public class Main {
    static int res = 0;

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        long cap = scanner.nextLong();
        long[] w = new long[n];
        long totle = 0;
        for (int i = 0; i < n; i++) {
            w[i] = scanner.nextLong();
            totle += w[i];
        }
        if (totle <= cap) System.out.println((int)Math.pow(2, n));
        else {
           helper(0, n, 0, w, cap);
            System.out.println(res);
        }
    }

    private static void helper(int i, int n, long sum, long[] w, long cap) {
        if (i >= n) {
            if (sum <= cap) res++;
            return;
        }
        if (sum > cap) return;
        helper(i + 1, n, sum + w[i], w, cap);
        helper(i + 1, n, sum, w, cap);
    }
}