刷题小记：
主要偏向扎实编码基础的考察，但貌似近些年题目难度有所提高，仅供参考。
卡码网136.获取连通的相邻节点列表（卡码网136.获取连通的相邻节点列表）
题目分析：
题目描述：
存在N个转发节点，每个转发节点有自己唯一的标识TB且每个节点有M个端口，节点间通过端口通讯。现在将这些端口划分为多个通讯平面，通过VLAN隔离：
- 如果两个端口的VLAN ID相同，则说明位于同个VLAN，处于连通状态。
- 如果两个端口的VLAN ID不同，则说明位于不同VLAN，彼此不连通。
现在给出节点A的端口数以及每个端口的VLAN ID，以及节点A相邻的其他节点及其端口信息，求所有与节点A连通的相邻节点的标识符列表（按从小到大的顺序输出）。
输入描述：
输入的第一行：包含M + 1个用空格隔开的数，第一个数表示A有M个端口，后M个数分别表示这M个端口的VLAN ID。
输入的第二行：包含一个整数N，表示有N个与A相邻的节点，取值为[0, 4000)
输入的第三行开始有N行数据，每一行：第一个数表示节点x的标识符，第二个数表示它的端口数m_x，然后有m_x个数表示每个端口所属的VLAN ID。
其中，标识符TB的的取值范围达到long型。
输出描述：
第一行：与节点A连通的相邻节点的个数。
第二行：升序排列的这些连通节点的标识符TB
解题思路：
关键点是处理好输入，尤其是TB需要用long型存储。
遍历每个相邻节点的端口数，只要有端口的VLAN ID与节点A的端口的VLAN ID相同（即contains），那么该节点就与节点A连通。
java
import java.util.*;
class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
while(in.hasNext()) {
int M = in.nextInt();
List<Integer> portA = new ArrayList<>();
for(int i = 0; i < M; i++) {
portA.add(in.nextInt());
}
int N = in.nextInt();
long[] TB = new long[N];
List<List<Integer>> ports = new ArrayList<>();
for(int i = 0; i < N; i++) {
List<Integer> port_i = new ArrayList<>();
TB[i] = in.nextLong();
int m = in.nextInt();
for(int j = 0; j < m; j++) {
port_i.add(in.nextInt());
}
ports.add(new ArrayList<>(port_i));
}
List<Long> resList = new ArrayList<>();
for(int i = 0; i < N; i++) {
List<Integer> port_i = ports.get(i);
for(int port : port_i) {
if(portA.contains(port)) {
resList.add(TB[i]);
break;
}
}
}
Collections.sort(resList);
System.out.println(resList.size());
for(int i = 0; i < resList.size(); i++) {
if(i != 0) System.out.print(" ");
System.out.print(resList.get(i));
}
}
}
}卡码网137.字符串处理器（卡码网137.字符串处理器）
题目分析：
设计一个带游标的字符处理器，实现如下功能：
- 插入：在游标处添加文本，其对应操作是insert str：insert表示插入操作命令关键字（区分大小写），str表示待操作的字符串，该操作执行后将str拼接到右表当前位置，且游标移动到str的右边。
- 删除：在游标处删除文本，其对应操作是delete len：delete表示删除命令关键字，len是一个整数，表示删除游标左边字符串的长度，如果len大于游标所在处左侧字符串的长度 或者 len是负数，那么操作非法，不做任何处理。
- 移动：将游标左右移动，其对应操作是move cnt：move表示移动命令关键字，cnt是一个整数，表示游标移动次数，如果cnt为负数表示向左移动cnt次，如果cnt为正数表示向右移动cnt次，如果为0则不移动，如果超过字符串左右边界则认为输入命名非法，不做任何处理。
- 复制：将游标左边字符串复制并插入到游标的右边，且游标位置不变（如果游标右边有字符，复制插入到游标和原有字符中间），对应操作为copy：copy表示复制操作命令关键字。
输入描述：
支持输入多行，每行包含一个操作命令，当输入end（区分大小写）表示操作停止。
首次执行时字符串处理器内部字符串为空，游标位置索引为0，此时字符串处理器序列化结果为"|"。
输出描述：
当前字符串处理器的序列化结果，游标用"|"表示。
java
import java.util.*;
class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
StrOperator strOperator = new StrOperator();
while(in.hasNext()) {
String[] op = in.nextLine().split(" ");
switch(op[0]) {
case "insert":
strOperator.insert(op[1]);
break;
case "delete":
strOperator.delete(Integer.parseInt(op[1]));
break;
case "move":
strOperator.move(Integer.parseInt(op[1]));
break;
case "copy":
strOperator.copy();
break;
case "end":
strOperator.end();
break;
default:
break;
}
}
in.close();
}
}
class StrOperator {
int cur;
int length;
StringBuilder sb;
StrOperator() {
this.cur = 0;
this.length = 0;
this.sb = new StringBuilder();
}
void insert(String str) {
sb.insert(cur, str);
cur += str.length();
length += str.length();
}
void delete(int len) {
if(cur >= len && len >= 0) {
sb.delete(cur - len, cur);
cur -= len;
length -= len;
}
}
void move(int cnt) {
if(cur + cnt < 0 || cur + cnt > length) {
return;
}else {
cur += cnt;
}
}
void copy() {
String str = sb.substring(0, cur);
sb.insert(cur, str);
length += str.length();
}
void end() {
if(length == 0) {
System.out.println("|");
} else {
sb.insert(cur, "|");
System.out.println(sb.toString());
}
}
}卡码网138.消息传输（卡码网138.消息传输）
题目分析：
题目描述：
给定m×n（1<= m, n <= 1000)的网格地图grid中，分布着一些信号塔。
每个单元格可以有以下三种状态：
- 值0表示空地，无法传递信号
- 值1表示信号塔A，收到消息后，在1ms后将信号发送给上下左右四个方向的信号塔；
- 值2表示信号塔B，2ms后完成信号发送
给定一个坐标(j, k)，输入保证该处一定有信号塔。现求网格地图中所有信号塔收到信号的最短时间，单位为ms，如果有信号塔无法收到信号，则返回-1。
注意：以信号塔A为例，在它收到信号后，经过1ms将信号发送至上下左右四个方向的一格处，信号塔B同理。
输入描述：
第一行：网格的列数n
第二行：网格的行数m
第三行：给定坐标(j, k)
接下来的m行，每行n个用空格隔开的整数，表示单元格状态。
输出描述：
输出返回网格地图中所有信号塔都已收到信号的最小时间，如果无法实现，返回-1。
解题思路：
用一个大小与grid相同的time数组，初始化全部元素为-1，用于记录信号塔接收到信号的最短时间。
本题显然适用广度优先搜索遍历，当一个点接收到信号时，有4种可能性：
- 该点为空地，忽略
- 该点是信号塔，第一次接收信号，更新time并将其添入que
- 该点是信号塔，不是第一次接收信号，该次访问时间不小于time，忽略
- 该点是信号塔，不是第一次接收信号，该次访问时间小于time，更新time并将其添入que
最终遍历time数组，在确认全部信号塔的接收时间不为-1的情况下，所得到的最大值就是至少需要的时间。
java
import java.util.*;
class Main{
private static int[][] dir={{1,0},{-1,0},{0,1},{0,-1}};
public static void main (String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
int m = in.nextInt();
int startx = in.nextInt(), starty = in.nextInt();
int[][] time=new int[m][n];
int[][] grid=new int[m][n];
for(int[] t:time){
Arrays.fill(t,-1);
}
in.nextLine();
for(int i = 0; i < m; i++){
String s = in.nextLine();
String[] t=s.split(" ");
for(int j = 0; j < n; j++){
grid[i][j]=Integer.valueOf(t[j]);
}
}
bfs(grid, time, startx, starty);
int ans = 0;
boolean valid = true;
for(int i = 0; i < m; i++){
for(int j = 0; j < n; j++){
if(grid[i][j] > 0) {
if(time[i][j] == -1) {
valid = false;
break;
}
ans=Math.max(ans,time[i][j]);
}
}
if(!valid) break;
}
if(valid) System.out.println(ans);
else System.out.println(-1);
}
private static void bfs(int[][] grid, int[][] time, int startx, int starty) {
Deque<int[]> que = new ArrayDeque<>();
time[startx][starty] = 0;
que.offer(new int[]{startx, starty});
while (!que.isEmpty()) {
int[] towerIndex = que.poll();
int x = towerIndex[0], y = towerIndex[1];
for (int[] d : dir) {
int nextx = x + d[0];
int nexty = y + d[1];
if (nextx >= 0 && nextx < grid.length && nexty >= 0 && nexty < grid[0].length && grid[nextx][nexty] > 0) {
int newtime = time[x][y] + grid[x][y];
if (time[nextx][nexty] == -1 || newtime < time[nextx][nexty]) {
time[nextx][nexty] = newtime;
que.offer(new int[]{nextx, nexty});
}
}
}
}
}
}