CSP 小中大问题

题目很唬人，说什么有小数仅保留一位小数，其实如果有小数最多也就只有一位。。。但是注意，如果运算结果没有小数必须以整数的形式输出，这时候可以利用flag判断一下是否是整数。

PS：CSP java等级真的低。。。

package test;

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        int []a=new int[n+1];
        for(int i=0;i<n;i++){
            a[i]=in.nextInt();
        }
        int min=0,max=0;
        int medium=0;
        double mid=0;
        boolean flag=false;
        if(a[n-1]>=a[0]){   //升序
            max=a[n-1];
            min=a[0];
        }
        else {
            min = a[n-1];
            max = a[0];
        }
        if(n%2==0){  //偶数个
            if((a[n/2]+a[n/2-1])%2!=0)
            {
                flag=true;
            }
            else
            {
                medium=(a[n/2]+a[n/2-1])/2;
            }
        }
        else {
            medium=a[n/2];
        }
        if(flag){
            mid=(a[n/2]+a[n/2-1])/2.0;
            System.out.println(max+" "+mid+" "+min);
        }
        else
        {
            System.out.println(max+" "+medium+" "+min);
        }
    }
}

2.期末预测阈值问题（重点在数的大小上）

package test;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        int n;
        Scanner in=new Scanner(System.in);
        n=in.nextInt();
        long sum=0;
        int w,score;
        for(int i=0;i<n;i++) {
            w = in.nextInt();
            score = in.nextInt();
            sum += w * score;
        }
        long y=Math.max(sum,0);
        System.out.println(y);
    }
}

3.稀疏向量

都是用的map，为啥java超内存了。。。但是C++可以。。。

#include<stdlib.h>
#include<iostream>
#include<algorithm>
#include<Windows.h>
#include<string>
#include<map>
#include<vector>
#include<set>
using namespace std;

int main(){
	map<int, int> mapA;
	map<int, int> mapB;
	int n, a, b;
	int first, second;
	cin >> n >> a >> b;
	for (int i = 0; i < a; i++) {
		cin >> first >> second;
		mapA[first] = second;
	}

	for (int i = 0; i < b; i++) {
		cin >> first >> second;
		mapB[first] = second;
	}
	map<int, int>::iterator it = mapA.begin();
	int index;
	int valueA, valueB;
	long long sum = 0;
	for (it; it != mapA.end(); it++) {
		index = it->first;
		if (mapB.find(index) != mapB.end()) {
			valueA = it->second;
			valueB = mapB.find(index)->second;
			sum += valueA * valueB;
		}
	}
	cout << sum;
}

4.种苹果

package test;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int sumFruit=0;
        int dropTreeNum=0;
        int E=0;
        int N=in.nextInt();
        int[] Drop=new int[N+1]; //初始值均为0，用于记录是否发生落果。
        int m;
        int sum;
        int temp;
        for(int i=0;i<N;i++){
            sum=0;  //本棵树最终的果子个数
            m=in.nextInt();
            for(int j=0;j<m;j++){
                if(j==0){
                   sum=in.nextInt();
                }
                else{
                    temp=in.nextInt();
                    if(temp<=0){
                        sum+=temp;
                    }
                    else{
                        if(temp<sum){  //发生落果
                            Drop[i]=1;
                            sum=temp;
                        }
                        else
                            continue;;
                    }
                }
            }
            sumFruit+=sum;
            if(Drop[i]==1){
                dropTreeNum++;
            }
        }
        //开始计算落果。
        for(int i=0;i<N;i++){
            if(Drop[i]==1&&Drop[(i+1)%N]==1&&Drop[(i+2)%N]==1){
                E++;
            }
        }
        System.out.println(sumFruit+" "+dropTreeNum+" "+E);
    }
}

5.公共钥匙盒问题：

问题描述
　　有一个学校的老师共用N个教室，按照规定，所有的钥匙都必须放在公共钥匙盒里，老师不能带钥匙回家。每次老师上课前，都从公共钥匙盒里找到自己上课的教室的钥匙去开门，上完课后，再将钥匙放回到钥匙盒中。
　　钥匙盒一共有N个挂钩，从左到右排成一排，用来挂N个教室的钥匙。一串钥匙没有固定的悬挂位置，但钥匙上有标识，所以老师们不会弄混钥匙。
　　每次取钥匙的时候，老师们都会找到自己所需要的钥匙将其取走，而不会移动其他钥匙。每次还钥匙的时候，还钥匙的老师会找到最左边的空的挂钩，将钥匙挂在这个挂钩上。如果有多位老师还钥匙，则他们按钥匙编号从小到大的顺序还。如果同一时刻既有老师还钥匙又有老师取钥匙，则老师们会先将钥匙全还回去再取出。
　　今天开始的时候钥匙是按编号从小到大的顺序放在钥匙盒里的。有K位老师要上课，给出每位老师所需要的钥匙、开始上课的时间和上课的时长，假设下课时间就是还钥匙时间，请问最终钥匙盒里面钥匙的顺序是怎样的？
输入格式
　　输入的第一行包含两个整数N, K。
　　接下来K行，每行三个整数w, s, c，分别表示一位老师要使用的钥匙编号、开始上课的时间和上课的时长。可能有多位老师使用同一把钥匙，但是老师使用钥匙的时间不会重叠。
　　保证输入数据满足输入格式，你不用检查数据合法性。
输出格式
　　输出一行，包含N个整数，相邻整数间用一个空格分隔，依次表示每个挂钩上挂的钥匙编号。
　　
样例输入
5 2
4 3 3
2 2 7
样例输出
1 4 3 2 5

关键在于还钥匙的时候是根据钥匙号从小到大还！！！

package test;
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int N=in.nextInt();  //N把钥匙
        int []numList=new int[N+1];
        for(int i=1;i<=N;i++){  //初始时每个位置的钥匙号。
            numList[i]=i;
        }
        int K=in.nextInt();  //K个老师操作
        int [][]borrowTime=new int[K][2];
        int [][]returnTime=new int[K][2];
        for(int i=0;i<K;i++){
            borrowTime[i][0]=in.nextInt();  //借的钥匙号码
            returnTime[i][0]=borrowTime[i][0];
            borrowTime[i][1]=in.nextInt();  //开始使用的时间
            returnTime[i][1]=borrowTime[i][1]+in.nextInt();  //归还的时间
        }
        //排序，按时间排序；
        quickSort(borrowTime,0,K-1);
        quickSort(returnTime,0,K-1);
        int borrowRecord=0,returnRecord=0;  //记录到谁了。
        for(int t=1;t<=10101;t++){
            int []record=new int[K];
            int k=0;
            for(int i=returnRecord;i<K;i++){  //注意，还钥匙有顺序
                if(returnTime[i][1]>t){
                    returnRecord=i;
                    break;
                }
                else if(returnTime[i][1]<t){
                    continue;
                }
                else if(returnTime[i][1]==t){
                    record[k++]=returnTime[i][0];
                }
            }
            if(k!=0){
                quickSortInt(record,0,k-1);
                for(int z=0;z<k;z++){
                    int location=findEmpty(numList);
                    numList[location]=record[z];
                }
            }

            for(int j=borrowRecord;j<K;j++){
                if(borrowTime[j][1]>t){
                    borrowRecord=j;
                    break;
                }
                else if(borrowTime[j][1]<t){
                    continue;
                }
                else if(borrowTime[j][1]==t){
                    int location=findLocation(numList,borrowTime[j][0]);
                    numList[location]=0; //钥匙拿走。
                }
            }
        }
        for(int i=1;i<=N;i++){  //最终每个位置的钥匙号。
            System.out.print(numList[i]+" ");
        }
    }

    public static int findLocation(int[] numList,int borrowNum){
        int i;
        for(i=1;i<=numList.length;i++){
            if(numList[i]==borrowNum){
                break;
            }
        }
        return i;
    }

    public static int findEmpty(int[] numList){  //找最小空闲位置
        int i;
        for(i=1;i<=numList.length;i++){
            if(numList[i]==0){
                break;
            }
        }
        return i;
    }

    public static int pivocky(int[][] Time,int low,int high){  //按照第二维度排序
        int []temp=new int[2];
        temp=Time[low];
        int pivock=Time[low][1];
        while(low<high){
            while(low<high&&Time[high][1]>=pivock) high--;
            Time[low]=Time[high];
            while (low<high&&Time[low][1]<=pivock) low++;
            Time[high]=Time[low];
        }
        Time[high]=temp;
        return high;
    }

    public static void quickSort(int[][] Time,int low,int high){
        if(low<high){
            int pivock=pivocky(Time,low,high);
            quickSort(Time,low,pivock-1);
            quickSort(Time,pivock+1,high);
        }
    }

    public static int pivockyint(int[] Time,int low,int high){  //按照第二维度排序
        int temp;
        temp=Time[low];
        int pivock=Time[low];
        while(low<high){
            while(low<high&&Time[high]>=pivock) high--;
            Time[low]=Time[high];
            while (low<high&&Time[low]<=pivock) low++;
            Time[high]=Time[low];
        }
        Time[high]=temp;
        return high;
    }

    public static void quickSortInt(int[]Time,int low,int high){
        if(low<high){
            int pivock=pivockyint(Time,low,high);
            quickSortInt(Time,low,pivock-1);
            quickSortInt(Time,pivock+1,high);
        }
    }
}