1. 行程安排
题目描述：
我是一个大帅哥，因此有很多粉丝想和我合影，想请我吃饭，也有很多签售演唱会等着我，总之我很忙。可是，我的秘书非常的不靠谱，他总是把一些日程安排在重复的时间上，比如我今天的日程是：早上8:00 - 10:00粉丝见面会、早上 9:00 - 9:30粉丝早餐会、下午 1:30 - 5:00 午睡（是的，这很重要）、晚上 8:00 - 9:30 婚礼表演嘉宾。所以，由于粉丝见面会更重要，我不得不取消粉丝早餐会了，因为他们在同一时间进行。那么问题来了，现在我需要一套算法，当我输入一天的行程，我需要这个算法告诉我，今天至少要取消多少个行程才能让每个日程之间时间不重叠。skrskr~~
输入
原始输入为时间点数目（行程数*2）以及各个行程的开始结束时间点。
需要先转化为一个二元组list，如list[（8.0,10.0），（8.0,10.0），（8.0,10.0），（8.0,10.0），（12.0,14.5）]。其中二元组内第一第二个元素分别为事项的开始时间和结束时间，以float显示，如早上9:00 - 10:00 表示为（9.0 - 10.0），下午1:30 - 下午5:00表示为（13.5,17.0）。
输出
需要取消多少个行程，以int显示。
样例输入
10
8.0
10.0
8.0
10.0
8.0
10.0
8.0
10.0
12.0
14.5
样例输出
3
思路：
1. 先把数据放到二维数组里面：
| 8.0 | 10.0 |
| 8.0 | 10.0 |
| 8.0 | 10.0 |
| 8.0 | 10.0 |
| 12.0 | 14.5 |
2.两种情况：
情况1：第一个行程的结束时间大于后面行程的开始时间，证明第一个行程和后面行程有重叠，踢去第一个行程。然后再接着比较第二个行程的结束时间大于后面行程的开始时间，证明第二个行程和后面行程有重叠，踢去第二个行程，以此类推。
情况2：后一个行程的结束时间大于前一个行程的开始时间，这是符合情况的。但是，如果前一个行程的结束时间大于后一个行程的开始时间，那么这俩个行程就相互重叠，需要踢到一个。
import java.util.Scanner;
public class Main3 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner in = new Scanner(System.in);
int res;
int N = 0;
N = Integer.parseInt(in.nextLine().trim());
float[][] _data = new float[N/2][2];
float _data_item;
for(int _data_i = 0; _data_i < N/2; _data_i++) {
for(int i=0; i<2; i++) {
_data_item = Float.parseFloat(in.nextLine().trim());
_data[_data_i][i] = _data_item;
}
}
res = schedule(_data);
System.out.println(String.valueOf(res));
}
public static int schedule(float[][] data) {
int count = 0;
boolean flag = false;
for(int i=0; i<data.length;i++) {
flag = false;
for(int j=i+1; j< data.length;j++) {
if(data[i][1]>data[j][0]||(data[j][1]>data[i][0]&&data[i][1]>data[j][1])) {
flag = true;
break;
}
}
if(flag == true) {
count++;
}
}
return count;
}
}2. 给定一个整数数组，求出现频率最高的2个元素之和，如果有相同频率时按先在数组中出现的元素计算。
我的解法：桶排序（Bucket Sort），时间复杂度O(n)。
思路：
1. 遍历数组nums，利用LinkedHashMap统计各元素出现次数。（使用LinkedHashMap的原因是：LinkedHashMap输出的顺序和输入的相同，这样就保证了“如果有相同频率数据时按先在数组中出现的元素计算”）
2. 遍历LinkedHashMap，利用嵌套列表ArrayList记录出现次数为i（ i∈[1, n] ）的所有元素
3. 逆序遍历ArrayList，将其中的前k个元素输出。
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
public class Leet347Top_K {
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] array = {3,2,1};
List<Integer> resArray = topKFrequent(array, 2);
int res = 0;
for (int a : resArray) {
res += a;
}
System.out.print(res);
}
public static List<Integer> topKFrequent(int[] nums, int k){
//计算每一个元素出现的次数
LinkedHashMap<Integer, Integer> map = new LinkedHashMap<Integer, Integer>();
for(int num : nums) {
if(map.containsKey(num)) {
map.put(num, map.get(num)+1);
} else {
map.put(num, 1);
}
}
//得到最频繁出现的
int max = 0;
for(Map.Entry<Integer, Integer> entry : map.entrySet()) {
max = Math.max(max, entry.getValue());
}
//初始化一个ArrayList。索引是出现的次数，ArrayList的值是数。
ArrayList<Integer>[] arr = (ArrayList<Integer>[]) new ArrayList[max + 1];
for(int i=1; i<=max; i++) {
arr[i] = new ArrayList<Integer>();
}
for(Map.Entry<Integer, Integer> entry: map.entrySet()){
int count = entry.getValue();
int number = entry.getKey();
arr[count].add(number);
}
List<Integer> result = new ArrayList<Integer>();
//add most frequent numbers to result
for(int j=max; j>=1; j--){
if(arr[j].size()>0){
for(int a: arr[j]){
result.add(a);
//if size==k, stop
if(result.size()==k){
return result;
}
}
}
}
return null;
}
}