L2-034 口罩发放 (25 分)--java

最新推荐文章于 2023-01-31 18:57:03 发布

"星尘"

最新推荐文章于 2023-01-31 18:57:03 发布

阅读量871

点赞数 2

分类专栏：天梯实战小技巧

本文链接：https://blog.csdn.net/smxingchen/article/details/119406297

版权

天梯实战小技巧专栏收录该内容

3 篇文章 1 订阅

订阅专栏

本文探讨了在抗击COVID19期间，某市口罩分配小程序的算法实现，涉及数据筛选、处理规则及优化方法。主要算法包括状态标记法和日期间隔判断法，但面临超时问题。题目要求根据天数D和间隔P筛选符合条件的市民，考虑身份证合法性、申请间隔及时间顺序。优化目标是提高算法效率，确保大数据量下的运行速度。

摘要由CSDN通过智能技术生成

明确一点 Java：

一定会超时！一定会超时！一定会超时！

有大佬可以优化的，一定要在喷我的时候把代码给我，万分感谢！

方法三是目前最稳定的解法！其他两种可以作为模拟过程的参考流程！

仅是提交AC的同学请注意，该篇代码均会超时仅供交流，我会以我这个萌新的视角，尽可能细致的描述整个模拟的过程和核心算法！

为了抗击来势汹汹的 COVID19 新型冠状病毒，全国各地均启动了各项措施控制疫情发展，其中一个重要的环节是口罩的发放。

某市出于给市民发放口罩的需要，推出了一款小程序让市民填写信息，方便工作的开展。小程序收集了各种信息，包括市民的姓名、身份证、身体情况、提交时间等，但因为数据量太大，需要根据一定规则进行筛选和处理，请你编写程序，按照给定规则输出口罩的寄送名单。

输入格式:

输入第一行是两个正整数 D 和 P（1≤D,P≤30），表示有 D 天的数据，市民两次获得口罩的时间至少需要间隔 P 天。

接下来 D 块数据，每块给出一天的申请信息。第 i 块数据（i=1,⋯,D）的第一行是两个整数 Ti 和 Si（1≤Ti,Si≤1000），表示在第 i 天有 Ti 条申请，总共有 Si 个口罩发放名额。随后 Ti 行，每行给出一条申请信息，格式如下：

姓名 身份证号 身体情况 提交时间

给定数据约束如下：

姓名 是一个长度不超过 10 的不包含空格的非空字符串；
身份证号 是一个长度不超过 20 的非空字符串；
身体情况 是 0 或者 1，0 表示自觉良好，1 表示有相关症状；
提交时间 是 hh:mm，为24小时时间（由 00:00 到 23:59。例如 09:08。）。注意，给定的记录的提交时间不一定有序；
身份证号 各不相同，同一个身份证号被认为是同一个人，数据保证同一个身份证号姓名是相同的。

能发放口罩的记录要求如下：

身份证号 必须是 18 位的数字（可以包含前导0）；
同一个身份证号若在第 i 天申请成功，则接下来的 P 天不能再次申请。也就是说，若第 i 天申请成功，则等到第 i+P+1 天才能再次申请；
在上面两条都符合的情况下，按照提交时间的先后顺序发放，直至全部记录处理完毕或 Si 个名额用完。如果提交时间相同，则按照在列表中出现的先后顺序决定。

输出格式:

对于每一天的申请记录，每行输出一位得到口罩的人的姓名及身份证号，用一个空格隔开。顺序按照发放顺序确定。

在输出完发放记录后，你还需要输出有合法记录的、身体状况为 1 的申请人的姓名及身份证号，用空格隔开。顺序按照申请记录中出现的顺序确定，同一个人只需要输出一次。

输入样例:

4 2
5 3
A 123456789012345670 1 13:58
B 123456789012345671 0 13:58
C 12345678901234567 0 13:22
D 123456789012345672 0 03:24
C 123456789012345673 0 13:59
4 3
A 123456789012345670 1 13:58
E 123456789012345674 0 13:59
C 123456789012345673 0 13:59
F F 0 14:00
1 3
E 123456789012345674 1 13:58
1 1
A 123456789012345670 0 14:11

结尾无空行

输出样例:

D 123456789012345672
A 123456789012345670
B 123456789012345671
E 123456789012345674
C 123456789012345673
A 123456789012345670
A 123456789012345670
E 123456789012345674

结尾无空行

样例解释：

输出中，第一行到第三行是第一天的部分；第四、五行是第二天的部分；第三天没有符合要求的市民；第六行是第四天的部分。最后两行按照出现顺序输出了可能存在身体不适的人员。

算法一：

这种算法的核心就是状态标记，第n天获得的口罩就标记为n，以后每天获得者数组的标记都会减一，当这个人的标记为0时才有资格重新获取，这样就解了模拟发放的操作，但是当数据为空时代码就回崩溃，故始终会有一组数据无法通过！

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner cin = new Scanner (System.in);
		BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));
		int n = cin.nextInt();
		int p = cin.nextInt();
		P pp[][] = new P[n][];
		P out[] = new P[100];
		int sum[]=new int[n];
		for(int i=0;i<n;i++){
			int n2 = cin.nextInt();
			int p2 = cin.nextInt();
			sum[i]=p2;
			pp[i]=new P[n2];
			for(int j=0;j<n2;j++) {
				String name =cin.next();
				String sfz = cin.next();
				int qk = cin.nextInt();
				String sj =cin.next();
				String ss[] = sj.split(":");
				int hh = Integer.parseInt(ss[0]);
				int mm = Integer.parseInt(ss[1]);
				pp[i][j] = new P(sfz,name,qk,hh,mm,0);
			}
		}
		
		String ch="";				//判断是1的人，存入out2
		P out2[]=new P[100];
		int tt3=0;
		for(int i=0;i<n;i++){
			for(int j=0;j<pp[i].length;j++){
				if(pp[i][j].qk==1&&!ch.contains(pp[i][j].sfz)){
					out2[tt3]=pp[i][j];
					ch=ch+pp[i][j].sfz+" ";//拿字符串当容器存储数据查重
					tt3++;
				}
			}
		}
		
		int tt=0;			//记录一共几人获得口罩
		for(int i=0;i<n;i++){
			int t=0;
			Arrays.sort(pp[i]);
			for(int j=0;j<pp[i].length;j++){
				Pattern pe = Pattern.compile("\\d{18}");
				Matcher m = pe.matcher(pp[i][j].sfz);
				if(pp[i][j].sfz.length()==18&&m.matches()) {
					if(t!=sum[i]){
						if(pp[i][j].flag==0){//只有当标志为0时才可以重新接受口罩
							out[tt]=pp[i][j];
							t++;
							for(int i2=0;i2<n;i2++){
								for(int j2=0;j2<pp[i2].length;j2++){
									if(pp[i2][j2].sfz.equals(pp[i][j].sfz)){
										pp[i2][j2].flag=p+1;
									}
								}
							}
							tt++;
							}
						}
					}else{
						continue;
					}
					
			}
			for (int i2 = 0; i2 < n; i2++) {
				for (int j2 = 0; j2 < pp[i2].length; j2++) {
					if (pp[i2][j2].flag > 0) {
						pp[i2][j2].flag--;//每天都会把标志减减
					}
				}
			}
		}
		for (int i = 0; i < tt;i++){
			System.out.println(out[i].toString());
		}
		for (int i = 0; i < tt3;i++){
			System.out.println(out2[i].toString());
		}
	}
}
class P implements Comparable<P>{
	String sfz;
	String name;		//名字
	int qk;				//身体情况
	int hh;				//时
	int mm;				//分
	int flag;
	public P(String sfz, String name, int qk, int hh, int mm, int flag) {
		super();
		this.sfz = sfz;
		this.name = name;
		this.qk = qk;
		this.hh = hh;
		this.mm = mm;
		this.flag = flag;
	}
	@Override
	public String toString() {
		return name+" "+sfz;
	}
	@Override
	public int compareTo(P o) {
		// TODO Auto-generated method stub
		if(this.hh>o.hh) {
			return 1;
		}else if(this.hh<o.hh) {
			return -1;
		}else {
			if(this.mm>o.mm)
				return 1;
			else if(this.mm<o.mm)
				return -1;
			else
				return 0;
		}
	}
}

算法二：

这个版本结构清但是只能过便面数据，可以用来辅助理解！

思路是：每次发口罩时日期会作为标记存储，下次申请时比较日期间隔是否充足！

中间用了两个Hashmap用来查重和存储，比较近单思路清晰，但是只能过表面数据！

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;

public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner cin = new Scanner(System.in);
		int n = cin.nextInt();//总天数
		int cd =cin.nextInt();//时间间隔
		cin.nextLine();
		Person p[][] = new Person[n][];
		int dayn[] = new int[n];//设置日期数组传递每日数量
		int cdn[] = new int[n];//每日发放数量
		Person out[] = new Person[100];//符合输出要求的对象
		Map< String,Integer >map = new HashMap< String , Integer>();
		Map< String,String >map1 = new HashMap< String , String>();
		for(int i=0;i<n;i++) {
			int num =cin.nextInt();//当日数量
			int dn = cin.nextInt();//当日发放
			p[i] = new Person[num];
			cin.nextLine();
			dayn[i] = num;//数量上传
			cdn[i] =dn;
			for(int j=0;j<num;j++) {
				String s =cin.nextLine();
				String ss[] = s.split(" ");
				String sss[] = ss[3].split(":");
				int tt = Integer.parseInt(sss[0])*60+Integer.parseInt(sss[1]);
				p[i][j] = new Person(ss[0], ss[1], Integer.parseInt(ss[2]), tt, i);
				if(p[i][j].boday==1&&!map1.containsKey(p[i][j].name)) {
					map1.put(p[i][j].name, p[i][j].id);//状态为1的病人存储
				}
				
			}
			Arrays.sort(p[i]);//对每天内的数据进行排序
		}
		int ok = 0;
		for(int i =0;i<n;i++) {
			int ccd = 0;//发放计数
			for(int j =0;j<dayn[i];j++) {
				if(p[i][j].id.length()==18) {
					
					if(!map.containsKey(p[i][j].name)) {
						out[ok] =p[i][j];
						map.put(out[ok].name, out[ok].flag);
						//System.out.println(map.toString());
						ok++;
						ccd++;
					}else if(i-cd>map.get(p[i][j].name)){//判断最后一次口罩的日期间隔
						out[ok] =p[i][j];
						map.put(out[ok].name, out[ok].flag);
						//System.out.println(map.toString());
						ok++;
						ccd++;
					}
					
					
				}
				if(ccd==cdn[i]) {
					break;
				}
				
			}
		}
//		for(int i =0;i<n;i++) {
//			for(int j =0;j<dayn[i];j++) {
//				System.out.println(p[i][j].toString()+i);
//			}
//		}
		for(int k=0;k<ok;k++) {
			System.out.println(out[k].toString());
		}
		Set keys = map1.keySet();
		for (Object key : keys) {
			System.out.println(key+" "+map1.get(key));
		}
		
		
	}

}
class Person implements Comparable<Person>{ 
	String name;//名字
	String id;  //身份证
	int boday ; //身体状态
	int time;   //时间：时*分
	int flag;   //日期标志，就是最后一次获得口罩的日期
	
	public Person(String name, String id, int boday, int time, int flag) {
		super();
		this.name = name;
		this.id = id;
		this.boday = boday;
		this.time = time;
		this.flag = flag;
	}

	@Override
	public String toString() {
		return  name + " " + id;
		//return  name + " " + id +" "+flag ;
	}

	@Override
	public int compareTo(Person arg0) {
		// TODO Auto-generated method stub
		return this.time-arg0.time;
	}
	
	
	
	
}

方法三：

这个方法目前是最稳定的，通过率最高！but超时问题依旧解决不点，等待大佬指点！

import java.awt.List;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeSet;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner cin = new Scanner(System.in);
		Set<String> s = new HashSet<String>();
		// Map<String, Integer> mp = new HashMap<String, Integer>();
		ArrayList<String> list = new ArrayList<String>();
		int d, p; // f记录口罩数
		int r = 0;
		d = cin.nextInt(); // 天数
		int ko[] = new int[d];
		p = cin.nextInt();// 隔p天
		People[][] po = new People[d][]; // 10
		Pattern pa = Pattern.compile("\\d{18}");
		for (int i = 0; i < d; i++) {
			int a, b; // a人数， b口罩数；
			a = cin.nextInt();
			b = cin.nextInt();
			ko[i] = b;
			People pp[] = new People[a];
			for (int j = 0; j < a; j++) {
				String name = cin.next();
				String id = cin.next();
				int body = cin.nextInt();
				String time = cin.next();
				String nameid = name + " " + id;
				pp[j] = new People(name, id, body, time, 0);
				Matcher m = pa.matcher(pp[j].id);
				if (id.length() == 18 && body == 1 && m.matches()) {
					// s.add(nameid);
					list.add(nameid);

				}

				// System.out.println(pp[j]);

			}
			Arrays.sort(pp);
			po[i] = pp;
		}

		People pp2[] = new People[100];
		for (int i = 0; i < d; i++) {

			for (int j = 0; j < po[i].length; j++) {
				// System.out.println(po[i][j].ds);
				Matcher m = pa.matcher(po[i][j].id);
				if (po[i][j].id.length() == 18 && ko[i] > 0 && po[i][j].ds <= i && m.matches()) {
					// System.out.println("23---");
					ko[i]--;
					pp2[r] = po[i][j];
					// System.out.println(pp2[r]+" -- "+i);
					r++;
					po[i][j].ds = i + p + 1;
					for (int k = 0; k < d; k++) {
						for (int l = 0; l < po[k].length; l++) {
							if (po[k][l].id.equals(po[i][j].id)) {
								po[k][l].ds = po[i][j].ds;
							}
						}
					}
					// System.out.println(po[i][j].toString());
				}
			}
		}
		for (int i = 0; i < r; i++) {
			System.out.println(pp2[i].toString());
		}
		for (int i = 0; i < list.size() - 1; i++) {
			for (int j = i + 1; j < list.size() - 1; j++) {
				if (list.get(i).equals(list.get(j))) {
					list.remove(j);
				}
			}
		}
		// Iterator<String> iter = s.iterator();
		Iterator<String> iter = list.iterator();
		while (iter.hasNext()) {
			System.out.println(iter.next());
		}
	}

}

class People implements Comparable<People> {
	String name;
	String id;
	int body;
	String time;
	int ds;

	public People(String name, String id, int body, String time, int ds) {
		super();
		this.name = name;
		this.id = id;
		this.body = body;
		this.time = time;
		this.ds = ds;
	}

	public String toString() {
		return name + " " + id;
	}

	public int compareTo(People o) {
		// TODO Auto-generated method stub
		String a[] = o.time.split(":");
		String d[] = this.time.split(":");
		int b = Integer.parseInt(a[0]) * 60 + Integer.parseInt(a[1]);
		int c = Integer.parseInt(d[0]) * 60 + Integer.parseInt(d[1]);
		return c - b;
	}
}