牛牛的闹钟

#include <iostream>

using namespace std;

int main()
{
    int N, hi, mi, x, goclass;
    int res = 0;
    cin >> N;
    int getup[N];
    for (int i = 0; i < N; i++)
    {
        cin >> hi >> mi;
        getup[i] = hi * 60 + mi;
    }
    cin >> x >> hi >> mi;
    goclass = hi * 60 + mi;
    for (int i = 0; i < N; i++)
    {
        if (getup[i] + x <= goclass && getup[i] > res)
            res = getup[i];
    }
    cout << res / 60 << ' ' << res % 60;
    return 0;
}

	

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int N = in.nextInt();
        int hh = 0 , mm = 0;
        int [] a = new int[N];
        for (int i = 0; i < N; i++) {
            hh = in.nextInt();
            mm = in.nextInt();
            a[i] =( hh * 60 ) + mm;
        }
        int lushi = in.nextInt();
        int ScHH = in.nextInt();
        int ScMM = in.nextInt();
        int School = (ScHH * 60) + ScMM;
        int min = 0;
        for (int i = 0; i < a.length; i++) {
            if(School - (lushi + a[i]) < 0 ){
                continue;
            }else{
                if(School -(lushi + a[i]) < School - (lushi + a[min])){
                    min = i;
                }
            }
        }
        
        System.out.println(a[min]/60+ " " +a[min]%60);
    }
}

思路

把时间都转换为分钟计数，上课时间-路上时间得到最晚起床时间，把所有闹钟时间排序后，二分查找最晚起床时间。

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int h=0,m=0;
        int[] a = new int[n];
        for(int i=0;i<n;i++){
            h = sc.nextInt();
            m = sc.nextInt();
            a[i] = h*60+m;
        }
        int t = sc.nextInt();
        h = sc.nextInt();
        m = sc.nextInt();
        int p = h*60+m-t;
        Arrays.sort(a);
        t = Arrays.binarySearch(a,p);
        if(t <0) t = -(t+2);
        h = a[t]/60;
        m = a[t]%60;
        System.out.print(h+" "+m);
    }
}

本套8道题全部pass的C++代码已挂到了我的GitHub(https://github.com/shiqitao/NowCoder-Solutions)
牛客网上的其他题目解答也在持续更新。

#include <iostream>
using namespace std;
int main()
{
    int n; cin >> n;
    int max_h = 0, max_m = 0, maxTime = 0;
    int *hour = new int[n];
    int *minute = new int[n];
    int *time = new int[n];
    for (int i = 0; i < n; i++) {
        cin >> hour[i] >> minute[i];
        time[i] = hour[i] * 60 + minute[i];
    }
    int X; cin >> X;
    int reach_h, reach_m; cin >> reach_h >> reach_m;
    int reachTime = reach_h * 60 + reach_m;
    for (int i = 0; i < n; i++) {
        if (time[i]>maxTime && time[i] + X <= reachTime) {
            maxTime = time[i];
            max_h = hour[i];
            max_m = minute[i];
        }
    }
    cout << max_h << " " << max_m;
    delete[] hour;
    delete[] minute;
    delete[] time;
    return 0;
}

n = int(input())
clock = []
for _ in range(n):
    temp = input()
    hm = list(map(int, temp.split()))
    # 以0点0分为原点，将所有闹钟时间转换为绝对时间
    clock.append([temp, hm[0] * 60 + hm[1]])
# 到教室需要花费的时间
time_cost = int(input())
# 将上课时间也转换为绝对时间
hm = list(map(int, input().split()))
target = hm[0] * 60 + hm[1]
# 过滤掉会迟到的闹钟时间
clock = [item for item in clock if item[1] + time_cost <= target]
# 选择最接近上课时间的闹钟时间
print(sorted(clock, key=lambda x: target - x[1])[0][0])

import java.util.Arrays;
import java.util.Scanner;

public class Main{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        //输入闹钟个数
        int n = sc.nextInt();
        int[] clock = new int[n];
        //输入闹钟时间
        for (int i = 0; i < n; i++) {
            int hour = sc.nextInt();
            int minute = sc.nextInt();
            clock[i] = hour*60 + minute;
        }
        Arrays.sort(clock);

        int walkTime = Integer.parseInt(sc.next());
        int hour = sc.nextInt();
        int minute = sc.nextInt();
        int classTime = hour*60+minute;
        int getupTime = classTime-walkTime;

        int i = n-1;
        //如果闹钟大于起床时间，继续往下找到最晚起床时间
        while (getupTime < clock[i]){
            i--;
        }
        System.out.println(clock[i]/60+" "+clock[i]%60);
    }
}

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        int N=sc.nextInt();
        int[] arr=new int[N];
        for(int i=0;i<N;i++){
            int Hi=sc.nextInt();
            int Mi=sc.nextInt();
            arr[i]=Hi*60+Mi;
        }
        Arrays.sort(arr);
        int X=sc.nextInt();
        int A=sc.nextInt();
        int B=sc.nextInt();
        int sk=A*60+B;
        for(int i=0;i<N;i++){
            int t=sk-X-arr[i];
            if(t==0){
                System.out.print(arr[i]/60+" "+arr[i]%60);
                break;
            }
            if(t<0){
                System.out.print(arr[i-1]/60+" "+arr[i-1]%60);
                break;
            }
        }
    }
}

1 思路

1. 先将所有的闹钟时间按照从早到晚排序。

2. 通过上课时间和赶路时间计算出最晚起床时间。

3. 用二分查找在所有闹钟时间中找最晚起床时间，如果找到则直接输出，如果没找到就输出插入位置前一个闹钟。

import java.util.Scanner;
import java.util.Arrays;
 
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int N = scanner.nextInt();
        Integer[][] alarms = new Integer[N][2];
        for (int i = 0; i < N; ++i) {
            alarms[i][0] = scanner.nextInt();
            alarms[i][1] = scanner.nextInt();
        }
        
        // 对闹钟进行排序
        Arrays.sort(alarms, (Integer[] a1, Integer[] a2)->{
            // 如果时不相等就返回时的比较结果
            if (a1[0].compareTo(a2[0]) != 0) {
                return a1[0].compareTo(a2[0]);
            } else {
                // 否则返回分的比较结果
                return a1[1].compareTo(a2[1]);
            }
        });
        
        int X = scanner.nextInt();
        int A = scanner.nextInt();
        int B = scanner.nextInt();
        
        // 算出最晚起床时间
        A -= X / 60;
        X %= 60;
        if (B >= X) {
            B -= X;
        } else {
            --A;
            B = B + 60 - X;
        }
        Integer[] getUp = {A, B};
        
        // 用二分查找在所有闹钟时间中查找起床时间
        int result = Arrays.binarySearch(alarms, getUp, (Integer[] a1, Integer[] a2)->{
            // 如果时不相等就返回时的比较结果
            if (a1[0].compareTo(a2[0]) != 0) {
                return a1[0].compareTo(a2[0]);
            } else {
                // 否则返回分的比较结果
                return a1[1].compareTo(a2[1]);
            }
        });
        
        // 如果正好找到就输出此闹钟
        if (result >= 0) {
            System.out.println(alarms[result][0] + " " + alarms[result][1]);
        } else {
            // 如果没有恰好相等的，返回的是恰好大于起床时间的那个闹钟的 - index - 1，
            // 所以要输出 - result - 2 位置的闹钟。
            System.out.println(alarms[- result - 2][0] + " " + alarms[- result - 2][1]);
        }
    }
}

import java.util.*;
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 a[][]=new int[n][2];
		for(int i=0;i<n;i++) {
			a[i][0]=cin.nextInt();//当天的A时B分中的A
			a[i][1]=cin.nextInt();//当天的A时B分中的B
		}
		int c[][]=new int[1][2];
        int x=cin.nextInt();//去教室需要用到的时间
        int b[][]=new int [1][2];//上课时间A时B分
        b[0][0]=cin.nextInt();
        b[0][1]=cin.nextInt();
        if(x<b[0][1]) {
        	c[0][0]=b[0][0];
        	c[0][1]=b[0][1]-x;
        	
        }
        else if(x==b[0][1]) {
        	c[0][0]=b[0][0];
        	c[0][1]=0;
        }
        else {
        	if(x-b[0][1]<=60) {
        		c[0][0]=b[0][0]-1;
            	c[0][1]=60-(x-b[0][1]);	
        	}
        	else {
        		c[0][0]=b[0][0]-2;
            	c[0][1]=60-(x-b[0][1]-60);	
        		
        	}
        }
        
        for (int i = 1; i < n; i++) {
			int temp0 = a[i][0];// 待插入的值
			int temp1 = a[i][1];// 待插入的值
			
			int index = i;// 待插入的位置
			while ((index > 0 && a[index - 1][0] > temp0) || (index > 0 && (a[index - 1][0] == temp0 && index > 0 && a[index - 1][1] > temp1)  )) {
			a[index][1] = a[index - 1][1];// 待插入的位置重新赋更大的值
			a[index][0] = a[index - 1][0];
			
			index--;// 位置往前移
			}
			a[index][1] = temp1;
			a[index][0] = temp0;
			}
       
         int temp[][]=new int[1][2];
        for(int i=0;i<n;i++) {
        	if(c[0][0]<a[i][0] || (c[0][0]==a[i][0]  && c[0][1]<a[i][1]))break;
        	temp[0][0]=a[i][0];
        	temp[0][1]=a[i][1];
        }

        System.out.print(temp[0][0]+" "+temp[0][1]);
		
	}

}

#include<bits/stdc++.h>
using namespace std;
typedef pair<int, int> p;
int main()
{
	int N;cin >> N;
	p time[N];
	for (int i = 0;i < N;i++)
        cin >> time[i].first >> time[i].second;
    
	sort(time, time + N);
	int X;cin >> X;
	int A, B;cin >> A >> B;

	//计算它最晚的起床时间
	if (B - X >= 0)
		B = B - X;
	else
	{
		A -= 1;
		B = B - X + 60;
	}

	//和闹钟比较
	for (int i = N - 1;i >= 0;i--)
	{
		if (time[i].first < A||(time[i].first == A && time[i].second <= B))
		{
			cout << time[i].first<<' ' << time[i].second << endl;
			break;
		}
	}

	return 0;

}

import java.util.*;
//1.将输入的闹钟时间转换成分钟数存入矩阵，方便计算
//2.将上课时间减去到达教室所需时间，得到起床时间
//3.由于只有闹钟响时才决定起不起床，因此在小于等于起床时间的所有闹钟里面，最大的那个就是我们需要的最晚闹钟时间
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        //时间转换成分钟数
        int[] minutes = new int[N];
        int hour = 0;
        int minute = 0;
        for(int i = 0; i < N; i++){
            hour = sc.nextInt();
            minute = sc.nextInt();
            minutes[i] = hour * 60 + minute;
        }
        int needTime = sc.nextInt();
        hour = sc.nextInt();
        minute = sc.nextInt();
        int classTime = hour * 60 + minute;
        //得到最晚起床时间
        int lastMinute = classTime - needTime;
        //设置一个max，在小于等于起床时间的闹钟时间里，更新最大的闹钟时间为max
        int max = 0;
        for(int i = 0; i < N; i++){
            if(lastMinute >= minutes[i]){
                max = Math.max(max, minutes[i]);
            }
        }
        //转换成时间
        hour = max / 60;
        minute = max % 60;
        System.out.print(hour + " " + minute);
    }
}

import sys
def plus_time(t,x):
    if t[1]+x<60:
        return [t[0],t[1]+x]
    else:
        return [t[0]+1,t[1]+x-60]
    
if __name__=='__main__':
    n=int(sys.stdin.readline().strip())
    time=[]
    for i in range(n):
        time.append(list(map(int,sys.stdin.readline().split())))
    x=int(sys.stdin.readline().strip())
    start=list(map(int,sys.stdin.readline().split()))
    time=sorted(time,key=lambda x:x[::1])
    i=0
    while i<len(time):
        if plus_time(time[i],x)[0]<start[0]:
            i+=1
        elif plus_time(time[i],x)[0]==start[0] and plus_time(time[i],x)[1]<=start[1]:
            i+=1
        else:
            print(' '.join(map(str,time[i-1])))
            break