九坤算法考试题

九坤内部有很多数据任务，任务编号记为0 到 taskNum -1。这些任务并不是完全独立的，有相应的依赖关系，这里给出一个数组prerequisites， 数组中描述的是两个任务i、j的依赖关系[i, j] 代表任务i 依赖任务j的完成。 例如：只有任务1完成了，任务0才能开始，表示的数组为 [0, 1] 现在假设给大家N个数据任务，并给出数组prerequisites，还请返回任何一个可行的数据任务执行顺序。如这些任务不可能执行完成，返回一个空数组即可。 示例： 输入：task_num= 4，prerequisites = [[1, 0], [2, 0], [3, 1], [3,2] ] 输出：[0, 2, 1, 3] go 实现

输入实例数据图

在 Go 语言中，我们可以使用拓扑排序算法来解决这个问题。以下是实现代码：

Go

package main

import (
	"bufio"
	"encoding/json"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func findOrder(taskNum int, prerequisites [][]int) []int {
	tasks := make(map[int][]int)
	inDegree := make([]int, taskNum)

	for _, pair := range prerequisites {
		tasks[pair[1]] = append(tasks[pair[1]], pair[0])
		inDegree[pair[0]]++
	}

	queue := make([]int, 0, taskNum)
	for i, degree := range inDegree {
		if degree == 0 {
			queue = append(queue, i)
		}
	}

	order := make([]int, 0, taskNum)
	for len(queue) > 0 {
		currTask := queue[0]
		queue = queue[1:]
		order = append(order, currTask)

		for _, dep := range tasks[currTask] {
			inDegree[dep]--
			if inDegree[dep] == 0 {
				queue = append(queue, dep)
			}
		}
	}

	if len(order) != taskNum {
		return []int{}
	}

	return order
}

func main() {
	//taskNum := 4
	//prerequisites := [][]int{{1, 0}, {2, 0}, {3, 1}, {3, 2}}3
	reader := bufio.NewReader(os.Stdin)
	fmt.Println("Enter number of tasks")
	taskNumStr, _ := reader.ReadString('\n')
	taskNum, _ := strconv.Atoi(strings.TrimSpace(taskNumStr))
	fmt.Println("Enter pre ")
	preStr, _ := reader.ReadString('\n')
	pre := strings.TrimSpace(preStr)
	var prerequisites [][]int
	_ = json.Unmarshal([]byte(pre), &prerequisites)
	result := findOrder(taskNum, prerequisites)
	fmt.Println(result)
}

这段代码首先构建了一个任务依赖图（邻接表），并计算每个任务的入度（有多少任务依赖于它）。然后从入度为0的任务开始，依次处理它们并将已处理的任务从依赖图中移除，直到所有任务都被处理或者发现有环（即无法完成所有任务时返回空数组）。对于给定的例子，输出结果将会是 [0, 2, 1, 3]。