数据结构第12节 有向图

news2024/10/6 6:59:49

有向图（Directed Graph 或 Digraph）是一种图数据结构，其中的边具有方向性。这意味着在一个有向图中，边可以被视为箭头，箭头从一个顶点指向另一个顶点，表示从起点到终点的单向关系。有向图的这种特性使得它在许多现实问题的建模中非常有用，例如网络流分析、计算机网络、基因调控网络、网页链接结构等。

有向图的基本概念：

  1. 顶点（Vertex）：有向图中的基本单元，可以表示实体或状态。
  2. 边（Edge）或弧（Arc）：连接两个顶点的有向线段，表示从一个顶点到另一个顶点的关系。边由一对顶点组成，通常写作 <u, v> 或 (u, v)，其中 u 是边的起点（尾部）而 v 是终点（头部）。
  3. 邻接：如果存在一条从顶点 u 指向顶点 v 的边，则称 v 是 u 的邻接顶点，同时 u 是 v 的前驱顶点。
  4. 出度（Out-degree）：一个顶点的出度是所有以该顶点为起点的边的数量。
  5. 入度（In-degree）：一个顶点的入度是所有以该顶点为终点的边的数量。
  6. 路径：在有向图中，从顶点 u 到顶点 v 的路径是由一系列顶点组成的序列 u, v1, v2, …, v，其中每对连续顶点之间都存在一条指向序列前进方向的边。
  7. 环（Cycle）：如果存在一条路径从顶点 u 开始，经过一系列顶点后又回到顶点 u，则称有向图中存在环。
  8. 强连通图：如果一个有向图中任意两个顶点都可以相互到达，则称这个有向图为强连通的。
  9. 有向无环图（DAG）：如果一个有向图中不存在环，则称这个有向图为有向无环图。

有向图的表示：

  1. 邻接矩阵：一个二维数组，其中 adj[u][v] 表示是否存在从顶点 u 到顶点 v 的边。对于有向图，邻接矩阵通常不是对称的。
  2. 邻接表：对于每个顶点，邻接表是一个链表或数组，其中包含所有与该顶点直接相连的顶点。邻接表对于稀疏图（边的数量远小于顶点数量的平方）更节省空间。

有向图的应用算法：

  1. 拓扑排序：在有向无环图（DAG）中，对顶点进行排序，使得对于每条边 (u, v)，顶点 u 在排序中出现在顶点 v 之前。
  2. 最短路径算法：例如 Dijkstra 算法和 Bellman-Ford 算法，用于寻找图中两点间最短路径。
  3. 强连通分量算法：例如 Kosaraju’s 算法和 Tarjan’s 算法，用于识别有向图中的强连通分量。
  4. 流网络算法：例如 Ford-Fulkerson 算法，用于求解网络的最大流问题。

有向图在计算机科学和其他领域中有广泛的应用，掌握其基本概念和相关算法对于解决实际问题是至关重要的。

有向图在游戏开发中扮演着重要的角色，特别是在涉及路径寻找、任务规划、NPC行为、游戏地图生成等方面。有向图是由顶点（节点）和边组成的数据结构，其中边是有方向的，这意味着从一个顶点到另一个顶点的路径可能与反方向的路径不同。

在Java中，我们可以使用邻接表或者邻接矩阵的方式来表示有向图。下面我将使用邻接表的方式，结合一个简单的游戏场景来讲解有向图的应用。

游戏场景描述

想象一下，你正在开发一个角色扮演游戏，游戏中有一个由村庄、森林、山脉、城堡等组成的大陆。玩家可以从村庄出发，探索这个世界，完成各种任务。我们的目标是使用有向图来表示游戏世界中的各个地点以及它们之间的连接关系。

Java实现

import java.util.*;

public class GameWorld {
    private Map<String, List<String>> graph;

    public GameWorld() {
        graph = new HashMap<>();
    }

    // 添加地点
    public void addLocation(String location) {
        graph.put(location, new ArrayList<>());
    }

    // 添加边，即两个地点之间的连接
    public void addConnection(String from, String to) {
        List<String> connections = graph.get(from);
        if (!connections.contains(to)) {
            connections.add(to);
        }
    }

    // 获取地点的所有可前往的地点
    public List<String> getConnections(String location) {
        return graph.get(location);
    }

    // 深度优先遍历示例，可以用于探索游戏世界
    public void dfs(String start) {
        Set<String> visited = new HashSet<>();
        dfsHelper(start, visited);
    }

    private void dfsHelper(String current, Set<String> visited) {
        System.out.println("Visited " + current);
        visited.add(current);

        for (String neighbor : graph.get(current)) {
            if (!visited.contains(neighbor)) {
                dfsHelper(neighbor, visited);
            }
        }
    }

    // 测试代码
    public static void main(String[] args) {
        GameWorld world = new GameWorld();
        world.addLocation("Village");
        world.addLocation("Forest");
        world.addLocation("Mountain");
        world.addLocation("Castle");

        world.addConnection("Village", "Forest");
        world.addConnection("Forest", "Mountain");
        world.addConnection("Mountain", "Castle");
        world.addConnection("Castle", "Village");

        world.dfs("Village");
    }
}

游戏应用实例

在这个游戏中，我们创建了一个有向图表示游戏世界。我们首先添加了四个地点：“Village”、“Forest”、“Mountain”和“Castle”。然后，我们添加了连接，表示从一个地点到另一个地点的路径。最后，我们使用深度优先搜索算法来遍历整个游戏世界，模拟玩家的探索过程。

通过这种方式，我们可以在游戏中实现复杂的路径寻找和任务规划。例如，我们可以使用图算法来确定从一个地点到另一个地点的最短路径，或者规划一系列任务的最优顺序。有向图为我们提供了一种强大的工具，可以用来表示和处理游戏世界中的复杂关系。

为了进一步扩展游戏并深入利用有向图的概念，我们可以添加更多的功能，比如：

  1. 双向边：允许玩家从一个地点往返另一个地点。
  2. 边的权重：代表移动到下一个地点所需的时间或消耗的能量。
  3. 动态变化的图：游戏世界中的某些路径可能因为天气、时间或其他因素而暂时不可用。
  4. 任务系统：基于图的连通性，设计任务流程和奖励机制。

接下来，我们将通过更新之前的代码来实现这些功能。

import java.util.*;

public class GameWorld {
    private Map<String, List<Edge>> graph;
    
    public GameWorld() {
        graph = new HashMap<>();
    }
    
    public void addLocation(String location) {
        graph.put(location, new ArrayList<>());
    }
    
    public void addConnection(String from, String to, int weight) {
        Edge edge = new Edge(to, weight);
        List<Edge> connections = graph.get(from);
        if (!connections.contains(edge)) {
            connections.add(edge);
        }
    }
    
    public List<Edge> getConnections(String location) {
        return graph.get(location);
    }
    
    public void dfs(String start) {
        Set<String> visited = new HashSet<>();
        dfsHelper(start, visited);
    }
    
    private void dfsHelper(String current, Set<String> visited) {
        System.out.println("Visited " + current);
        visited.add(current);
        
        for (Edge edge : graph.get(current)) {
            if (!visited.contains(edge.to)) {
                dfsHelper(edge.to, visited);
            }
        }
    }
    
    // 新增方法：获取到达目的地的总权重
    public int getTotalWeight(String start, String end) {
        return getTotalWeightHelper(start, end, 0, new HashSet<>());
    }
    
    private int getTotalWeightHelper(String current, String end, int weight, Set<String> visited) {
        if (current.equals(end)) {
            return weight;
        }
        visited.add(current);
        int minWeight = Integer.MAX_VALUE;
        for (Edge edge : graph.get(current)) {
            if (!visited.contains(edge.to)) {
                int newWeight = getTotalWeightHelper(edge.to, end, weight + edge.weight, visited);
                if (newWeight != Integer.MAX_VALUE) {
                    minWeight = Math.min(minWeight, newWeight);
                }
            }
        }
        visited.remove(current);
        return minWeight;
    }
    
    // 边类
    private static class Edge {
        String to;
        int weight;
        
        Edge(String to, int weight) {
            this.to = to;
            this.weight = weight;
        }
        
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Edge edge = (Edge) o;
            return weight == edge.weight && Objects.equals(to, edge.to);
        }
        
        @Override
        public int hashCode() {
            return Objects.hash(to, weight);
        }
    }
    
    // 测试代码
    public static void main(String[] args) {
        GameWorld world = new GameWorld();
        world.addLocation("Village");
        world.addLocation("Forest");
        world.addLocation("Mountain");
        world.addLocation("Castle");
        world.addLocation("Lake");
        
        world.addConnection("Village", "Forest", 2);
        world.addConnection("Forest", "Mountain", 3);
        world.addConnection("Mountain", "Castle", 4);
        world.addConnection("Castle", "Village", 5);
        world.addConnection("Village", "Lake", 1);
        
        world.dfs("Village");
        System.out.println("Total Weight from Village to Castle: " + world.getTotalWeight("Village", "Castle"));
    }
}

扩展说明

在这个扩展版本中，我们增加了Edge类来表示带权重的边，这允许我们计算从一个地点到另一个地点的总消耗。我们还添加了一个getTotalWeight方法，它使用递归深度优先搜索来找到从起点到终点的最短路径，并返回这条路径上的总权重。

通过这种方式，我们可以为游戏增加更多真实感和策略性，例如，玩家需要权衡时间成本和资源消耗，选择最佳的旅行路线。此外，我们还可以在此基础上添加更多复杂的功能，如动态障碍物、动态边权重（例如，随天气变化的路径难度），以及更高级的任务和奖励系统。


这种设计不仅增强了游戏的可玩性和沉浸感，同时也展示了有向图在游戏开发中的强大应用潜力。通过不断迭代和改进，我们能够构建出更加丰富和多变的游戏世界。

为了进一步扩展这个游戏，我们可以考虑引入更复杂的元素，如角色状态、动态事件、NPC交互和物品系统。以下是针对这些新增功能的代码实现：

import java.util.*;

public class GameWorld {
    private Map<String, List<Edge>> graph;
    private Map<String, Location> locations;
    private Player player;

    public GameWorld() {
        graph = new HashMap<>();
        locations = new HashMap<>();
        player = new Player();
    }

    public void addLocation(String name, String description) {
        Location location = new Location(name, description);
        locations.put(name, location);
        graph.put(name, new ArrayList<>());
    }

    public void addConnection(String from, String to, int distance) {
        Edge edge = new Edge(to, distance);
        List<Edge> connections = graph.get(from);
        if (!connections.contains(edge)) {
            connections.add(edge);
        }
    }

    public List<Edge> getConnections(String location) {
        return graph.get(location);
    }

    public void movePlayer(String destination) {
        player.setCurrentLocation(destination);
    }

    public Location getPlayerLocation() {
        return player.getCurrentLocation();
    }

    public void interactWithNPC(String npcName) {
        Location currentLocation = player.getCurrentLocation();
        NPC npc = currentLocation.getNPC(npcName);
        if (npc != null) {
            npc.interact(player);
        } else {
            System.out.println("No such NPC in the current location.");
        }
    }

    public void addItemToInventory(String itemName) {
        Item item = new Item(itemName);
        player.addItemToInventory(item);
    }

    public void removeItemFromInventory(String itemName) {
        player.removeItemFromInventory(itemName);
    }

    public void printInventory() {
        player.printInventory();
    }

    public static void main(String[] args) {
        GameWorld world = new GameWorld();
        world.addLocation("Village", "A small village surrounded by dense forests.");
        world.addLocation("Forest", "A dark and mysterious forest with hidden paths.");
        world.addLocation("Mountain", "A steep mountain with breathtaking views.");
        world.addLocation("Castle", "An ancient castle with a rich history.");

        world.addConnection("Village", "Forest", 2);
        world.addConnection("Forest", "Mountain", 3);
        world.addConnection("Mountain", "Castle", 4);
        world.addConnection("Castle", "Village", 5);

        world.player.setCurrentLocation("Village");
        world.addItemToInventory("Map");
        world.addItemToInventory("Compass");

        world.movePlayer("Forest");
        world.interactWithNPC("Old Hermit");
        world.movePlayer("Mountain");
        world.interactWithNPC("Mountain Guide");
        world.movePlayer("Castle");
        world.interactWithNPC("King");

        world.printInventory();
    }
}

class Player {
    private Location currentLocation;
    private List<Item> inventory;

    public Player() {
        inventory = new ArrayList<>();
    }

    public void setCurrentLocation(String locationName) {
        currentLocation = GameWorld.this.locations.get(locationName);
    }

    public Location getCurrentLocation() {
        return currentLocation;
    }

    public void addItemToInventory(Item item) {
        inventory.add(item);
    }

    public void removeItemFromInventory(String itemName) {
        inventory.removeIf(item -> item.getName().equals(itemName));
    }

    public void printInventory() {
        System.out.println("Inventory:");
        for (Item item : inventory) {
            System.out.println("- " + item.getName());
        }
    }
}

class Location {
    private String name;
    private String description;
    private List<NPC> npcs;

    public Location(String name, String description) {
        this.name = name;
        this.description = description;
        npcs = new ArrayList<>();
    }

    public void addNPC(NPC npc) {
        npcs.add(npc);
    }

    public NPC getNPC(String name) {
        for (NPC npc : npcs) {
            if (npc.getName().equals(name)) {
                return npc;
            }
        }
        return null;
    }
}

class NPC {
    private String name;
    private String greeting;

    public NPC(String name, String greeting) {
        this.name = name;
        this.greeting = greeting;
    }

    public void interact(Player player) {
        System.out.println(greeting);
        // Additional interaction logic can be added here.
    }

    public String getName() {
        return name;
    }
}

class Item {
    private String name;

    public Item(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

class Edge {
    private String to;
    private int distance;

    public Edge(String to, int distance) {
        this.to = to;
        this.distance = distance;
    }

    public String getTo() {
        return to;
    }

    public int getDistance() {
        return distance;
    }
}

扩展功能说明：

  1. 角色状态：我们引入了Player类，用于管理玩家的状态，如当前位置和背包物品。
  2. 动态事件：虽然在这个简单示例中没有具体实现，但我们可以通过在NPC类中添加更多交互逻辑，以及在Location类中添加随机事件来实现动态事件。
  3. NPC交互：我们添加了NPC类，玩家可以与之互动。目前的交互仅限于打印问候语，但可以进一步扩展，如交易、接受任务等。
  4. 物品系统：Item类用于表示玩家可以收集的物品。Player类中的inventory属性用于存储这些物品。

通过这些扩展，游戏变得更加丰富和有趣。玩家可以在游戏世界中探索、与NPC互动、收集物品，并根据自己的选择影响游戏进程。这不仅提高了游戏的可玩性，也为开发者提供了更多创造性的空间，以构建更加复杂和引人入胜的游戏体验。

为了进一步扩展游戏，我们可以增加一些更复杂的功能，如任务系统、战斗机制、技能树和角色成长。以下是在现有游戏框架基础上的扩展代码：

import java.util.*;

public class GameWorld {
    private Map<String, List<Edge>> graph;
    private Map<String, Location> locations;
    private Player player;

    public GameWorld() {
        graph = new HashMap<>();
        locations = new HashMap<>();
        player = new Player();
    }

    // ... 保留之前的方法 ...

    public void acceptQuest(Quest quest) {
        player.acceptQuest(quest);
    }

    public void completeQuest(Quest quest) {
        player.completeQuest(quest);
    }

    public void attackMonster(Monster monster) {
        player.attack(monster);
    }

    public void levelUp() {
        player.levelUp();
    }

    // ... 其他方法 ...

    public static void main(String[] args) {
        GameWorld world = new GameWorld();
        // ... 地图初始化代码 ...

        // 创建NPC并分配任务
        NPC oldHermit = new NPC("Old Hermit", "Greetings, young traveler!");
        Quest hermitQuest = new Quest("FindHerbs", "Collect 5 herbs", 10);
        oldHermit.setQuest(hermitQuest);
        world.locations.get("Forest").addNPC(oldHermit);

        // 创建怪物
        Monster wolf = new Monster("Wolf", 5, 2);
        world.locations.get("Forest").addMonster(wolf);

        // 主循环
        while (true) {
            Location currentLocation = world.getPlayerLocation();
            System.out.println("You are in " + currentLocation.getName() + ".");
            System.out.println(currentLocation.getDescription());

            // 处理NPC交互
            for (NPC npc : currentLocation.getNPCs()) {
                System.out.println("NPC: " + npc.getName());
                world.interactWithNPC(npc.getName());
            }

            // 处理怪物战斗
            for (Monster monster : currentLocation.getMonsters()) {
                System.out.println("Encountered a " + monster.getName() + "!");
                world.attackMonster(monster);
            }

            // 更新玩家状态
            world.player.update();

            // 休息和恢复
            System.out.println("Resting...");
            player.rest();

            // 接受和完成任务
            for (Quest quest : player.getQuests()) {
                if (quest.isCompleted()) {
                    System.out.println("Quest completed: " + quest.getName());
                    world.completeQuest(quest);
                }
            }

            // 级别提升
            if (player.canLevelUp()) {
                world.levelUp();
            }

            // 移动到下一个地点
            List<Edge> connections = world.getConnections(currentLocation.getName());
            if (!connections.isEmpty()) {
                Edge nextEdge = connections.get(new Random().nextInt(connections.size()));
                world.movePlayer(nextEdge.getTo());
            }
        }
    }
}

class Player {
    private Location currentLocation;
    private List<Item> inventory;
    private List<Quest> quests;
    private int level;
    private int experience;
    private int health;
    private int maxHealth;

    public Player() {
        inventory = new ArrayList<>();
        quests = new ArrayList<>();
        level = 1;
        experience = 0;
        health = maxHealth = 100;
    }

    // ... 保留之前的方法 ...

    public void acceptQuest(Quest quest) {
        quests.add(quest);
    }

    public void completeQuest(Quest quest) {
        quests.remove(quest);
        experience += quest.getExperienceReward();
    }

    public void attack(Monster monster) {
        // 攻击逻辑
        int damage = 10; // 假定固定伤害
        monster.takeDamage(damage);
    }

    public void levelUp() {
        level++;
        maxHealth += 10;
        health = maxHealth;
    }

    public boolean canLevelUp() {
        return experience >= level * 100;
    }

    public void rest() {
        health = maxHealth;
    }

    public void update() {
        // 更新玩家状态
    }

    // ... 其他方法 ...
}

// ... 其他类 ...

class Quest {
    private String name;
    private String description;
    private int experienceReward;

    public Quest(String name, String description, int experienceReward) {
        this.name = name;
        this.description = description;
        this.experienceReward = experienceReward;
    }

    public boolean isCompleted() {
        // 判断任务是否完成
        return false;
    }
}

class Monster {
    private String name;
    private int health;
    private int damage;

    public Monster(String name, int health, int damage) {
        this.name = name;
        this.health = health;
        this.damage = damage;
    }

    public void takeDamage(int damage) {
        this.health -= damage;
    }
}

// ... 其他类 ...

新增功能说明：

  1. 任务系统：我们引入了Quest类，NPC可以分配任务给玩家。在主循环中，玩家可以接受任务，并在完成后获得经验值奖励。
  2. 战斗机制：Monster类表示游戏中的敌人，玩家可以攻击怪物。这里简化了战斗逻辑，但可以进一步扩展，如加入回合制战斗、技能释放等。
  3. 角色成长：Player类中包含了级别、经验值、健康等属性，支持角色成长和升级。
  4. 主循环：游戏现在有了一个基本的主循环，处理玩家在不同地点之间的移动、与NPC的交互、战斗、任务完成和角色状态更新。

通过这些扩展，游戏变得更加复杂和吸引人。玩家可以享受探索、战斗、任务完成和角色成长的乐趣。当然，这只是一个基础框架，可以根据需要进一步完善和扩展，例如，增加更多的物品、技能、NPC对话、剧情分支等，以构建一个更加丰富多彩的游戏世界。

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

C++面向对象的常见面试题目(一)

C++面向对象的常见面试题目(一)

1. 面向对象的三大特征 &#xff08;1&#xff09;封装&#xff1a;隐藏对象的内部状态&#xff0c;只暴露必要的接口。 #include <iostream> #include <string>// 定义一个简单的类 Person class Person { private: // 私有成员&#xff0c;外部不可直接访问std…
阅读更多...
【LeetCode】十三、分治法：多数元素 + 最大子序列和

【LeetCode】十三、分治法：多数元素 + 最大子序列和

文章目录 1、分治法2、leetcode169&#xff1a;多数元素3、leetcode53&#xff1a;最大子序和 1、分治法 分治一般都搭配递归使用&#xff1a; 用分治法的一个应用——归并排序&#xff1a;将一组数不停的一分为二&#xff0c;直到分到每组只有一个数的时候 分到每组只有一个数…
阅读更多...
【qt】TCP 服务端怎么收到信息?

【qt】TCP 服务端怎么收到信息?

上一节,我已经讲了,TCP的监听,是基于上一节的,不知道的可以看看. 当我们的TCP 服务器 有 客户端请求连接的时候,会发出一个信号newConnection(). 在TCP服务端与客户端的通信中,我们需要使用到套接字 QTcpSocket类. 套接字相当于是网络通信的接口,服务段和客户端都要通过它进行通…
阅读更多...
【网络安全】实验一（网络拓扑环境的搭建）

【网络安全】实验一（网络拓扑环境的搭建）

一、本次实验的实验目的 学习利用 VMware 创建虚拟环境 学习利用 VMware 搭建各自网络拓扑环境 二、创建虚拟机 三、克隆虚拟机 选择克隆的系统必须处于关机状态。 方法一&#xff1a; 方法二&#xff1a; 需要修改克隆计算机的名字&#xff0c;避免产生冲突。 四、按照要求完…
阅读更多...
JavaWeb—js（1）

JavaWeb—js（1）

概述 javascript简称js 1.js的特点&#xff0c;基本语法&#xff0c;对象等 2.js的功能&#xff0c;用来操作页面元素&#xff0c;用户交互&#xff0c;浏览器交互&#xff0c;网络数据的请求 后期使用的更多的是js的框架 jquery.js vue.js react.js JS相关概念 javascrip…
阅读更多...
python使用pywebview集成vue3和element-plus开发桌面系统框架

python使用pywebview集成vue3和element-plus开发桌面系统框架

随着web技术越来越成熟&#xff0c;就连QQ的windows客户端都用web技术来开发&#xff0c;所以在未来&#xff0c;web技术来开发windows桌面软件也会越来越多&#xff0c;所以在此发展驱动之下&#xff0c;将最近流程的python与web技术相结合&#xff0c;使用vue3和element-plus…
阅读更多...
蚁剑编码器编写——中篇

蚁剑编码器编写——中篇

看第二个示例 hex编码 木马 <?php foreach($_POST as $k > $v){$_POST[$k]pack("H*", $v);} eval($_POST[ant]); ?>pack(“H*”, $v)是将 $v 转换为为二进制&#xff0c;也就是ASCII解码 编码器 module.exports (pwd, data) > {let ret {};for (…
阅读更多...
C/C++ 代码注释规范及 doxygen 工具

C/C++ 代码注释规范及 doxygen 工具

参考 谷歌项目风格指南——注释 C doxygen 风格注释示例 ubuntu20 中 doxygen 文档生成 doxygen 官方文档 在 /Doxygen/Special Command/ 章节介绍 doxygen 的关键字 注释说明 注释的目的是提高代码的可读性与可维护性。 C 风格注释 // 单行注释/* 多行注释 */ C 风格注…
阅读更多...
ESP32 步进电机精准控制：打造高精度 DIY 写字机器人，实现流畅书写体验

ESP32 步进电机精准控制：打造高精度 DIY 写字机器人，实现流畅书写体验

摘要: 想让你的 ESP32 不再仅仅是控制灯光的工具吗&#xff1f; 本文将带你使用 ESP32 开发板、步进电机和简单的机械结构打造一个能够自动写字的机器人。我们将深入浅出地讲解硬件连接、软件代码以及控制逻辑&#xff0c;并提供完整的项目代码和电路图&#xff0c;即使是 Ardu…
阅读更多...
AI与编程：一个学生的心路历程与思考

AI与编程：一个学生的心路历程与思考

前言 大家好&#xff0c;本人是在一个在校的大学生&#xff0c;方向是前端语言。爱好是码代码和看一点小新闻&#xff0c;游戏也是喜爱的。其实本篇文章的想法是源于网上一些人对AI以及对前端的看法&#xff0c;看完网上的评论后我也是有感而发。本篇文章的讨论中心也是围绕着A…
阅读更多...
我国网络安全领域有哪些法律法规？主要内容是什么？

我国网络安全领域有哪些法律法规？主要内容是什么？

1. 背景介绍 网络信息安全方面的法规在全球范围内都有相应的立法&#xff0c;我们主要的立法有《网络安全法》、《密码法》、《数据安全法》以及《个人信息保护法》。当前也有一些相关的条例和管理办法&#xff0c;接下来就为大家一一介绍。 2. 法规介绍 在中国&#xff0c;…
阅读更多...
昇思25天学习打卡营第14天|基于MindNLP的文本解码原理

昇思25天学习打卡营第14天|基于MindNLP的文本解码原理

基于MindNLP的文本解码原理 文本解码 文本解码是自然语言处理中的一个关键步骤，特别是在任务如机器翻译、文本摘要、自动回复生成等领域。解码过程涉及将编码器（如语言模型、翻译模型等）的输出转换为可读的文本序列。以下是一些常见的文本解码方法和原理： 1. 自回归解码：…
阅读更多...
2.3.2 主程序和外部IO交互 （文件映射方式）----C#调用范例

2.3.2 主程序和外部IO交互 （文件映射方式）----C#调用范例

2.3.2 主程序和外部IO交互 &#xff08;文件映射方式&#xff09;----C#调用范例 效果显示 1 说明 1 .1 Test_IOServer是64bit 程序&#xff0c; BD_SharedIOServerd.dll 在 /Debug文件夹中 1 .2 Test_IOServer是32bit 程序&#xff0c; BD_SharedIOClientd.dll (32bit&#…
阅读更多...
安卓的组件

安卓的组件

人不走空 &#x1f308;个人主页&#xff1a;人不走空 &#x1f496;系列专栏&#xff1a;算法专题 ⏰诗词歌赋&#xff1a;斯是陋室&#xff0c;惟吾德馨 目录 &#x1f308;个人主页&#xff1a;人不走空 &#x1f496;系列专栏&#xff1a;算法专题 ⏰诗词歌…
阅读更多...
六、数据可视化—flask框架入门（爬虫及数据可视化）

六、数据可视化—flask框架入门（爬虫及数据可视化）

六、数据可视化—flask框架入门&#xff08;爬虫及数据可视化&#xff09; 1&#xff0c;数据可视化简介2&#xff0c;flask&#xff08;1&#xff09;创建flask项目&#xff08;2&#xff09;开启debug模式&#xff08;3&#xff09;通过访问路径传递参数&#xff08;4&#x…
阅读更多...
【鸿蒙学习笔记】页面布局

【鸿蒙学习笔记】页面布局

官方文档&#xff1a;布局概述 常见页面结构图 布局元素的组成 线性布局&#xff08;Row、Column&#xff09; 了解思路即可&#xff0c;更多样例去看官方文档 Entry Component struct PracExample {build() {Column() {Column({ space: 20 }) {Text(space: 20).fontSize(15)…
阅读更多...
C语言 指针和数组——指针和二维数组之间的关系

C语言 指针和数组——指针和二维数组之间的关系

目录 换个角度看二维数组 指向二维数组的行指针 按行指针访问二维数组元素 再换一个角度看二维数组 按列指针访问二维数组元素 二维数组作函数参数 指向二维数组的行指针作函数参数 指向二维数组的列指针作函数参数​编辑 用const保护你传给函数的数据 小结 换个角度看…
阅读更多...
Mysql explain语句详解与实例展示

Mysql explain语句详解与实例展示

首先简单介绍sql&#xff1a; SQL语言共分为四大类&#xff1a;数据查询语言DQL&#xff0c;数据操纵语言DML&#xff0c;数据定义语言DDL&#xff0c;数据控制语言DCL。 1. 数据查询语言DQL 数据查询语言DQL基本结构是由SELECT子句&#xff0c;FROM子句&#xff0c;WHERE子句…
阅读更多...
Kafka（一）基础介绍

Kafka（一）基础介绍

一&#xff0c;Kafka集群 一个典型的 Kafka 体系架构包括若Producer、Broker、Consumer&#xff0c;以及一个ZooKeeper集群&#xff0c;如图所示。 ZooKeeper&#xff1a;Kafka负责集群元数据的管理、控制器的选举等操作的&#xff1b; Producer&#xff1a;将消息发送到Broker…
阅读更多...
k8s学习之cobra命令库学习

k8s学习之cobra命令库学习

1.前言 打开k8s代码的时候&#xff0c;我发现基本上那几个核心服务都是使用cobra库作为命令行处理的能力。因此&#xff0c;为了对代码之后的代码学习的有比较深入的理解&#xff0c;因此先基于这个库写个demo&#xff0c;加深对这个库的一些理解吧 2.cobra库的基本简介 Git…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023