nyoj ACM:点的变换(矩阵运算)

点的变换
时间限制：2000 ms | 内存限制：65535 KB
难度：5
描述
平面上有不超过10000个点，坐标都是已知的，现在可能对所有的点做以下几种操作：

平移一定距离(M)，相对X轴上下翻转(X)，相对Y轴左右翻转(Y),坐标缩小或放大一定的倍数(S),所有点对坐标原点逆时针旋转一定角度(R)。

操作的次数不超过1000000次，求最终所有点的坐标。

提示：如果程序中用到PI的值，可以用acos(-1.0)获得。

输入
只有一组测试数据
测试数据的第一行是两个整数N,M，分别表示点的个数与操作的个数(N<=10000,M<=1000000)
随后的一行有N对数对，每个数对的第一个数表示一个点的x坐标，第二个数表示y坐标，这些点初始坐标大小绝对值不超过100。
随后的M行，每行代表一种操作，行首是一个字符：
首字符如果是M,则表示平移操作，该行后面将跟两个数x,y，表示把所有点按向量(x,y)平移;
首字符如果是X，则表示把所有点相对于X轴进行上下翻转;
首字符如果是Y，则表示把所有点相对于Y轴进行左右翻转;
首字符如果是S，则随后将跟一个数P,表示坐标放大P倍;
首字符如果是R，则随后将跟一个数A,表示所有点相对坐标原点逆时针旋转一定的角度A(单位是度)
输出
每行输出两个数，表示一个点的坐标(对结果四舍五入到小数点后1位，输出一位小数位）
点的输出顺序应与输入顺序保持一致
样例输入
2 5
1.0 2.0 2.0 3.0
X
Y
M 2.0 3.0
S 2.0
R 180
样例输出
-2.0 -2.0
0.0 0.0

对所有的操作，我们可以用一个矩阵储存起来，一系列的操作，我们可以利用矩阵相乘，来储存！

将单个矩阵 操作转化为 矩阵乘法

多个矩阵操作

在多个矩阵操作中，下一个操作的矩阵一定 左乘 上面所有操作结果矩阵。
即后一个操作矩阵一定放在前面操作的左边。
同时由于矩阵没有乘法交换律，所以绝对不能弄反。
例如按上述顺序操作（先旋转，再缩放，再关于y轴对称，然后再关于x轴对称，最后在平移）

上面图片来自博客http://blog.csdn.net/hearthougan/article/details/24841293

注意：
1. cmath库中cos(A) , sin(A) 要求输入的参数应该为弧度，要将角度换成弧度再输入
2. 角度化为弧度 ， 弧度=角度/180 * PI
3. PI = acos(-1.0)

下面代码的思路：
1. 开始是定义3*3矩阵temp，将其初始化为单位矩阵（因为要做乘法）
2. 然后，每接收一个操作命令，用该操作对应的3*3矩阵pin，去左乘 temp ， 即pin * temp 。然后把结果保存在temp上，也就是说，temp保存的是前面所有操作的乘积。
3. 所有操作都执行完成后，定义一个3*3矩阵next ，每次接收一个点的坐标，然后右乘temp. 注意：这里与上面不同，这里要求右乘temp ，即temp * next 。
next的形式为

其中xi为第i个点的横坐标，yi为第i个点的纵坐标
期间总是不小心改了temp的值，这里要注意

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
using namespace std;
#define PI acos(-1.0)
typedef struct{
    double k[3][3];
}node;
node temp;

node Multiply(node l,char c)
{
    node f,jishu;
    jishu=temp;
    if(c=='r')
    {

        f=l;
        l=jishu;
        jishu=f;
    }
    memset(f.k,0,sizeof(f.k));

    for(int i=0;i<3;i++)
    {
        for(int j=0;j<3;j++)
        {
            for(int k=0;k<3;k++)
                f.k[i][j]+=l.k[i][k]*jishu.k[k][j];
        }
    }
    return f;
}
void pingyi()
{
    double a,b;
    scanf("%lf%lf",&a,&b);
    node pin;
    memset( pin.k,0,sizeof(pin.k));
    pin.k[0][0]=pin.k[1][1]=pin.k[2][2]=1;
    pin.k[0][2]=a;
    pin.k[1][2]=b;
    temp=Multiply(pin,'l');
}

void Xfanzhuan()
{
    node pin;
    memset( pin.k,0,sizeof(pin.k));
    pin.k[0][0]=pin.k[2][2]=1;
    pin.k[1][1]=-1;
    temp=Multiply(pin,'l');
}

void Yfanzhuan()
{
    node pin;
    memset( pin.k,0,sizeof(pin.k));
    pin.k[1][1]=pin.k[2][2]=1;
    pin.k[0][0]=-1;
    temp=Multiply(pin,'l');
}

void Pbei()
{
    double P;
    scanf("%lf",&P);
    node pin;
    memset( pin.k,0,sizeof(pin.k));
    pin.k[0][0]=pin.k[1][1]=P;
    pin.k[2][2]=1;
    temp=Multiply(pin,'l');
}
void Axzhuan()
{
    double A;
    scanf("%lf",&A);
    node pin;
    A=A*PI/180; 
    memset( pin.k,0,sizeof(pin.k));
    pin.k[0][0]=pin.k[1][1]=cos(A);//注意了，在c/c++中,cos(A) 里面天的应该是弧度，要把角度化成弧度才能正确 
    pin.k[0][1]=-sin(A);
    pin.k[1][0]=sin(A);
    pin.k[2][2]=1;
    temp=Multiply(pin,'l');
}

int main()
{
    int N,M;
    scanf("%d%d",&N,&M);
    double a[3][N];
    for(int i=0;i<N;i++)
    {
        scanf("%lf%lf",&a[0][i],&a[1][i]);
        a[2][i]=1;
    }
    memset( temp.k,0,sizeof(temp.k));
    temp.k[0][0]=1;
    temp.k[1][1]=1;
    temp.k[2][2]=1;
    char c;
    for(int i=0;i<M;i++)
    {
            getchar();
            scanf("%c",&c);
            //printf("c %c\n",c);
            switch(c)
            {
                case 'M':pingyi();break;
                case 'X':Xfanzhuan();break;
                case 'Y':Yfanzhuan();break;
                case 'S':Pbei();break;
                case 'R':Axzhuan();break;
            }

    }
    //printf("cos 180 %lf   sin 180 %lf\n",cos(180),sin(180));
    node next;
    for(int i=0;i<N;i++)
    {
        memset(next.k,0,sizeof(next.k));
        next.k[0][0]=a[0][i];
        next.k[1][0]=a[1][i];
        next.k[2][0]=a[2][i];

        next=Multiply(next,'r');
        printf("%0.1lf %0.1lf\n",next.k[0][0],next.k[1][0]);

    }
    return 0;
}