位图[bitmap],也叫做点阵图,栅格图像,像素图。如上图所示,是由n*m个点组成,每个点

Question

位图[bitmap]，也叫做点阵图，栅格图像，像素图。如上图所示，是由nm个点组成，每个点显示一种颜色就形成了图形，最小单位是像素。一个点的颜色一般用一个整数表示，因此一幅点阵图我们常常用一个nm的矩阵保存，矩阵的元素值代表该点的颜色。
给定一个n行m列的图像各像素点的颜色值，对该图像有4种操作：
1）顺时针旋转90度；2）逆时针旋转90度；3）水平翻转；4）垂直翻转。对其有一系列操作，输出经过一系列操作后新图像各点的颜色值
【输入格式】
第一行 三个整数n、m、p分别表示行数、列数、操作次数（1<=n<=1600;1<=m<=1200;1<=p<=1000）
第2至第n+1行，每行m个整数，每个整数用一个空格隔开
第n+2行，有p个大写字母（A 表示顺时针旋转90度 ；B表示逆时针旋转90度；C表示水平翻转；D表示垂直翻转）表示操作的种类，每个字母由一个空格隔开。
【输出格式】n’行，每行m’个整数，每个整数由一个空格隔开
样例输入
3 3 1
1 2 3
4 5 6
7 8 9
A
样例输出
7 4 1
8 5 2
9 6 3

#include<bits/stdc++.h>
using namespace std;
int a[1605][1205],b[1605][1205],m,n,k;
char s;
void CwAcw()
{
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
            if(s=='A')
                b[j][n+1-i]=a[i][j];
            else
                b[m+1-j][i]=a[i][j];
    swap(n,m);memcpy(a,b,sizeof b);
}
void LvPd()
{
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
            if(s=='C')
                b[i][m+1-j]=a[i][j];
            else
                b[n+1-i][j]=a[i][j];
    memcpy(a,b,sizeof b );
}
int main()
{
    cin>>n>>m>>k;
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
            cin>>a[i][j];
    for(int i=1;i<=k;i++
    {
        cin>>s;
        switch(s)
        {
            case 'A':case 'B':CwAcw();break;
            default:LvPd();
        }
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
            cout<<a[i][j]<<' ';
        cout<<endl;
    }
    return 0;
}

总是超时，代码可以怎样优化？

Answer 1

不知道你这个问题是否已经解决, 如果还没有解决的话:

• 这个问题的回答你可以参考下: https://ask.csdn.net/questions/7533007
• 以下回答来自chatgpt:

  首先，我们需要根据输入来构建位图。 根据输入格式，可以将位图构建为一个二维数组，每个元素代表一个像素点的颜色值。

  接下来，根据给定的操作类型，对位图进行相应的操作。 1. 顺时针旋转90度：可以使用一个新的二维数组来存储旋转后的位图，遍历原位图的每个元素，将其旋转后的位置赋值给新的数组。 旋转后的位置可以通过公式: new_i = j, new_j = n - i - 1计算得出。 示例代码如下：

  int[][] rotateClockwise(int[][] bitmap) {
      int n = bitmap.length;
      int m = bitmap[0].length;
      int[][] newBitmap = new int[m][n];
  
      for (int i = 0; i < n; i++) {
          for (int j = 0; j < m; j++) {
              newBitmap[j][n - i - 1] = bitmap[i][j];
          }
      }
  
      return newBitmap;
  }
  

  1. 逆时针旋转90度：与顺时针旋转90度类似，只是对应的公式为: new_i = m - j - 1, new_j = i。 示例代码如下：

  int[][] rotateCounterClockwise(int[][] bitmap) {
      int n = bitmap.length;
      int m = bitmap[0].length;
      int[][] newBitmap = new int[m][n];
  
      for (int i = 0; i < n; i++) {
          for (int j = 0; j < m; j++) {
              newBitmap[m - j - 1][i] = bitmap[i][j];
          }
      }
  
      return newBitmap;
  }
  

  1. 水平翻转：可以直接对位图的每一行进行翻转操作。 示例代码如下：

  int[][] flipHorizontal(int[][] bitmap) {
      int n = bitmap.length;
      int m = bitmap[0].length;
      int[][] newBitmap = new int[n][m];
  
      for (int i = 0; i < n; i++) {
          for (int j = 0; j < m; j++) {
              newBitmap[i][j] = bitmap[i][m - j - 1];
          }
      }
  
      return newBitmap;
  }
  

  1. 垂直翻转：与水平翻转类似，只是对应的操作是对每一列进行翻转。 示例代码如下：

  int[][] flipVertical(int[][] bitmap) {
      int n = bitmap.length;
      int m = bitmap[0].length;
      int[][] newBitmap = new int[n][m];
  
      for (int i = 0; i < n; i++) {
          for (int j = 0; j < m; j++) {
              newBitmap[i][j] = bitmap[n - i - 1][j];
          }
      }
  
      return newBitmap;
  }
  

  最后，根据给定的操作顺序，按照顺序对位图进行相应的操作，并输出结果。

  完整代码如下：

  def rotate_clockwise(bitmap):
      n = len(bitmap)
      m = len(bitmap[0])
      new_bitmap = [[0] * n for _ in range(m)]
  
      for i in range(n):
          for j in range(m):
              new_bitmap[j][n - i - 1] = bitmap[i][j]
  
      return new_bitmap
  
  def rotate_counter_clockwise(bitmap):
      n = len(bitmap)
      m = len(bitmap[0])
      new_bitmap = [[0] * n for _ in range(m)]
  
      for i in range(n):
          for j in range(m):
              new_bitmap[m - j - 1][i] = bitmap[i][j]
  
      return new_bitmap
  
  def flip_horizontal(bitmap):
      n = len(bitmap)
      m = len(bitmap[0])
      new_bitmap = [[0] * m for _ in range(n)]
  
      for i in range(n):
          for j in range(m):
              new_bitmap[i][j] = bitmap[i][m - j - 1]
  
      return new_bitmap
  
  def flip_vertical(bitmap):
      n = len(bitmap)
      m = len(bitmap[0])
      new_bitmap = [[0] * m for _ in range(n)]
  
      for i in range(n):
          for j in range(m):
              new_bitmap[i][j] = bitmap[n - i - 1][j]
  
      return new_bitmap
  
  def optimize_bitmap(n, m, p, bitmap, operations):
      for operation in operations:
          if operation == 'A':
              bitmap = rotate_clockwise(bitmap)
          elif operation == 'B':
              bitmap = rotate_counter_clockwise(bitmap)
          elif operation == 'C':
              bitmap = flip_horizontal(bitmap)
          elif operation == 'D':
              bitmap = flip_vertical(bitmap)
  
      for row in bitmap:
          print(' '.join(map(str, row)))
  
  # 输入示例
  n, m, p = map(int, input().split())
  bitmap = []
  for _ in range(n):
      row = list(map(int, input().split()))
      bitmap.append(row)
  operations = input().split()
  
  optimize_bitmap(n, m, p, bitmap, operations)
  

  这样，我们就完成了对位图进行优化操作的代码，并避免了超时。

如果你已经解决了该问题, 非常希望你能够分享一下解决方案, 写成博客, 将相关链接放在评论区, 以帮助更多的人 ^-^