北航2023年考研机试题

【问题描述】一共6个手机基站，具有记录手机连接基站的能力，6个手机基站分别为ABCDEF，他们具有自己的覆盖范围且任何两个基站的覆盖范围不想交，基站保存的手机登陆日志包括手机号（11位，用字符串保存），基站编号，登陆时间（6位数，用字符串保存），登出时间（6位，用字符串保存）

        要求：某一天多个基站的手机登陆日志信息和一个要查找的人员手机号，查找与该人员同时空的手机号

        输入：一个N和N条登陆日志信息，最后还有一个要查找人员的手机号

        输出：输出与要查找人员时间和地点有重叠的人员信息（即日志信息），依次输出手机号，基站编号，登陆时间和登出时间；按照登陆时间进行排序，如果登陆时间相同按照手机号进行排序（如果一个人员的登出时间和另一个人员的登陆时间相同也算时间重叠）

输入：样例

7 

11111 A 080000 225959

22222 B 080000 225959

33333 A 100000 110000

44444 B 101000 110000

55555 A 120000 131000

66666 A 225959 235959

77777 A 100000 120000

11111

第一个是手机号；第二个是基站编号；第三个是登陆时间，上面的例子就是：08:00:00；第四个是登出时间，上面的例子对应的时间就是23:59:59，每个日志中间还有一个空行。

暴力代码：

#include<bits/stdc++.h>
using namespace std;
//结构体数组，类，容器 
struct Basic{
		string  phone;//11位手机号 
		char basic;//基站编号 
		string intime;//登陆时间 
		string outtime; //登出时间 
};
int  yes;
vector<Basic> x;//结构体即是一种数据类型与地点，时间有重叠的结构体编号 
vector<int> y;//存储判断是否重复 
bool compare(const Basic &a,const Basic &b){//使用方式，结构体名称加解引用 
	if(a.intime==b.intime){
		return a.phone<b.phone;
	}
	return a.intime<b.intime;
}
int main(){
	int n;//n条需要输入的信息
	cin>>n; 
	Basic pary[n];//重点
	bool panduan =true;//判断容器中是否出现重复元素 
	for(int i=0;i<n;i++){
		string  phone;//11位手机号 
		char basic;//基站编号 
		string intime;//登陆时间 
		string outtime; //登出时间 
		cin>>phone>>basic>>intime>>outtime;
		pary[i].phone=phone;
		pary[i].basic=basic;
		pary[i].intime=intime;
		pary[i].outtime=outtime;
	} 
	string search;
	cin>>search;
	for(int i=0;i<n;i++){//循环判断找要查找人员的信息 
		if(pary[i].phone==search){
			yes=i;
		} 
	}
	//找到了手机号对应的全部信息，num，time，out
	for(int i=0;i<n;i++){//先遍历基站一样的 
		if(pary[i].basic==pary[yes].basic&&yes!=i){
			x.push_back(pary[i]);
			y.push_back(i);
		} 
	} 
	for(int i=0;i<n;i++){//再遍历入时间一样的 
		if(pary[i].intime==pary[yes].intime&&yes!=i){
			for(int j=0;j<x.size();j++){
				if(y[j]==i){//有重复数字 
				panduan=false;
				}
			}
			if(panduan==true){
				y.push_back(i);
					x.push_back(pary[i]);
				} 
		}
	}
		for(int i=0;i<n;i++){//再遍历出时间一样的 
		if(pary[i].outtime==pary[yes].outtime&&yes!=i){
				for(int j=0;j<x.size();j++){
				if(y[j]==i){//有重复数字 
				panduan=false;
				}
			}
			if(panduan==true){
					x.push_back(pary[i]);
					y.push_back(i);
				} 
		}	 
	}
		for(int i=0;i<n;i++){//再遍历入时间一样的 
		if(pary[i].intime==pary[yes].outtime||pary[i].outtime==pary[yes].intime){
			if(yes!=i){//把基准去掉 
					for(int j=0;j<x.size();j++){
				if(y[j]==i){//有重复数字 
				panduan=false;
				}
			}
			if(panduan==true){
					x.push_back(pary[i]);
					y.push_back(i);
				} 
			}
		} 
	}
	sort(x.begin(),x.end(),compare); 
	for(int i=0;i<x.size();i++){
		cout<<x[i].phone<<" "<<x[i].basic<<" "<<x[i].intime<<" "<<x[i].outtime<<endl; 
	}
	
}

思路：通过定义一个Basic容器对一条日志进行存储，一个int型容器对符合要求的容器下标进行存储，顺便进行判断是否重叠，最后把整个结构体容器按照compare定义的排序方式进行排序，最后输出结果。

重点：vector<Basic> x; 结构体即是一种数据结构，可以通过容器定义一次，在往容器中传入数据时，可以把一整个结构体传进去。

        传入时，结构体容器将结构体数组的一个元素传入，即为一个完整的结构体。

注意：sort函数的语法自定义排序时需要定义一个函数，且如果是要用容器结构体时，要在compare中对应好变量类型。

附：gpt简化后的代码:

#include <iostream>
#include <vector>
#include <algorithm>
 
using namespace std;
 
// 结构体 
struct Basic {
    string phone;
    char basic;
    string intime;
    string outtime;
};
 
// 辅助函数：判断两个时间段是否有重叠
bool isTimeOverlap(const Basic& a, const Basic& b) {
    // 注意：此处假设时间字符串可以直接比较，实际项目中应转换为合适的数据结构进行比较
    return (a.intime <= b.outtime && b.intime <= a.outtime) || (a.outtime <= b.intime && b.outtime <= a.intime);
}
 
bool compare(const Basic &a, const Basic &b) {
    if (a.intime == b.intime) {
        return a.phone < b.phone;
    }
    return a.intime < b.intime;
}
 
int main() {
    int n;
    cin >> n;
    Basic pary[n];
 
    for (int i = 0; i < n; i++) {
        cin >> pary[i].phone >> pary[i].basic >> pary[i].intime >> pary[i].outtime;
    }
 
    string search;
    cin >> search;
 
    for (int i = 0; i < n; i++) {
        if (pary[i].phone == search) {
            vector<Basic> x;//结构体容器 
            for (int j = 0; j < n; j++) {
                if (i != j && (pary[j].basic == pary[i].basic || isTimeOverlap(pary[i], pary[j]))) {
                    x.push_back(pary[j]);
                }
            }
 
            sort(x.begin(), x.end(), compare);
            for (const auto& record : overlapping_records) {
                cout << record.phone << " " << record.basic << " " << record.intime << " " << record.outtime << endl;
            }
            break;
        }
    }
 
    return 0;
}