腾讯2020校园招聘-后台&综合-第一次笔试

最新推荐文章于 2021-06-01 15:47:13 发布

Arthur_____

最新推荐文章于 2021-06-01 15:47:13 发布

阅读量949

点赞数

分类专栏：笔试

本文链接：https://blog.csdn.net/Arthur_____/article/details/104614854

版权

笔试专栏收录该内容

2 篇文章 0 订阅

订阅专栏

[编程题]压缩算法（01）

时间限制：C/C++ 2秒，其他语言4秒

空间限制：C/C++ 256M，其他语言512M

小Q想要给他的朋友发送一个神秘字符串，但是他发现字符串的过于长了，于是小Q发明了一种压缩算法对字符串中重复的部分进行了压缩，对于字符串中连续的m个相同字符串S将会压缩为m|S，例如字符串ABCABCABC将会被压缩为[3|ABC]，现在小Q的同学收到了小Q发送过来的字符串，你能帮助他进行解压缩么？

输入描述:
输入第一行包含一个字符串s，代表压缩后的字符串。
S的长度<=1000;
S仅包含大写字母、[、]、|;
解压后的字符串长度不超过100000;
压缩递归层数不超过10层;

输出描述:
输出一个字符串，代表解压后的字符串。

输入例子1:
HG[3|B[2|CA]]F

输出例子1:
HGBCACABCACABCACAF

例子说明1:
HG[3|B[2|CA]]F−>HG[3|BCACA]F−>HGBCACABCACABCACAF

思路

使用递归迭代计算，构建辅助函数helper用于计算1组[...]的真实值；
helper首先检索数字，也即是要重复的次数；然后用StringBuilder来存储后面的字符串；在此检索到 ']' 的时候，递归下一个helper;

	public static void main(String[] args) {
		Scanner c = new Scanner(System.in);
		String s = c.next();
		char[] str = s.toCharArray();
		StringBuilder result = new StringBuilder();
		for(int i=0;i<str.length;) {
			if(str[i]!= '[')
				result.append(str[i++]);
			else
				i = helper(str, i,result);
		}
		System.out.println(result.toString());
	}
	private static int helper(char[] str,int index,StringBuilder result) {
		//当前的index是‘【’
		index++;
		StringBuilder sb = new StringBuilder();
		//先检索数字
		while(str[index] != '|') {
			sb.append(str[index]);
			index++;
		}
		int num = Integer.valueOf(sb.toString());
		sb = new StringBuilder();
		index++;
		
		while(index < str.length) {
			if(str[index] == ']') break;
			else if (str[index] == '[') {
				index = helper(str, index, sb);
				continue;
			}
			else {
				sb.append(str[index]);
			}
			index++;
		}
		String one = sb.toString();
		sb = new StringBuilder();
		while(num-->0) {
			result.append(one);
		}
		return index+1;
	}

[编程题]逛街（02）

时间限制：C/C++ 2秒，其他语言4秒

空间限制：C/C++ 256M，其他语言512M

小Q在周末的时候和他的小伙伴来到大城市逛街，一条步行街上有很多高楼，共有n座高楼排成一行。
小Q从第一栋一直走到了最后一栋，小Q从来都没有见到这么多的楼，所以他想知道他在每栋楼的位置处能看到多少栋楼呢？（当前面的楼的高度大于等于后面的楼时，后面的楼将被挡住）

输入描述:
输入第一行将包含一个数字n，代表楼的栋数，接下来的一行将包含n个数字wi(1<=i<=n)，代表每一栋楼的高度。
1<=n<=100000;
1<=wi<=100000;

输出描述:
输出一行，包含空格分割的n个数字vi，分别代表小Q在第i栋楼时能看到的楼的数量。

输入例子1:
6
5 3 8 3 2 5

输出例子1:
3 3 5 4 4 4

例子说明1:
当小Q处于位置3时，他可以向前看到位置2,1处的楼，向后看到位置4,6处的楼，加上第3栋楼，共可看到5栋楼。当小Q处于位置4时，他可以向前看到位置3处的楼，向后看到位置5,6处的楼，加上第4栋楼，共可看到4栋楼。

思路

构建两个辅助数组qian和hou；
其中，qian数组的每个[i]值表示，当从第i+1个元素往前看的时候，能看到多少栋楼房；其计算逻辑为：
（1）当nums[i+1] < nums[i]时，qian[i+1] = qian[i]+1;
（2）当nums[i+1] = nums[i]时，qian[i+1] = qian[i];
（3）否则，qian[i+1] = qian[k]+1，k满足nums[k] > nums[i+1]的；
hou数组的建立同理；

public static void main(String[] args) {
		Scanner c = new Scanner(System.in);
		int n = c.nextInt();
		int[] nums = new int[n];
		int[] qian = new int[n];
		int[] hou  = new int[n];
		nums[0] = c.nextInt();
		qian[0] = 1;
		for(int i=1;i<n;i++) {
			nums[i] = c.nextInt();
			if(nums[i]<nums[i-1]) {
				qian[i] = qian[i-1] + 1;
			}else if(nums[i] == nums[i-1]) {
				qian[i] = qian[i-1]; 
			}else {
				qian[i] = 1;//自己
				for(int j = i-2;j>-1;j--) {
					if(nums[j] > nums[i]) {
						qian[i] += qian[j];
						break;
					}else if(nums[j] == nums[i]) {
						qian[i] = qian[j];//减去自身
						break;
					}
				}
			}
		}
		hou[n-1] = 1;
		for(int i=n-2;i>-1;i--) {
			if(nums[i] < nums[i+1]) {
				hou[i] = hou[i+1] + 1;
			}else if(nums[i] == nums[i+1]) {
				hou[i] = hou[i+1];
			}else {
				hou[i] = 1;
				for(int j=i+2;j<n;j++) {
					if(nums[j] > nums[i]) {
						hou[i] += hou[j];
						break;
					}else if(nums[j] == nums[i]) {
						hou[i] = hou[j];
						break;
					}
				}
			}
		}
		c.close();
		
		for(int i=0;i<n;i++) {
			int now = 1;
			//看他前面的
			if(i!=0) {
				now += qian[i-1];
			}
			//看后面
			if(i!=n-1) {
				now += hou[i+1];
			}
			System.out.print(now + " ");
		}
		
		
		
	}

[编程题]逆序对（03）

作为程序员的小Q，他的数列和其他人的不太一样，他有个数。
老板问了小Q一共 m次，每次给出一个整数, 要求小Q把这些数每分为一组，然后把每组进行翻转，小Q想知道每次操作后整个序列中的逆序对个数是多少呢？

例如:
对于序列1 3 4 2，逆序对有(4, 2),(3, 2),总数量为2。
翻转之后为2 4 3 1，逆序对有(2, 1),(4, 3), (4, 1), (3, 1),总数量为4。

输入描述:
第一行一个数
第二行个数，表示初始的序列()
第三行一个数
第四行m个数表示

输出描述:
m行每行一个数表示答案。

输入例子1:
2
2 1 4 3
4
1 2 0 2

输出例子1:
0
6
6
0

例子说明1:
初始序列2 1 4 3
2^{q_1} = 2 ->
第一次：1 2 3 4 -> 逆序对数为0
2^{q_2} = 4 ->
第二次：4 3 2 1 -> 逆序对数为6
2^{q_3} = 1 ->
第三次：4 3 2 1 -> 逆序对数为6
2^{q_4} = 4 ->
第四次：1 2 3 4 -> 逆序对数为0

思路

首先说明下，我的通过率只有60%，不知道哪里出错了，这里来抛转引玉讲下我的思路；
首先，问题的关键在于求翻转后的逆序对个数，显然不能暴力翻转然后求个数；这时候问题来了，怎么快速的求翻转后的逆序对呢？
因为每组进行翻转的时候，翻转的个数也满足2^qi，是2的倍数，有这样一个规律：
在这里插入图片描述

那么接下来，就用归并排序，计算初始的时候的每一层的逆序对，然后在计算每次翻转后的逆序对个数。

	public static void main(String[] args) {
		Scanner c = new Scanner(System.in);
		int n = c.nextInt();
		int[] nums = new int[(int)Math.pow(2, n)];
		long[] nixu = new long[n];
		long[] max  = new long[n];
		for(int i=0;i<nums.length;i++) {
			nums[i] = c.nextInt();
		}

		int index = 0;
		long result = 0;

		//使用归并排序！！【归并排序】
		sort(nums,0,nums.length-1,n-1, nixu);
		for(int i=0;i<n;i++) result += nixu[i];
		//更新最大层元素
		max[0] = nums.length / 2;
		for(int i=1;i<n;i++) {
			max[i] = max[i-1] * 2;
		}
		//下面继续接受
		int m = c.nextInt();
		index = 0;
//		System.out.println("nixu : " + Arrays.toString(nixu));
//		System.out.println("max :  " + Arrays.toString(max));
		while(index++ < m) {
			int now = c.nextInt();
			System.out.println(result = helper(nixu, max, now,result));
		}
		c.close();

	}
	private static long helper(long[] nixu, long[] max, int fenzu,long result) {
		int index = 0;
		while(index < fenzu) {
			result -= nixu[index];
			nixu[index] = max[index] - nixu[index];
			result += nixu[index];	
			index++;
//			System.out.println("nixu : " + Arrays.toString(nixu));
		}
		return result;
	}

	
	public static void sort(int[] arr, int L, int R,int cengshu, long[] nixu) {
	    if(L == R) {
	        return;
	    }
	    int mid = L + ((R - L) >> 1);
	    sort(arr, L, mid,cengshu-1,nixu);
	    sort(arr, mid + 1,R,cengshu-1,nixu);
	    merge(arr, L, mid, R,cengshu,nixu);
	}

	public static void merge(int[] arr, int L, int mid, int R,int cengshu, long[] nixu) {
	    int[] temp = new int[R - L + 1];
	    int i = 0;
	    int p1 = L;//左边的第一个
	    int p2 = mid + 1;//右边的第一个
	    
	    // 比较左右两部分的元素，哪个小，把那个元素填入temp中
	    while(p1 <= mid && p2 <= R) {
	    	if(arr[p1] <= arr[p2]) {
	    		temp[i++] = arr[p1++];
	    	}else {
	    		temp[i++] = arr[p2++];
	    		nixu[cengshu] += mid - p1 + 1;
	    	}
	    }
	    // 上面的循环退出后，把剩余的元素依次填入到temp中
	    // 以下两个while只有一个会执行
	    while(p1 <= mid) {
	        temp[i++] = arr[p1++];
	    }
	    while(p2 <= R) {
	        temp[i++] = arr[p2++];
	    }
	    // 把最终的排序的结果复制给原数组
	    for(i = 0; i < temp.length; i++) {
	        arr[L + i] = temp[i];
	    }
	}

[编程题]假期（04）

时间限制：C/C++ 2秒，其他语言4秒

空间限制：C/C++ 256M，其他语言512M

由于业绩优秀，公司给小Q放了 n 天的假，身为工作狂的小Q打算在在假期中工作、锻炼或者休息。他有个奇怪的习惯：不会连续两天工作或锻炼。只有当公司营业时，小Q才能去工作，只有当健身房营业时，小Q才能去健身，小Q一天只能干一件事。给出假期中公司，健身房的营业情况，求小Q最少需要休息几天。

输入描述:
第一行一个整数表示放假天数
第二行 n 个数每个数为0或1,第 i 个数表示公司在第 i 天是否营业
第三行 n 个数每个数为0或1,第 i 个数表示健身房在第 i 天是否营业
（1为营业 0为不营业）

输出描述:
一个整数，表示小Q休息的最少天数

输入例子1:
4
1 1 0 0
0 1 1 0

输出例子1:
2

例子说明1:
小Q可以在第一天工作，第二天或第三天健身，小Q最少休息2天

思路

我用的是一个相对麻烦的动态规划，更新三种状态：今天做[0,1,2]时候的最小的休息天数dp[i][0]，dp[i][1]，dp[i][2]；

	public static void main(String[] args) {
		Scanner c = new Scanner(System.in);
		int n = c.nextInt();
		int[] work  = new int[n];
		int[] sport = new int[n];
		for(int i=0;i<n;i++) work[i] = c.nextInt();
		for(int i=0;i<n;i++) sport[i] = c.nextInt();
		c.close();
		int max = 100001;
		int[][] dp = new int[n][3];
		dp[0][0] = 1;
		dp[0][1] = work[0] == 1 ? 0:max;
		dp[0][2] = sport[0] == 1 ? 0:max;
		for(int i=1;i<n;i++) {
			int beforeMin = min(dp[i-1][0],dp[i-1][1],dp[i-1][2]);
			if(work[i] == 0 && sport[i] == 0) {
				dp[i][0] = beforeMin+1;
				dp[i][1] = max;
				dp[i][2] = max;
			}else if(work[i] == 1 && sport[i] == 1) {
				dp[i][0] = beforeMin+1;				
				dp[i][1] = Math.min(dp[i-1][0], dp[i-1][2]);				
				dp[i][2] = Math.min(dp[i-1][0], dp[i-1][1]);
			}else if(work[i] == 1) {
				dp[i][0] = beforeMin+1;			
				dp[i][1] = Math.min(dp[i-1][0], dp[i-1][2]);	
				dp[i][2] = max;
			}else {
				dp[i][0] = beforeMin +1;	
				dp[i][1] = max;
				dp[i][2] = Math.min(dp[i-1][0], dp[i-1][1]);
			}
			
		}
//		System.out.println(Arrays.deepToString(dp));
		System.out.println(min(dp[n-1][0],dp[n-1][1],dp[n-1][2]));
		
	}
	private static int min(int a ,int b, int c) {
		a = Math.min(a, b);
		return Math.min(a, c);
	}

[编程题]视野争夺（05）

时间限制：C/C++ 1秒，其他语言2秒

空间限制：C/C++ 256M，其他语言512M

小Q在进行一场竞技游戏,这场游戏的胜负关键就在于能否能争夺一条长度为L的河道,即可以看作是[0,L]的一条数轴。
这款竞技游戏当中有n个可以提供视野的道具−真视守卫,第i个真视守卫能够覆盖区间[xi,yi]。现在小Q想知道至少用几个真视守卫就可以覆盖整段河道。

输入描述:
输入包括n+1行。

第一行包括两个正整数n和L(1<=n<=105,1<=L<=109)

接下来的n行,每行两个正整数xi,yi(0<=xi<=yi<=109),表示第i个真视守卫覆盖的区间。

输出描述:
一个整数，表示最少需要的真视守卫数量, 如果无解, 输出-1。

输入例子1:
4 6
3 6
2 4
0 2
4 7

输出例子1:
3

思路

排序之后，区当前相同起始下标最大的，然后更新max
下一次回溯当前val — max为下标的即可

	public static void main(String[] args) {
		Scanner c = new Scanner(System.in);
		int n = c.nextInt();
		int L = c.nextInt();
		int[][] nums = new int[n][2];
		for(int i=0;i<n;i++) {
			nums[i][0] = c.nextInt();
			nums[i][1] = c.nextInt();
		}
		c.close();
		Arrays.sort(nums,new Comparator<int[]>() {
			@Override
			public int compare(int[] o1, int[] o2) {
				if(o1[0] == o2[0]) return -(o1[1]-o2[1]);
				return o1[0] - o2[0];
			}
		});
//		System.out.println("nums = " + Arrays.deepToString(nums));
		if(nums[0][0] != 0) {
			System.out.println(-1);return;
		}
		int index = 1;
		while(index < n && nums[index] == nums[index-1]) index++;//index 指向下一个[k,***]的索引
		int max = nums[0][1];
		int result = 1;
		while(max < L && index < n) {
//			System.out.println("max = " + max + ", index = " + index);
			int nowMax = 0;
			while(index < n && nums[index][0] <= max) {
				nowMax = Math.max(nowMax, nums[index][1]);
				index++;
				while(index < n && nums[index] == nums[index-1]) index++;
			}
			result ++;
			max = nowMax;
		}
		if(max > L ) System.out.println(result);
		else System.out.println(-1);

	}

Arthur_____

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
1
评论
腾讯2020校园招聘-后台&综合-第一次笔试

[编程题]压缩算法（01）时间限制：C/C++ 2秒，其他语言4秒空间限制：C/C++ 256M，其他语言512M小Q想要给他的朋友发送一个神秘字符串，但是他发现字符串的过于长了，于是小Q发明了一种压缩算法对字符串中重复的部分进行了压缩，对于字符串中连续的m个相同字符串S将会压缩为m|S，例如字符串ABCABCABC将会被压缩为[3|ABC]，现在小Q的同学收到了小Q发送过来的字符串，你能帮...
复制链接

扫一扫

专栏目录