Question

我能够解决那些每行只有1个字符串的测试用例的问题。但如果单行中有多个字符串，我就会失败。

例如：

测试用例类型1：

大矩阵：

小矩阵：

9505
3845
3530

我通过了这些测试用例，因为Big Matrix内最多发生一次9505。

测试用例类型：2

Big Matrix：

7652157548860692421022503
9283597467877865303553675
4160389485250089289309493
2583470721457150497569300
3220130778636571709490905
3588873017660047694725749
9288991387848870159567061
4840101673383478700737237
8430916536880190158229898
8986106490042260460547150
2591460395957631878779378
1816190871689680423501920
0704047294563387014281341
8544774664056811258209321
9609294756392563447060526
0170173859593369054590795
6088985673796975810221577
7738800757919472437622349
5474120045253009653348388
3930491401877849249410013
1486477041403746396925337
2955579022827592919878713
2625547961868100985291514
3673299809851325174555652
4533398973801647859680907

小矩阵：

我在这些类型的测试用例中失败，其中5250（或小矩阵中的任何其他行）在同一行较大矩阵内出现不止一次：

以下是我写的代码：

import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;


public class Solution {

    public static void main(String[] args) {

      HashMap<Integer,Integer> rowCol=new HashMap();      
      Scanner in = new Scanner(System.in);
        int t = in.nextInt();
        for(int a0 = 0; a0 < t; a0++){
            //bigger array
            int R = in.nextInt();
            int C = in.nextInt();
            String G[] = new String[R];
            for(int G_i=0; G_i < R; G_i++){
                G[G_i] = in.next();
            }
            //smaller array
            int r = in.nextInt();
            int c = in.nextInt();
            String P[] = new String[r];
            for(int P_i=0; P_i < r; P_i++){
                P[P_i] = in.next();
            }

          for(int i = 0;i<R-r;i++)//obvious
            {
              for(int j = 0; j<r;j++ )//obvious
                {
                  //if string found put in map(row at which found,column at whch found)
                  if(G[i].indexOf(P[j])>=0)//string found
                    {
                      rowCol.put(i,G[i].indexOf(P[j]));
                    }
                }
            }

          //now check if rows are consecutive(1,2,3) and columns are equal(1,1,1)
          HashSet<Integer> mc = new HashSet<Integer>(rowCol.values());//if size==1 then same column
          ArrayList<Integer> mr = new ArrayList<Integer>(rowCol.keySet());
          int count = 0;
          for(int m = 0 ;m<mr.size()-1;m++)//checking if keys are consecutive
            {

              if(mr.get(m)+1==mr.get(m+1))
                {
                  count++;//how many values are same ,hw mny strings found at same index
                }
            }

          //System.out.println(count+"+++++"+(mr.size()-1));
          //System.out.println( rowCol.values().size()+"==="+r);

          if(mc.size()==1 && count==(mr.size()-1) && rowCol.keySet().size()==r)//all column same && all rows are consecutive && 
            {
              System.out.println("YES");
            }
          else
            {
              System.out.println("NO");
            }


        }


    }
}

Answer 1

你的逻辑错了。

  for(int i = 0;i<R-r;i++)//obvious
    {
      for(int j = 0; j<r;j++ )//obvious
        {
          //if string found put in map(row at which found,column at whch found)
          if(G[i].indexOf(P[j])>=0)//string found
            {
              rowCol.put(i,G[i].indexOf(P[j]));
            }
        }
    }

这遍历了G中的所有行和P的所有行。如果P的那一行存在于G的那一行，它将被放置在地图中。

但首先，它只告诉你来自P的某些行在G的那一行，它不会告诉你哪一行。这意味着当你正在寻找一个像现有矩阵但不同线条顺序的小矩阵时，它也会失败。

其次，如果G行中的小矩阵有多行，它将保持P的下行索引。也就是说，如果你在G中的同一行同时有5250和7660 ，它将只保留7660的索引并忽略5250。

ArrayList<Integer> mr = new ArrayList<Integer>(rowCol.keySet());

您正在使用mr检查连续的行，但是您正在使用HashMap中的密钥集填充它。这意味着订单无法保证 - 您可以按照5,3,1,2,4或其他任何顺序获取行号。

你应该用不同的逻辑编写你的程序。不要试图收集所有线路的所有位置。找到P的第一行的位置，并立即检查其余部分是否到位。假设您在第30行的第15行找到了第一行P.然后检查第2行是否在索引15的第31行，如果第3行在第32行是第15行，依此类推。

如果全部匹配，请打印＆＃34; YES＆＃34;和从方法返回。不要继续循环。但如果不是全部匹配，请继续寻找P [0]。

请注意，在G中的同一行中可能存在多个P [0]。因此，如果匹配失败，则继续在G的同一行中搜索，直到不再出现P [0]，并且然后才移到G的下一行。
如果您没有找到任何匹配项，那么在循环结束时您可以打印＆＃34; NO＆＃34;。

在更大的2D阵列中查找2D数组

1 个答案: