迅雷笔试题目

• 第一题
  • 输入
  • 输出
  • 样例
  • 思路
  • 代码
• 第二题
  • 输入
  • 输出
  • 样例
  • 代码
• 第三题
  • 输入
  • 输出
  • 样例
  • 思路
  • 代码

记录一下迅雷笔试，都比较简单

第一题

螺旋矩阵生成

输入

一个正整数n

输出

一个n行n列的螺旋矩阵

样例

输入：
3
输出：
1 2 3
8 9 4
7 6 5

思路

模拟即可，注意细节

代码

package main

import "fmt"

// 生成一个n×n的螺旋矩阵
func generateSpiralMatrix(n int) [][]int {
	// 初始化一个n×n的零矩阵
	matrix := make([][]int, n)
	for i := range matrix {
		matrix[i] = make([]int, n)
	}

	// 定义方向：右、下、左、上
	right := []int{0, 1}
	down := []int{1, 0}
	left := []int{0, -1}
	up := []int{-1, 0}

	directions := [][]int{right, down, left, up}
	directions := [][]int{{0,1},{1,0},{0,-1},{-1,0}}
	directionIdx := 0

	row, col := 0, 0 // 起始位置
	num := 1         // 从1开始填充

	for i := 0; i < n*n; i++ {
		matrix[row][col] = num
		num++

		// 计算下一个位置
		nextRow := row + directions[directionIdx][0]
		nextCol := col + directions[directionIdx][1]

		// 检查是否需要改变方向
		if nextRow < 0 || nextRow >= n || nextCol < 0 || nextCol >= n || matrix[nextRow][nextCol] != 0 {
			// 改变方向，直接省去了很多代码
			directionIdx = (directionIdx + 1) % 4
			nextRow = row + directions[directionIdx][0]
			nextCol = col + directions[directionIdx][1]
		}

		row, col = nextRow, nextCol
	}

	return matrix
}

// 打印矩阵
func printMatrix(matrix [][]int) {
	for _, row := range matrix {
		fmt.Println(row)
	}
}

func main() {
	// 生成并打印3×3的螺旋矩阵
	n := 3
	spiral := generateSpiralMatrix(n)
	fmt.Printf("%d×%d的螺旋矩阵:\n", n, n)
	printMatrix(spiral)

	// 生成并打印4×4的螺旋矩阵
	n = 4
	spiral = generateSpiralMatrix(n)
	fmt.Printf("\n%d×%d的螺旋矩阵:\n", n, n)
	printMatrix(spiral)
}

第二题

字符串数字相加减

给定两个以字符串形式表示的非负整数 num1 和 num2，返回 num1 和 num2 的乘积，它们的乘积也表示为字符串形式。注意:不能使用任何内置的 BigInteger 库或直接将输入转换为整数。 输入格式:两个非负整数的字符串，用空格隔开输出格式:结果数值的字符串 提示: 1 <= num1.length,num2.ength <= 200 num1 和 num2 只能由数字组成。 num1 和 num2 都不包含任何前导零，除了数字0本身,

输入

两个数字

输出

两个数字的乘积

样例

输入：
123 456
输出：
56088

代码

直接模拟即可，使用单个位置输出就好了

package main
import "fmt"
import "strconv"


func main() {
	var num1, num2 string
	
	// 使用fmt.Scan读取两个数字
	fmt.Scan(&num1, &num2)
	
	// 计算乘积
	result := multiply(num1, num2)
	
	// 输出结果
	fmt.Println(result)
}

func multiply(num1 string, num2 string) string {
	// 处理特殊情况
	if num1 == "0" || num2 == "0" {
		return "0"
	}
	
	// 初始化结果数组，最大长度为 num1.length + num2.length
	result := make([]int, len(num1)+len(num2))
	
	// 从右往左遍历 num1
	for i := len(num1) - 1; i >= 0; i-- {
		// 从右往左遍历 num2
		for j := len(num2) - 1; j >= 0; j-- {
			// 计算当前位的乘积
			mul := int(num1[i]-'0') * int(num2[j]-'0')
			// 计算当前乘积在结果数组中的位置
			p1 := i + j
			p2 := i + j + 1  // 进位
			// 累加到结果数组
			sum := mul + result[p2]
			
			result[p1] += sum / 10
			result[p2] = sum % 10
		}
	}
	
	// 构建结果字符串
	var sb strings.Builder
	// 跳过前导零
	i := 0
	for i < len(result) && result[i] == 0 {
		i++
	}
	// 转换为字符串
	for ; i < len(result); i++ {
		sb.WriteByte(byte(result[i] + '0'))
	}
	
	if sb.Len() == 0 {
		return "0"
	}
	return sb.String()
}

第三题

在网络传输中，SDN(软件定义网络)需要动态调整路由策略以优化传输效率。假 设数据包从 源节点到目标节点有多条路径可选，每条路径的带宽占用和传输延迟不同。现需在 总带宽消耗 不超过阈值的前提下，找到延迟最小的路径。

输入

给定一个带权有向图，包含 N 个节点和 M 条边。每条边e有三个属性:起点 u、终点 v 带宽消耗 b和延迟 d。要求从源节点$ 到目标节点T的路径，使得路径上所有边 的带宽消耗总和不超过 B，且总延迟最小。若不存在合法路径，返回-1。

输出

最小延迟值

样例

输入：
输入格式:
N M S T
u1 v1 b1 d1
u2 v2 b2 d2
B

示例输入
3 3 0 2
0 1 2 3
0 2 5 10
1 2 2 4
5

输出：
7

思路

使用dijkstra算法，但是需要修改一下，因为需要考虑带宽的限制，就多加一个贷款条件下的最小延迟。

代码

import heapq

def solve():
    line1 = input().split()
    n = int(line1[0])
    m = int(line1[1])
    start_node = int(line1[2])
    end_node = int(line1[3])

    edges = []
    for _ in range(m):
        line = input().split()
        u = int(line[0])
        v = int(line[1])
        b = int(line[2])
        d = int(line[3])
        edges.append((u, v, b, d))

    max_bandwidth = int(input())

    adj = [[] for _ in range(n + 1)]
    for u, v, b, d in edges:
        adj[u].append((v, b, d))

    min_delay = {}  # (node, bandwidth) -> min_delay
    pq = [(0, 0, start_node)]  # (delay, bandwidth, node)

    while pq:
        delay, bandwidth, u = heapq.heappop(pq)

        if (u, bandwidth) in min_delay and min_delay[(u, bandwidth)] <= delay:
            continue
        min_delay[(u, bandwidth)] = delay  # 存入，满足要求贷款下的延迟

        if u == end_node:
            continue

        for v, b, d in adj[u]:
            new_bandwidth = bandwidth + b
            new_delay = delay + d
            if new_bandwidth <= max_bandwidth:
                heapq.heappush(pq, (new_delay, new_bandwidth, v))

    result = float('inf')
    found_path = False
    for bandwidth in range(max_bandwidth + 1):
        if (end_node, bandwidth) in min_delay:
            result = min(result, min_delay[(end_node, bandwidth)])
            found_path = True

    if found_path:
        print(result)
    else:
        print(-1)

if __name__ == "__main__":
    solve()