Acwing第99周，周赛

四则运算（简单）

给定三个整数 a,b,c，请你计算并输出 (axb)/b+c 的值。

输入格式

共一行，包含三个整数 a,b,c。

输出格式

一个实数，表示结果。

结果保留四位小数。

数据范围

所有测试点满足 1≤a,b,c≤1000。

输入样例1：

100 50 50

 输出样例1：

50.0000

 输入样例2：

199 60 40

 输出样例2：

119.4000

 

import java.util.Scanner;

public class Main{
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int a=in.nextInt();
        int b=in.nextInt();
        int c=in.nextInt();
        double res=(a*b)*1.0/(b+c);
        System.out.println(String.format("%.4f",res));
    }
}

总结

非常基础，不会的小伙伴要反思了。打卡题

整理账本（中等）

 

账本中记录了一种产品的 n 条买卖记录。

记录分为两种，格式如下：

• B p q，表示以 p 元/件的价格，买入 q 件该种商品。
• S p q，表示以 p 元/件的价格，卖出 q 件该种商品。

任何卖出记录的交易价格都高于任何买入记录的交易价格。

也就是说，不会存在卖出记录和买入记录的交易价格相同的情况。

现在，请你对账本进行整理，对所有交易价格相同的记录进行合并，使得每个交易价格只存在一条记录，新记录的交易数量等于所有参与合并的旧记录的交易数量之和。

具体来说，如果账本中有 k条记录的交易价格为 p，它们的交易数量分别为 q1,q2,…,qk，则将它们合并为一条新记录，新记录的交易价格仍为 p，交易数量为 q1+q2+…+qk。

注意：

• 合并为新记录后，参与合并的旧记录就从帐本中抹除了。
• 新纪录的交易类型（买入或卖出）保持不变，即与参与合并的旧记录保持一致。
• 不会存在卖出记录和买入记录的交易价格相同的情况。

整理完毕后，对于现有的所有记录，请你找到其中交易价格最低的 s 条卖出记录和交易价格最高的 s条买入记录。

输入格式

第一行包含两个正整数 n,s。

接下来 n 行，每行包含一个记录，格式如题目描述。

输出格式

首先，按照交易价格从高到低的顺序，输出交易价格最低的 s 条卖出记录，每行一条，格式与输入相同。如果不足 s 条，则有多少输出多少。

然后，按照交易价格从高到低的顺序，输出交易价格最高的 s 条买入记录，每行一条，格式与输入相同。如果不足 s 条，则有多少输出多少。

数据范围

前 44 个测试点满足 1≤n≤6。
所有测试点满足 1≤n≤1000，1≤s≤50，0≤p≤10e5，1≤q≤10e4。

输入样例：

6 2
B 10 3
S 50 2
S 40 1
S 50 6
B 20 4
B 25 10

 输出样例：

S 50 8
S 40 1
B 25 10
B 20 4

import java.util.Iterator;
import java.util.Scanner;
import java.util.TreeSet;

public class test02 {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        long[] B=new long[100000+100];
        long[] S=new long[100000+100];
        TreeSet<Integer> sB=new TreeSet<>();
        TreeSet<Integer> sS=new TreeSet<>();
        int n=in.nextInt();
        int s=in.nextInt();
        String temp=in.next();
        boolean one=true;
        for(int i=0;i<n;i++){
            String str=in.nextLine();
            if(one){
                str=temp+str;
                one=false;
            }
            String[] strings = str.split(" ");
            if(strings[0].equals("B")){
                B[Integer.parseInt(strings[1])]+=Integer.parseInt(strings[2]);
                sB.add(Integer.parseInt(strings[1]));
            }else{
                S[Integer.parseInt(strings[1])]+=Integer.parseInt(strings[2]);
                sS.add(Integer.parseInt(strings[1]));
            }
        }
        int count=s-1;
        int[] arr2=new int[s];
        Iterator<Integer> iterator1 = sS.iterator();
        while (iterator1.hasNext()) {
            Integer next = iterator1.next();
            arr2[count--]=next;
            if(count==-1){
                break;
            }
        }
        count=0;
        for (int i=0;i<arr2.length;i++){
            if(arr2[i]==0){
                if(count==s-1){
                    break;
                }
                continue;
            }
            System.out.println("S "+arr2[i]+" "+S[arr2[i]]);
        }
        int[] arr1=new int[sB.size()];
        Iterator<Integer> iterator = sB.iterator();
        count=0;
        while (iterator.hasNext()) {
            Integer next = iterator.next();
            arr1[count++]=next;
        }
        for (int i=sB.size()-1;i>sB.size()-s-1;i--){
            if(i==-1||(arr1[i]==0&&B[arr1[i]]==0)){
                break;
            }
            System.out.println("B "+arr1[i]+" "+B[arr1[i]]);
        }
    }
}

 总结

nextInt两次转nextline(next)都会有读取问题，c/c++应该不会，我将第一次的第一个字符保存下来，然后拼接，第2-n次都不会有该问题.将数据用TreeSet(TreeMap)保存，利用特性排序，后对数据进行处理，相当于模拟题吧

 扩展区间(困难)

给定 n 个区间，编号 1∼n。

其中，第 i个区间为 [xi,xi]。

初始时，任意两个区间的交集为空。

对于每个区间，你都可以选择一个方向（向左或向右）对其进行扩展，当然也可以选择不对其进行扩展。每个区间最多只能扩展一次。

第 i 个区间的固定扩展长度为 li。

具体来说，对于第 i个区间，你有三个选择：

• 如果你选择使其向左扩展，那么它变为 [xi−li,xi]。
• 如果你选择使其向右扩展，那么它变为 [xi,xi+li]。
• 如果你选择不对其进行扩展，那么它仍保持 [xi,xi] 不变。

我们希望尽可能多的区间能够得到扩展，但是必须保证所有扩展结束后，任意两个区间的交集为空仍然成立。

请问，最多可以扩展多少个区间？

输入格式

第一行包含整数 n。

接下来 n 行，每行包含两个整数 xi,li。

所有区间按照 xi 从小到大的顺序给出。

输出格式

一个整数，表示可以扩展的最大区间数量。

数据范围

前 6 个测试点满足 1≤n≤5。
所有测试点满足 1≤n≤10e5，1≤x1<x2<…<xn≤10e9，1≤li≤10e9。

输入样例1：

5
1 2
2 1
5 10
10 9
19 1

输出样例1： 

3

 输入样例2：

5
1 2
2 1
5 10
10 9
20 1

 输出样例2：

4

import java.util.Scanner;

public class Main{
    static int n;
    static long[][] arr;
    static long max=-1;
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        n=in.nextInt();
        if(n==1){
            System.out.println(1);
            return;
        }
        arr=new long[n][2];
        for(int i=0;i<n;i++){
            arr[i][0]=in.nextLong();
            arr[i][1]=in.nextLong();
        }
        bfs(0,0);

        System.out.println(max);
    }
    static void bfs(long ans,int count){
        if(count==n){
            max=Math.max(max,ans);
            return;
        }
        if(count==0){
            bfs(ans+1,count+1);
        }
        if(count!=0&&arr[count][0]-arr[count][1]>arr[count-1][0]){
            bfs(ans+1,count+1);
        }
        bfs(ans,count+1);
        if(count==n-1)
        {
            bfs(ans+1,count+1);
        }
        if(count!=n-1&&arr[count][0]+arr[count][1]<arr[count+1][0]){
            bfs(ans+1,count+1);
        }
    }
}

 总结

不能全部对，只能过13/22，应该是递归没有考虑第i(i>2)时，[x(i-1),x(i-1)+li(i-1)]与[x(i),x(i)+li(x)]会有重合，但用Set会爆，过5/22个吧。欢迎大佬补充这题