版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
第一题
题目描述
提供火车进出某个火车站的时刻表，给出最少需要多少个站台，才能让所有的火车进入该站时都不需要等候；
输入描述
输入两行数组（数字用空格间隔），第一行代表到达时刻表，第二行代表出发时刻表，如下：
900 940 950 1100
910 1200 1120 1130
以上内容代表
到达时刻表：9:00 9:40 9:50 11:00
出发时刻表：9:10 12:00 11:20 11:30
输出描述：
正整数，代表站台数量
3
思路：
处理输入：读取时因为读取的是一行数字，且题目中没有提时刻表的size，所以通过nextline读取两行字符串，然后通过String.split()以空格分割字符串为字符串数组，然后通过Integer.parseInt()得到整形数组；
统计站台：利用优先队列（最小堆）将第一辆车的离开时间加入堆，然后拿堆顶的离开时间与下一个车到达时间相比，如果后者小或者相等的话说明在前一辆车出发之前，下一辆车已经到达，此时将这辆车的离开时间加入堆；
如果后者大的话，移除堆顶元素；如果此时堆为空并且后续还有车要来，就将下一辆车的离开时间加入堆；继续拿堆顶的离开时间比较下一辆车的到达时间（重复上一步骤），直到没有时刻表上的内容遍历过；
记录堆的size，每次加入元素时比较先前记录的最大size是否依旧最大并保持更新。
代码：
public class Liulishuo1 {
public static void main(String[] args) {
Liulishuo1 test = new Liulishuo1();
Scanner in = new Scanner(System.in);
String str1 = in.nextLine();
String str2 = in.nextLine();
String[] S1 = str1.split("[ ]");
String[] S2 = str2.split("[ ]");
int arrive[] = test.shift(S1);
int leave[] = test.shift(S2);
in.close();
System.out.println(test.train(arrive, leave));
}
private int train(int[] arrive, int[] leave) {
PriorityQueue<Integer> queue = new PriorityQueue<Integer>();
int y = 0;
int maxsize = 0;
queue.add(leave[y]);
maxsize = queue.size();
y++;
while ( y < arrive.length) {
if (queue.peek() >= arrive[y]) {
queue.add(leave[y]);
maxsize = Math.max(maxsize, queue.size());
y++;
} else {
queue.poll();
if (queue.isEmpty() && y < arrive.length) {
queue.add(leave[y]);
y++;
}
}
}
return maxsize;
}
public int[] shift(String S[]) {
int[] arr = new int[S.length];
for (int i = 0; i < S.length; i++) {
arr[i] = Integer.parseInt(S[i]);
}
return arr;
}
}
第二题
题目描述：
爬楼梯：每次可以爬一层或两层台阶，当台阶数为N时有多少种方法？（0<=N<=90）
**思路：**动态规划的题，找到递推公式就好
时间复杂度 O(n)
注意：N到足够大时int，long类型将超出范围，所以返回值应该用double类保险，但是打印时有如下区别
System.out.printf("%.0f",res.methodCount(90));
System.out.println(" ");
System.out.println(res.doubleTrans(res.methodCount(m)));
90
4660046610375530500
4660046610375530496
基本数据类型，字节数，位数，最大值和最小值。
1、
基本类型：short 二进制位数：16
包装类：java.lang.Short
最小值：Short.MIN_VALUE=-32768 （-2的15此方）
最大值：Short.MAX_VALUE=32767 （2的15次方-1）
2、
基本类型：int 二进制位数：32
包装类：java.lang.Integer
最小值：Integer.MIN_VALUE= -2147483648 （-2的31次方）
最大值：Integer.MAX_VALUE= 2147483647 （2的31次方-1）
3、
基本类型：long 二进制位数：64
包装类：java.lang.Long
最小值：Long.MIN_VALUE=-9223372036854775808 （-2的63次方）
最大值：Long.MAX_VALUE=9223372036854775807 （2的63次方-1）
4、
基本类型：float 二进制位数：32
包装类：java.lang.Float
最小值：Float.MIN_VALUE=1.4E-45 （2的-149次方）
最大值：Float.MAX_VALUE=3.4028235E38 （2的128次方-1）
5、
基本类型：double 二进制位数：64
包装类：java.lang.Double
最小值：Double.MIN_VALUE=4.9E-324 （2的-1074次方）
最大值：Double.MAX_VALUE=1.7976931348623157E308 （2的1024次方-1）
代码1：
public class Main{
public Tongcheng3() {
// TODO Auto-generated constructor stub
}
public double methodCount(int m) {
double x, y, cur, tmp;
x = 1;
y = 2;
if (m == 1 || m == 2) {
return m;
}
for (cur = 3; cur < m; cur ++) {
tmp = x + y;
x = y;
y = tmp;
}
return x + y;
}
public String doubleTrans(double d){
return String.valueOf((long)d);
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner s = new Scanner(System.in);
int m = s.nextInt();
Main res = new Main();
System.out.printf("%.0f",res.methodCount(90));
System.out.println(" ");
System.out.println(res.doubleTrans(res.methodCount(m)));
s.close();
}
}
思路2：斐波那契数列公式
时间复杂度log n
代码2：
public class Solution {
public int climbStairs(int n) {
double sqrt5=Math.sqrt(5);
double fibn=Math.pow((1+sqrt5)/2,n+1)-Math.pow((1-sqrt5)/2,n+1);
return (int)(fibn/sqrt5);
}
}