4.1携程笔试

第一题

工作人员接电话，大于等于就可以接上电话，问最少有几个工作人员
输入：
5
0,30
0,50
10,20
15,30
20,50

输出
5

solution 贪心

其实这道题很简单，当时总想着往做过的题上靠，思想就箍住了，其实自己可以想出来的‘
就是从头i 的for循环，记录end
然后里面套一个j的for循环从第二个开始遍历 ，start比较end如果大于等于，就标记这个代表已经选了，可以变成Integer.MIN_VALUE, 然后更新end
每次就判断start如果不是Integer.MIN_VALUE，就++

package xiecheng;
import java.util.*;
public class test1 {

	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		while(sc.hasNext()) {
			int n=sc.nextInt();
			int[][] num=new int[n][2];
			sc.nextLine();
			for(int i=0;i<n;i++) {
				String[] str=sc.nextLine().trim().split(",");
				num[i][0]=Integer.valueOf(str[0]);
				num[i][1]=Integer.valueOf(str[1]);
			}
			int res=solution(num);
			System.out.println(res);
	    }

    }

	private static int solution(int[][] num) {
		int n=num.length;
		if(num==null || n==0) return 0;
		
		Arrays.sort(num, new Comparator<int[]>() {
	        @Override
	        public int compare(int[] a, int[]  b) {
	            return a[0]-b[0];
	        
	        }
	    });
		int count=1;
		int end=num[0][1];
		for(int i=0;i<num.length;i++) {
			if(num[i][0]!=Integer.MIN_VALUE) count++;
			int curEnd=num[i][1];
			for(int j=i+1;j<num.length;j++) {
				if(num[j][0]>=curEnd) {
					num[j][0]=Integer.MIN_VALUE;
					curEnd=num[j][1];
				}
			}
		}
		return count;
	}
}
	

第二题：

海豚从0岁开始，到生孩子的天时每个生一个从0开始，求第s天还有多少只海豚，返回

n为开始有多少海豚，
m为每只海豚寿命，
k为生孩子的天有几个
1
。。。
k
s为算多少天过后
例
输入：
5
5
2
2
4
5
输出
20

solution

这道题其实不难，就是当时没有想到好方法，应该多在纸上练几个数，就会了，因为这个就是求个数所以应该类似数组动态规划 ，如果是求具体的什么寿命就用List<List< Integer >> 存 到时候导出来，但是这题是求个数 ，用数组存就可以，返回 dp【year】

zhu:这次学会了找不出来就用Sop调试嘿嘿

这是复杂方法

import java.util.*;
public class test2 {


/*	n（初始海豚数）
	m（海豚寿命）
	海豚生宝宝的年份数量(假设为p)
	海豚生宝宝的年份1
	...
	海豚生宝宝的年份p
	x（几年后）
	输出*/
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		while(sc.hasNext()) {
			int n=sc.nextInt();
			int shou=sc.nextInt();
			int m=sc.nextInt();
			PriorityQueue<Integer> queue=new PriorityQueue<>(m);
	
			for(int i=0;i<m;i++) {
				queue.add(sc.nextInt());
			}
			System.out.println(queue);
			int year=sc.nextInt();
			int res=solution(n,shou,queue,m,year);
			System.out.println(res);
		}
		

	}

private static int solution(int n, int shou, PriorityQueue<Integer> queue, int m, int year) {
	if(n<=0 || shou<=0 ||year<0 ||m<0) return 0;
//	if(year==0) return n;
	if(year==0) return 0;
	int sum=0;
	if(shou>=year) { 
		sum+=n*Math.pow(2, queue.size());
	}
	int[] dp=new int[year+1];
	dp[0]=n;
	List<List<Integer>> res=new ArrayList<>();
	List<Integer> list=new ArrayList<>();
	list.add(0);
	res.add(list);
	for(int i=1;i<=year;i++) {
		res.add(new ArrayList<>());
	}
	for(int i=1;i<=shou;i++) {
		res.get(i).add(i);
	}
	
//	for(List<Integer> cur:res) {
//		System.out.println(cur);
//	}
	while(!queue.isEmpty()) {  // 一定要这么写可以的
		int cur=queue.poll();
		int count=res.get(cur).size();
		System.out.println(count);
		while(count-- >0) {
			for(int k=cur,j=0;k<=(cur+shou)&& k<=year;k++,j++) {
				res.get(k).add(j);
		//		System.out.println(res.get(k));
			}
			
		}
	//	System.out.println(res.get(cur));
		
	}
//	System.out.println(res.get(year));	
	return res.get(year).size()*n;
}
}

数组简单方法

其实上面的方法把具体的寿命也写进去了，其实就见一个year长度数组，然后里面放一就可以，每次循环叠加放一，最后统计最后一个1的个数，再*n

嘿嘿自己sop调了半天，做出来了
嘿嘿嘿

private static int solution(int n, int shou, PriorityQueue<Integer> queue, int m, int year) {
	if(n<=0 || shou<=0 ||year<0 ||m<0) return 0;
//	if(year==0) return n;
	if(year==0) return 0;
	int sum=0;
	if(shou>=year) { 
		sum+=n*Math.pow(2, queue.size());
	}
	int[] dp=new int[year+1];
//	dp[0]=n;
	for(int i=0;i<=shou;i++) {
		dp[i]=1;
	}
	for(int a:dp) {
		System.out.println(a);
	}
	while(!queue.isEmpty()) {
		int cur=queue.poll();
		int curNum=dp[cur];
	//	while(dp[cur]-- >0) {
			for(int i=cur;i<=cur+shou && i<=year;i++) {
				dp[i]+=curNum;
				for(int a:dp) {
					System.out.print(a);
					
				}
				System.out.println();
				
			}
//		}
		
	}
	return n*dp[year];}