Thread Distanzmatrix erstellen (8 answers)
Opened by Perl-Beginner at 2011-10-24 17:32

topeg
 2011-10-24 19:42
#153517 #153517
User since
2006-07-10
2611 Artikel
BenutzerIn

user image
suchst du so was?:
more (19.4kb):
Code (perl): (dl )
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
#!/usr/bin/perl
use strict;
use warnings;
use Data::Dumper;

my %HoA = (
    root=>['A', 'B'],
    A=>['C', 'D'],
    B=>['E', 'F'],
    C=>['G', 'H'],
    D=>['I'],
    G=>['K'],
    E=>['J'],
  );

my ($tree,$names)=make_tree(\%HoA,'root');
$tree={'root' => $tree};

print Dumper($tree);

my @list=make_list($tree);

#print Dumper(\@list);

my @nn=@$names;
while(my $name=shift(@nn))
{
  for my $nn (@nn)
  {
    my $dist=make_diff(\@list,$name,$nn);
    print "dist $name <> $nn => $dist\n";
  }
}


########################################################################
sub make_tree
{
  my $data=shift;
  my $node=shift;
  return '',[$node] unless(exists($data->{$node}));
  my $ref={};
  my @names=($node);
  for my $name (@{$data->{$node}})
  {
    my $nn;
    ($ref->{$name},$nn)=make_tree($data,$name);
    push(@names,@$nn);
  }
  return $ref,\@names;
}

sub make_list
{
  my $tree=shift;
  my @lst;
  for my $node (keys(%$tree))
  {
    push(@lst,[$node]);
    if(ref($tree->{$node}))
    {
      my @ret=make_list($tree->{$node});
      push(@lst,[$node,@$_]) for(@ret);
    }
  }
  return @lst;
}

sub make_diff
{
  my $list=shift;
  my $name1=shift;
  my $name2=shift;
  my $l1;
  my $l2;
  for my $elm (@list)
  {
    $l1=$elm if($elm->[-1] eq $name1);
    $l2=$elm if($elm->[-1] eq $name2);
    last if($1 and $l2);
  }
  return -1 if(!$l1 or !$l2);

  my $size=$#$l1+$#$l2+1;

  my $p=0;
  while($p<$#$l1 and $p<$#$l2)
  {
    if($l1->[$p] eq $l2->[$p])
    { $size-=2; }
    else
    { last; }
    $p++;
  }

  $size-- if($p==$#$l1 || $p==$#$l2);
  return $size;
}


Ausgabe:
Code: (dl )
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
$VAR1 = {
'root' => {
'A' => {
'D' => {
'I' => ''
},
'C' => {
'H' => '',
'G' => {
'K' => ''
}
}
},
'B' => {
'F' => '',
'E' => {
'J' => ''
}
}
}
};
dist root <> A => 1
dist root <> C => 2
dist root <> G => 3
dist root <> K => 4
dist root <> H => 3
dist root <> D => 2
dist root <> I => 3
dist root <> B => 1
dist root <> E => 2
dist root <> J => 3
dist root <> F => 2
dist A <> C => 1
dist A <> G => 2
dist A <> K => 3
dist A <> H => 2
dist A <> D => 1
dist A <> I => 2
dist A <> B => 0
dist A <> E => 1
dist A <> J => 2
dist A <> F => 1
dist C <> G => 1
dist C <> K => 2
dist C <> H => 1
dist C <> D => 0
dist C <> I => 1
dist C <> B => 1
dist C <> E => 3
dist C <> J => 4
dist C <> F => 3
dist G <> K => 1
dist G <> H => 0
dist G <> D => 1
dist G <> I => 3
dist G <> B => 2
dist G <> E => 4
dist G <> J => 5
dist G <> F => 4
dist K <> H => 1
dist K <> D => 2
dist K <> I => 4
dist K <> B => 3
dist K <> E => 5
dist K <> J => 6
dist K <> F => 5
dist H <> D => 1
dist H <> I => 3
dist H <> B => 2
dist H <> E => 4
dist H <> J => 5
dist H <> F => 4
dist D <> I => 1
dist D <> B => 1
dist D <> E => 3
dist D <> J => 4
dist D <> F => 3
dist I <> B => 2
dist I <> E => 4
dist I <> J => 5
dist I <> F => 4
dist B <> E => 1
dist B <> J => 2
dist B <> F => 1
dist E <> J => 1
dist E <> F => 0
dist J <> F => 1

View full thread Distanzmatrix erstellen