CSP 201809-2买菜---java版100分

一定注意题目中的陷阱以及用例的局限性，可以自己多写一些特殊用例。
题目描述
小H和小W来到了一条街上，两人分开买菜，他们买菜的过程可以描述为，去店里买一些菜然后去旁边的一个广场把菜装上车，两人都要买n种菜，所以也都要装n次车。具体的，对于小H来说有n个不相交的时间段[a1,b1],[a2,b2]…[an,bn]在装车，对于小W来说有n个不相交的时间段[c1,d1],[c2,d2]…[cn,dn]在装车。其中，一个时间段[s, t]表示的是从时刻s到时刻t这段时间，时长为t-s。
　　由于他们是好朋友，他们都在广场上装车的时候会聊天，他们想知道他们可以聊多长时间。
输入格式
　　输入的第一行包含一个正整数n，表示时间段的数量。
　　接下来n行每行两个数ai，bi，描述小H的各个装车的时间段。
　　接下来n行每行两个数ci，di，描述小W的各个装车的时间段。
输出格式
　　输出一行，一个正整数，表示两人可以聊多长时间。
样例输入
4
1 3
5 6
9 13
14 15
2 4
5 7
10 11
13 14
样例输出
3
数据规模和约定
　　对于所有的评测用例，1 ≤ n ≤ 2000, ai < bi < ai+1，ci < di < ci+1,对于所有的i(1 ≤ i ≤ n)有，1 ≤ ai, bi, ci, di ≤ 1000000。

import javax.crypto.spec.PSource;
import java.util.Scanner;

public class Main {

    public static void main (String[] args) {
        /*
        输入的第一行包含一个正整数n，表示时间段的数量。
　　     接下来n行每行两个数ai，bi，描述小H的各个装车的时间段。
　　     接下来n行每行两个数ci，di，描述小W的各个装车的时间段。
        */
        //注意注意题目有个套就是没跟你说甲第i次一定跟乙的第i次对应，
        // 不一定，而且还有可能我一次对应他两次，都有可能，所以，千万不要被用例迷惑。
        int n;
        Scanner in=new Scanner(System.in);
        n=in.nextInt();
        int a1,b1;
        int c1,d1;
        int []a=new int[n+1];
        int []b=new int[n+1];
        int []c=new int[n+1];
        int []d=new int[n+1];
        for(int i=0;i<n;i++){
            a[i]=in.nextInt();
            b[i]=in.nextInt();
        }
        int talkTime=0;
        for(int i=0;i<n;i++) {
            c[i] = in.nextInt();
            d[i] = in.nextInt();
            //talkTime+=calculateTime(a[i],b[i],c[i],d[i]);
        }
        int record=0;
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                if(c[j]>=b[i]){
                    break;
                }
                else if(d[j]<=a[i]){
                    continue;
                }
                else{
                    talkTime+=calculateTime(a[i],b[i],c[j],d[j]);
                }
            }
        }
        System.out.println(talkTime);
    }

    public static int calculateTime(int a1,int a2,int b1,int b2){
        return Math.min(a2,b2)-Math.max(a1,b1);
    }
}

小明放学：

题目背景
　　汉东省政法大学附属中学所在的光明区最近实施了名为“智慧光明”的智慧城市项目。具体到交通领域，通过“智慧光明”终端，可以看到光明区所有红绿灯此时此刻的状态。小明的学校也安装了“智慧光明”终端，小明想利用这个终端给出的信息，估算自己放学回到家的时间。
问题描述
　　一次放学的时候，小明已经规划好了自己回家的路线，并且能够预测经过各个路段的时间。同时，小明通过学校里安装的“智慧光明”终端，看到了出发时刻路上经过的所有红绿灯的指示状态。请帮忙计算小明此次回家所需要的时间。
输入格式
　　输入的第一行包含空格分隔的三个正整数 r、y、g，表示红绿灯的设置。这三个数均不超过 10^6。
　　输入的第二行包含一个正整数 n，表示小明总共经过的道路段数和路过的红绿灯数目。
　　接下来的 n 行，每行包含空格分隔的两个整数 k、t。k=0 表示经过了一段道路，将会耗时 t 秒，此处 t 不超过 106；k=1、2、3 时，分别表示出发时刻，此处的红绿灯状态是红灯、黄灯、绿灯，且倒计时显示牌上显示的数字是 t，此处 t 分别不会超过 r、y、g。
输出格式
　　输出一个数字，表示此次小明放学回家所用的时间。
样例输入
30 3 30
8
0 10
1 5
0 11
2 2
0 6
0 3
3 10
0 3
样例输出
46
样例说明
　　小明先经过第一段路，用时 10 秒。第一盏红绿灯出发时是红灯，还剩 5 秒；小明到达路口时，这个红绿灯已经变为绿灯，不用等待直接通过。接下来经过第二段路，用时 11 秒。第二盏红绿灯出发时是黄灯，还剩两秒；小明到达路口时，这个红绿灯已经变为红灯，还剩 11 秒。接下来经过第三、第四段路，用时 9 秒。第三盏红绿灯出发时是绿灯，还剩 10 秒；小明到达路口时，这个红绿灯已经变为红灯，还剩两秒。接下来经过最后一段路，用时 3 秒。共计 10+11+11+9+2+3 = 46 秒。
评测用例规模与约定
　　有些测试点具有特殊的性质：
　　* 前 2 个测试点中不存在任何信号灯。
　　测试点的输入数据规模：
　　* 前 6 个测试点保证 n ≤ 10^3。
　　* 所有测试点保证 n ≤ 10^5。

注意本体的坑在于，数的大小，本能再是int类型的了，t不超过10^6，而且所有的测试点所有测试点保证 n ≤ 10^5， 而int类型的数据占32比特位，最大就只是2.3X10^9 那个样子，所以满足不了数在10^10到1011的要求，要改用long型（64比特位大概可以到9*10^18）。

import javax.crypto.spec.PSource;
import java.util.Scanner;
 //本体需要注意，t不超过10^6，而且所有的测试点所有测试点保证 n ≤ 10^5,
 // 而int类型的数据最大就只是2.3*10^9那个样子
public class Main {

    public static void main (String[] args) {
        long sumTime=0;
        int r,y,g;  //r、y、g，表示红绿灯的设置
        Scanner in=new Scanner(System.in);
        r=in.nextInt();
        y=in.nextInt();
        g=in.nextInt();
        int n;  //小明总共经过的道路段数和路过的红绿灯数目
        n=in.nextInt();
        for(int i=0;i<n;i++){
            int k,t;
            k=in.nextInt();
            t=in.nextInt();
            sumTime+=calculateTime(sumTime,k,t,r,y,g);
        }
        System.out.println(sumTime);
    }

    public static long calculateTime(long sumTime,int k,int t,int r,int y,int g){
        long calTime=0;
        if(k==0){
            calTime=t;
        }
        else{
            sumTime=sumTime%(r+y+g);
            sumTime=sumTime-t;
            if(k==1){  //红灯
                if(sumTime<0){  //红灯未结束
                    calTime=Math.abs(sumTime);
                }
                else if(sumTime>=0&&sumTime<=g){  //在绿灯处
                    calTime=0;
                }
                else if(sumTime>g&&sumTime<=g+y){
                    calTime=g+y-sumTime+r;
                }
                else if(sumTime>g+y&&sumTime<=g+y+r){
                    calTime=g+y+r-sumTime;
                }
            }
            else if(k==2){  //黄灯
                if(sumTime<=0){
                    calTime=Math.abs(sumTime)+r;
                }
                else if(sumTime>0&&sumTime<=r){
                    calTime=r-sumTime;
                }
                else if(sumTime>r&&sumTime<=r+g){
                    calTime=0;
                }
                else if(sumTime>r+g&&sumTime<=r+g+y){
                    calTime=r+g+y-sumTime+r;
                }
            }
            else if(k==3){  //绿灯
                if(sumTime<=0){
                    calTime=0;
                }
                else if(sumTime>0&&sumTime<=y){
                    calTime=y-sumTime+r;
                }
                else if(sumTime>y&&sumTime<=y+r){
                    calTime=y+r-sumTime;
                }
                else if(sumTime>y+r&&sumTime<=y+r+g){
                    calTime=0;
                }
            }
        }
        return calTime;
    }

}