销售点分布调查

题目描述

终端部门按层级管理销售负责人，即：销售总裁直接对接公司分布在若干个国家的销售负责人，每个国家的销售负责人对接本国各大区负责人，大区负责人对接本区内各省负责人，各省负责人对接本省各市负责人等等…… 这里假设每个级别的负责人都仅向唯一的上级领导汇报。

假设共有N（N<100）位销售负责人，每人有一个两位数的代号（从 01 到 N），销售总裁的代号为01。如下样例给出了一个23人销售负责人的层级结构图：

给定销售负责人的层级关系数据，请统计指定负责人名下人数最多的层级是哪一层，该层有多少人？

当有多个层级的人数相同时，选择最高的那个层级。
所统计的层级是相对的，指定负责人的层级为 1，其下的层级逐层递增。

解答要求时间限制：1000ms, 内存限制：256MB

输入

第一行一个整数 N 表示销售负责人总数，取值范围：[1,100)。
第二行一个整数 M （0 <= M < N）表示有下属的负责人的人数。
随后 M 行，每行给出一位负责人，格式为ID K ID[1] ID[2] ... ID[K]，其中 ID 是该负责人的代号，K (K > 0) 是其下属人数，后面给出的其下属们的代号。
最后一行给出待统计的指定负责人的代号ID

输出

两个数字，依次表示指定负责人名下人数最多的层级，及该层级的人数。

样例

输入样例 1 复制

23
13
21 1 23
01 4 03 02 04 05
03 3 06 07 08
06 2 12 13
13 1 21
08 2 15 16
02 2 09 10
11 2 19 20
17 1 22
05 1 11
07 1 14
09 1 17
10 1 18
01

输出样例 1

[4 9]

提示样例 1

01号负责人，其名下人数最多的层级是第4层（01号自身算第1层，其名下的层级逐层递增），该层有9人；因此输出[4 9]

补充说明：

如果统计09号负责人：其名下所有层级的人数都是1人，取最高层级即自身层级 1，输出[1 1]。

如果统计06号负责人：其名下第2层人数最多，有2人，输出[2 2]。

如果统计20号负责人：其名下没有层级，取自身层级 1，人数 1，输出[1 1]。

BFS模版：

package main

import "fmt"

type TreeNode struct {
    val   int
    nodes []*TreeNode
}

func NewTreeNode(val int) *TreeNode {
    return &TreeNode{val: val}
}

func bfs(root *TreeNode) int {
    // 1.队列存当前节点,初春
    queue := make([]*TreeNode, 0)
    visited := make(map[*TreeNode]bool)

    queue = append(queue, root)
    // 2. 标记已访问过,标访
    visited[root] = true
    // root节点本身深度是1
    depth := 1

    // 3.循环队列非空,循空
    for len(queue) > 0 {
        size := len(queue)

        for i := 0; i < size; i++ {
            // 4.取出队首节点,然后移除队首
            cur := queue[0]
            queue = queue[1:]

            if cur.nodes == nil {
                fmt.Println(cur.val)
                return depth
            }
            // 5.遍历其所有邻居 遍邻
            for _, adj := range cur.nodes {
                // 6.若未访问过则标记并入队 入队
                if !visited[adj] {
                    queue = append(queue, adj)
                    visited[adj] = true
                }
            }
        }
        depth++
    }
    return depth
}

func main() {
    node1 := NewTreeNode(1)
    node2 := NewTreeNode(2)
    node3 := NewTreeNode(3)
    node4 := NewTreeNode(4)
    node5 := NewTreeNode(5)
    node6 := NewTreeNode(6)

    node1.nodes = append(node1.nodes, node2)
    node1.nodes = append(node1.nodes, node3)
    node2.nodes = append(node1.nodes, node4)
    node4.nodes = append(node1.nodes, node5)
    fmt.Printf("期望结果2, 实际 %d\n", bfs(node1))
    node3.nodes = append(node3.nodes, node6)
    fmt.Printf("期望结果3, 实际 %d\n", bfs(node1))
}



默写100篇

以下是一个简单的 bfs 口诀:

队列存当前节点，
标记已访问过，

循环队列非空，
取出队首节点，

遍历其所有邻居，
若未访问过则标记并入队。

View Code

AC:

 /*
 * Copyright (c) Huawei Technologies Co., Ltd. 2020-2020. All rights reserved.
 * Description: 上机编程认证
 * Note: 缺省代码仅供参考，可自行决定使用、修改或删除
 * 只能import Go标准库
 */
package main

import (
    "bufio"
    "errors"
    "fmt"
    "io"
    "os"
    "strconv"
    "strings"
)

// 待实现函数，在此函数中填入答题代码
func pointSaleSurvey(totalSales int, relationMap map[int][]int, appointSale int) []int {
    // 最终求什么 指定负责人下的最多人数层级 
    maxCount := 0
    maxDepth := 0
    queue := make([]int, 0) 
    queue = append(queue, appointSale)  
    depth := 0  
    for len(queue) > 0 {
        size := len(queue) 
        for i:=0; i<size; i++ {
            cur := queue[0]
            queue = queue[1:]
            for parent, relation := range relationMap {
                if cur == parent { 
                    queue = append(queue, relation...)
                }
            }
        }
        depth++   
        if maxCount < size {
            maxCount = size
            maxDepth = depth
        } 
    }  
    return []int{maxDepth, maxCount}
}

func main() {
    reader := bufio.NewReader(os.Stdin)
    totalSales, _ := readInputInt(reader)
    row, _ := readInputInt(reader)
    relationMap, err := readInputIntArrayFromNlines(reader, row)
    if err != nil {
        fmt.Println(err.Error())
        return
    }
    appointSale, _ := readInputInt(reader)
    result := pointSaleSurvey(totalSales, relationMap, appointSale)
    fmt.Print("[")
    for ind, val := range result {
        fmt.Print(val)
        if ind != len(result)-1 {
            fmt.Print(" ")
        }
    }
    fmt.Print("]")
}
func readInputInt(reader *bufio.Reader) (int, error) {
    var num int
    if _, err := fmt.Fscanf(reader, "%d\n", &num); err != nil {
        fmt.Println(err.Error())
        return 0, err
    }
    return num, nil
}

func readInputIntArrayFromNlines(reader *bufio.Reader, row int) (map[int][]int, error) {
    result := make(map[int][]int, 0)
    if row == 0 {
        return result, nil
    }
    for i := 0; i < row; i++ {
        lineBuf, err := reader.ReadString('\n')
        if err != nil && err != io.EOF {
            return nil, err
        }
        lineBuf = strings.TrimRight(lineBuf, "\r\n")
        lineBuf = strings.TrimSpace(lineBuf)
        ints := map2IntArray(lineBuf, " ")
        if len(ints)-2 != ints[1] {
            return result, errors.New("K len is error")
        }
        result[ints[0]] = ints[2:]
    }

    return result, nil
}

func map2IntArray(str string, dem string) []int {
    tempArray := strings.Split(str, dem)
    result := make([]int, len(tempArray))
    for index, value := range tempArray {
        value = strings.TrimSpace(value)
        intVal, _ := strconv.Atoi(value)
        result[index] = intVal
    }
    return result
}

View Code

感受：

1.感觉用BFS状态还行，但是具体写的时候没有想到队列，queue

2.但BFS不够熟悉，最终求什么一定要清晰

3.感觉如果是BFS的话，默写BFS模版100篇，一定要感受到queue为止，说的bfs就是queue

posted @ 2023-12-19 10:38 易先讯阅读(6) 评论(0) 编辑收藏举报

易先讯

关注程序员个人发展