blocks|key|2213747|text|它涉及到对矩阵的预处理。这将沉重的内存，但它应该是更好的计算时间。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2213748|检查之前，检查子矩阵的大小是否小于矩阵的大小。|unordered-list-item|2213749|在构造矩阵时，构建一个构造，将矩阵中的值映射到矩阵中的(x，y)位置数组。这将允许您检查是否存在一个候选可以存在的子矩阵。您将在子矩阵中使用(0,0)的值，并得到该值在较大矩阵中的可能位置。如果职位列表为空，则没有候选人，因此子矩阵不存在。这是一个开始(然而，更有经验的人可能认为这是一种天真的方法)。|offset|length|style|BOLD|2213750|2213751|2213752|entityMap^0|0|0|1G|2|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$]]|$1|E|3|F|5|D|7|Q|8|@$G|R|H|S|I|J]]|9|@]|A|$]]|$1|K|3|-4|5|6|7|T|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|N|$]]

It involves preprocessing the matrix. This will be heavy on memory, but it should be better in terms of computation time.

<ul>
<li>Check if the size of the sub-matrix is less than that of the matrix before you do the check.</li>
<li>While constructing the matrix, build a construct that maps a value in the matrix to an array of (x,y) positions in the matrix. This will allow you to check for the existence of a sub-matrix where candidates could exist. You would use the value at (0,0) in the sub-matrix and get the possible positions of this value in the larger matrix. If the list of positions is empty, you have no candidates, and so, the sub-matrix does not exist. There's a start (More experienced people might consider this a naive approach however).</li>
</ul>

blocks|key|3247695|text|如果要多次查询同一个大矩阵和相同大小的子矩阵，请执行以下操作。大矩阵的预处理有很多种解决方案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3247696|这里有一个类似的(甚至相同的)问题。|3247697|Fastest+way+to+Find+a+m+x+n+submatrix+in+M+X+N+matrix|offset|length|3247698|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/10529278/fastest-way-to-find-a-m-x-n-submatrix-in-m-x-n-matrix^0|0|0|0|1H|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@$F|S|G|T|1|U]]|A|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

If you want to query multiple times for a same big matrix and same size submatrices. There are many solutions to preprocess the big matrix.

A similar ( or even same ) problem is here.

<a href="https://stackoverflow.com/questions/10529278/fastest-way-to-find-a-m-x-n-submatrix-in-m-x-n-matrix">Fastest way to Find a m x n submatrix in M X N matrix</a>

blocks|key|2213767|text|因为你只想知道给定的矩阵是否在另一个大矩阵中。如果您知道如何使用C%2B%2B中的Matlab代码，则可以直接使用Matlab中的ismember。另一种方法可能是在Matlab中尝试找出ismember是如何工作的，然后在C%2B%2B中实现相同的内容。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2213768|请参阅Find+location+of+submatrix|2213769|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/15084991/how-to-find-all-locations-of-a-sub-matrix-of-the-given-matrixbut-the-same-canno^0|1P|8|0|3|Q|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|S|8|@]|D|@$9|T|A|U|1|V]]|E|$]]|$1|H|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|I|$J|$5|K|L|M|E|$N|O]]]]

Since you only want to know whether a given matrix is inside another big matrix. If you know how to use Matlab code from C++, you may directly use <code>ismember</code> from Matlab. Another way may be try to figure out how ismember works in Matlab, then implement the same thing in C++.

See <a href="https://stackoverflow.com/questions/15084991/how-to-find-all-locations-of-a-sub-matrix-of-the-given-matrixbut-the-same-canno">Find location of submatrix</a>

blocks|key|3053070|text|由于您也将问题标记为C%2B%2B，所以我提供了这段代码。这是一种蛮力技术，绝对不是解决这个问题的理想方法。对于S+X+T主矩阵和M+X+N子矩阵，算法的时间复杂度为O(STMN)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3053071|cout<<"\nEnter+the+order+of+the+Main+Matrix";
cin>>S>>T;
cout<<"\nEnter+the+order+of+the+Sub+Matrix";
cin>>M>>N;

//+Read+the+Main+Matrix+into+MAT[S][T]

//+Read+the+Sub+Matrix+into+SUB[M][N]

for(i=0;+i<(S-M);+i%2B%2B)
{
+++for(j=0;+j<(T-N);+j%2B%2B)
+++{
++++++flag=0;
++++++for(p=0;+p<M;+p%2B%2B)
++++++{
+++++++++for(q=0;+q<N;+q%2B%2B)
+++++++++{
++++++++++++if(MAT[i%2Bp][j%2Bq]+!=+SUB[p][q])
++++++++++++{
+++++++++++++++flag=1;
+++++++++++++++break;+
++++++++++++}
+++++++++}
+++++++++if(flag==0)
+++++++++{
++++++++++++cout<<"Match+Found+in+the+Main+Matrix+at+starting+location+"<<(i%2B1)+<<"X"<<(j%2B1);
++++++++++++break;
+++++++++}
++++++}
++++++if(flag==0)
++++++{
+++++++++break;
++++++}
+++}++++++++++++
+++if(flag==0)
+++{
++++++break;
+++}
}+|code-block|syntax|javascript|3053072|entityMap^0|A|3|1G|5|1P|5|27|7|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]|$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|L|$]]

Since you have tagged the question as <code>C++</code> also, I am providing this code. This is a brute force technique and definitely not the ideal solution for this problem. For an <code>S X T</code> Main Matrix and a <code>M X N</code> Sub Matrix, the time complexity of the algorithm is <code>O(STMN)</code>.

<pre><code>cout&lt;&lt;"\nEnter the order of the Main Matrix";
cin&gt;&gt;S&gt;&gt;T;
cout&lt;&lt;"\nEnter the order of the Sub Matrix";
cin&gt;&gt;M&gt;&gt;N;

// Read the Main Matrix into MAT[S][T]

// Read the Sub Matrix into SUB[M][N]

for(i=0; i&lt;(S-M); i++)
{
 for(j=0; j&lt;(T-N); j++)
 {
 flag=0;
 for(p=0; p&lt;M; p++)
 {
 for(q=0; q&lt;N; q++)
 {
 if(MAT[i+p][j+q] != SUB[p][q])
 {
 flag=1;
 break; 
 }
 }
 if(flag==0)
 {
 cout&lt;&lt;"Match Found in the Main Matrix at starting location "&lt;&lt;(i+1) &lt;&lt;"X"&lt;&lt;(j+1);
 break;
 }
 }
 if(flag==0)
 {
 break;
 }
 } 
 if(flag==0)
 {
 break;
 }
} 
</code></pre>

blocks|key|3247992|text|修正的deepu-benson代码
|type|blockquote|depth|inlineStyleRanges|entityRanges|data|3247993|unstyled|3247994|int+Ma[][5]=+{
++++++++{0,+0,+1,+0,+0},
++++++++{0,+0,+1,+0,+0},
++++++++{0,+1,+0,+0,+0},
++++++++{0,+1,+0,+0,+0},
++++++++{1,+1,+1,+1,+0}
++++};


++++int+Su[][3]=+{
++++++++{1,+0,+0},
++++++++{1,+0,+0},


++++};

++++int+S+=+5;//+Size+of+main+matrix+row
++++int+T+=+5;//Size+of+main+matrix+column
++++int+M+=+2;+//+size+of+desire+matrix+row
++++int+N+=+3;+//+Size+of+desire+matrix+column

int+flag,+i,j,p,q;

for(i=0;+i<=(S-M);+i%2B%2B)
{
+++for(j=0;+j<=(T-N);+j%2B%2B)
+++{
++++++flag=0;
++++++for(p=0;+p<M;+p%2B%2B)
++++++{
+++++++++for(int+q=0;+q<N;+q%2B%2B)
+++++++++{
++++++++++++if(Ma[i%2Bp][j%2Bq]+!=+Su[p][q])
++++++++++++{
+++++++++++++++flag=1;

+++++++++++++++break;
++++++++++++}
+++++++++}
++++++}
++++++if(flag==0)
++++++{
+++++++++++printf("Match+Found+in+the+Main+Matrix+at+starting+location+%25d,+%25d",(i%2B1)+,(j%2B1));
+++++++++break;
++++++}
+++}
+++if(flag==0)
+++{
++++++++printf("Match+Found+in+the+Main+Matrix+at+starting+location+%25d,+%25d",(i%2B1)+,(j%2B1));
++++++break;
+++}
}|code-block|syntax|javascript|3247995|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|-4|5|C|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|C|7|N|8|@]|9|@]|A|$]]]|J|$]]

<blockquote>
 Modified Code of deepu-benson
</blockquote>

<pre><code>int Ma[][5]= {
 {0, 0, 1, 0, 0},
 {0, 0, 1, 0, 0},
 {0, 1, 0, 0, 0},
 {0, 1, 0, 0, 0},
 {1, 1, 1, 1, 0}
 };


 int Su[][3]= {
 {1, 0, 0},
 {1, 0, 0},


 };

 int S = 5;// Size of main matrix row
 int T = 5;//Size of main matrix column
 int M = 2; // size of desire matrix row
 int N = 3; // Size of desire matrix column

int flag, i,j,p,q;

for(i=0; i&lt;=(S-M); i++)
{
 for(j=0; j&lt;=(T-N); j++)
 {
 flag=0;
 for(p=0; p&lt;M; p++)
 {
 for(int q=0; q&lt;N; q++)
 {
 if(Ma[i+p][j+q] != Su[p][q])
 {
 flag=1;

 break;
 }
 }
 }
 if(flag==0)
 {
 printf("Match Found in the Main Matrix at starting location %d, %d",(i+1) ,(j+1));
 break;
 }
 }
 if(flag==0)
 {
 printf("Match Found in the Main Matrix at starting location %d, %d",(i+1) ,(j+1));
 break;
 }
}
</code></pre>

blocks|key|2213943|text|我最初的答案是在断点下面，想一想有几个优化，这些优化指的是最初答案的步骤。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2213944|对于步骤B)，不要搜索整个S：您可以折扣所有不允许F适合的列和行。(在下面的示例中，只搜索左上角的2x2矩阵)。在F占S的很大一部分的情况下，这将节省大量时间。|offset|length|style|CODE|2213945|如果S中的值范围很小，那么创建查找表将大大减少步骤B所需的时间)。|2213946|2213947|使用这两个矩阵|2213948|发现|2213949|📷|atomic|2213950|内部|2213951|2213952|​|2213953|(+A)从较小的矩阵中选择一个值：|2213954|2213955|2213956|2213957|(+B)在更大的范围内定位|2213958|2213959|2213960|2213961|(+C)检查相邻单元格是否匹配|2213962|2213963|2213964|unordered-list-item|2213965|2213966|2213967|2213968|2213969|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://developer.qcloudimg.com/http-save/yehe-900000/26e47c5cecd7295ef7b5b8d7570e9f11.png|imageAlt|1|https://developer.qcloudimg.com/http-save/yehe-900000/81bc29d14dceef87f32aced78df985ee.png|2|https://developer.qcloudimg.com/http-save/yehe-900000/048792db1ce16208e4776e669b84815c.png|3|https://developer.qcloudimg.com/http-save/yehe-900000/eb03b251ec6f47a39e3badb8fd59a168.png|4|https://developer.qcloudimg.com/http-save/yehe-900000/ffaaa29d52c3855d8e65c0f1e38b9b2d.png|5|https://developer.qcloudimg.com/http-save/yehe-900000/56986f52f3e986be15d91d5c0e047ecd.png^0|0|D|1|P|1|1L|1|1N|1|0|2|1|0|0|0|0|0|1|0|0|0|0|1|1|0|0|0|0|0|1|2|0|0|0|0|0|1|3|0|0|0|0|0|1|4|0|0|0|0|0|1|5|0|0^^$0|@$1|2|3|4|5|6|7|1Z|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|20|8|@$D|21|E|22|F|G]|$D|23|E|24|F|G]|$D|25|E|26|F|G]|$D|27|E|28|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|29|8|@$D|2A|E|2B|F|G]]|9|@]|A|$]]|$1|J|3|-4|5|6|7|2C|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|2D|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|2E|8|@]|9|@]|A|$]]|$1|O|3|P|5|Q|7|2F|8|@]|9|@$D|2G|E|2H|1|2I]]|A|$]]|$1|R|3|S|5|6|7|2J|8|@]|9|@]|A|$]]|$1|T|3|P|5|Q|7|2K|8|@]|9|@$D|2L|E|2M|1|2N]]|A|$]]|$1|U|3|V|5|6|7|2O|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|2P|8|@]|9|@]|A|$]]|$1|Y|3|V|5|6|7|2Q|8|@]|9|@]|A|$]]|$1|Z|3|P|5|Q|7|2R|8|@]|9|@$D|2S|E|2T|1|2U]]|A|$]]|$1|10|3|V|5|6|7|2V|8|@]|9|@]|A|$]]|$1|11|3|12|5|6|7|2W|8|@]|9|@]|A|$]]|$1|13|3|V|5|6|7|2X|8|@]|9|@]|A|$]]|$1|14|3|P|5|Q|7|2Y|8|@]|9|@$D|2Z|E|30|1|31]]|A|$]]|$1|15|3|V|5|6|7|32|8|@]|9|@]|A|$]]|$1|16|3|17|5|6|7|33|8|@]|9|@]|A|$]]|$1|18|3|V|5|6|7|34|8|@]|9|@]|A|$]]|$1|19|3|P|5|Q|7|35|8|@]|9|@$D|36|E|37|1|38]]|A|$]]|$1|1A|3|-4|5|1B|7|39|8|@]|9|@]|A|$]]|$1|1C|3|-4|5|6|7|3A|8|@]|9|@]|A|$]]|$1|1D|3|-4|5|6|7|3B|8|@]|9|@]|A|$]]|$1|1E|3|P|5|Q|7|3C|8|@]|9|@$D|3D|E|3E|1|3F]]|A|$]]|$1|1F|3|V|5|6|7|3G|8|@]|9|@]|A|$]]|$1|1G|3|-4|5|6|7|3H|8|@]|9|@]|A|$]]]|1H|$1I|$5|1J|1K|1L|A|$1M|1N|1O|-4]]|1P|$5|1J|1K|1L|A|$1M|1Q|1O|-4]]|1R|$5|1J|1K|1L|A|$1M|1S|1O|-4]]|1T|$5|1J|1K|1L|A|$1M|1U|1O|-4]]|1V|$5|1J|1K|1L|A|$1M|1W|1O|-4]]|1X|$5|1J|1K|1L|A|$1M|1Y|1O|-4]]]]

My original answer is below the break, thinking about it there are several optimisations, these optimisations refer to the steps of the original answer.

For Step B) do not search the entirety of <code>S</code>: you can discount all columns and rows which would not allow <code>F</code> to fit. (in the below example, only search the upper left 2x2 matrix). In cases where <code>F</code> is a significant proportion of <code>S</code> this would save considerable time.

If the range of values within <code>S</code> is quite low then creating a lookup table would greatly reduce the time required for step B).

<hr>

Working with these 2 matrices

find<img src="https://i.stack.imgur.com/t3Ryz.png" alt="mat2"> inside <img src="https://i.stack.imgur.com/s4K8O.png" alt="mat1">

A) Select one value from the smaller matrix:

<img src="https://i.stack.imgur.com/DWf9V.png" alt="mat4">

B) locate it within the larger

<img src="https://i.stack.imgur.com/gsurP.png" alt="mat3">

C) Check the adjacent cells to see if they match

<img src="https://i.stack.imgur.com/gMGqG.png" alt="mat6"> - <img src="https://i.stack.imgur.com/P04zB.png" alt="mat5">

blocks|key|3247942|text|答案在很大程度上取决于你在重复做什么。你是为了同一个子矩阵测试一堆巨大的矩阵吗？你在测试一个巨大的矩阵，寻找一堆不同的子矩阵吗？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3247943|是否有任何矩阵有重复的模式，或者它们是好的和随机的，或者你不能对数据不作任何假设？|3247944|另外，子矩阵必须是连续的吗？S是否包含|3247945|F3+=+1+3
+++++7+9|code-block|syntax|javascript|3247946|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|O|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|P|8|@]|9|@]|A|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Much of the answer depends on what you're doing repetitively. Are you testing a bunch of huge matrices for the same submatrix? Are you testing one huge matrix looking for a bunch of different submatrices?

Do any of the matrices have repetitive patterns, or are they nice and random, or can you make no assumptions about the data?

Also, does the submatrix have to be contiguous? Does S contain

<pre><code>F3 = 1 3
 7 9
</code></pre>

blocks|key|2214048|text|如果矩阵中的数据不是随机分布的，那么对其进行一些统计分析是有帮助的。然后，你可以通过比较它的元素的逆概率来找到子矩阵。它可能会更快，然后是一个普通的野蛮人。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2214049|比如说，你有一个正态分布整数的矩阵，它的高斯中心是0。你想要找到子矩阵就说：|2214050|1+3+-12
-3+43+-1
198+2+2|code-block|syntax|javascript|2214051|您必须开始搜索198，然后检查右上元素为43，然后它的右上角为-12，然后任何3或-3都可以，依此类推。与最残酷的解决方案相比，这将大大减少比较的数量。|2214052|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

If the data in matrix isn't randomly distributed, it would be helpful to run some statistical analysis on it. Then you could find the sub matrix by comparing its element ranged by their inverse probability. It could be faster, then a plain bruteforce.

Say, you have the matrix of some normally distributed integers with the Gaussian center in 0. And you want to find submatrix say:

<pre><code>1 3 -12
-3 43 -1
198 2 2
</code></pre>

You have to start searching for 198, then checking upper right element to be 43 then its upper right for -12, then any 3 or -3 will do; and so on. This would greatly reduce the number of comparisons comparing to the most brutal solution.

blocks|key|3053113|text|在O(N*M*(logN%2BlogM))中可以这样做。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3053114|等式可以表示为平方差之和为0：|3053115|sum[i,j](square(S(n%2Bi,m%2Bj)-F(i,j)))=0
sum[i,j]square(S(n%2Bi,m%2Bj))%2Bsum[i,j](square(F(i,j))-2*sum[i,j](S(n%2Bi,m%2Bj)*F(i,j))=0|code-block|syntax|javascript|3053116|第一部分可以对O(N*M)中的所有(n，m)进行类似于运行平均值的计算。|3053117|第二部分按通常的O((F))计算，小于O(N*M)。|3053118|第三部分是最有趣的部分。它的卷积可以用快速傅里叶变换algorithms在O(N*M*(algorithms))中计算。|3053119|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Convolution#Fast_convolution_algorithms|1^0|1|I|0|0|0|0|0|Q|A|0|18|A|1|0^^$0|@$1|2|3|4|5|6|7|11|8|@$9|12|A|13|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|14|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|15|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|16|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|17|8|@]|D|@]|E|$]]|$1|Q|3|R|5|6|7|18|8|@]|D|@$9|19|A|1A|1|1B]|$9|1C|A|1D|1|1E]]|E|$]]|$1|S|3|-4|5|6|7|1F|8|@]|D|@]|E|$]]]|T|$U|$5|V|W|X|E|$Y|Z]]|10|$5|V|W|X|E|$Y|Z]]]]

It's possible to do in <code>O(N*M*(logN+logM))</code>.

Equality can be expressed as sum of squared differences is 0:

<pre><code>sum[i,j](square(S(n+i,m+j)-F(i,j)))=0
sum[i,j]square(S(n+i,m+j))+sum[i,j](square(F(i,j))-2*sum[i,j](S(n+i,m+j)*F(i,j))=0
</code></pre>

First part can be calculated for all (n,m) in O(N*M) similarly to running average.

Second part is calculated as usual in O(sizeof(F)) which is less than O(N*M).

Third part is the most interesting. It's convolution which can be calculated in O(N*M*(logN+logM)) using Fast Fourier Transform: <a href="http://en.wikipedia.org/wiki/Convolution#Fast_convolution_algorithms" rel="nofollow">http://en.wikipedia.org/wiki/Convolution#Fast_convolution_algorithms</a>

I have a very large <code>n*m</code> matrix <code>S</code>. I want to efficiently determine whether there exists a submatrix <code>F</code> inside of <code>S</code>. The large matrix <code>S</code> can have a size as big as <code>500*500</code>.

To clarify, consider the following:

<pre><code>S = 1 2 3 
 4 5 6
 7 8 9

F1 = 2 3 
 5 6

F2 = 1 2 
 4 6
</code></pre>

In such a case:

<ul>
<li><code>F1</code> is inside <code>S</code></li>
<li><code>F2</code> is not inside <code>S</code></li>
</ul>

Each element in the matrix is a <code>32-bit</code> integer. I can only think of using a brute-force approach to find whether <code>F</code> is a submatrix of <code>S</code>. I googled to find an effective algorithm, but I can't find anything.

Is there some algorithm or principle to do it faster? (Or possibly some method to optimize the brute force approach?)

PS the statistics data

<pre><code>A total of 8 S
On average, each S will be matched against about 44 F.
The probability of success match (i.e. F appears in a S) is 
19%.
</code></pre>

find a matrix in a big matrix

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

EdgeOne AI 安全实战专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云AI代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

功能1上新10个字符

功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符。

功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符。

功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符

功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符

功能4上新

文章&问答评论现已支持表情

全新交互，全新视觉，新增快捷键、悬浮工具栏、高亮块等功能并同时优化现有功能，全面提升创作效率和体验

社区富文本编辑器全新改版！诚邀体验～ 

精选全网热门MCP server，让你的AI更好用 🚀

💥开发者 MCP广场重磅上线！

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

我有一个很大的n*m矩阵S。我想有效地确定在F中是否存在子矩阵S。大矩阵S的大小可以和500*500一样大。为澄清这一问题，请考虑以下几点：S = 1 2 3     4 5 6    7 8 9F1 = 2 3      5 6F2 = 1 2      4 6在这种情况下：F1在S里面F2不在S里面矩阵中的每个元素都是32-bit整数。我只能用蛮力的方法来找出F是否是S的子矩阵。我在谷歌上搜索

问在一个大矩阵中找到一个矩阵
EN

回答 9

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在一个大矩阵中找到一个矩阵EN

回答 9

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在一个大矩阵中找到一个矩阵
EN