java 健康监测代码 java代码在线测试

编程题：3x20=60分
这是我做过得笔试题中目前觉得最简单的了，因为觉得，虽然测试用例时间复杂度什么的运行出来有问题，但是都能想出来
看来我得好好看一下时间复杂度这个问题了

import java.util.Scanner;
/**
 * 判断矩形重叠
 * 输入：
 * 第一行输入矩形的个数
 * 第二行输入x1[0]....x1[n-1]个左下角横坐标
 * 第三行输入y1[0]....y1[n-1]个左下角纵坐标
 * 第四行输入x2[0]....x2[n-1]个右上角横坐标
 * 第五行输入y2[0]....y2[n-1]个右上角纵坐标
 * 输出
 * 如果矩形之间发生重叠，输出重叠的矩形个数
 * 
 * 样例输入
 * 2
 * 0 90
 * 0 90
 * 100 200
 * 200 200
 * 样例输出
 * 2
 * 
 * 我的思想：
 * 可将矩形不重叠的情况分为四种
 * 以两个矩形的情况为例
 * 以第一个矩形为参考矩形，
 * 第二个矩形与第一个矩形不重叠，
 * 他的位置可以是在第一个矩形的
 * 右边，x1[1]>x2[0]
 * 上边，y1[1]>y2[0]
 * 左边，x2[1]<x1[0]
 * 下边，y2[1]<y2[0]
 * 
 * 之前在线运行的时候，我的程序最终运行结果为：未能满足所有测试用例，case10%
 * 自己把不重叠的情况给输出去了，唉，真是脑残！
 * 
 * 不知道现在这个可以满足多少测试用例呢？感兴趣的亲，可以试试
 * @author 小花花
 *
 */
public class Main {


    public static void main(String[] args) {
        int count=0;//重叠数
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();//个数
        int[] x1=new int[n];
        int[] x2=new int[n];
        int[] y1=new int[n];
        int[] y2=new int[n];

        for(int i=0;i<n;i++){
            x1[i]=sc.nextInt();
            y1[i]=sc.nextInt();
            x2[i]=sc.nextInt();
            y2[i]=sc.nextInt();

        }
        for(int i=1;i<x1.length;i++){
            for(int j=i-1;j<x2.length;j++){
               if( x1[i]>=x2[j]||y1[i]>=y2[j]||x2[i]<=x1[j]||y2[i]<=y1[j]){
                   count++;
               }
            }
        }

        System.out.println(count);

    }
}

import java.util.Scanner;
/**
 * 数对
 * 输入n,k
 * 求出所有满足x<=n,y<=n,x%y>=2
 * 的（x,y)对数
 * 
 * 运行结果：
 * 程序运行时间过长，可能是时间复杂度过大
 * 测试用例未能全部满足，case10%
 * 
 * 不知道是什么情况，这还能怎么改啊
 * 
 * 样子输入
 * 5 2
 * 样例输出
 * 7
 * @author 小花花
 *
 */
public class Main2 {


    public static void main(String[] args) {
       Scanner sc=new Scanner(System.in);
       int n=sc.nextInt();
       int k=sc.nextInt();


        int count=0;
        for(int x=1;x<=n;x++) {
            for(int y=1;y<=n;y++) {
                if(x%y>=k){
                    count++;
                }
            }
        }

        System.out.println(count);

    }
}

import java.util.Scanner;
/**
 * 计算小伙伴的工作报酬
 * 如果小伙伴的能力值不小于工作的难度系数，则可以获得相应的报酬
 * 
 * 输入：
 * 第一行：n:工作个数 m:小伙伴个数
 * 第二行：第一个工作对应的难度值 对应的报酬
 * 第二行：第二个工作的对应的难度值 对应的报酬
 * 。。。。。。。。。。。。。。。。。
 * 。。。。。。。。、、、
 * 第n+1行：第n个工作的对应的难度值 对应的报酬
 * 第n+2行：m个小伙伴对应的能力值
 * 
 * 输出：
 * 每个小伙伴对对应的报酬
 * 
 * 样例输入：
 * 3 3
 * 5 1000
 * 10 10000
 * 100000 1000000000
 * 9 10 100000
 * 样例输出
 * 1000 10000 1000000000
 * 
 * 用的数组的方式做的
 * 注意！在计算报酬的时候，能力值大的可能比很多难度值都大，一定要选取对应的报酬最大的！
 * 所以要先将难度值从大到小排序，同时交换对应的报酬值(但前提是难度值一定要和报酬成正比），大于当前最大的就break
 * 觉得可以用双列集合来做，刚好有k,v
 * 用的HashMap,但是发现HashMap存取的顺序不一致，最后小伙伴的输入顺序，和输出的报酬肯定无法相对应
 * 
 * 如果要保证有序，那就得选用带链表的结构的LinkedHashMap了
 * 然后也需要将难度值与对应报酬排序
 * @author 小花花
 *
 */
public class Main3 {

    //降序排列
    public static void sort(int[] a,int[] b) {

        for(int i=0;i<a.length-1;i++) {
            for(int j=i+1;j<a.length;j++) {
                if(a[i]<a[j]) {
                    int temp=a[i];
                    a[i]=a[j];
                    a[j]=temp;

                    int temp2=b[i];
                    b[i]=b[j];
                    b[j]=temp2;

                }
            }
        }
    }

    public static void main(String[] args) {


        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int m=sc.nextInt();

        int[] d=new int[n];
        int[] p=new int[n];

        int[] s=new int[m];
        int[] k=new int[m];

        for(int i=0;i<n;i++) {
            d[i]=sc.nextInt();
            p[i]=sc.nextInt();

        }

        //将难度值降序排列
        sort(d,p);

        //m*n次
        for(int i=0;i<m;i++) {
            s[i]=sc.nextInt();
            for(int j=0;j<d.length;j++) {
                if(s[i]>=d[j]) {
                    k[i]=p[j];
                    break;
                }
            }
        }

        for(int v:k) {
            System.out.print(v+"    ");
        }   
    }
}

集合的方式

import java.util.LinkedHashMap;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeMap;
/**
 * 计算小伙伴的工作报酬
 * 如果小伙伴的能力值不小于工作的难度系数，则可以获得相应的报酬
 * 
 * 输入：
 * 第一行：n:工作个数 m:小伙伴个数
 * 第二行：第一个工作对应的难度值 对应的报酬
 * 第二行：第二个工作的对应的难度值 对应的报酬
 * 。。。。。。。。。。。。。。。。。
 * 。。。。。。。。、、、
 * 第n+1行：第n个工作的对应的难度值 对应的报酬
 * 第n+2行：m个小伙伴对应的能力值
 * 
 * 输出：
 * 每个小伙伴对对应的报酬
 * 
 * 样例输入：
 * 3 3
 * 5 1000
 * 10 10000
 * 100000 1000000000
 * 9 10 100000
 * 样例输出
 * 1000 10000 1000000000
 * 
 * 觉得可以用双列集合来做，刚好有k,v
 * 
 * 用的HashMap,但是发现HashMap存取的顺序不一致，最后小伙伴的输入顺序，和输出的报酬肯定无法相对应
 * 
 * 如果要保证输出的报酬与输入的小伙伴闲的对应，那就得选用带链表的结构的LinkedHashMap来存储小伙伴的能力值与对应的报酬
 * 
 * 然后也需要将难度值与对应报酬排序，这样可以会便于比较，同时减少比较次数
 * 
 * 可以使用TreeMap来存储工作的难度值与对应报酬，因为TreeMap实现了自然排序(升序),再将TreeMap的建和值逆序之后就是降序
 * 
 * @author 小花花
 *
 */
public class Main31 {


    public static void main(String[] args) {

        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int m=sc.nextInt();

        TreeMap<Integer,Integer> dp=new TreeMap<Integer,Integer>();
        LinkedHashMap<Integer,Integer> mp=new LinkedHashMap<Integer,Integer>();

        for(int i=0;i<n;i++) {
            dp.put(sc.nextInt(), sc.nextInt());
        }

        for(int j=0;j<m;j++) {
            mp.put(sc.nextInt(), null);
        }

        Set<Integer> mpkey=mp.keySet();
        Set<Integer> dpkey=dp.keySet();

        int[] key=new int[mpkey.size()];
        //比较之前先进行排序

        int k=dpkey.size()-1;//存放难度值
        //降序
        for(int i:dpkey) {
            key[k]=i;
            k--;
        }

        for(Integer i:mpkey) {
            int p=0;
            for(int j:key) {
                if(i>=j) {
                    p=dp.get(j);
                    break;
                }

            }
            mp.put(i, p);
        }

        for(Integer i:mpkey) {
            System.out.print(mp.get(i)+"     ");
        }

    }

}

集合和数组哪种方式更好呢？