如何在shell中的有向图中快速求和值？

Question

我有一个有2000个节点的有向图存储在一个文件中。 每行表示从存储在第一列中的节点到存储在第二列中的节点的边缘，甚至可以容易地将数据可视化，例如在点（1）中 。 列由制表符分隔，行由换行符分隔，节点以任何a-zA-Z0-9_字符命名。 树可以有多个根，它可能有循环，应该被忽略。 我不关心周期，它们是多余的，但它们可以在输入中发生。 下面我将展示一个图形示例，其中tr用于替换选项卡和here-document的空格，以便于重现输入文件：

tr ' ' '\t' <<EOF >connections.txt
str1 str2
str2 str3
str3 str4
str100 str2
str100 str101
str101 str102
EOF

我还有一个图表中某个节点的列表，名为heads。 这些将是起始节点，即。 头：

tr ' ' '\t' <<EOF >heads.txt
str1
str100
EOF

我还有一个与每个节点相关的“成本”列表。 一些随机数据的示例：

tr ' ' '\t' <<EOF >cost.txt
str1 1
str2 5
str3 10
str4 548
str100 57
str101 39
str102 23
EOF

我想在从head.txt中存储的节点遍历树时总结每个节点的“成本”，并使用每个叶子的一些遍历信息打印成本。

我想要：

• 对于heads.txt中的每个节点
  • 将节点的cost.txt中的成本加到某个变量中
  • 在connections.txt中找到该节点
  • 找到此节点连接的内容
  • 并为节点连接的每个节点重复算法
  • 当节点没有连接时，打印成本总和

理想情况下，脚本看起来像：

$ script.sh heads.txt connections.txt cost.txt
str1->str2->str3->str4    1+5+10+548   564
str100->str2->str3->str4  57+5+10+548  620
str100->str101->str102    57+39+23     119

我甚至写过这个，它有效：

#!/bin/bash
set -euo pipefail

headsf=$1
connectionsf=$2
costf=$3


get_cost() {
    grep "^$1"$'\t' "$costf" | cut -f2 || echo 0
}

get_conn() {
    grep "^$1"$'\t' "$connectionsf" | cut -f2
}

check_conns() {
    grep -q "^$1"$'\t' "$connectionsf"
}

f_output() {
    printf "%s\t%s\n" "$1" "$2"
}

f() {
    local func cost
    func="$1"
    cost=$(get_cost "$func")

    if ! check_conns "$func"; then
        f_output "${2:+$2->}$func" "${3:+$3+}$cost"
        return
    fi

    get_conn "$func" |
    while IFS=$'\t' read -r calls; do
        if [ "$func" = "$calls" ]; then
            echo "$func is recursive" >&2
            continue
        fi
        if <<<"$2" grep -q -w "$calls"; then
            printf "$2 calls recursive $calls\n" >&2
            continue
        fi

        f "$calls" "${2:+$2->}$func" "${3:+$3+}$cost"
    done
}

while IFS= read -r head; do
    f "$head" "" ""
done < "$headsf" |
while IFS=$'\t' read -r func calc; do
    tmp=$(<<<$calc bc)
    printf "%s\t%s\t%s\n" "$func" "$calc" "$tmp"
done | 
column -t -s $'\t'

然而，对于更大的投入来说，这是不可能的慢。 即使这里有示例文件（只有6行），脚本在我的机器上需要200ms。 我怎样才能加快速度？ 可以对输入进行排序，以某种方式加入以加快输入（grep并不关心输入是否已排序）？ 这可以在awk或其他unix工具中更快地完成吗？

我想限制自己使用bash shell和标准* unix工具，coreutils，moreutils，datamash等。 我尝试在awk中做，但失败了，我不知道如何在awk的输入中递归地找到一些东西。 这对我来说在shell脚本中的“可行”非常快。

Answer 1

由于还没有人发布答案，这里有一个awk解决方案作为起点：

#!/usr/bin/awk -f
BEGIN {
  FS=OFS="\t"
}
FILENAME=="connections.txt" {
  edges[$1,++count[$1]]=$2
  next
}
FILENAME=="cost.txt" {
  costs[$1]=$2
  next
}
FILENAME=="heads.txt" {
  f($1)
}

function f(node,
    path,cost,sum,prev,sep1,sep2,i) {
  if(node in prev)
    # cycle detected
    return

  path=path sep1 node
  cost=cost sep2 costs[node]
  sum+=costs[node]

  if(!count[node]) {
    print path,cost,sum
  }
  else {
    prev[node]
    for(i=1;i<=count[node];++i)
      f(edges[node,i],path,cost,sum,prev,"->","+")
    delete prev[node]
  }
}

让它在cost.txt之前读取connections.txt和heads.txt 。
它的输出（填充）：

$ awk -f tst.awk connections.txt cost.txt heads.txt
str1->str2->str3->str4     1+5+10+548     564
str100->str2->str3->str4   57+5+10+548    620
str100->str101->str102     57+39+23       119

Answer 2

你说你只想要标准工具，但你也提到在你的数据上使用dot ，所以我假设你有其他的graphviz实用程序可用...特别是gvpr ，就像图表的awk ：

#!/usr/bin/env bash

graph=$(mktemp)

join -t$'\t' -j1 -o 0,1.2,2.2 -a2 \
     <(sort -k1,1 connections.txt) \
     <(sort -k1,1 cost.txt) |
    awk -F$'\t' 'BEGIN { print "digraph g {" }
         { printf "%s [cost = %d ]\n", $1, $3
           if ($2 != "") printf "%s -> %s\n", $1, $2  }
         END { print "}" }' > "$graph"

while read root; do
    gvpr -a "$root" '
BEGIN {
      int depth;
      int seen[string];
      string path[int];
      int costs[int];
}
BEG_G {
      $tvtype = TV_prepostfwd;
      $tvroot = node($, ARGV[0]);
}
N {
  if ($.name in seen) {
     depth--;
  } else {
    seen[$.name] = 1;
    path[depth] = $.name;
    costs[depth] = $.cost;
    depth++;
    if (!fstout($) && path[0] == ARGV[0]) {
       int i, c = 0;
       for (i = 0; i < depth - 1; i++) {
         printf("%s->", path[i]);
       }
       printf("%s\t", $.name);
       for (i = 0; i < depth - 1; i++) {
         c += costs[i];
         printf("%d+", costs[i]);
       }       
       c += $.cost;
       printf("%d\t%d\n", $.cost, c);
    }
  }
}' "$graph"
done < heads.txt

rm -f "$graph"

在创建数据文件后运行此命令：

$ ./paths.sh
str1->str2->str3->str4  1+5+10+548  564
str100->str2->str3->str4    57+5+10+548 620
str100->str101->str102  57+39+23    119

---

或者，因为它无处不在，它可能是标准的，基于sqlite的解决方案。 与上面不同，这个甚至不需要bash / zsh / ksh93。

$ sqlite3 -batch -noheader -list <<EOF
.separator "\t"
CREATE TABLE heads(node TEXT);
.import heads.txt heads
CREATE TABLE costs(node TEXT PRIMARY KEY, cost INTEGER) WITHOUT ROWID;
.import cost.txt costs
CREATE TABLE connections(from_node TEXT, to_node TEXT
                       , PRIMARY KEY(from_node, to_node)) WITHOUT ROWID;
.import connections.txt connections
WITH RECURSIVE paths(tail, path, costs, cost) AS
 (SELECT h.node, h.node, c.cost, c.cost
  FROM heads AS h
  JOIN costs AS c ON h.node = c.node
  UNION ALL
  SELECT conn.to_node, p.path || '->' || conn.to_node
       , p.costs || '+' || c.cost, p.cost + c.cost
  FROM paths AS p
  JOIN connections AS conn ON conn.from_node = p.tail
  JOIN costs AS c ON c.node = conn.to_node
 )
SELECT path, costs, cost FROM paths AS p
WHERE tail NOT IN (SELECT from_node FROM connections)
ORDER BY path;
EOF
str1->str2->str3->str4  1+5+10+548  564
str100->str101->str102  57+39+23    119
str100->str2->str3->str4    57+5+10+548 620