202309 CSP认证

考场上拿了两百分，第三题无法下笔…
浅浅记录一下前两题然后做一下第三题吧…
1 坐标变换其一

#include<bits/stdc++.h>
using namespace std;
int main()
{
    int n, m; cin >> n >> m;
    long long dx = 0, dy = 0;
    long long x, y;
    
    while(n --) {
        cin >> x >> y;
        dx += x; dy += y;
    }
    
    while(m --){
        cin >> x >> y;
        cout << x + dx <<" " << y + dy << endl;
    }
    return 0;
}

---

坐标变换（其二）

#include<bits/stdc++.h>
using namespace std;
const int N = 100005;

double k[N] = {1};
double s[N] = {0};

int main()
{
    int n,m; cin>>n>>m;
    k[0] = 1;
    s[0] = 0;

    for(int i = 1;i <= n;i ++){
        int type; cin>>type;
        double w; cin>>w;
        if(type == 1){
            k[i] = k[i - 1] * w;
            s[i] = s[i - 1];
        }
        else{
            s[i] = s[i - 1] + w;
            k[i] = k[i - 1];
        }
    }

    for(int l = 0;l < m;l ++){
        int left,right;
        double x,y;
        cin>>left>>right>>x>>y;
        double ki = k[right] / k[left - 1];
        x *= ki;
        y *= ki;

        double sita = s[right] - s[left - 1];
        double xi = x,yi = y;
        x = xi * cos(sita) - yi * sin(sita);
        y = xi * sin(sita) + yi * cos(sita);



        printf("%5f",x);
        cout<<" ";
        printf("%5f",y);
        cout<<endl;
    }
    return 0;
}

---

梯度求解

自己在考场上面也写了快一个小时，结果一分没有拿到…因为基本的对后缀式的处理就做的不好，总体来说就是对栈的应用已经非常不熟练了，加上对字符串的处理也本身算弱势（其实很多第三题的模拟都要围绕字符串打交道的）

这次写的时候参考了代码：CSP 202309-3 梯度求解
这个代码比较简洁，第一个是使用了很多我都不太了解的库包和语法
第二个是对整体的划分也比较少，将所有的工作都封装到了一个solve()函数里了

这里解释几个代码中出现的标准库封装函数（不了解的函数）的解释

1. ll index = atoi(str.substr(1).c_str());
   • str.substr(1) : 把字符串str从下标1开始截取子字符串。
   • .c_str(): 把子字符串转换成const char*（常量指针，指针所指示的地址空间不可更改，但是地址空间内的内容可以更改）类型。
   • atoi(): C语言标准函数,用来把const char*类型的数据转成整数。
   • ll: long long类型,C/C++中支持的最大整型。
     总的来说这段简单的代码解决了我在考场中好像搞了快半个小时的问题…这里非常熟练的运用了封装的一些标准的库函数
2. isdigit()函数：传入一个char字符，通过ASCII码表判断该字符是否为数字，返回一个BOOL值
3. nihao

除了熟练的使用标准库函数，对比另外一份代码，我发现这份代码的思维也更加简洁。
比起传统的思路，先去处理表达式，然后再对输入的变量求导，然后再带入值计算，本题的做法更为直接，直接和答案对标。在这段代码中，先拿到需要求导的自变量，再对函数做处理。看似好像会对表达式做重复处理，但是单次处理会变得简单很多；
此时我的关注点只放在需要求导的自变量身上，而其他自变量可以直接替换为输入的常数；而且单次输入的目标自变量只会是一次的，那么此时在处理中

• 当遇到变量项时,如果是目标求导变量会设置指数为1,其他为0。
• 计算乘法时,需要叠加指数。也即map<ll, ll>的key字段进行相加, value字段相乘

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 1005;
const int mod = 1e9 + 7;

ll coef[N];
int n, m, to_solve;
vector<string> vec;

void solve() {
    //用map<ll, ll>来保存一个多项式,第一个key字段为指数,value字段为系数
    stack<map<ll, ll>> expr;
    
    for (auto& str: vec) {
        if (str.empty()) {continue;}
        if (str[0] == 'x') {  // var
            // 使用标准库函数提取序号
            ll index = atoi(str.substr(1).c_str());
            
            map<ll, ll> tp;
            if (index == to_solve) {
                tp[1] = 1;   //为目标变量则指数为1
            } 
            
            else {
                tp[0] = coef[index] % mod;   //否则视为常量
            }
            expr.push(tp);
        } 
        
        else if (str.size() == 1 && !isdigit(str[0])) { // operator
            auto pre = expr.top(); expr.pop();
            auto suf = expr.top(); expr.pop();
            map<ll, ll> res;
            
            if (str == "+") {
                for(auto& p: pre) {
                    res[p.first] = (p.second % mod);
                }
                for (auto& p: suf) {
                    res[p.first] = (res[p.first] + p.second) % mod;
                }
            } 
            else if (str == "-") {
                for(auto& p: suf) {
                    res[p.first] = (p.second % mod);
                }
                for (auto& p: pre) {
                    res[p.first] = (res[p.first] - p.second) % mod;
                }
            } 
            else {
                for (auto& p: pre) {
                    for (auto& q: suf) {
                        //指数相加，系数相乘
                        ll zs = p.first + q.first;
                        ll bs = (p.second * q.second) % mod;
                        res[zs] = (res[zs] + bs) % mod;
                    }
                }
            }
            
            expr.push(res);
        } 
        
        else { // digit常数项
            ll digit = atoi(str.c_str());
            digit %= mod;
            map<ll, ll> tp;
            tp[0] = digit;
            expr.push(tp);
        }
    }
    
    assert(expr.size() == 1);   //最终只有一个表达式才是合法的
    
    ll res = 0;
    
    while (!expr.empty()) {
        auto final_expr = expr.top();
        expr.pop();
        
        for (auto& p: final_expr) {  
            // 遍历表达式里面的每一个pair对
            ll pw = 1;
            
            //指数×系数, 也就是把指数放下来,系数减一, 遵循求导法则
            ll bs = (p.second * p.first) % mod;
            ll c = p.first - 1;
            while (c > 0) {
                c--;
                pw = (pw * coef[to_solve]) % mod;
            }
            
            pw = (pw * bs) % mod;  //x的c次方×系数得到当前项的和
            
            res = (res + pw) % mod;
        }
    }
    
    res %= mod;
    res = (res + mod) % mod;   //针对题干的第二个提示
    
    cout << res << '\n';
 
 
}
int main() {
    cin >> n >> m;
    getchar();   //根据输入做的一个调整
    
    string line, tmp;
    getline(cin, line);
    stringstream sin(line);
    while (sin >> tmp) {
        vec.push_back(tmp);
    }
    while (m --) {
        cin >> to_solve;
        for (int i = 1; i <= n; i++) {
            cin >> coef[i];
        }
        solve();
    }
}

这个函数大量使用了C++11的语言，主要就是auto的使用…however这并不是重点…我把代码看懂都花了快两个小时，感觉是个我完全写不出来的东西了…