精华内容
下载资源
问答
  • 有序矩阵图
    千次阅读
    2016-03-24 20:17:23

    A. 问题描述

    在一个二维数组中,每一行都按照从左到右递增的顺序排序,每一列都按照从上到下递增的顺序排序。请完成一个函数,输入这样的一个二维数组和一个整数,判断数组中是否含有该整数。

    B. 问题分析

    其实笨方法有很多种啦:
    * 全部无脑遍历一次,时间复杂度为O(NM)
    * 对每行/列做二分查找,时间复杂度为O(Nlog M)
    * 好像还不够好,可以整体用二分吗?

    我们来看一个性质,对于一个N*M的如题所述的矩阵A,如果存在某个值等于要找的target值,看A的最右上角的元素key = A[0][M-1],从这个位置每步向左走或向下走,必定存在一条路径到达target。

    所以关键是如何走出这样一条路径出来?

    其实需要先对矩阵的性质有一个了解。如下图所示,注意区域2只有一个元素,就是当前矩阵的右上角的位置,很明显,区域1的所有值都是不大于key(即区域2的值),而区域4的所有值都是不小于key的,区域3的元素的值与key暂时没有明确的关系。

    不过上面的性质已经足够加快很多了!!!
    1. 如果target = key,那么就找到咯!
    2. 比如发现target > key,那么明显区域1和2都没必要继续搜索了,对不对?现在需要搜索的矩阵变成了区域3和区域4组成的新的子矩阵了!!!
    3. 反之,如果target < key,那么也很明显,区域2和区域4就没必要搜索了,接下来只需要搜索区域1和区域3组成的子矩阵即可!

    所以,总的来说,这个算法的复杂度为O(N + M),应该能够很容易分析出来吧?
    分析

    C. 代码实现

    class Solution {
    public:
        bool Find(vector<vector<int> >& array, int target) {
            if (array.empty())
                return false;
            int rowSize = array.size(), colSize = array[0].size();
            int x = 0, y = colSize - 1;
            while (check(0, rowSize, x) && check(0, colSize, y)) {
                if (target == array[x][y])
                    return true;
                else if (target < array[x][y])
                    --y;
                else
                    ++x;
            }
    
            return false;
        }
    
        bool check(int lower, int upper, int now) {
            return now >= lower && now < upper;
        }
    };

    D. 还有更快的算法吗?

    应该是有的,不过有点复杂,思路是——在对角线上做二分查找,然后递归下去,这样的话,分治收敛得更快,有兴趣的可以实现出来交流一下,我等下次回来再实现。【未完待续】


    参考:July的《编程之法》4.2节

    更多相关内容
  • 一种简单的有序抖动算法(半色调图像)
  • leetcode378. 有序矩阵中第 K 小的元素

    千次阅读 2022-03-22 15:01:28
    378. 有序矩阵中第 K 小的元素 给你一个 n x n 矩阵 matrix ,其中每行和每列元素均按升序排序,找到矩阵中第 k 小的元素。 请注意,它是 排序后 的第 k 小元素,而不是第 k 个 不同 的元素。 你必须找到一个内存...

    378. 有序矩阵中第 K 小的元素

    给你一个 n x n 矩阵 matrix ,其中每行和每列元素均按升序排序,找到矩阵中第 k 小的元素。
    请注意,它是 排序后 的第 k 小元素,而不是第 k 个 不同 的元素。

    你必须找到一个内存复杂度优于 O(n2) 的解决方案。

    示例 1:

    输入:matrix = [[1,5,9],[10,11,13],[12,13,15]], k = 8
    输出:13 解释:矩阵中的元素为
    [1,5,9,10,11,12,13,13,15],第 8 小元素是 13

    示例 2:

    输入:matrix = [[-5]], k = 1 输出:-5

    提示:

    n == matrix.length n == matrix[i].length 1 <= n <= 300
    -109 <= matrix[i][j] <= 109 题目数据 保证 matrix 中的所有行和列都按 非递减顺序 排列 1 <= k <= n2

    进阶:

    你能否用一个恒定的内存(即 O(1) 内存复杂度)来解决这个问题? 你能在 O(n)
    的时间复杂度下解决这个问题吗?这个方法对于面试来说可能太超前了,但是你会发现阅读这篇文章( this paper )很有趣。

    分析
    1,根据矩阵元素值范围二分,left=1 , right=16 , mid=8,可以发现大于8的全都在右下角,小于8的在左上角,因此可以统计左右两侧个数二分。
    2,如果小于8个数nums<=k,则right=mid,否则,left=mid+1;
    在这里插入图片描述
    code

    class Solution {
    public:
        bool check(vector<vector<int>>& matrix, int mid,int k,int n){
            int i=n-1;
            int j=0;
            int cnt=0;
            while(i>=0&&j<n){
                if(matrix[i][j]<=mid){
                    cnt+=i+1;
                    j++;
                }
                else
                    i--;
            }
            return cnt>=k;
        }
        int kthSmallest(vector<vector<int>>& matrix, int k) {
            int n=matrix.size();
            int left=matrix[0][0];
            int right=matrix[n-1][n-1];
            while(left<right){
                int mid=(left+right)>>1;
                // 如果check返回值为true,结果应该<=mid,因此这里应该保留mid
                if(check(matrix,mid,k,n)){
                    right=mid;
                }
                else{
                    left = mid + 1;
                }
            }
            return left;
        }
    };
    

    图片来源,题目来源:leetcode378

    展开全文
  • 为了将图像中内容特征相近的像素尽可能分割到同一区块,提高图像分割的针对性和自适应性,提出了一种基于有序数据聚类的图像自适应分条算法。该算法首先计算图像中所有像素点的梯度值,相加每列像素梯度值得到列累积...
  • 378、有序矩阵中第K小的元素

    千次阅读 2020-07-04 18:08:33
      由题目给出的性质可知,这个矩阵的每一行均为一个有序数组。问题即转化为从这 n 个有序数组中找第 k 大的数,可以想到利用归并排序的做法,归并到第 k 个数即可停止。 一般归并排序是两个数组归并,而本题是 nn ...

    题目:给定一个 n x n 矩阵,其中每行和每列元素均按升序排序,找到矩阵中第 k 小的元素

    归并排序

    思路及算法

      由题目给出的性质可知,这个矩阵的每一行均为一个有序数组。问题即转化为从这 n 个有序数组中找第 k 大的数,可以想到利用归并排序的做法,归并到第 k 个数即可停止。

    一般归并排序是两个数组归并,而本题是 n 个数组归并,所以需要用小根堆维护,以优化时间复杂度。

    public int kthSmallest2(int[][] matrix, int k){
    
            PriorityQueue<int[]> pq = new PriorityQueue<int[]>(new Comparator<int[]>() {
                @Override
                public int compare(int[] a, int[] b) {
                    return a[0] - b[0];
                }
            });
            int n = matrix.length;
            for (int i = 0; i < n; i++) {
                pq.offer(new int[]{matrix[i][0], i, 0});
            }
            //维护最左侧的一列最小值候选人,当有序队列弹出7个最小值,此时队列中的最小值即为所求
            for (int i = 0; i < k - 1; i++) {
                int[] now = pq.poll();
                if (now[2] != n - 1) {
                    pq.offer(new int[]{matrix[now[1]][now[2] + 1], now[1], now[2] + 1});
                }
            }
            return pq.poll()[0];
        }
    

    时间复杂度:O(klogn),归并 k 次,每次堆中插入和弹出的操作时间复杂度均为logn。
    空间复杂度:O(n),堆的大小始终为 n。

    其实解决这个问题的关键,在于维护一组“最小值候选人”
    在整个矩阵中,每次弹出矩阵中最小的值,第k个被弹出的就是我们需要的数字。

    现在我们的目的很明确:每次弹出矩阵中最小的值。你需要保证最小值必然从这组候选人中产生,于是每次只要从候选人中弹出最小的一个即可。

    我们来选择第一组候选人,在这里可以选择第一列,因为每一个数字都是其对应行的最小值,全局最小值也必然在其中。然后使用ProrityQueue有序队列来存储这一组候选人,就能保证每次从队列中弹出的都是候选人中的最小值。
    例:
      选取以下矩阵,开始的候选人为第一列,然后每次选择候选人中的最小值弹出,然后被弹出的那一行的候选人右移以为记得到该行新的候选人,当某一行的值弹完后将候选人队列中长度减1即可,知道弹出第k-1个值,此时最小值队列的值即为所求第k小的值

    步骤如下图所示:在这里插入图片描述

    二分查找

    思路及算法

    由题目给出的性质可知,这个矩阵内的元素是从左上到右下递增的(假设矩阵左上角为 matrix[0][0])。以下图为例:
    在这里插入图片描述
    我们知道整个二维数组中 matrix[0][0] 为最小值,matrix[n−1][n−1] 为最大值,现在我们将其分别记作 l 和 r。

    可以发现一个性质:任取一个数 mid 满足l≤mid≤r,那么矩阵中不大于 mid 的数,肯定全部分布在矩阵的左上角。

    例如下图,取 mid=8:
    在这里插入图片描述
    我们可以看到,矩阵中大于 mid 的数就和不大于 mid 的数分别形成了两个板块,沿着一条锯齿线将这个矩形分开。其中左上角板块的大小即为矩阵中不大于 mid 的数的数量。

    我们只要沿着这条锯齿线走一遍即可计算出这两个板块的大小,也自然就统计出了这个矩阵中不大于mid 的数的个数了。

    走法演示如下,依然取 mid=8:
    在这里插入图片描述
    可以这样描述走法:

     1、初始位置在 matrix[n−1][0](即左下角);
     2、设当前位置为 matrix[i][j]。若 matrix[i][j]≤mid,则将当前所在列的不大于 mid 的数的数量(即 i+1)累加到答案中,并向右移动,否则向上移动;
     3、不断移动直到走出格子为止。

    我们发现这样的走法时间复杂度为 O(n),即我们可以线性计算对于任意一个 mid,矩阵中有多少数不大于它。这满足了二分查找的性质。

    不妨假设答案为 x,那么可以知道 l≤x≤r,这样就确定了二分查找的上下界。

    每次对于「猜测」的答案 mid,计算矩阵中有多少数不大于mid

    如果数量不少于 k,那么说明最终答案 x 不大于 mid;
    如果数量少于 k,那么说明最终答案 x 大于 mid。
    这样我们就可以计算出最终的结果 x 了。

    public int kthSmallest3(int[][] matrix, int k){
            int n = matrix.length;
            int left = matrix[0][0];
            int right = matrix[n - 1][n - 1];
            while (left < right) {
                int mid = left + ((right - left) >> 1);
                if (check(matrix, mid, k, n)) {
                    right = mid;
                } else {
                    left = mid + 1;
                }
            }
            return left;
        }
        //判断数量是否大于k
        public boolean check(int[][] matrix, int mid, int k, int n) {
            int i = n - 1;
            int j = 0;
            int num = 0;
            while (i >= 0 && j < n) {
                if (matrix[i][j] <= mid) {
                    num += i + 1;
                    j++;
                } else {
                    i--;
                }
            }
            return num >= k;
        }
    

    时间复杂度:O(nlog(r−l)),二分查找进行次数为 O(log(r−l)),每次操作时间复杂度为 O(n)。
    空间复杂度:O(1)。

    暴力法:直接排序

    public int kthSmallest(int[][] matrix, int k) {
    
            int rows = matrix.length;
            int columns = matrix[0].length;
            int []sorted = new int[rows*columns];
            int index = 0;
            for (int[] row : matrix) {
                for (int num : row) {
                    sorted[index++] = num;
                }
            }
            Arrays.sort(sorted);
            return sorted[k-1];
        }
    

    时间复杂度:O(n^2logn),对 n^2个数排序。
    空间复杂度:O(n^2),一维数组需要存储这 n^2个数。

    暴力法容易理解,就是直接先把二维数组转换为一维数组,然后对该一维数组排序(调用Arrays.sort()函数即可),然后排序后数组中下标为k-1的值即为所求,但是这种方法没有用到有序数组的性质,而且新产生了一个n*n的一维数组,所以时间和空间复杂度都很高。

    其它方法自行查看Leetcode官方题解。
    参考:
    Leetcode题解1
    Leecode官方题解

    展开全文
  • 使用二分查找的方法,解决《378. 有序矩阵中第K小的元素》问题

    378. 有序矩阵中第K小的元素


    题目来源:力扣(LeetCode)https://leetcode-cn.com/problems/kth-smallest-element-in-a-sorted-matrix

    题目


    给定一个 n x n 矩阵,其中每行和每列元素均按升序排序,找到矩阵中第 k 小的元素。
    请注意,它是排序后的第 k 小元素,而不是第 k 个不同的元素。

    示例:

    matrix = [
       [ 1,  5,  9],
       [10, 11, 13],
       [12, 13, 15]
    ],
    k = 8,
    
    返回 13。
    

    提示:

    • 你可以假设 k 的值永远是有效的,1 ≤ k ≤ n2 。

    解题思路


    先审题,题目中给出的是二维数组,而问题需要求得的是二维数组中第 k 小的元素。在这里,最直接的方法就是将二维数组转换为一维数组,对于转换后的一维数组进行升序排序,那么此时的一维数组中的第 k 个元素就是所求的结果。代码大致如下:

    # python
    def kthSmallest(self, matrix: List[List[int]], k: int) -> int:
        res = []
        for row in matrix:
            for ele in row:
                res.append(ele)
        res.sort()
        return res[k-1]
    

    在这里,代码并没有使用矩阵的特性。而是转换为一维数组进行求解。这个解法的时间复杂度为 O(n^2logn),即是对 n x n 个数进行排序。

    因为上面的解法是将矩阵转换为一维数组,并不是在矩阵的基础上解决问题。下面使用二分查找,来尝试以在矩阵的前提下,对问题进行分析解答。

    思路:二分查找

    考虑使用二分查找的原因,因为题目中说明,矩阵中,每行每列元素都是升序排序的。

    也就是说在题目给定的矩阵当中,元素由左上到右下是递增的,以示例为基础扩充展开分析:

    示例:

    matrix = [
       [ 1,  5,  9],
       [10, 11, 13],
       [12, 13, 15]
    ],
    k = 8
    

    将上面的示例稍微扩充如下(仅为更方便展示二分查找方法的效果):

    matrix = [
       [ 1,  5,  9, 10, 11],
       [10, 11, 13, 14, 15],
       [12, 13, 15, 16, 17],
       [13, 14, 16, 17, 18],
       [14, 18, 22, 26, 30]
    ],
    k = 8
    

    将上面二维数组转换为下图:

    矩阵示图

    我们假设左上角的元素为 matrix[0][0],右下角的元素为 matrix[n-1][n-1],根据题意以及上面的示图可知。matrix[0][0] 是二维数组中的最小值,matrix[n-1][n-1] 是最大值。

    我们现在使用二分查找的方法来分析,设 matrix[0][0]matrix[n-1][n-1] 分别为 leftright

    现在我们尝试取 mid(left <= mid <= right),可以发现在矩阵当中小于等于 mid 值的元素会分布在矩阵的左上部分,而大于 mid 值的元素则分布在矩阵的右下部分。例如下图所示,此时取 mid 为 15:

    矩阵划分

    在这里大于 mid 和小于等于 mid 的元素分为两部分,沿着红色的分割线将两者分开。此时,我们就可以看到,大于 mid 和小于等于 mid 两者元素的个数分别有多少。

    上面红色分割线划分的依据,在这里进行分析:

    因为每行每列的元素都是升序排列的,我们前面的分析,元素需要与 mid 进行比较。例如,我们现在要求分布在左边部分的元素,也就是元素值小于等于 mid 的部分。

    此时我们可以考虑从左下角开始出发,往右上角去找。这样能够快速收缩范围。具体的流程如下:

    • 以左下角为起始点,往右上角开始扩散
    • 如果当前位置的元素值小于等于 mid 值时,说明从当前位置开始往上的所有元素都小于等于 mid(因为每列升序排列),记录当前元素个数 count,注意维护更新。
    • 此时满足元素值小于等于 mid 值时,向右边移动再次比较。否则,就向上移动,寻找稍小的元素进行比较,直至移动到边界。

    在这里,当取 mid 值后进行划分时,按照上面的方法,能够确定小于或等于 k 的个数,那么就会出现以下两种情况:

    • 当 count 大于或等于 k 时,那么可以确定要找的答案在 [left, mid] 这边;
    • 否则,答案在 [mid+1, right] 这个区间。

    那么根据这个思路,循环直至找到答案。

    关于二分查找方法执行流程,可看如下简略图示(若不太理解,可手画图帮忙理解):

    简略图示

    具体的代码实现如下。

    代码实现


    class Solution:
        def kthSmallest(self, matrix: List[List[int]], k: int) -> int:
            def search(mid, n):
                # 从左下角开始往右上角找
                i, j = n-1, 0
                # 统计小于或等于 mid 的元素个数
                count = 0
                while i >= 0 and j < n:
                    if matrix[i][j] <= mid:
                        # 当此时元素小于等于 mid
                        # 那么该元素往上的所有元素都会小于或等于 mid
                        count += (i + 1)
                        # 向右移动,继续比较
                        j += 1
                    else:
                        # 当此时元素大于 mid 时,说明这个元素不包含在内,往上移动
                        i -= 1
                # count 与 k 值比对,判断所求元素落在哪边
                return count >= k
            
            n = len(matrix)
    
            left, right = matrix[0][0], matrix[n-1][n-1]
    
            while left < right:
                mid = left + (right - left) // 2
                if search(mid, n):
                    # 当 count 大于等于 k 时,表明答案落在 [left, mid]
                    # 否则落在 [mid+1, right]
                    right = mid
                else:
                    left = mid + 1
            
            return left
    

    实现结果


    实现结果


    文章原创,觉得写得还可以,欢迎关注点赞。微信公众号《书所集录》同步更新,同样欢迎关注。

    qrcode_for_Demon

    展开全文
  • 利用矩阵半张量积和置换矩阵,通过博弈的支付矩阵求取势有向的邻接矩阵.通过收缩势有向中的双向圈,将单向圈的存在性问题转化为判断收缩后的中圈的存在性问题.此外,分析有序势函数的一些基本性质,并给出有序势...
  • 使用这些功能,我们扩展了递归关系,该递归关系定义了图矩阵中各个结点之间的得分矩阵中的得分。 除了SSW的标准评分功能外,GSSW还支持仿射间隙,将回溯固定到最佳的起始或结束节点,以及全长对齐的优点,可通过...
  • 该方法通过控制旋转和平移 2 个外部参数矩阵,利用已知的外部参数对内部参数进行标定,而不再同时标定外部参数.通过一维高精度移动平台精确控制标定板到镜头的物距,获得一系列有序图像,从而获得可控的高精度外部参数....
  • 稀疏(有序,无序,位,命名,一维和键控)和密集向量 稀疏和密集矩阵(行分片,列主排序) 元组(二维和三维) Java 8中lambda的所有原语上的函数 路线 字节码优化器(在下面进一步阅读) 张量 接口的更多操作和...
  • 中6*6矩阵线条所示为输出顺序,如果输出正确的话应该输出1~36有序数字。  我想的是这么做的: #include <stdio> //#define LEN 1 //#define LEN 2 //#define LEN 3 #define LEN 4 void printClock(int a[][LEN...
  • 写在前边的话:你的支持是我写作的动力,有帮助到你的话麻烦点赞加收藏呦。感激不尽!...一个有向具有有序拓扑序列,那么他的邻接矩阵必为(C) A.对称矩阵 B.系数矩阵 C.三角矩阵 D.一般矩阵 ...
  • java实现(邻接矩阵

    千次阅读 2022-01-06 16:56:37
    一、的知识点: 二、的实现(都包含在Graph类中) 三、的遍历(包含在类Graph中) (一) 深度优先遍历 (二) 广度优先遍历 一、的知识点: 1. 的概念:是由顶点集合及顶点间的关系集合组成的一...
  • 有序矩阵: 每一行都按照从左到右递增的顺序排序,每一列都按照从上到下递增的顺序排序。 有序查找用二分法较快,借用一张说明思路:(原地址: http://justjavac.iteye.com/blog/1310178 ) ...
  • 运行程序时,会创建一个带有多个选项卡的excel,每个选项卡包含排列成矩阵的数据列,矩阵的末尾分别是平均值、最大值和最小值的行。 然后是百分位矩阵,第一行对应50%,第二行对应75%,第三行对应95%。 4. ...
  • 一、关系矩阵 、 二、关系矩阵示例 、 三、关系矩阵性质 、 四、关系矩阵运算 、 五、关系 、 六、关系示例 、 七、关系表示相关性质 、
  • 是不同于树的另一种非线性数据结构。在树结构中,数据元素之间存在着一种层次结构的关系,每一层上的数据元素可以和下一层的多个数据元素相关,但只能和上一层的单个数据元素相关。也就是说,树结构的数据元素之间...
  • 图图的定义有向概念模板邻接矩阵邻接表无向概念模板邻接矩阵邻接表简单完全 的定义 GGG 由顶点集 VVV 和边集 EEE 组成,记为 G=(V,E)G=(V,E)G=(V,E),其中 V(G)V(G)V(G) 表示 GGG 中顶点的有限非空集...
  • 1)、邻接矩阵 2)、邻接表 是除了树之外的另一大类非线性表数据结构,应对到现实生活中有大量的应用,比如微博、微信、QQ等怎么表示其好友关系,关注、被关注(粉丝),亲密度等;地图出行,怎么查询到一个地方...
  • 特里斯坦·乌塞尔2018 年 8 月 autocorrmat = imageautocorr(im_stack) autocorrmat = imageautocorr(mat_data) ... 'autocorrmat' 是一个自相关矩阵,给出数据的任意两个时间点之间的归一化相关系数 (-1 <
  • 数据结构-的创建(邻接矩阵,邻接表)C语言实现

    千次阅读 多人点赞 2020-06-04 18:54:59
    的定义: (Graph)G由两个集合V和E组成,记为:G=(V,E)...是有序的,表示它从V到W的一条有向边。所以,<W,V>表示的和<V,W>不同的边,顶点的指向不同。有向中顶点对用尖括号表示<>,<x,y>
  • 有序抖动 任意大小的Bayer矩阵(只要尺寸是2的幂) 簇状点-许多不同的预编程矩阵 一些异常的水平或垂直线矩阵 你的? 使用PixelMapperFromMatrix ,该库可以使用任何矩阵抖动 如果需要更多自由度,可以使用...
  • 的一些基本知识:,邻居,度矩阵,邻接矩阵

    万次阅读 多人点赞 2020-03-07 19:29:18
    目录前言(graph)邻居(neighborhood)度矩阵(degree)邻接矩阵(adjacency)参考文献 前言       本文介绍了一些图论的基础知识,包括的表示、邻接矩阵、度矩阵等(边不带权值的情况),本文...
  • 无向的邻接矩阵(数组表示法)

    千次阅读 2021-10-30 08:39:07
    的逻辑结构:多对多 ...表示有序,或存在一条边,从i到j,用()表示无序,那矩阵下标为ij的元素arcs[i][j]就为1,若不存在,就记为0,这就是邻接矩阵的定义 来看无向的例子:这个邻接矩阵...
  • 一文掌握有序logistic回归分析

    万次阅读 2020-08-28 17:12:31
    Logistic回归分析(logit回归)一般可分为3类,分别是二元logistic回归分析、多分类Logistic回归分析和有序Logistic回归分析。logistic回归分析类型如下所示。 Logistic回归分析用于研究X对Y的影响,并且对X...
  • 的表示形式:邻接矩阵和邻接表

    千次阅读 2021-03-21 08:48:40
    有向:在有向中,一条边由一对有序的顶点(i,j)表示,其中边起源于顶点i并终止于顶点j。下面给出的是有向的示例。 :D.1 无向:在无向中,边由无序顶点对表示。下面给出了无向的示例。 :...
  • 带你了解有向无环和拓扑排序

    千次阅读 2020-04-09 19:19:42
    在图论中,如果一个有向无法从某个顶点出发经过若干条边回到该点,则这个是一个有向无环(DAG)。而提到DAG,就差不多会联想到拓扑排序,拓扑排序是指由某个集合上的一个偏序得到该集合上的一个全序的操作。...
  • pcl有序点云分析

    千次阅读 2021-08-08 13:58:13
    在工作和学习中,只要是与点云打交道,那基本离不开pcl(point cloud library),点云pcd文件是我们最常接触到的文件,它的数据组织形式,可以分为有序(HEIGHT字段不为1)和无序两种(HEIGHT字段为1),对于有序点云...
  • Python矩阵图表

    2020-03-21 17:28:46
    1、多个变量,一起展示,形成n*n矩阵 2、默认情况下,PairGrid 只能展示数值变量 g = sb.PairGrid(data = df, vars = ['num_var1', 'num_var2', 'num_var3']) #直方放在对角线 g.map_diag(plt.hist) #其余的放置...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 30,073
精华内容 12,029
热门标签
关键字:

有序矩阵图

友情链接: 1.zip