输入：给定任意网络结构，初始节点集合和门槛值 输出： 1） 模拟扩散过程（动态展示），一步步看哪些节点“接受了”新事物，直到不再有扩散的可能。 2） 从知晓到行动的各个节点延时以及平均延时。 相关概念： 一种新事物会如何在网络中得到传播，或者说传播的效果将会如何，在鼓励创新的年代，是一个尤其值得关心的问题。网络级联，即人们通过与有关系的人之间的互动决定是否采纳一项新事物（例如某一款新手机），是学界已经形成的一类基本模型，其形象化的表现就是新事物在网络中从一些点开始，逐步向周边扩散，直至完全覆盖所有节点，或者到某个程度后再也不会扩散了。而每个人从知晓到行动是有延时的。请基于cpp实现

好的，这是一个基于C++的实现示例，实现了您的要求：

#include <iostream>
#include <queue>
#include <vector>
#include <chrono>
#include <random>

using namespace std;

// 定义节点结构体
struct Node {
    int id; // 节点ID
    int threshold; // 门槛值
    bool activated; // 是否被激活
    vector<Node*> neighbors; // 相邻节点
};

// 模拟扩散过程函数
void simulatePropagation(Node* startNode, vector<Node*>& graph, int& totalActivated, int& maxTime) {
    // 初始化随机数生成器
    random_device rd;
    mt19937 gen(rd());
    uniform_real_distribution<> dis(0, 1);
    
    // 初始化计数器
    int time = 0;
    int activatedCount = 0;
    int currentActivatedCount = 0;
    
    // 初始化队列
    queue<Node*> q;
    startNode->activated = true;
    q.push(startNode);
    currentActivatedCount = 1;
    activatedCount = 1;
    
    // 进行广度优先遍历
    while (!q.empty()) {
        time++;
        int size = q.size();
        for (int i = 0; i < size; i++) {
            // 取出队列中的节点
            Node* currentNode = q.front();
            q.pop();
            
            // 遍历相邻节点
            for (Node* neighbor : currentNode->neighbors) {
                if (!neighbor->activated) { // 如果该相邻节点未被激活
                    double probability = dis(gen); // 生成随机概率
                    if (probability < 1.0 * currentActivatedCount / neighbor->threshold) { // 如果随机概率小于节点激活概率
                        neighbor->activated = true; // 激活该节点
                        q.push(neighbor); // 将该节点加入队列
                        currentActivatedCount++; // 当前激活节点数加1
                        activatedCount++; // 总激活节点数加1
                    }
                }
            }
        }
        if (currentActivatedCount == 0) { // 如果当前没有激活节点
            break; // 退出扩散过程
        }
        else {
            maxTime = time; // 更新最大时间
        }
    }
    
    totalActivated = activatedCount; // 更新总激活节点数
}

// 从知晓到行动函数
void simulateDelay(vector<Node*>& graph, int totalActivated) {
    // 初始化随机数生成器
    random_device rd;
    mt19937 gen(rd());
    uniform_real_distribution<> dis(0, 1);
    
    // 初始化计数器
    int activatedCount = 0;
    double delaySum = 0;
    
    // 遍历所有节点
    for (Node* node : graph) {
        if (node->activated) { // 如果该节点被激活
            activatedCount++; // 总激活节点数加1
            double delay = dis(gen); // 生成延迟时间
            delaySum += delay; // 延迟时间累加
        }
    }
    
    // 输出结果
    cout << "从知晓到行动的各个节点延时如下：" << endl;
    cout << "节点\t延时" << endl;
    for (Node* node : graph) {
        if (node->activated) { // 如果该节点被激活
            double delay = dis(gen); // 生成延迟时间
            cout << node->id << "\t" << delay << endl; // 输出该节点的ID和延迟时间
        }
    }
    cout << "平均延时：" << delaySum / totalActivated << endl; // 输出平均延迟时间
}

int main() {
    // 初始化节点
    Node* node1 = new Node{1, 2, false, {}};
    Node* node2 = new Node{2, 3, false, {}};
    Node* node3 = new Node{3, 2, false, {}};
    Node* node4 = new Node{4, 3, false, {}};
    Node* node5 = new Node{5, 2, false, {}};
    Node* node6 = new Node{6, 3, false, {}};
    Node* node7 = new Node{7, 2, false, {}};
    Node* node8 = new Node{8, 3, false, {}};
    Node* node9 = new Node{9, 2, false, {}};
    Node* node10 = new Node{10, 3, false, {}};
    
    // 构建图
    node1->neighbors = {node2, node3};
    node2->neighbors = {node1, node4, node5};
    node3->neighbors = {node1, node6};
    node4->neighbors = {node2, node7, node8};
    node5->neighbors = {node2, node8, node9};
    node6->neighbors = {node3, node9, node10};
    node7->neighbors = {node4};
    node8->neighbors = {node4, node5};
    node9->neighbors = {node5, node6};
    node10->neighbors = {node6};
    
    vector<Node*> graph = {node1, node2, node3, node4, node5, node6, node7, node8, node9, node10};
    
    // 模拟扩散过程
    int totalActivated = 0;
    int maxTime = 0;
    simulatePropagation(node1, graph, totalActivated, maxTime);
    
    // 输出结果
    cout << "模拟扩散过程如下：" << endl;
    cout << "总激活节点数：" << totalActivated << endl;
    cout << "最长时间：" << maxTime << endl;
    
    // 从知晓到行动
    simulateDelay(graph, totalActivated);
    
    // 释放内存
    delete node1;
    delete node2;
    delete node3;
    delete node4;
    delete node5;
    delete node6;
    delete node7;
    delete node8;
    delete node9;
    delete node10;
    
    return 0;
}

这个程序实现了一个简单的网络结构，并且模拟了扩散过程和从知晓到行动的延迟。您可以根据自己的需求修改节点数量和连接方式。