我来帮你搞定这个需求！针对从igraph提取的有向加权邻接矩阵，计算节点间共享入链的数量和权重矩阵，我们可以用矩阵运算+简单逻辑实现，下面是具体步骤和代码，完全适配你的场景：

首先我把你描述的网络转换成可运行的igraph对象，还给边加了不同权重方便演示（你可以替换成自己的边数据）：

library(igraph)

# 按你的描述构建边列表，自定义权重
edges <- data.frame(
  from = c("A", "B", "C", "C", "D"),
  to = c("C", "A", "A", "B", "A"),
  weight = c(1, 2, 3, 4, 5) # 可替换为你的实际权重
)
# 创建有向图
g <- graph_from_data_frame(edges, directed = TRUE)

这里用as_adjacency_matrix提取矩阵，注意行代表起点，列代表终点，矩阵中M[w, u]的数值就是节点w指向u的边权重，没有边则为0：

# 提取加权邻接矩阵（非稀疏格式，方便后续计算）
M <- as_adjacency_matrix(g, attr = "weight", sparse = FALSE)

共享入链数量指的是：同时有边指向节点u和v的前驱节点总数。我们可以把矩阵转成0-1矩阵（存在边为1，否则0），再通过转置矩阵相乘得到结果：

# 转成0-1矩阵（仅标记是否存在边）
M_binary <- ifelse(M > 0, 1, 0)
# 计算共享入链数量：t(M_binary) %*% M_binary 会统计每个节点对的共同前驱数
shared_in_count <- t(M_binary) %*% M_binary
# 给矩阵加上节点名称，方便识别
rownames(shared_in_count) <- colnames(shared_in_count) <- V(g)$name

这里提供两种常用的权重计算方式，你可以根据需求选择：

方式1：共享入链的权重乘积之和 #

适合衡量共同入链的"关联强度"——如果两个节点都被同一个高权重节点指向，乘积会放大这个贡献：

shared_in_weight_product <- t(M) %*% M
rownames(shared_in_weight_product) <- colnames(shared_in_weight_product) <- V(g)$name

方式2：共享入链的权重总和之和 #

直接把每个共享前驱指向两个节点的权重相加，再汇总所有共享前驱的总和：

# 初始化权重总和矩阵
shared_in_weight_sum <- matrix(
  0, 
  nrow = nrow(M), 
  ncol = ncol(M), 
  dimnames = list(V(g)$name, V(g)$name)
)
nodes <- V(g)$name

# 遍历所有节点对计算
for (u in nodes) {
  for (v in nodes) {
    # 找到同时指向u和v的前驱节点
    shared_predecessors <- which(M_binary[, u] == 1 & M_binary[, v] == 1)
    # 计算权重总和
    shared_in_weight_sum[u, v] <- sum(M[shared_predecessors, u] + M[shared_predecessors, v])
  }
}

运行上面的代码后，我们可以查看结果：

# 共享入链数量矩阵
print(shared_in_count)
#>    A B C D
#> A  3 1 0 0
#> B  1 1 0 0
#> C  0 0 1 0
#> D  0 0 0 0
# 解释：A和B共享1个入链（节点C），A自己有3个入链（B、C、D），符合你的网络结构

# 权重乘积之和矩阵
print(shared_in_weight_product)
#>    A  B  C D
#> A 38 12  0 0
#> B 12 16  0 0
#> C  0  0  1 0
#> D  0  0  0 0
# 解释：A和B的乘积和是3*4=12（C指向A的权重3，指向B的权重4），A自己的乘积和是2²+3²+5²=38

# 权重总和之和矩阵
print(shared_in_weight_sum)
#>    A  B C D
#> A 10  7 0 0
#> B  7  8 0 0
#> C  0  0 1 0
#> D  0  0 0 0
# 解释：A和B的总和是3+4=7，B自己的总和是4+4=8

如果你的图规模很大，建议用稀疏矩阵格式（sparse=TRUE）来提升计算效率，逻辑是完全一样的~

内容的提问来源于stack exchange，提问作者Filippo Santi