CCF CSP 2023年9月第二题坐标变换（其二）

爱编程的Justin

已于 2024-09-21 21:57:07 修改

阅读量432

点赞数 4

文章标签：算法 leetcode 性能优化蓝桥杯

于 2024-09-21 21:12:22 首次发布

本文链接：https://blog.csdn.net/m0_74158536/article/details/142424232

版权

题目描述

题目分析

直接用模拟法，按照题目意思进行求解，但是注意一个小细节！！！！

在旋转操作中，对y坐标进行操作时，使用的还是还未改变的x下标，所以应当用temp_x存储未变化的x。

double temp_x = b[i][2]; // 先存储未变换前的值，防止计算y时被更新
b[i][2] = b[i][2]* cos(a[index][1]) - b[i][3]* sin(a[index][1]);
b[i][3] = temp_x * sin(a[index][1]) + b[i][3]* cos(a[index][1]);

但是超时了,得到了80分

超时原因如下

对于每个查询，都需要遍历指定范围内的所有操作。当操作数和查询数都很大（高达 10^5）时，时间复杂度为 $O(n \times m)$ ，总的计算次数会达到 $10^{10}$ ，无法在合理时间内完成。

超时代码如下（80分)

#include <bits/stdc++.h>

using namespace std;

int main() {
    int n, m; //输入操作和查询个数
    cin >> n >> m;

    //定义操作数和查询数的数组
    double a[n][2];
    double b[m][4];

    //存入操作数
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < 2; j++) {
           cin >> a[i][j];
        }
    }

    //存入查询数
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < 4; j++) {
            cin >> b[i][j];
        }
    }
    //对查询数进行操作
    for (int i = 0; i < m; i++) {
            //判断要对查询数进行操作的范围
            int time = b[i][1] - b[i][0] + 1 ; //记录需要操作的次数,因为第一次也算，要加1
            int index = b[i][0] - 1; //记录操起始操作的下标
            while (time > 0) { //计算执行次数
                if (a[index][0] == 1) { //说明是拉伸变换
                    b[i][2] *= a[index][1];
                    b[i][3] *= a[index][1];
                }
                if (a[index][0] == 2) { //说明是旋转变换
                    double temp_x = b[i][2]; // 先存储未变换前的值，防止计算y时被更新
                    b[i][2] = b[i][2]* cos(a[index][1]) - b[i][3]* sin(a[index][1]);
                    b[i][3] = temp_x * sin(a[index][1]) + b[i][3]* cos(a[index][1]);
                }
                time--; //操作完一次，计数减少一次
                index++; //起始操作地址加1
                }
            //对一个查询操作完毕，进行输出
            printf("%f %f" "\n", b[i][2],b[i][3]);
            }
    return 0;
}

经过优化，对每个位置进行缩放和旋转的积累的预处理操作，将时间复杂度降到O(n + m）

输在了数学上

  // 预处理累积缩放系数和旋转角度
        vector<double> scale(n + 1, 1.0);
        vector<double> angle(n + 1, 0.0 ); //起始就是那个θ值

预处理累积缩放系数和旋转角度：

定义两个数组 scale 和 angle，其中：

scale[i] 表示从第 1 个操作到第 i 个操作的总缩放系数；
angle[i] 表示从第 1 个操作到第 i 个操作的总旋转角度

  // 预处理累积缩放系数和旋转角度
        vector<double> scale(n + 1, 1.0);
        vector<double> angle(n + 1, 0.0 ); //起始就是那个θ值

难点：在那一段区间的操作，基于前缀和进行操作

在分别计算出累加的缩放和旋转系数后

//在那一个区间的总的拉伸和旋转系数，分别用除法和减法代表区间内积累的值，非常巧妙
        double total_scale = scale[r] / scale[l - 1];
        double total_angle = angle[r] - angle[l - 1];

具体代码

#include <bits/stdc++.h>
using namespace std;

int main() {
    int n, m;
    cin >> n >> m;

    vector<int> op_type(n + 1);      // 操作类型，1 为拉伸，2 为旋转
    vector<double> op_value(n + 1);  // 操作对应的值（k 或 θ）

    // 输入操作
    for (int i = 1; i <= n; ++i) {
        cin >> op_type[i] >> op_value[i];
    }

        // 预处理累积缩放系数和旋转角度
        //数学积累：经过n次旋转变换后的坐标(x,y)，等同于绕原点角度 (θ1+θ2) 的角度,即可以不断累加
        vector<double> scale(n + 1, 1.0);
        vector<double> angle(n + 1, 0.0 ); //起始就是那个θ值

    for (int i = 1; i <= n; i++) {
        if (op_type[i] == 1) { //说明为缩放操作
            //此时缩放系数变化，拉伸系数保持不变
            scale[i] = scale[i - 1] * op_value[i];
            angle[i] = angle[i - 1];
        }
        else { //说明为旋转操作
            //此时拉伸系数变化，旋转系数保持不变
            scale[i] = scale[i - 1];
            angle[i] = angle[i - 1] + op_value[i];
        }
    }

    // 处理查询
    for (int i = 0; i < m; i++) {
        int l, r; //操作的左区间和右区间
        double x, y; //每一行的查询数的坐标
        cin >> l >> r >> x >> y;

        //利用了前缀和
        //在那一个区间的总的拉伸和旋转系数，分别用除法和减法代表区间内积累的值，非常巧妙
        double total_scale = scale[r] / scale[l - 1];
        double total_angle = angle[r] - angle[l - 1];

        // 应用缩放
        x *= total_scale;
        y *= total_scale;

        // 应用旋转，保存原始坐标
        double orig_x = x;
        double orig_y = y;

        x = orig_x * cos(total_angle) - orig_y * sin(total_angle);
        y = orig_x * sin(total_angle) + orig_y * cos(total_angle);

        // 输出结果，保留足够的精度
        printf("%.10f %.10f\n", x, y);
    }

    return 0;
}