一个php的面试题，大家看看
```
$listData = [
    '111' => ['a', 'b', 'c', 'a'],
    '222' => ['d', 'e', 'f', 'f', 'b'],
    '333' => ['g', 'h'],
    '444' => ['i', 'j'],
    ...
];
```
定义一个函数，传入$listData
如果`111`里面的元素，和 222/333/444... 里面的元素有重复，返回false 
如果`222`里面的元素，和 111/333/444... 里面的元素有重复，返回false 
如果`333`里面的元素，和 111/222/444... 里面的元素有重复，返回false 
如果 ... 
允许 111/222/333/444 自己里面的元素重复，返回true  
其他情况返回true
已知:
$listData长度未知
111/222/333/444... 的长度未知
111/222/333/444... 里的元素为字符串和数字
我自己实现了一下，感觉算法很糟，请问有没有其他方法
```
function test ($array) {

    $tempValueList  = [];
    foreach ($array as $key => $valueList) {
        
        foreach ($valueList as $value) {
            
            $tempValueList[]    = $key . '~' . $value;
        }
    }
    $result         = true;
    foreach ($array as $key => $valueList) {
        
        foreach ($valueList as $value) {
            
            foreach ($tempValueList as $_value) {
                
                $pos    = strpos($_value, '~');
                $_key   = substr($_value, 0, $pos);
                $_val   = substr($_value, $pos + 1);

                if ($key == $_key) {

                    continue;
                }
                if ($_val == $value) {

                    $result = false;
                    break 3;
                }
            }
        }
    }

    return      $result;
}
```
我对子数组的定义是像 ['a', 'b', 'c', 'a'] 这样的单个数组。
我的答案：
```
$result = array();
foreach ($listData as $line) {
    //子数组内部去重,再组装回原来的格式
    $result[] = array_unique($line);
}

//子数组先去重再合并的结果数量 和 先合并子数组再去重的结果数量 做比较。
//如果是相同的，意味着不存在跨子数组的重复，只存在子数组内部重复，所以`True`
var_dump(count(array_merge(...$result)) === count(array_unique(array_merge(...$listData))));
```
我这个答案调用系统函数次数比较多，看起来简洁一些，但是PHP array_xxx 这类函数很大一部分性能是不具备优势的，如果不用这些函数，能相对程度提高运行效率。
另外，想要在各种情形下都能保持最高效率，可以参考以下代码。
```function check($arr)
{
  $chk = [];
  foreach ($arr as $k => $v)
    foreach ($v as $i)
    {
      if (isset($chk[$i] && $chk[$i] != $k))
        return false;
      $chk[$i] = $k;
    }
  return true;
}```
方便理解的辅助参考信息：
原始数据：
```
$listData = [
    '111' => ['a', 'b', 'c', 'a'],
    '222' => ['d', 'e', 'f', 'f', 'b'],
    '333' => ['g', 'h'],
    '444' => ['i', 'j']
];

```
然后 $result 最终是这样的：
```
$listData = [
        '111' => ['a', 'b', 'c'],
        '222' => ['d', 'e', 'f', 'b'],
        '333' => ['g', 'h'],
        '444' => ['i', 'j']
];

```
子数组先去重再合并的结果
```
Array
(
    [0] => a
    [1] => b
    [2] => c
    [3] => d
    [4] => e
    [5] => f
    [6] => b
    [7] => g
    [8] => h
    [9] => i
    [10] => j
)

```
用于和上面进行数量（数组元素数量）比较的，所谓的“先合并子数组再去重的结果”：
```
Array
(
    [0] => a
    [1] => b
    [2] => c
    [4] => d
    [5] => e
    [6] => f
    [9] => g
    [10] => h
    [11] => i
    [12] => j
)
```