Question

对于从1到A * B的所有不同数字的A * B矩阵，我们首先对每列进行排序，然后按索引的递增顺序连接所有列，以形成大小为A * B的数组。列的编号增加从左到右订购。

例如，如果矩阵是

[1 5 6] [3 2 4]

我们首先对所有列进行排序以获取

[1 2 4] [3 5 6]

现在，我们按索引的递增顺序连接列以获取数组

[1,3,2,5,4,6]

鉴于此最终数组，您必须计算可能有多少不同的初始矩阵。返回所需答案模10 ^ 9 + 7。

如果符合以下情况，两个矩阵是不同的： - 它们的尺寸不同。 - 或者两个矩阵中的任何相应行是否不同。

示例：

如果输入数组为[1,3,2,4]，则可能的不同初始矩阵为：

[1 3 2 4]

============

[1 2]

[3 4]

=============

[1 4]

[3 2]

===========

[3 2]

[1 4]

===========

[3 4]

[1 2]

===========

即总共5个矩阵。

这是做了什么的：我发现了我们可以在每个大小的子阵列（len / 2）中排列值的方法。所以如果一个数组是[1,2,3,4] 我们有两个子阵列[1,2]和[3,4]。所以答案是2！* 2！。我们必须得到唯一的行。这就是我的代码失败的地方。你能指导我正确的方向吗？这是我的代码;

 public int cntMatrix(ArrayList<Integer> a) {
    if(a.size()==1){
        return 1;
    }

    int n=a.size();
    int len=n/2;
    int i=0;
    long ans=1;
    if(n%2!=0){  //n is odd

        ans=fact(n); //factorial function

    }else{

    while(i<n){

        int x=i;
        int y=i+len;

        HashMap<Integer,Integer> map=new HashMap<>(); //frequency of each element in subarray[x..y]

        for(int m=i;m<y;m++){

            if(map.containsKey(a.get(m))){
                map.put(a.get(m),map.get(a.get(m))+1);
            }else{
                map.put(a.get(m),1);
            }
        }

        long p=fact(len);
        long q=1;
     for(Map.Entry<Integer,Integer> set:map.entrySet()){
            int key=set.getKey();
            int value=set.getValue();
            q*=fact(value);
        }

        ans*=p/q;   //ncr

        map.clear();
        i+=len;
    }
    }
    ans%=1000000007;
    return ((int)ans+1);
}

如何处理独特的行

在interviewbit.com上提问

Answer 1

我注意到的一件事是你检查长度是否为奇数。

这是不对的，例如，如果长度为9，你可以安排一个足以满足条件的3x3矩阵。

我认为你应该尝试'＃34; cut＆＃34;将数组放入大小为1 - n的列中，并为每个大小检查它是否可以是初始矩阵。我的算法的复杂性是O（n ^ 2），虽然我觉得有更好的算法。

这是我的python代码 -

class Solution:
# @param A : list of integers
# @return an integer
def cntMatrix(self, A):
    count = 0
    n = len(A)
    # i = number of rows
    for i in range(1, n + 1):
        if n % i == 0:
            can_cut = True
            start = 0
            while start < len(A) and can_cut:
                prev = 0
                for j in range(start, start + i):
                    if prev > A[j]:
                        can_cut = False
                    prev = A[j]
                start += i

            if can_cut:
                count = (count + pow(math.factorial(i), n / i)) % (pow(10, 9) + 7)

    return count

我没有在他们的网站上查看它，因为问题页面已经找不到了，我只在忍者测试中看到它。

跑完后 -

s = Solution()
print(s.cntMatrix([1, 2, 3, 1, 2, 3, 1, 2, 3]))

我们得到 - 217 = 3！ * 3！ * 3！ + 1

Answer 2

class Solution:
# @param A : list of integers
# @return an integer
def cntMatrix(self, A):
    self.factCache = {}
    bucket = 1
    buckets = []
    while bucket <= len(A):
        if len(A) % bucket == 0:
            buckets.append(bucket)
        bucket += 1
    valid_buckets = []
    for bucket in buckets:
        counter = 1
        invalid = False
        for i in range(1, len(A)):
            if counter == bucket:
                counter = 1
                continue
            if A[i] > A[i - 1]:
                counter += 1
            else:
                invalid = True
                break
        if not invalid:
            valid_buckets.append(bucket)
    combs = 0
    for bucket in valid_buckets:
        rows = bucket
        columns = int(len(A)/rows)
        combs += (self.fact(rows) ** columns)
    return combs % 1000000007
def fact(self, number):
    if number == 0 or number == 1:
        return 1
    fact = 1
    for i in range(1, number + 1):
        fact = fact * i
    return fact

不同的初始矩阵

2 个答案: