华为OD机试C卷 - 最富裕的小家庭（ Python C C++ JavaGo JS PHP）

题目描述

在一颗树中，每个节点代表一个家庭成员，节点的数字表示其个人的财富值。一个小家庭由一个节点及其直接相连的子节点组成。

现在给定一颗树，我们需要计算最富裕的小家庭的财富和。

输入描述

输入包括以下几行：

  1. 一个整数N，表示树中家庭成员的总数，1 ≤ N ≤ 1000。
  2. N个由空格分隔的整数，表示每个家庭成员的财富值，-100 ≤ 财富值 ≤ 1000000。
  3. N-1行，每行包含两个由空格分隔的整数（N1, N2），表示N1是N2的父亲。

输出描述

输出一个整数，表示最富裕的小家庭的财富和。

用例

在这里插入图片描述

题目解析

首先，我们需要明确题目要求。题目描述了一个树形结构，每个节点代表一个家庭成员，节点的数字表示其个人的财富值。一个小家庭由一个节点及其直接相连的子节点组成。我们需要计算最富裕的小家庭的财富和。

为了解决这个问题，我们可以使用深度优先搜索（DFS）来遍历树形结构。在DFS过程中，我们可以记录每个小家庭的财富值，并找到最富裕的小家庭。

具体步骤如下：

  1. 创建一个字典family，用于记录每个节点的子节点及其财富值。
  2. 创建一个字典family_wealth，用于记录每个小家庭的财富值。初始时，将字典中的所有值都设为0。
  3. 创建一个变量max_wealth，用于记录最富裕的小家庭的财富值。初始时，将max_wealth设为0。
  4. 使用DFS遍历树形结构，对于每个节点：
    • 如果当前节点不是叶子节点，则递归遍历其子节点。
    • 计算当前小家庭的财富值，并将其存储在family_wealth中。当前小家庭的财富值为当前节点的财富值加上其子节点的财富值之和。
    • 如果当前小家庭的财富值大于max_wealth，则更新max_wealth为当前小家庭的财富值。
  5. 输出最富裕的小家庭的财富值。

Python代码实现

# 定义一个函数，用于计算小家庭的财富和
def calculate_family_wealth(node, family, family_wealth):
    # 如果当前节点不是叶子节点，则递归遍历其子节点
    if len(family[node]) > 0:
        for child in family[node]:
            calculate_family_wealth(child, family, family_wealth)
    
    # 计算当前小家庭的财富值，并将其存储在 family_wealth 中
    family_wealth[node] = family_wealth.get(node, 0) + family[node][0]
    
    # 更新最富裕的小家庭的财富值
    if family_wealth[node] > max_wealth:
        max_wealth = family_wealth[node]

# 初始化变量和字典
max_wealth = 0  # 最富裕的小家庭的财富值
family = {}  # 记录每个节点的子节点及其财富值
family_wealth = {}  # 记录每个小家庭的财富值

# 读取输入数据
N = int(input().strip())  # 家庭成员的总数
family_wealth[1] = int(input().strip())  # 第一个家庭成员的财富值，也是整个家庭的财富值
family[1] = []  # 第一个家庭成员没有子节点
for i in range(2, N+1):
    node = int(input().strip())  # 当前家庭成员的编号
    wealth = int(input().strip())  # 当前家庭成员的财富值
    parent = int(input().strip())  # 当前家庭成员的父亲编号
    family[node] = []  # 初始化当前家庭成员的子节点列表
    family[parent].append(node)  # 将当前家庭成员添加为其父亲的子节点
    family_wealth[node] = wealth  # 记录当前家庭成员的财富值

# 使用深度优先搜索遍历树形结构，计算最富裕的小家庭的财富和
calculate_family_wealth(1, family, family_wealth)

# 输出最富裕的小家庭的财富和
print(max_wealth)

C代码实现

#include <stdio.h>
#include <stdbool.h> 

int max_wealth; // 定义最大财富
int family[100001][2]; // 定义一个二维数组来存储家族关系
int family_wealth[100001]; // 定义一个数组来存储每个成员的财富

void calculate_family_wealth(int node, int (*family)[2], int *wealth) 
{ // 定义一个函数来计算家族财富
   if (family[node][0] > 0) { // 如果该成员有孩子
       for (int i = 0; i < family[node][0]; i++) { // 遍历该成员的所有孩子
           calculate_family_wealth(family[node][1 + i], family, wealth); // 递归计算每个孩子的财富
       }
   }

   family_wealth[node] = family_wealth[node] + family[node][0]; // 加上该成员的财富

   if (family_wealth[node] > max_wealth) { // 如果该成员的财富比最大财富还要多
       max_wealth = family_wealth[node]; // 更新最大财富
   }
}

int main() {
   int N; // 定义一个变量来存储家族人数
   scanf("%d", &N); // 读取家族人数
   scanf("%d", &family_wealth[1]); // 读取第一个成员的财富
   max_wealth = family_wealth[1]; // 将最大财富初始化为第一个成员的财富

   for (int i = 2; i <= N; i++) 
   { // 遍历家族中的所有成员
       int node, wealth, parent; // 定义三个变量来存储当前成员的信息
       scanf("%d %d %d", &node, &wealth, &parent); // 读取当前成员的信息
       family[node][0] = 0; // 将当前成员的子节点数初始化为0
       family[parent][0]++; // 将父节点的孩子数加1
       family[parent][family[parent][0]++] = node; // 将当前成员添加到父节点的子节点数组中
       family_wealth[node] = wealth; // 将当前成员的财富初始化为输入的财富
   }

   calculate_family_wealth(1, family, family_wealth); // 调用函数计算家族财富

   printf("%d\n", max_wealth); // 输出最大财富

   return 0; // 程序结束
}

C++代码实现

#include <iostream>
#include <vector>

int max_wealth; // 定义最大财富
std::vector<std::vector<int>> family; // 定义一个二维数组来存储家族关系
std::vector<int> family_wealth; // 定义一个数组来存储每个成员的财富

void calculate_family_wealth(int node, const std::vector<std::vector<int>>& family, std::vector<int>& wealth) 
{ // 定义一个函数来计算家族财富
   if (family[node][0] > 0) { // 如果该成员有孩子
       for (int i = 0; i < family[node][0]; i++) { // 遍历该成员的所有孩子
           calculate_family_wealth(family[node][1 + i], family, wealth); // 递归计算每个孩子的财富
       }
   }

   family_wealth[node] = family_wealth[node] + family[node][0]; // 加上该成员的财富

   if (family_wealth[node] > max_wealth) { // 如果该成员的财富比最大财富还要多
       max_wealth = family_wealth[node]; // 更新最大财富
   }
}

int main() {
   int N; // 定义一个变量来存储家族人数
   std::cin >> N; // 读取家族人数
   std::cin >> family_wealth[1]; // 读取第一个成员的财富
   max_wealth = family_wealth[1]; // 将最大财富初始化为第一个成员的财富

   for (int i = 2; i <= N; i++) 
   { // 遍历家族中的所有成员
       int node, wealth, parent; // 定义三个变量来存储当前成员的信息
       std::cin >> node >> wealth >> parent; // 读取当前成员的信息
       family[node].resize(1, 0); // 将当前成员的子节点数初始化为0
       family[parent][0]++; // 将父节点的孩子数加1
       family[parent].push_back(node); // 将当前成员添加到父节点的子节点数组中
       family_wealth[node] = wealth; // 将当前成员的财富初始化为输入的财富
   }

   calculate_family_wealth(1, family, family_wealth); // 调用函数计算家族财富

   std::cout << max_wealth << std::endl; // 输出最大财富

   return 0; // 程序结束
}

Java代码实现

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Main {
    static int max_wealth; // 定义最大财富
    static List<List<Integer>> family; // 定义一个二维数组来存储家族关系
    static List<Integer> family_wealth; // 定义一个数组来存储每个成员的财富

    public static void calculate_family_wealth(int node, List<List<Integer>> family, List<Integer> wealth) 
    { // 定义一个函数来计算家族财富
        if (family.get(node).get(0) > 0) { // 如果该成员有孩子
            for (int i = 0; i < family.get(node).get(0); i++) { // 遍历该成员的所有孩子
                calculate_family_wealth(family.get(node).get(1 + i), family, wealth); // 递归计算每个孩子的财富
            }
        }

        family_wealth.set(node, family_wealth.get(node) + family.get(node).get(0)); // 加上该成员的财富

        if (family_wealth.get(node) > max_wealth) { // 如果该成员的财富比最大财富还要多
            max_wealth = family_wealth.get(node); // 更新最大财富
        }
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int N; // 定义一个变量来存储家族人数
        System.out.println("请输入家族人数：");
        N = scanner.nextInt(); // 读取家族人数
        System.out.println("请输入第一个成员的财富：");
        family_wealth.add(1, scanner.nextInt()); // 读取第一个成员的财富，并将其添加到成员财富列表中
        max_wealth = family_wealth.get(1); // 将最大财富初始化为第一个成员的财富

        for (int i = 2; i <= N; i++) 
        { // 遍历家族中的所有成员
            int node, wealth, parent; // 定义三个变量来存储当前成员的信息
            System.out.println("请输入当前成员的信息：");
            node = scanner.nextInt();
            wealth = scanner.nextInt();
            parent = scanner.nextInt();
            family.add(node, new ArrayList<>()); // 将当前成员添加到家族关系列表中
            family.get(parent).add(node); // 将当前成员添加到父节点的子节点数组中
            family_wealth.add(node, wealth); // 将当前成员的财富初始化为输入的财富
        }

        calculate_family_wealth(1, family, family_wealth); // 调用函数计算家族财富

        System.out.println("最大财富为：" + max_wealth); // 输出最大财富
    }
}

Go代码实现

package main

import (
	"fmt"
	"io"
	"strings"
	"stdio"
)

func main() {
	var maxWealth int
	var family [][]int
	var familyWealth []int

	fmt.Readln(&N) // 读取家族人数
	fmt.Readln(&familyWealth[1]) // 读取第一个成员的财富
	maxWealth = familyWealth[1] // 将最大财富初始化为第一个成员的财富

	for i := 2; i <= N; i++ { // 遍历家族中的所有成员
		var node, wealth, parent int
		fmt.Readln(&node, &wealth, &parent) // 读取当前成员的信息
		family[node] = append(family[node], 0) // 将当前成员的子节点数初始化为0
		family[parent][0]++ // 将父节点的孩子数加1
		family[parent] = append(family[parent], node) // 将当前成员添加到父节点的子节点数组中
		familyWealth[node] = wealth // 将当前成员的财富初始化为输入的财富
	}

	calculateFamilyWealth(1, family, familyWealth) // 调用函数计算家族财富

	fmt.Println(maxWealth) // 输出最大财富
}

func calculateFamilyWealth(node int, family [][]int, familyWealth []int) {
	if family[node][0] > 0 { // 如果该成员有孩子
		for i := 0; i < family[node][0]; i++ { // 遍历该成员的所有孩子
			calculateFamilyWealth(family[node][1+i], family, familyWealth) // 递归计算每个孩子的财富
		}
	}

	familyWealth[node] = familyWealth[node] + family[node][0] // 加上该成员的财富

	if familyWealth[node] > maxWealth { // 如果该成员的财富比最大财富还要多
		maxWealth = familyWealth[node] // 更新最大财富
	}
}

PHP代码实现

<?php

$max_wealth = 0; // 定义最大财富
$family = array(); // 定义一个二维数组来存储家族关系
$family_wealth = array(); // 定义一个数组来存储每个成员的财富

function calculate_family_wealth($node, $family, $wealth) { // 定义一个函数来计算家族财富
    if ($family[$node][0] > 0) { // 如果该成员有孩子
        for ($i = 0; $i < $family[$node][0]; $i++) { // 遍历该成员的所有孩子
            calculate_family_wealth($family[$node][1 + $i], $family, $wealth); // 递归计算每个孩子的财富
        }
    }

    $family_wealth[$node] = $family_wealth[$node] + $family[$node][0]; // 加上该成员的财富

    if ($family_wealth[$node] > $max_wealth) { // 如果该成员的财富比最大财富还要多
        $max_wealth = $family_wealth[$node]; // 更新最大财富
    }
}

public function main() {
    $scanner = new Scanner(STDIN);
    $N = 0; // 定义一个变量来存储家族人数
    echo "请输入家族人数：<br>";
    $N = $scanner->nextInt(); // 读取家族人数
    echo "请输入第一个成员的财富：<br>";
    $family_wealth[] = $scanner->nextInt(); // 读取第一个成员的财富，并将其添加到成员财富列表中
    $max_wealth = $family_wealth[1]; // 将最大财富初始化为第一个成员的财富

    for ($i = 2; $i <= $N; $i++) { // 遍历家族中的所有成员
        $node = 0;
        $wealth = 0;
        $parent = 0;
        echo "请输入当前成员的信息：<br>";
        $node = $scanner->nextInt();
        $wealth = $scanner->nextInt();
        $parent = $scanner->nextInt();
        $family[] = array($node, array()); // 将当前成员添加到家族关系列表中
        $family[$parent][] = $node; // 将当前成员添加到父节点的子节点数组中
        $family_wealth[] = $wealth; // 将当前成员的财富初始化为输入的财富
    }

    calculate_family_wealth(1, $family, $family_wealth); // 调用函数计算家族财富

    echo "最大财富为：" . $max_wealth; // 输出最大财富
}

main();

JS代码实现


const maxWealth = 0; // 定义最大财富
const family = new Array(100001).fill(0).map(() => new Array(2).fill(0)); // 定义一个二维数组来存储家族关系
const familyWealth = new Array(100001).fill(0); // 定义一个数组来存储每个成员的财富

function calculateFamilyWealth(node, family, wealth) { // 定义一个函数来计算家族财富
   if (family[node][0] > 0) { // 如果该成员有孩子
       for (let i = 0; i < family[node][0]; i++) { // 遍历该成员的所有孩子
           calculateFamilyWealth(family[node][1 + i], family, wealth); // 递归计算每个孩子的财富
       }
   }

   familyWealth[node] = familyWealth[node] + family[node][0]; // 加上该成员的财富

   if (familyWealth[node] > maxWealth) { // 如果该成员的财富比最大财富还要多
       maxWealth = familyWealth[node]; // 更新最大财富
   }
}

async function main() {
   const N = parseInt(prompt("请输入家族人数：")); // 读取家族人数
   familyWealth[1] = parseInt(prompt("请输入第一个成员的财富：")); // 读取第一个成员的财富
   maxWealth = familyWealth[1]; // 将最大财富初始化为第一个成员的财富

   for (let i = 2; i <= N; i++) { // 遍历家族中的所有成员
       const node = i; // 定义一个变量来存储当前成员的编号
       const wealth = parseInt(prompt("请输入当前成员的财富：")); // 读取当前成员的财富
       const parent = parseInt(prompt("请输入当前成员的父节点编号：")); // 读取当前成员的父节点编号
       family[parent][0]++; // 将父节点的孩子数加1
       family[parent][family[parent][0]++] = node; // 将当前成员添加到父节点的子节点数组中
       familyWealth[node] = wealth; // 将当前成员的财富初始化为输入的财富
   }

   calculateFamilyWealth(1, family, familyWealth); // 调用函数计算家族财富

   console.log(maxWealth); // 输出最大财富
}
main();

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mfbz.cn/a/378857.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

Project2013下载安装教程，保姆级教程，附安装包和工具

Project2013下载安装教程，保姆级教程，附安装包和工具

前言 Project是一款项目管理软件&#xff0c;不仅可以快速、准确地创建项目计划&#xff0c;而且可以帮助项目经理实现项目进度、成本的控制、分析和预测&#xff0c;使项目工期大大缩短&#xff0c;资源得到有效利用&#xff0c;提高经济效益。软件设计目的在于协助专案经理发…
阅读更多...
2024年【广东省安全员B证第四批（项目负责人）】考试及广东省安全员B证第四批（项目负责人）考试题

2024年【广东省安全员B证第四批（项目负责人）】考试及广东省安全员B证第四批（项目负责人）考试题

题库来源&#xff1a;安全生产模拟考试一点通公众号小程序 广东省安全员B证第四批&#xff08;项目负责人&#xff09;考试考前必练&#xff01;安全生产模拟考试一点通每个月更新广东省安全员B证第四批&#xff08;项目负责人&#xff09;考试题题目及答案&#xff01;多做几…
阅读更多...
基于AST实现一键自动提取替换国际化文案

基于AST实现一键自动提取替换国际化文案

背景&#xff1a;在调研 formatjs/cli 使用&#xff08;使用 formatjs/cli 进行国际化文案自动提取 &#xff09;过程中&#xff0c;发现有以下需求formatjs/cli 无法满足&#xff1a; id 需要一定的语义化&#xff1b; defaultMessage和Id不能直接hash转换&#xff1b; 需要…
阅读更多...
MySQL篇----第七篇

MySQL篇----第七篇

系列文章目录 文章目录 系列文章目录前言一、水平分区二、分库分表之后,id 主键如何处理三、存储过程(特定功能的 SQL 语句集)前言 前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。点击跳转到网站，这篇文章男女通用，看懂了就去分享给你…
阅读更多...
仰暮计划|“舅舅的大女儿失踪了，当时找遍了整个村庄，也报了警”

仰暮计划|“舅舅的大女儿失踪了，当时找遍了整个村庄，也报了警”

我的舅舅是1961年出生在一个偏僻的小山沟里&#xff0c;我只在很小的时候跟着我的妈妈回去过&#xff0c;我对于那里的印象很模糊&#xff0c;只有半镶在土窑里的小平房&#xff0c;门前的一条栽满樱桃树的很深的土沟&#xff0c;通往门前的陡峭的小路和露天的院子里那一颗茂盛…
阅读更多...
LabVIEW动平衡测试与振动分析系统

LabVIEW动平衡测试与振动分析系统

LabVIEW动平衡测试与振动分析系统 介绍了利用LabVIEW软件和虚拟仪器技术开发一个动平衡测试与振动分析系统。该系统旨在提高旋转机械设备的测试精度和可靠性&#xff0c;通过精确测量和分析设备的振动数据&#xff0c;以识别和校正不平衡问题&#xff0c;从而保证机械设备的高…
阅读更多...
图数据库 之 Neo4j - 环境搭建(2)

图数据库 之 Neo4j - 环境搭建(2)

运行环境&#xff1a; centos7 Docker version 18.09.6 下载镜像 docker search neo4j docker pull neo4j 创建 neo4j 用户 # 创建 neo4j 用户 # -M 不创建用户的主目录 sudo useradd -M neo4j # usermod 用于修改用户属性命令 # -L 锁定用户&#xff0c;用户无法登录系统 user…
阅读更多...
深入Pandas：精通文本数据处理的20+技巧与应用实例【第68篇—python：文本数据处理】

深入Pandas：精通文本数据处理的20+技巧与应用实例【第68篇—python：文本数据处理】

文章目录 Pandas文本数据处理方法详解1. str/object类型转换2. 大小写转换3. 文本对齐4. 获取长度5. 出现次数6. 编码方向7. 字符串切片8. 字符串替换9. 字符串拆分10. 字符串连接11. 字符串匹配12. 去除空格13. 多条件过滤14. 字符串排序15. 字符串格式化16. 多列文本操作17. …
阅读更多...
Android Studio安装过程遇到SDK无法安装问题解决

Android Studio安装过程遇到SDK无法安装问题解决

首次打开studio遇到该类问题&#xff0c;需要下载SDK文件&#xff0c;后又发现SDK由于是Google源&#xff0c;无法进行正常安装&#xff0c;故转而进行SDK的镜像安装。 一、下载SDK Tools 地址&#xff1a;AndroidDevTools - Android开发工具 Android SDK下载 Android Studio…
阅读更多...
c语言动态数组的实现

c语言动态数组的实现

动态数组是在程序运行时动态分配内存空间的数组&#xff0c;可以根据需要随时改变大小。在C语言中&#xff0c;动态数组通常通过指针和malloc函数来实现。 使用malloc函数动态分配内存空间&#xff1a; int *arr; int size 10; arr (int*)malloc(size * sizeof(int));使用r…
阅读更多...
【Java八股面试系列】并发编程-进程与线程

【Java八股面试系列】并发编程-进程与线程

目录 进程 线程 线程和进程的区别 Java线程和操作系统的线程的区别 请简要描述一下进程和线程在Java中的关系&#xff0c;区别及优缺点&#xff1f;​编辑​编辑​编辑 并发和并行的区别 为什么要使用多线程? 线程的生命周期 什么是线程上下文切换? sleep() 方法和…
阅读更多...
Java Stram 流对于返回对象的处理 （结束流）

Java Stram 流对于返回对象的处理 （结束流）

Java Stram 流对于返回对象的处理 &#xff08;结束流&#xff09; package com.zhong.streamdemo.showdownstreamdemo;import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor;import java.util.*; import java.util.stream.Collectors; im…
阅读更多...
Springboot 整合 Elasticsearch（三）：使用RestHighLevelClient操作ES ①

Springboot 整合 Elasticsearch（三）：使用RestHighLevelClient操作ES ①

&#x1f4c1; 前情提要&#xff1a; Springboot 整合 Elasticsearch&#xff08;一&#xff09;&#xff1a;Linux下安装 Elasticsearch 8.x Springboot 整合 Elasticsearch&#xff08;二&#xff09;&#xff1a;使用HTTP请求来操作ES 目录 一、Springboot 整合 Elasticsea…
阅读更多...
【FPGA】快速学习路径

【FPGA】快速学习路径

FPGA学习教程、功利式学习路径、以找工作为目的&#xff0c;早日入门FPGA_哔哩哔哩_bilibili
阅读更多...
Redis篇之集群

Redis篇之集群

一、主从复制 1.实现主从作用 单节点Redis的并发能力是有上限的&#xff0c;要进一步提高Redis的并发能力&#xff0c;就需要搭建主从集群&#xff0c;实现读写分离。主节点用来写的操作&#xff0c;从节点用来读操作&#xff0c;并且主节点发生写操作后&#xff0c;会把数据同…
阅读更多...
倒计时61天

倒计时61天

M-智乃的36倍数(normal version)_2024牛客寒假算法基础集训营3 (nowcoder.com) //非ac代码,超时了,54.17/100#include<bits/stdc.h> using namespace std; const int N1e55; const int inf0x3f3f3f3f; #define int long long int n; string s1[N]; void solve() {cin>…
阅读更多...
第五篇【传奇开心果系列】vant开发移动应用示例：深度解读高度可定制

第五篇【传奇开心果系列】vant开发移动应用示例：深度解读高度可定制

传奇开心果博文系列 系列博文目录Vant 开发移动应用示例系列 博文目录前言一、Vant高度可定制的重要作用二、样式定制介绍和示例代码三、组件定制介绍和示例代码四、组件库定制介绍和示例代码五、主题定制介绍和示例代码六、语言环境定制介绍和示例代码七、资源加载定制介绍和示…
阅读更多...
[当人工智能遇上安全] 11.威胁情报实体识别 (2)基于BiGRU-CRF的中文实体识别万字详解

[当人工智能遇上安全] 11.威胁情报实体识别 (2)基于BiGRU-CRF的中文实体识别万字详解

您或许知道&#xff0c;作者后续分享网络安全的文章会越来越少。但如果您想学习人工智能和安全结合的应用&#xff0c;您就有福利了&#xff0c;作者将重新打造一个《当人工智能遇上安全》系列博客&#xff0c;详细介绍人工智能与安全相关的论文、实践&#xff0c;并分享各种案…
阅读更多...
DMA直接内存访问，STM32实现高速数据传输使用配置

DMA直接内存访问，STM32实现高速数据传输使用配置

1、DMA运用场景 随着智能化、信息化的不断推进&#xff0c;嵌入式设备的数据处理量也呈现指数级增加&#xff0c;因此对于巨大的数据量处理的情况时&#xff0c;必须采取其它的方式去替CPU减负&#xff0c;以保证嵌入式设备性能。例如SD卡存储器和音视频、网络高速通信等其它情…
阅读更多...
探讨CSDN等级制度：博客等级、原力等级、创作者等级

探讨CSDN等级制度：博客等级、原力等级、创作者等级

个人名片&#xff1a; &#x1f981;作者简介&#xff1a;学生 &#x1f42f;个人主页&#xff1a;妄北y &#x1f427;个人QQ&#xff1a;2061314755 &#x1f43b;个人邮箱&#xff1a;2061314755qq.com &#x1f989;个人WeChat&#xff1a;Vir2021GKBS &#x1f43c;本文由…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站