Arranging The Sheep

这篇博客介绍了如何运用贪心策略解决一个计算机科学中的问题:最小化移动羊使得羊群聚集的步骤数。文章通过读取输入的字符串,计算每只羊与中间羊的距离,并计算总移动次数。核心思想是选取中间羊为基准,让其他羊向其靠拢,从而达到最少移动次数。代码实现中,涉及到了字符串处理、向量操作和绝对值计算等编程概念。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

题目大意:移动羊使得羊在一起,输出最少的移动次数
思路:贪心选定中间的羊,让两边的羊向中间靠拢。
代码实现:
向量v中存储的是从最左边到该羊之间存在多少空格。所以相减得到的是两只羊之间存在的空格数量。两只羊u,v之间的某只羊移动并不会改变两只羊u,v之间的空格。

#include <bits/stdc++.h>
using namespace std;
#define ll long long
int main(){
    int _;
    scanf("%d",&_);
    while(_--){
        int n,cur=0;
        string s;
        vector<int> v;
        cin>>n;
        cin>>s;
        for(auto i:s){
            if(i=='.') ++cur;
            else v.push_back(cur);
        }
        if(v.empty()){
            cout<<'0'<<endl;
            continue;
        }
        int m=v[v.size()/2];
        ll ans = 0;
        for(auto k:v){
            cout<<k<<" ";
            ans += abs(k-m);
        }
        cout<<endl<<ans<<endl;
    }
    return 0;
}
<think>嗯,用户让我写一个程序来判断两个矩形网格上的图案是否通过特定的变换可以相互转换。这个问题看起来像是需要处理旋转、反射等几何变换后的图案比较。首先,我需要理解题目要求的具体步骤。 题目中提到,变换的顺序很重要,必须按照保持、90度旋转、180度旋转、270度旋转、垂直反射、反射后旋转90、180、270度的顺序来检查。所以,我需要为每一种变换生成对应的变换后的图案,然后与原图案比较,看是否有匹配的。 接下来,我需要考虑如何表示这些变换。例如,对于一个二维数组表示的网格,旋转90度可以通过转置矩阵然后反转每一行来实现。垂直反射则是将每一行进行反转。旋转180度可以看作是两次90度旋转,或者直接反转行和列的顺序。同理,其他变换也需要对应的操作。 然后,程序需要读取两个输入图案,对第一个图案应用所有可能的变换,每次变换后与第二个图案比较。如果其中任何一个变换后的结果与第二个图案相同,就返回对应的变换类型。否则,说明无法通过简单变换得到。 需要注意的是,输入格式的处理。用户可能会输入由字符组成的网格,比如用'.'和'X'表示不同的位置。读取时可能需要处理多行的输入,每一行代表网格的一行。要确保两个网格的行列数相同,否则直接判定不匹配。 另外,比较两个图案是否相同时,必须每个对应位置的字符都完全一致。所以在变换生成后,要逐个字符检查是否相等。 可能的难点在于正确实现所有变换的算法,尤其是旋转和反射的组合。例如,反射后的旋转需要先进行垂直反射,然后再进行相应的旋转操作。需要确保变换的顺序正确,避免逻辑错误。 测试用例方面,可以考虑几个典型情况,比如原图不变、旋转后的结果、反射后的结果,以及组合变换的情况。例如,用户提到的八皇后问题的例子,不同的变换可能导致相同的图案被归为同一类。 最后,程序的结构大概可以分为:读取输入、生成所有变换后的图案、按顺序比较、输出结果。为了提高效率,可以先生成第一个图案的所有可能变换,然后逐一与第二个图案比较,一旦找到匹配就立即返回结果,不需要继续检查后面的变换。 需要注意的是,输入的网格可能不是方阵,比如行数和列数不同的情况,这时候旋转后的维度会变化吗?例如,一个m×n的矩阵旋转90度后会变成n×m的矩阵。如果原图案和第二个图案的行列数不满足对应的变换后的尺寸,那么该变换可以直接跳过。例如,原图是3×4的,旋转90度后应该是4×3的,如果第二个图案不是4×3的,那么旋转后的比较就没有必要进行,直接跳过。 因此,在比较之前,首先要检查两个图案的尺寸是否符合当前变换的要求。比如,保持变换下,行列数必须相同;旋转90或270度时,原图的行数必须等于目标图的列数,原图的列数等于目标图的行数;旋转180度时,行列数必须相同;垂直反射同样需要行列数相同。对于反射后的旋转,同样需要考虑变换后的尺寸是否与目标图匹配。 这可能会增加一些复杂度,需要针对每个变换检查尺寸是否匹配,否则直接跳过。例如,在检查90度旋转时,如果原图是m×n,而目标图是n×m,否则无法通过该变换得到,直接跳过该变换的比较。 因此,程序的逻辑大致如下: 1. 读取两个图案A和B。 2. 检查是否完全相同(保持),如果是,返回preservation。 3. 否则,检查B是否是A旋转90度的结果。此时需要A的行数等于B的列数,A的列数等于B的行数。如果满足,生成A旋转90度后的图案,比较是否与B相同。 4. 继续按顺序检查其他变换,每个变换前先检查尺寸是否允许,若不允许则跳过。 5. 如果所有变换都不匹配,则返回不匹配。 这要求每个变换函数能够处理不同尺寸的网格,并正确生成变换后的网格。 现在,具体实现方面,如何表示图案?例如,用列表的列表,或者字符串的列表。例如,每个图案是一个二维数组,每个元素是字符。 例如,对于旋转90度,可以先将矩阵转置,然后反转每一行。例如,原矩阵的行i会变成转置后的列i,然后反转每一行,即相当于顺时针旋转90度。 例如,原矩阵: A B C D E F 转置后变成: A D B E C F 然后反转每一行(每行变为D A, E B, F C),所以整体变为: D A E B F C 这相当于原矩阵顺时针旋转90度后的结果。此时,原矩阵是2行3列,旋转后是3行2列。 所以,当处理旋转时,需要生成正确的变换后的矩阵,并且比较尺寸是否符合目标矩阵。 其他变换如垂直反射,就是将每一行反转。例如,原行是ABC,反射后是CBA。 反射后的旋转,比如,先反射,再旋转90度,这相当于另一种变换组合。 因此,每个变换对应的函数需要正确生成变换后的图案。 现在,编写代码的大致步骤: 1. 读取两个图案。假设输入是逐行输入的,每个图案由n行组成,每行有m个字符。读取时需要确定每个图案的行数和列数。 例如,输入可能如下: 3 ..X. X.X. ..X. 然后另一个图案。但需要具体看输入格式如何。假设用户输入每个图案的行数,然后是各行字符。 不过,题目中的输入格式可能需要更明确的处理。例如,每个图案可能由n行组成,每行m个字符。所以,读取时,先读取n行,每行去掉可能的换行符,得到每个图案的矩阵。 例如,第一个图案可能有n行,每行m个字符,第二个图案同样。 读取后,比较两个图案的尺寸是否可能通过某种变换匹配。例如,对于保持变换,必须行列相同;对于旋转90度,原行列交换;反射后的旋转也是如此。 所以,在代码中,对于每个变换,生成变换后的图案,然后比较是否与目标图案相同。 可能的代码结构: 函数:rotate90(pattern) → 生成旋转后的图案。 函数:rotate180(pattern) → 可以通过两次rotate90,或者直接处理。 函数:rotate270(pattern) → 三次rotate90,或者直接处理。 函数:reflect_vertical(pattern) → 每行反转。 然后,组合变换如reflect后rotate90、180、270。 对于每个变换步骤: 检查当前变换后的图案的行列是否与目标相同。例如,对于rotate90后的图案,行数等于原列数,列数等于原行数。如果目标的行列不符合,跳过该变换的比较。 否则,生成变换后的图案,并与目标比较。 如果找到匹配,返回对应的变换名称。 否则,继续下一个变换。 所以,可能的变换顺序列表: 1. preservation → 直接比较原图案。 2. rotate90 → 需要原行数等于目标列数,原列数等于目标行数。 3. rotate180 → 行列必须相同。 4. rotate270 → 同rotate90的条件? 或者,可能原行列和目标行列在旋转后的行列是否匹配。比如,原m行n列,旋转90度后是n行m列,所以目标必须也是n行m列。否则无法匹配,因此跳过。 所以,在比较每个变换前,需要检查目标的行列是否匹配变换后的尺寸,否则该变换不可能匹配,直接跳过。 例如,在比较rotate90时,如果原图案是m行n列,目标图案必须是n行m列,否则直接跳过该变换的比较。 否则,生成rotate90后的图案,比较是否与目标相同。 所以,在代码中,对于每个变换类型,需要知道变换后的行列数,并预先检查是否与目标的行列数匹配。如果匹配,才生成变换后的图案进行比较,否则跳过。 这将节省不必要的计算。 因此,程序的大体流程: 读取图案A和B。 如果A的行列数等于B的行列数,并且A == B,则返回preservation。 否则,检查下一个变换。 对于rotate90: 变换后的行列数是原A的列数、行数。如果B的行数等于A的列数,B的列数等于A的行数,那么生成A的rotate90后的图案,比较是否等于B。如果是,返回rotate90。 否则,继续。 对于rotate180: 变换后的行列数与原A相同。因此,如果B的行列数与A相同,生成rotate180后的A,比较是否等于B。否则跳过。 同理处理其他变换。 这样,每次检查变换前,先检查尺寸是否允许,避免不必要的计算。 现在,如何生成各种变换的图案? 例如,rotate90的实现: def rotate90(pattern): # 转置矩阵,然后反转每行 # 原矩阵是m行n列,转置后是n行m列,然后每行反转。 # 例如,原行0变为转置后的列0,反转后变成行n-1 -i ? # 另一种方法:取每列,反转后作为行。 # 例如,原矩阵的行是rows,列是cols. # 顺时针旋转90度后的矩阵,可以通过将原矩阵的列从下到上,作为新矩阵的行。 # 例如,原矩阵的最后一列,从上到下成为新矩阵的第一行。 rows = len(pattern) cols = len(pattern[0]) if rows >0 else 0 # 顺时针旋转90度后的矩阵是cols行, rows列。 rotated = [] for c in range(cols): new_row = [] for r in reversed(range(rows)): new_row.append(pattern[r][c]) rotated.append(''.join(new_row)) return rotated 例如,原矩阵为: 行0: ABC 行1: DEF 旋转后,cols是3,rows是2. c从0到2: c=0时,取r=1和0的c=0的字符,即 D和A → 新行是DA → 行0是DA. c=1时,取E和B → 行1是EB. c=2时,取F和C → 行2是FC. 所以旋转后的矩阵是: DA EB FC → 三行两列,与原矩阵的两行三列对应。 这似乎正确。 同理,其他变换函数也需要正确实现。 垂直反射的实现: def reflect_vertical(pattern): # 每行反转 return [row[::-1] for row in pattern] 旋转180度可以看作两次旋转90度,或者直接每行反转,然后每列反转? 或者更简单的方式: def rotate180(pattern): # 旋转180度,可以通过将行反转,并且每行中的元素反转? # 例如,原矩阵: # AB # CD # 旋转180度后是 DC BA → 行列反转? # 另一种方法:每个元素的位置是 (rows-1 - r, cols-1 -c) rows = len(pattern) cols = len(pattern[0]) if rows >0 else 0 rotated = [] for r in reversed(range(rows)): new_row = pattern[r][::-1] rotated.append(new_row) return rotated 例如,原矩阵: 行0: AB 行1: CD 旋转180度后: 行0: DC(原行1反转) 行1: BA(原行0反转) 这似乎正确。 同理,rotate270可以通过三次rotate90,或者逆时针旋转90度。实现方式类似,或者可以通过另一种方式: def rotate270(pattern): # 逆时针旋转90度,可以转置后反转列? # 或者,取每列的正序作为行,然后反转每行? rows = len(pattern) cols = len(pattern[0]) if rows >0 else 0 rotated = [] for c in reversed(range(cols)): new_row = [] for r in range(rows): new_row.append(pattern[r][c]) rotated.append(''.join(new_row)) return rotated 例如,原矩阵: AB CD 旋转270度后的矩阵: BD AC 因为: c的循环是1,0。 当c=1时,取行0的B,行1的D → 新行是BD. 当c=0时,取行0的A,行1的C → 新行是AC. 所以,旋转后的矩阵是: BD AC → 两行两列。如果是原矩阵是2行两列,那么旋转270后的结果是否正确? 顺时针旋转270度等于逆时针旋转90度,可能要看具体实现是否正确。 或者,另一种方法是,rotate270等同于三次rotate90。所以,可以调用rotate90三次。 例如,可以定义: def rotate90(pattern): ... 如前所述 ... 然后,rotate180可以调用两次rotate90,rotate270调用三次rotate90。这样可能更可靠,避免手动处理错误。 但需要注意,这样在每次旋转时都会生成中间结果,可能效率较低,但对于小规模的网格来说,问题不大。 接下来,处理反射后的旋转。例如,反射后的rotate90、180、270度。 例如,反射后的旋转90度相当于先反射,再旋转90度。所以,可以先将原图案反射,再旋转90度得到变换后的图案。 同样的,其他组合变换也是如此。 因此,在代码中,可以生成这些组合变换: 例如: 对于反射后的旋转90度: reflect_then_rotate90 = rotate90(reflect_vertical(pattern)) 同理,其他组合变换也是如此。 因此,在程序中,需要生成所有可能的变换后的图案,并按照顺序比较。 现在,将所有的变换顺序列举如下,并对应的生成函数: 变换顺序: 1. Preservation → 原图 2. rotate90 → 旋转90度后的图案 3. rotate180 → 旋转180度后的图案 4. rotate270 → 旋转270度后的图案 5. reflect_vertical → 垂直反射后的图案 6. reflect_vertical后rotate90 → 反射后旋转90度 7. reflect_vertical后rotate180 → 反射后旋转180度 8. reflect_vertical后rotate270 → 反射后旋转270度 所以,每个变换生成的方式需要正确。 现在,将这些变换用代码实现: 例如,定义一个函数生成所有可能的变换: def generate_transformations(pattern): transforms = [] # preservation transforms.append( ('preservation', pattern) ) # rotate90 transforms.append( ('rotate90', rotate90(pattern)) ) # rotate180 transforms.append( ('rotate180', rotate180(pattern)) ) # rotate270 transforms.append( ('rotate270', rotate270(pattern)) ) # reflect vertical reflected = reflect_vertical(pattern) transforms.append( ('reflect_vertical', reflected) ) # reflected + rotate90 transforms.append( ('reflect_rotate90', rotate90(reflected)) ) # reflected + rotate180 transforms.append( ('reflect_rotate180', rotate180(reflected)) ) # reflected + rotate270 transforms.append( ('reflect_rotate270', rotate270(reflected)) ) return transforms 但需要注意的是,某些变换的名称可能需要与题目中的要求一致。例如,题目中的变换顺序是: Preservation 90 degree rotation 180 degree rotation 270 degree rotation Vertical reflection Vertical reflection followed by 90 degree rotation Vertical reflection followed by 180 degree rotation Vertical reflection followed by 270 degree rotation 所以,变换顺序的名称可能需要对应,例如,反射后的旋转90度对应的名称可能如“reflection and 90 degree rotation”之类的。但具体输出名称需要根据题目要求来定。例如,题目示例中的输出可能需要特定的标签,比如: The transformations in order are: Preservation Rotation 90 Rotation 180 Rotation 270 Reflection Reflection + Rotation 90 Reflection + Rotation 180 Reflection + Rotation 270 或者可能有不同的命名方式,比如“Vertical reflection followed by a 90 degree rotation”等。 在代码中,返回对应的变换名称时,需要按照题目中的顺序,并且正确输出对应的名称。 例如,可能的变换名称列表: transform_orders = [ 'preservation', 'rotate90', 'rotate180', 'rotate270', 'reflect_vertical', 'reflect_rotate90', 'reflect_rotate180', 'reflect_rotate270', ] 每个变换的名称可能需要根据题目要求调整。例如,题目中的输出可能需要更正式的名称,如“Reflection followed by a 90 degree rotation”而不是“reflect_rotate90”。 但题目中的示例输出可能需要具体的描述,比如用户提到的变换顺序中的名称,可能需要像“Vertical reflection followed by a rotation of 90 degrees”等。 例如,在示例中的变换顺序: Preservation 90 degree rotation 180 degree rotation 270 degree rotation Vertical reflection Reflection followed by 90 degree rotation Reflection followed by 180 degree rotation Reflection followed by 270 degree rotation 因此,在代码中,变换的名称需要对应这些具体的描述。 例如,变换的名称列表应为: transform_names = [ "Preservation", "Rotation 90", "Rotation 180", "Rotation 270", "Vertical reflection", "Vertical reflection followed by rotation 90", "Vertical reflection followed by rotation 180", "Vertical reflection followed by rotation 270", ] 然后,在生成变换时,按照这个顺序生成对应的图案,并检查是否匹配。 因此,生成所有可能的变换时,必须按照这个顺序生成,并且在比较时一旦找到匹配的变换,立即返回对应的名称。 现在,代码的大致流程: 读取图案A和图案B: 首先,读取两个图案,可能每个图案由多行组成。例如,输入可能为: 4 X..X .... XX.. ..XX 4 ..XX XX.. .... X..X 其中,4代表行数,接下来的四行是图案。然后同样的方式读取第二个图案。 所以,读取函数可能需要先读取行数n,然后读取n行,每行去除可能的换行符,得到每个图案的列表。 例如: def read_pattern(): n = int(input()) pattern = [input().strip() for _ in range(n)] return pattern 然后,读取pattern_a = read_pattern() pattern_b = read_pattern() 然后,比较两个图案是否在某个变换下相同。 接下来,生成所有可能的变换后的图案,并按照顺序检查。 但是,对于每个变换后的图案,需要检查其行列数是否与pattern_b的行列数匹配,否则跳过。 例如,对于变换i,生成的图案是transformed,其行数为len(transformed),列数为len(transformed[0])(如果存在的话)。 而pattern_b的行数为 len(pattern_b),列数为 len(pattern_b[0])(假设所有行的长度相同)。 所以,在比较每个变换后的图案时,首先检查行数和列数是否与pattern_b匹配。如果行数或列数不匹配,则跳过该变换。 否则,比较两个图案的内容是否完全相同。 例如,在代码中: for name, transformed in transformations: if len(transformed) != len(pattern_b) or (len(transformed) >0 and len(transformed[0]) != len(pattern_b[0])): continue if transformed == pattern_b: return name 所以,这一步中的比较需要考虑行列数是否匹配,否则直接跳过。 这确保了变换后的图案与目标图案的尺寸一致,避免错误的比较。 现在,将所有步骤综合起来,代码的大致结构如下: 读取pattern_a和pattern_b. 生成所有可能的变换后的图案,按照顺序。 对于每个变换后的图案: 检查其行数和列数是否与pattern_b的相同。 如果相同,比较内容是否一致。 如果一致,输出对应的变换名称。 否则,继续下一个变换。 如果所有变换都不匹配,输出“无法通过简单变换得到”。 现在,测试几个案例: 案例1:图案A和B相同。此时,第一个变换preservation就会匹配,返回结果。 案例2:图案A旋转90度后得到B。假设A是2x3的矩阵,B是3x2的矩阵。此时,在rotate90变换时,生成的图案行列与B匹配,比较后返回正确。 案例3:图案A是垂直反射后的结果,此时变换4会匹配。 另一个案例:八皇后问题中的情况,可能变换后的图案需要多个步骤才能找到匹配。 现在,关于代码的正确性,需要注意以下几点: 1. 确保所有变换的实现正确,包括旋转和反射后的组合变换。 2. 确保在比较行列数时,正确处理空矩阵的情况,例如行数为0时,需要特殊处理,但题目中的图案应该至少是1x1的。 3. 输入的行数是否正确,例如用户可能输入的行数与实际读取的行数是否一致? 例如,在读取图案时,如果用户输入的n行中,某行的字符数与其他行不同,如何处理?题目可能假设所有行的字符数相同,视为合法输入,或者需要程序处理错误输入?可能题目中的输入保证是有效的,所以无需处理。 4. 变换的顺序是否正确,严格按照题目中给出的顺序:preservation、rotate90、rotate180、rotate270、reflect_vertical、reflect+rotate90、reflect+rotate180、reflect+rotate270. 现在,编写代码: 首先,实现各个变换函数: def rotate90(pattern): if not pattern: return [] rows = len(pattern) cols = len(pattern[0]) rotated = [] for c in range(cols): new_row = ''.join([pattern[rows - r -1][c] for r in range(rows)]) rotated.append(new_row) return rotated def rotate180(pattern): if not pattern: return [] rows = len(pattern) cols = len(pattern[0]) rotated = [] for r in reversed(range(rows)): new_row = pattern[r][::-1] rotated.append(new_row) return rotated def rotate270(pattern): if not pattern: return [] rows = len(pattern) cols = len(pattern[0]) rotated = [] for c in reversed(range(cols)): new_row = ''.join([pattern[r][c] for r in range(rows)]) rotated.append(new_row) return rotated def reflect_vertical(pattern): if not pattern: return [] return [row[::-1] for row in pattern] 然后,生成所有变换: def generate_all_transformations(pattern): transforms = [] # 0. Preservation transforms.append( ("Preservation", pattern) ) # 1. Rotation 90 transforms.append( ("Rotation 90", rotate90(pattern)) ) # 2. Rotation 180 transforms.append( ("Rotation 180", rotate180(pattern)) ) # 3. Rotation 270 transforms.append( ("Rotation 270", rotate270(pattern)) ) # 4. Vertical reflection reflected = reflect_vertical(pattern) transforms.append( ("Vertical reflection", reflected) ) # 5. Vertical reflection + Rotation 90 transforms.append( ("Vertical reflection followed by rotation 90", rotate90(reflected)) ) # 6. Vertical reflection + Rotation 180 transforms.append( ("Vertical reflection followed by rotation 180", rotate180(reflected)) ) # 7. Vertical reflection + Rotation 270 transforms.append( ("Vertical reflection followed by rotation 270", rotate270(reflected)) ) return transforms 然后,比较两个图案是否相同: def patterns_equal(a, b): if len(a) != len(b): return False for row_a, row_b in zip(a, b): if row_a != row_b: return False return True 主程序: def main(): pattern_a = read_pattern() pattern_b = read_pattern() # Check all transformations for name, transformed in generate_all_transformations(pattern_a): # Check if dimensions match if len(transformed) != len(pattern_b): continue if len(transformed) ==0: # both are empty if len(pattern_b) ==0: print(name) return else: continue if len(transformed[0]) != len(pattern_b[0]): continue if patterns_equal(transformed, pattern_b): print(f"Patterns are related by {name}.") return print("Patterns are not related by any simple transformation.") def read_pattern(): n = int(input()) pattern = [input().strip() for _ in range(n)] return pattern if __name__ == "__main__": main() 这个程序的大致逻辑是: 生成第一个图案的所有可能变换,按照顺序检查每个变换后的图案是否与第二个图案的尺寸和内容匹配。如果匹配,则输出对应的变换名称;否则,继续检查下一个变换。如果所有变换都不匹配,则输出无法转换。 测试案例: 例如,假设pattern_a是: X..X .... XX.. ..XX pattern_b是: ..XX XX.. .... X..X 这可能经过vertical reflection后的结果?或者需要其他变换。 另一个测试案例,原图和旋转90度后的图。 例如,原图: AB CD 旋转90度后的图: CA DB 需要确定变换函数是否正确生成。 综上,这应该是解决该问题的一个可行方案。需要注意各个变换函数的正确性,以及比较时的行列数检查。</think>要解决该问题,需通过几何变换判断两个网格图案是否相同。以下是逐步解决方案: --- ### **步骤分析** 1. **输入处理** 读取两个矩形网格的尺寸和内容,确保格式正确。 2. **变换定义** 定义所有可能的几何变换: - **保持(Preservation)**:直接比较是否相同。 - **旋转90度、180度、270度**:通过矩阵转置和反转实现。 - **垂直反射(镜像)**:反转每行字符。 - **反射后旋转**:组合变换(反射+旋转)。 3. **变换生成与比较** 按顺序生成第一个图案的所有变换版本,依次与第二个图案比较。若尺寸或内容不匹配,跳过当前变换。 4. **结果判断** 找到首个匹配的变换类型或判定无解。 --- ### **代码实现** ```python def rotate90(pattern): if not pattern: return [] rows = len(pattern) cols = len(pattern[0]) return [''.join([pattern[rows - r - 1][c] for r in range(rows)]) for c in range(cols)] def rotate180(pattern): if not pattern: return [] return [row[::-1] for row in reversed(pattern)] def rotate270(pattern): if not pattern: return [] rows = len(pattern) cols = len(pattern[0]) return [''.join([pattern[r][c] for r in range(rows)]) for c in reversed(range(cols))] def reflect_vertical(pattern): return [row[::-1] for row in pattern] def generate_transformations(pattern): transformations = [] transformations.append(("Preservation", pattern)) transformations.append(("Rotation 90", rotate90(pattern))) transformations.append(("Rotation 180", rotate180(pattern))) transformations.append(("Rotation 270", rotate270(pattern))) reflected = reflect_vertical(pattern) transformations.append(("Vertical reflection", reflected)) transformations.append(("Vertical reflection followed by rotation 90", rotate90(reflected))) transformations.append(("Vertical reflection followed by rotation 180", rotate180(reflected))) transformations.append(("Vertical reflection followed by rotation 270", rotate270(reflected))) return transformations def patterns_equal(a, b): return a == b def read_pattern(): n = int(input()) return [input().strip() for _ in range(n)] def main(): a = read_pattern() b = read_pattern() for name, transformed in generate_transformations(a): if len(transformed) != len(b): continue if len(transformed) == 0: if len(b) == 0: print(f"Patterns are related by {name}.") return else: continue if len(transformed[0]) != len(b[0]): continue if patterns_equal(transformed, b): print(f"Patterns are related by {name}.") return print("Patterns are not related by any simple transformation.") if __name__ == "__main__": main() ``` --- ### **关键点** 1. **变换顺序**:严格按题目要求的顺序检查变换。 2. **行列检查**:变换后若行列数与目标不匹配,直接跳过。 3. **效率优化**:找到首个匹配后立即终止,减少计算。 此方法确保正确比较所有可能的变换,适用于棋盘类问题(如八皇后布局)、图形谜题等场景。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值