2018校招真题【牛客网】练习（八）
1、字节跳动附加题
存在n+1个房间，每个房间依次为房间1 2 3…i，每个房间都存在一个传送门，i房间的传送门可以把人传送到房间pi(1<=pi<=i),现在路人甲从房间1开始出发(当前房间1即第一次访问)，每次移动他有两种移动策略：
A. 如果访问过当前房间 i 偶数次，那么下一次移动到房间i+1；
B. 如果访问过当前房间 i 奇数次，那么移动到房间pi；
现在路人甲想知道移动到房间n+1一共需要多少次移动；
思路：
参考 https://blog.csdn.net/flushhip/article/details/79458502
dp[i] = dp[i-1]+1 // 第一次从i-1移动到i
+1 // 从i传送到p[i]位置
+dp[i-1] - dp[ p[i]-1 ] - 1 //从p[i]位置移动到i-1
+ 1 //第二次从i-1移动到i
第三步中：dp[ p[i]-1 ]+1可以理解为，从1到p[i]位置需要移动的步数
代码：
import java.util.*;
public class Main{
public static void main(String[] args){
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
int[] p = new int[n+1];
for(int i=1;i<=n;i++){
p[i] = scanner.nextInt();
}
scanner.close();
long dp[] = new long[n+1];
for(int i=1;i<=n;i++){
dp[i] = (dp[i-1]*2%1000000007-dp[p[i]-1]+2)%1000000007;
}
System.out.println(dp[n]%1000000007);
}
}
2、字节跳动编程题1
题目描述：
有三只球队，每只球队编号分别为球队1，球队2，球队3，这三只球队一共需要进行 n 场比赛。现在已经踢完了k场比赛，每场比赛不能打平，踢赢一场比赛得一分，输了不得分不减分。已知球队1和球队2的比分相差d1分，球队2和球队3的比分相差d2分，每场比赛可以任意选择两只队伍进行。求如果打完最后的 (n-k) 场比赛，有没有可能三只球队的分数打平。
思路：
分类讨论。
代码：
import java.util.*;
public class Main{
public static void main(String[] args){
Scanner scanner = new Scanner(System.in);
int t = scanner.nextInt();
for(int i=0;i<t;i++){
boolean isSame =
possibleSame(scanner.nextLong(),scanner.nextLong()
,scanner.nextLong(),scanner.nextLong());
if(isSame){
System.out.println("yes");
}else{
System.out.println("no");
}
}
scanner.close();
}
public static boolean possibleSame(long n,long k,long d1,long d2){
// 1 < 2 < 3
long temp = k-d1-(d1+d2);
if(temp>=0&&temp%3==0){
long left = n-k-(d1+d2+d2);
if(left>=0&&left%3==0){
return true;
}
}
// 1 < 2 > 3
if(d1+d1-d2<0){
temp = k-(d2+d2-d1);
}else if(d2+d2-d1<0){
temp = k-(d1+d1-d2);
}else{
temp = k-Math.min(d1+d1-d2,d2+d2-d1);
}
if(temp>=0&&temp%3==0){
long left = n-k-(d1+d2);
if(left>=0&&left%3==0){
return true;
}
}
// 1 > 2 > 3
temp = k-d2-(d1+d2);
if(temp>=0&&temp%3==0){
long left = n-k-(d1+d1+d2);
if(left>=0&&left%3==0){
return true;
}
}
// 1 > 2 < 3
temp = k-d1-d2;
if(temp>=0&&temp%3==0){
long left = n-k-Math.max(d1+d1-d2,d2+d2-d1);
if(left>=0&&left%3==0){
return true;
}
}
return false;
}
}
3、字节跳动编程题2
题目描述：
有一个仅包含’a’和’b’两种字符的字符串s，长度为n，每次操作可以把一个字符做一次转换（把一个’a’设置为’b’，或者把一个’b’置成’a’)；但是操作的次数有上限m，问在有限的操作数范围内，能够得到最大连续的相同字符的子串的长度是多少。
思路：
以替换a为例，那么我们需要找到所有a的位置pos[n]，连续的最长的b就是a[i+m+1]-a[i]-1中最长的那一个子序列。
代码：
import java.util.*;
public class Main{
public static void main(String[] args){
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
int m = scanner.nextInt();
scanner.nextLine();
char[] str = scanner.nextLine().toCharArray();
System.out.println(Math.max(getLength(n,m,str,'a'),getLength(n,m,str,'b')));
}
public static int getLength(int n,int m,char[] str,char c){
ArrayList<Integer> pos = new ArrayList<>();
for(int i=0;i<n;i++){
if(str[i]==c){
pos.add(i);
}
}
if(pos.size()<=m){
return n;
}
pos.add(str.length);
int result = pos.get(m);
for(int i=m+1;i<pos.size();i++){
result = Math.max(result,pos.get(i)-pos.get(i-m-1)-1);
}
return result;
}
}
4、字节跳动附加题
题目描述：
二阶魔方又叫小魔方，是222的立方形结构。每一面都有4个块，共有24个块。每次操作可以将任意一面逆时针或者顺时针旋转90°，如将上面逆时针旋转90°操作如下。
Nero在小魔方上做了一些改动，用数字替换每个块上面的颜色，称之为数字魔方。魔方上每一面的优美度就是这个面上4个数字的乘积，而魔方的总优美度就是6个面优美度总和。
现在Nero有一个数字魔方，他想知道这个魔方在操作不超过5次的前提下能达到的最大优美度是多少。
魔方展开后每一块的序号如下图：
思路：
参考 https://blog.csdn.net/cswhit/article/details/87110959
写出六个面转动的交换，利用递归求最大值
代码：
import java.util.*;
public class Main{
public static void main(String[] args){
Scanner scanner = new Scanner(System.in);
while(scanner.hasNextInt()){
int[] num = new int[24];
for(int i=0;i<24;i++){
num[i] = scanner.nextInt();
}
System.out.println(maxGrace(num,5));
}
}
public static int maxGrace(int[] num,int times){
int grace = calculateGrace(num);
if(times==0){
return grace;
}
int[] numcp = new int[24];
for(int i=0;i<24;i++){
numcp[i] = num[i];
}
turnLeft(numcp);
grace = Math.max(maxGrace(numcp,times-1),grace);
for(int i=0;i<24;i++){
numcp[i] = num[i];
}
turnRight(numcp);
grace = Math.max(maxGrace(numcp,times-1),grace);
for(int i=0;i<24;i++){
numcp[i] = num[i];
}
turnTop(numcp);
grace = Math.max(maxGrace(numcp,times-1),grace);
for(int i=0;i<24;i++){
numcp[i] = num[i];
}
turnBottom(numcp);
grace = Math.max(maxGrace(numcp,times-1),grace);
for(int i=0;i<24;i++){
numcp[i] = num[i];
}
turnFront(numcp);
grace = Math.max(maxGrace(numcp,times-1),grace);
for(int i=0;i<24;i++){
numcp[i] = num[i];
}
turnBack(numcp);
grace = Math.max(maxGrace(numcp,times-1),grace);
return grace;
}
public static void turnLeft(int[] num){
change(num,0,6,16,20);
change(num,2,12,18,22);
change(num,4,5,11,10);
}
public static void turnRight(int[] num){
change(num,1,7,17,21);
change(num,3,13,19,23);
change(num,9,8,14,15);
}
public static void turnTop(int[] num){
change(num,4,6,8,23);
change(num,5,7,9,22);
change(num,2,3,1,0);
}
public static void turnBottom(int[] num){
change(num,10,12,14,21);
change(num,11,13,15,20);
change(num,16,17,19,18);
}
public static void turnFront(int[] num){
change(num,11,2,8,17);
change(num,5,3,14,16);
change(num,6,7,13,12);
}
public static void turnBack(int[] num){
change(num,10,0,9,19);
change(num,4,1,15,18);
change(num,22,23,21,20);
}
public static void change(int[] num,int i,int j,int k,int m){
int temp = num[i];
num[i] = num[j];
num[j] = num[k];
num[k] = num[m];
num[m] = temp;
}
public static int calculateGrace(int[] n){
return n[0]*n[1]*n[2]*n[3]
+n[4]*n[5]*n[10]*n[11]
+n[8]*n[9]*n[14]*n[15]
+n[6]*n[7]*n[12]*n[13]
+n[16]*n[17]*n[18]*n[19]
+n[20]*n[21]*n[22]*n[23];
}
}
5、字节跳动编程题1
题目描述：
有一个推箱子的游戏, 一开始的情况如下图:
上图中, ‘.’ 表示可到达的位置, ‘#’ 表示不可到达的位置，其中 S 表示你起始的位置, 0表示初始箱子的位置, E表示预期箱子的位置，你可以走到箱子的上下左右任意一侧, 将箱子向另一侧推动。如下图将箱子向右推动一格;
…S0… -> …S0.
注意不能将箱子推动到’#'上, 也不能将箱子推出边界;
现在, 给你游戏的初始样子, 你需要输出最少几步能够完成游戏, 如果不能完成, 则输出-1。
思路：
参考 https://blog.csdn.net/yuanxu716/article/details/78286266
（还没有完全理解，待以后补充）
代码：
import java.util.*;
import java.util.concurrent.ConcurrentLinkedQueue;
public class Main{
public static void main(String[] args){
Scanner scanner = new Scanner(System.in);
while(scanner.hasNextLine()){
String[] token = scanner.nextLine().split(" ");
int n = Integer.parseInt(token[0]);
int m = Integer.parseInt(token[1]);
char[][] matrix = new char[n][m];
int x = -1,y = -1,bx = -1,by = -1;
for(int i=0;i<n;i++){
String input = scanner.nextLine();
for(int j=0;j<m;j++){
matrix[i][j] = input.charAt(j);
if(matrix[i][j]=='S'){
x=i;
y=j;
}
if(matrix[i][j]=='0'){
bx=i;
by=j;
}
}
}
ArrayList<ArrayList<Integer>> next = new ArrayList<>();
//{-1,0},{1,0},{0,-1},{0,1}
ArrayList<Integer> a1 = new ArrayList<>();
a1.add(-1);a1.add(0);
ArrayList<Integer> a2 = new ArrayList<>();
a2.add(1);a2.add(0);
ArrayList<Integer> a3 = new ArrayList<>();
a3.add(0);a3.add(-1);
ArrayList<Integer> a4 = new ArrayList<>();
a4.add(0);a4.add(1);
next.add(a1);
next.add(a2);
next.add(a3);
next.add(a4);
//System.out.println(next);
ConcurrentLinkedQueue<ArrayList<Integer>> queue = new ConcurrentLinkedQueue<>();
ArrayList<Integer> a = new ArrayList<>();
a.add(x);a.add(y);a.add(bx);a.add(by);
queue.offer(a);
//System.out.println(queue);
int st[][][][] = new int[50][50][50][50];
st[x][y][bx][by] = 1;
while(!queue.isEmpty()){
ArrayList<Integer> pb = queue.poll();
x = pb.get(0);
y = pb.get(1);
bx = pb.get(2);
by = pb.get(3);
for(int i=0;i<next.size();i++){
int nx = x+next.get(i).get(0),
ny = y+next.get(i).get(1);
int nnx = nx+next.get(i).get(0),
nny = ny+next.get(i).get(1);
// 玩家从开始位置走到箱子的位置
if(valid(matrix,nx,ny)&&(nx!=bx||ny!=by)&&st[nx][ny][bx][by]==0){
st[nx][ny][bx][by] = st[x][y][bx][by]+1;
ArrayList<Integer> list = new ArrayList<>();
list.add(nx);list.add(ny);list.add(bx);list.add(by);
queue.offer(list);
continue;
}
// 玩家把箱子推到指定位置
else if(valid(matrix,nnx,nny)&&(nx==bx&&ny==by)&&st[nx][ny][nnx][nny]==0){
st[nx][ny][nnx][nny] = st[x][y][bx][by]+1;
if(matrix[nnx][nny]=='E'){
System.out.println(st[nx][ny][nnx][nny]-1);
return;
}
ArrayList<Integer> list = new ArrayList<>();
list.add(nx);list.add(ny);list.add(nnx);list.add(nny);
queue.offer(list);
}
}
}
System.out.println(-1);
return;
}
}
public static boolean valid(char[][] matrix,int x,int y){
if (x >= 0 && x < matrix.length && y >= 0 && y < matrix[0].length && matrix[x][y] != '#')
return true;
return false;
}
}