javascript - 如何存储对称矩阵表的数据？

Question

我会尽量解释我的问题。我需要以与矩阵表类似的方式存储一些数据，但需要使用代码。

我们以一个简单的表格为例:

我对此的第一个想法是创建一个 JS 对象来存储所有可能性，如下所示:

const Y = 'Yellow';
const R = 'Red';
const W = 'White';
const P = 'Pink';

const data = {
   Y: { Y: Y, R: Y, W: Y },
   R: { Y: Y, R: R, W: P }, 
   W: { Y: Y, R: P, W: W }
};

console.log(data['W']['R']); // 'Pink'

但考虑到我会有更多的可能性，这显然是不可维护的。

我也可以像这样减小对象的大小，但又怕难以维护:

const data = {
   Y: { Y: Y, R: Y, W: Y },
   R: { R: R, W: P }, 
   W: { W: W }
};

问题听起来很简单，但我找不到另一种方法来存储此类数据。有更好的方法吗？

---

另外，我想补充一点，我在这里使用了 JS，因为我更熟悉这种语言，但我必须将它与 PHP 一起使用，以防万一它有很大的不同。

Answer 1

最紧凑的表示形式是单个数组中的三 Angular 矩阵，除非您真的空间不足，否则我不推荐这样做。

function triMatrix(n) { // not really needed
    return new Array(n * (n + 1) / 2);
}

function trindex(row, col) {
    if (col > row) {
        var tmp = row; row = col; col = tmp;
    }
    return row * (row + 1) / 2 + col;
}

function triStore(tri, indexOfKey, rowKey, colKey, value) {
    tri[trindex(indexOfKey[rowKey], indexOfKey[colKey])] = value;
}

function triGet(tri, indexOfKey, rowKey, colKey) {
    return tri[trindex(indexOfKey[rowKey], indexOfKey[colKey])];
}

const keyOfIndex = ['Y', 'R', 'W'];
const indexOfKey = {'Y': 0, 'R': 1, 'W': 2}; // can be calculated
const N = keyOfIndex.length;
var tri = triMatrix(N); // could also be var tri = [];
triStore(tri, indexOfKey, 'Y', 'Y', 'Y');
triStore(tri, indexOfKey, 'Y', 'R', 'Y');
triStore(tri, indexOfKey, 'Y', 'W', 'Y');
triStore(tri, indexOfKey, 'R', 'R', 'R');
triStore(tri, indexOfKey, 'R', 'W', 'P');
triStore(tri, indexOfKey, 'W', 'W', 'W');
tri; // => [ "Y", "Y", "R", "Y", "P", "W" ]
triGet(tri, indexOfKey, 'R', 'W'); // => "P"
triGet(tri, indexOfKey, 'W', 'R'); // => "P"

重点是:您的矩阵是对称的，因此您只需要其上三 Angular 矩阵或下三 Angular 矩阵(包括对 Angular 线)。在您的建议中，您存储上三 Angular 矩阵，在我的建议中，我存储下三 Angular 矩阵，因为索引计算要简单得多。该数组将包含第 1 行的 1 个元素、第 2 行的 2 个元素、第 3 个元素的第 3 行等等。只要记住 1+2+...+n=n(n+1)/2 你就会明白如何计算数组索引。

M₀₀ M₀₁ M₀₂      M₀₀              T₀
M₁₀ M₁₁ M₁₂  =>  M₁₀ M₁₁      =>  T₁  T₂      =>  T₀ T₁ T₂ T₃ T₄ T₅
M₂₀ M₂₁ M₂₂      M₂₀ M₂₁ M₂₂      T₃  T₄  T₅

矩阵很容易扩展 1 行/列，不需要重新索引数组:

M₀₀ M₀₁ M₀₂ M₀₃      M₀₀                  T₀
M₁₀ M₁₁ M₁₂ M₁₃      M₁₀ M₁₁              T₁  T₂
M₂₀ M₂₁ M₂₂ M₂₃  =>  M₂₀ M₂₁ M₂₂      =>  T₃  T₄  T₅      => T₀ ... T₆ T₇ T₈ T₉
M₃₀ M₃₁ M₃₂ M₃₃      M₃₀ M₃₁ M₃₂ M₃₃      T₆  T₇  T₈  T₉

---

作为练习，我将上面的内容粗略地翻译成 PHP，这是您的目标语言。尽管我一开始不推荐“单个数组中的三 Angular 矩阵”方法，但欢迎您使用以下类作为黑盒，如果它符合您的需要(如果不符合，也许我可以提供帮助)。

class SymmetricMatrix
{
    private $n = 0;
    private $triangular = [];
    private $key_of_index = [];
    private $index_of_key = [];

    private function add_key_if_necessary($key) {
        if ( !isset($this->index_of_key[$key])) {
            $index = $this->n++;
            $this->index_of_key[$key] = $index;
            $this->key_of_index[$index] = $key;
            for ($i = 0; $i < $this->n; $i++) {
                $this->triangular[] = false; // avoid "jumping" index & init to "absent"
            }
        }
    }

    private static function trindex($row, $col) {
        if ($col > $row) {
            $tmp = $row; $row = $col; $col = $tmp;
        }
        return $row * ($row + 1) / 2 + $col;
    }

    public function put($key1, $key2, $value) {
        $this->add_key_if_necessary($key1);
        $this->add_key_if_necessary($key2);
        $trindex = self::trindex($this->index_of_key[$key1], $this->index_of_key[$key2]);
        $this->triangular[$trindex] = $value;
    }

    public function get($key1, $key2) {
        if (!isset($this->index_of_key[$key1]) || !isset($this->index_of_key[$key2])) {
            return false;
        }
        $trindex = self::trindex($this->index_of_key[$key1], $this->index_of_key[$key2]);
        return $this->triangular[$trindex];
    }

    public function find_first($value) { // $value !== false
        for ($row = 0; $row < $this->n; $row++) {
            for ($col = 0; $col <= $row; $col++) {
                $trindex = trindex($row, $col);
                if ($this->triangular[$trindex] === $value) {
                    return [$this->key_of_index[$row], $this->key_of_index[$col]];
                }
            }
        }
        return false;
    }

    public function get_keys() {
        return $this->key_of_index;
    }

    public function dump() {
        var_export($this);
        echo "\n";
    }
}

$m = new SymmetricMatrix();
$m->put('Y', 'Y', 'Y');
$m->put('Y', 'R', 'Y');
$m->put('Y', 'W', 'Y');
$m->put('R', 'R', 'R');
$m->put('R', 'W', 'P');
$m->put('W', 'W', 'W');
$m->dump();
echo "keys: ", implode(', ', $m->get_keys()), "\n";
echo "m[R][W]: ", $m->get('R', 'W'), "\n";
echo "m[W][R]: ", $m->get('W', 'R'), "\n";