第一题

统计误码频率最高的且长度最短的字符子串（哈希表）

误码编号1~255（好像），当编码为0时，不是误码。数组长度1~1000。

第一行输入时数组长度，第二行输入是误码编号数组

测试用例1

输入

5

1 2 2 4 1

输出

2

解释：该数组中出现误码频率最高的字符字串是'2'和'1'，都出现了2次。但'2'截取的子串数组是[2,2]，而'1'截取的字串数组是[1,2,2,4,1]，前者的长度更短，所以输出2

个人感悟：测试用例过了90%。我的思路是用哈希表统计了每个误码的出现索引数组，例如1=>[0,4] 2=>[1,2] 4=>[3]，然后对哈希表的值数组进行降序排序，找到出现频率最高的，计算下对应索引截取字符串的长度。若有多个频率最高，就分别计算对应索引截取字符串的长度，以测试用例为例，就是4-0+1 和 2-1+1，两个结果分别是5和2，最短的子串就是2。至于只过了90%，我估计是0的情况有些没考虑到，我也懒得去找，就下一题了。

第二题

统计友好度最大值（我直接暴力模拟了）

给你一组数组，里面只有1,0,2三个元素，0代表公司新人，1代表公司老人，2代表障碍物。每个新人的友好度是他左右所有老人的和，但遇到障碍物就会终止计算。

测试用例1

输入

1 1 0 1 2 1 0

输出

3

解释：该数组中出现了两个0，分别可以计算他们的友好度为3和1，前者左边2个老人，右边1个老人，遇到2终止了，总计友好度为2+1=3。而后者只有左边1位老人就遇到2了，所以友好度为1。取最大值，答案也就是3

个人感悟：测试用例过了80%。我一开始有想过用栈，后来又打算用bfs，最后思路有点乱就直接暴力了，结果只过了80%

第三题

输出给定位置的信号强弱（BFS）

题目给定一个m*n的矩阵，里面的元素只有-1和0以及唯一的正整数，也就是信号源。-1代表障碍物，会阻碍信号。每一块的信号强度都会从信号源处衰减1，向上下左右四个方向扩散。求给定位置[x,y]的信号强度是多少？

测试用例1

输入

6 5

0 0 0 -1 0 0 0 0 0 0 0 0 -1 4 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

2 1

输出

0

解释：

信号扩散后的图大致是这样（机试时画的，有点丑）

 从信号源强度为4的地方开始扩散，遇到黑色部分（障碍物）停止。目标位置是[2,1]，扩散完毕后该处信号强度为0，所以最后输出0

个人感悟：很典型的bfs题。可是，在第二题浪费了些时间，做到这题时间不多了，当时思路挺乱的，想着套递归，可是套不出来，浪费了更多时间。后来快交卷了，我换了种方法差不多能得到扩散完毕的矩阵了，挺可惜的，时间再多点肯定能做出来。测试用例只过了28%左右。所以，这也给了我一个教训：递归不熟练的时候，就别搁那递归了，越递归越乱！

考完又写了一遍，果然写出来了。BFS的题目其实和经典的力扣模板题“994.腐烂的橘子”差不了多少

var readline = require('readline');
const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
    terminal:false
});
// 行数和列数
let m=0,n=0
// 输入计数
let lineCount = 1
// 信号矩阵
let matrix = []
// 目标信号源的坐标
let x = 0, y = 0
// 最初的信号源的坐标
let t1 = 0, t2 = 0
// 上下左右移动方向数组
const dirs = [[0,1],[0,-1],[-1,0],[1,0]]
rl.on('line', function(line){ // javascript每行数据的回调接口
    if(lineCount % 3 === 1){
        [m,n] = line.split(' ').map(Number)
    } else if (lineCount % 3 === 2) {
        matrix = []
        let arr = line.split(' ').map(Number)
        for(let i = 0; i < m; i++){              
            let temp = arr.slice(i * 5, i * 5 + 5)
            // 提取最初的信号源的坐标
              for(let j = 0;j < temp.length; j++){
                  if(temp[j] !== 0 && temp[j] !== -1){
                      t1 = i
                      t2 = j
                      break;
                  }
              }
              matrix.push(temp)       
        }
    }else if(lineCount % 3 === 0){
        [x,y] = line.split(' ').map(Number)
    }
    if (lineCount % 3 === 0) {
        // 深拷贝一份原信号矩阵
        let newMat = JSON.parse(JSON.stringify(matrix))
        let queue = [[t1, t2]]
        // 开始BFS操作
            while (queue.length) {
                const len = queue.length
                for (let i = 0; i < len; i++){
                    let cur = queue.shift()
                    let [c1,c2] =cur
                    for(let [dx,dy] of dirs){
                        const row = c1 + dx
                        const col = c2 + dy
                        // 边界条件。包括不能超出矩阵范围，移动后的值不能等于0，且移动后的数值大小也不能比原位置的值大
                        if (newMat[row] === undefined || newMat[row][col] === undefined || newMat[row][col] === -1 || newMat[c1][c2] < newMat[row][col] || newMat[c1][c2] === 0) continue;
                        queue.push([row,col])
                        newMat[row][col] = newMat[c1][c2] - 1
                    }  
                }
            } 
            // console.log(newMat)
            console.log(newMat[x][y])
        }
        lineCount++
});