CSP认证2023-09：坐标变换(其一)、坐标变换（其二）、梯度求解，python满分代码解答

已于 2024-01-15 15:30:04 修改
阅读量1.4k 收藏 18
点赞数 33
分类专栏： leetcode 文章标签： python 数据结构 算法
于 2023-11-25 17:20:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53644346/article/details/134611437
版权

CSP认证2023-09：坐标变换(其一)、坐标变换（其二）、梯度求解，python满分代码解答

目录

一、坐标变换（其一）

问题描述

输入和输出

思路

代码和结果

c++代码

python代码

二、坐标变换（其二）

问题描述

输入和输出

思路

代码和结果

c++代码

​编辑 python代码

改进 

c++代码

python代码

三、梯度求解

问题描述

输入和输出

思路

代码和结果

一、坐标变换（其一）

问题描述

75a34c5f06f24e108691b40c9f6c76a1.png

输入和输出

26c6bf171e7b4cab82b592f9ae9b6724.png

输入

3 2
10 10
0 0
10 -20
1 -1
0 0

输出 

21 -11
20 -10

思路

定义一个起始原点坐标(0,0)，将n个操作依次累加，获得移动后的坐标(x_move,y_move)。接着输入m行坐标(x_res,y_res)时，直接加上移动后的坐标(x_move,y_move)输出结果即可。

代码和结果

c++代码

#include<iostream>
using namespace std;
int main() {
	int n, m;
	cin >> n >> m;
	int move_x = 0;
	int move_y = 0;
	for (int i = 0; i < n; i++) {//m行数据
		int x,y;
		cin >> x>>y;
		move_x += x;
		move_y += y;		
	}
	for (int j = 0; j < m; j++) {
		int input_x, input_y;
		cin >> input_x >> input_y;
		cout << input_x + move_x << " " << input_y + move_y << endl;
	}
}

2197131705794cc7b25ccfc007b13abb.png

python代码

n,m=list(map(int,input().split()))
x_move ,y_move= 0,0
for i in range(n):
    x_1,y_1 = list(map(int,input().split()))
    x_move+=x_1
    y_move+=y_1
for j in range(m):
    x_res, y_res = list(map(int, input().split()))
    x_res += x_move
    y_res += y_move
    print(x_res,' ',y_res)

e763ccd9e3644fd3946f1f9c0ae42702.png

二、坐标变换（其二）

问题描述

06edc47ea35645e4a8129e62f6bb69c1.jpeg

输入和输出

aae3c87c5bd1429c9856065fed44021c.png输入

10 5
2 0.59
2 4.956
1 0.997
1 1.364
1 1.242
1 0.82
2 2.824
1 0.716
2 0.178
2 4.094
1 6 -953188 -946637
1 9 969538 848081
4 7 -114758 522223
1 9 -535079 601597
8 8 159430 -511187

输出

-1858706.758 -83259.993
-1261428.46 201113.678
-75099.123 -738950.159
-119179.897 -789457.532
114151.88 -366009.892

思路

1、首先将利用两个数组op和value将操作和其对应的值存起来

2、在输入每一个查询时，找到数组op和value的起始位置和终止位置

3、从起始位置和终止位置进行运算即可

代码和结果

这里给出c++代码和python代码

c++代码

#include<iostream>
#include<math.h>
#include<iomanip>
using namespace std;

int main(){
	cout.setf(ios::fixed);

	cout.precision(3); // 精度为输出小数点后3位

	int n, m;
	cin >> n >> m;
	static int op[100001];
	static double value[100001];
	for (int i = 1; i <= n; i++) {
		int op1;
		double value1;
		cin >> op1 >> value1;
		op[i] = op1;
		value[i] = value1;
	}
	for (int j = 0; j < m; j++) {
		int op_start, op_end;
		double value1, value2;
		cin >> op_start >> op_end >> value1 >> value2;

		for (int op_index = op_start; op_index <= op_end; op_index++) {
			//对于第op_index进行以下操作
			int operation1 = op[op_index];//进行缩放或旋转
			double v1 = value[op_index];//
			if (operation1 == 1) {
				value1 = value1 * v1;
				value2 = value2 * v1;
			}
			else {
				double value1_copy = value1;
				value1 = value1 * cos(v1) - value2 * sin(v1);
				value2 = value1_copy * sin(v1) + value2 * cos(v1);
			}

		}
		cout <<value1 << " " << value2 << endl;

	}
}

99d859afa82646348fe2f1c4409cde30.png

python代码

import math

n,m = list(map(int,input().split()))
op = [0]
value = [0.]
for i in range(1,n+1):
    operate, v = input().split()
    op.append(int(operate))
    value.append(float(v))
for i in range(m):
    op_start_s,op_end_s,value1_s,value2_s= input().split()
    op_start = int(op_start_s)
    op_end = int(op_end_s)
    value1 = float(value1_s)
    value2 = float(value2_s)
    for j in range(op_start,op_end+1):
        #对于第op_index进行以下操作
        operation1 = op[j] # 进行缩放或旋转
        v1 = value[j]
        if operation1 == 1:
            value1 = value1 * v1
            value2 = value2 * v1
        else:
            value1_copy = value1 #这一步很重要
            value1 = value1 * math.cos(v1) - value2 * math.sin(v1)
            value2 = value1_copy * math.sin(v1) + value2 * math.cos(v1)
    print(value1,' ',value2)

feed4f10e22b443aa066efbf12d49233.png

改进 

然而由于查询过程中存在重复的查询，导致时间复杂度过高而只得到了80分。

通过观察发现，题目让我们求的是给定坐标经过op_start到op_end操作之后的结果，又通过操作内容可知，只包含旋转和坐标缩放这两种操作。从中可以得到以下结论：

首先，这两种操作是不受彼此干扰的；其次，旋转和缩放是可以累积计算的。

因此，我们可以通过两个数组记录从1到n个操作的结果，每一步操作是旋转操作和缩放操作的累积。首先计算从op_start到op_end旋转的角度，只需要用op_end旋转的角度减去op_start的角度；其次计算从op_start到op_end缩放的倍数，只需要用op_end缩放的倍数除以op_start缩放的倍数。

c++代码

//存在的问题：考虑到不能每次去遍历操作，因为这样会导致复杂度很高
//解决办法：将操作数组记录下来，因为缩放和旋转是无关的，所以可以使用两个数组存放；旋转是循环的可以实现累加，缩放也是可以累乘的
#include<iostream>
#include<math.h>
#include<iomanip>
using namespace std;
#define pai 3.14159265358979323846
int main() {
	cout.setf(ios::fixed);

	cout.precision(3); // 精度为输出小数点后3位

	int n, m;
	cin >> n >> m;
	//static int op_scale[100001];//分开存放两个操作
	//static int op_xuanzhuan[100001];
	static double value_scale[100001]={1};
	static double value_xuanzhuan[100001]={0};

	//累积缩放值
	double scale = 1;
	//累积旋转值，需要mod 2pai
	double xuanzhuan = 0;
	for (int i = 1; i <= n; i++) {//现在存放的就不是第i个操作了，而是前i个操作的累积
		int op1;
		double value1;
		cin >> op1 >> value1;
		if (op1 == 1) {
			//同时记录到上一轮的旋转
			value_xuanzhuan[i] = xuanzhuan;
			scale = scale * value1;
			value_scale[i] = scale;
		}
		else {
			//同时记录到上一轮的缩放
			value_scale[i] = scale;
			xuanzhuan = xuanzhuan + value1;//先不用取余，最后结果取余就行
			value_xuanzhuan[i] = xuanzhuan;
		}
	}
	for (int j = 0; j < m; j++) {
		int op_start, op_end;
		double value1, value2;
		cin >> op_start >> op_end >> value1 >> value2;

		//看op_start的缩放是多少，op_end的缩放系数是多少，除一下就是缩放的系数了
		double op_scale_start = value_scale[op_start-1];
		double op_scale_end = value_scale[op_end];

		double op_xuanzhuan_start = value_xuanzhuan[op_start-1];
		double op_xuanzhuan_end = value_xuanzhuan[op_end];

		//首先计算缩放了多少
		double scale_start_end = op_scale_end / op_scale_start;
		double xuanzhuan_start_end = fmod((op_xuanzhuan_end - op_xuanzhuan_start), 2 * pai);//op_xuanzhuan_start操作也是进行的
		double value1_copy = value1;
		value1 = scale_start_end*(value1 * cos(xuanzhuan_start_end) - value2 * sin(xuanzhuan_start_end));
		value2 = scale_start_end*(value1_copy * sin(xuanzhuan_start_end) + value2 * cos(xuanzhuan_start_end));
		cout << value1 << " " << value2 << endl;
	}
	return 0;

}

a0bbe917e0bc418a89cd2fa9466b7007.png

python代码

import math
n,m = list(map(int,input().split()))
#累积缩放值
scale = 1
#累积旋转值，需要mod 2pai
xuanzhuan = 0
value_scale = [1]
value_xuanzhuan = [0]
for i in range(1,n+1):#现在存放的就不是第i个操作了，而是前i个操作的累积
    op1_,value1_ = input().split()
    op1 = int(op1_)
    value1 = float(value1_)

    if op1 == 1:
        #同时记录到上一轮的旋转
        value_xuanzhuan.append(xuanzhuan)
        scale = scale * value1
        value_scale.append(scale)

    else:
        #同时记录到上一轮的缩放
        value_scale.append(scale)
        xuanzhuan = xuanzhuan + value1#先不用取余，最后结果取余就行
        value_xuanzhuan.append(xuanzhuan)
for j in range(m):
    op_start_s, op_end_s, value1_s, value2_s = input().split()
    op_start = int(op_start_s)
    op_end = int(op_end_s)
    value1 = float(value1_s)
    value2 = float(value2_s)

    #看op_start的缩放是多少，op_end的缩放系数是多少，除一下就是缩放的系数了
    op_scale_start = value_scale[op_start-1]
    op_scale_end = value_scale[op_end]

    op_xuanzhuan_start = value_xuanzhuan[op_start-1]
    op_xuanzhuan_end = value_xuanzhuan[op_end]

    #首先计算缩放了多少
    scale_start_end = op_scale_end / op_scale_start
    xuanzhuan_start_end = (op_xuanzhuan_end - op_xuanzhuan_start)%(2 * math.pi)#op_xuanzhuan_start操作也是进行的
    value1_copy = value1
    value1 = scale_start_end*(value1 * math.cos(xuanzhuan_start_end) - value2 * math.sin(xuanzhuan_start_end))
    value2 = scale_start_end*(value1_copy * math.sin(xuanzhuan_start_end) + value2 * math.cos(xuanzhuan_start_end))
    print(value1, ' ', value2)

三、梯度求解

问题描述

5f0b29a6f0c0470389daa0a260640276.png

输入和输出

5560175517f045d79e2c2b02ea1b7b2b.png

输入

2 2
x1 x1 x1 * x2 + *
1 2 3
2 3 4

输出

15
3

思路

本题是一道求偏导的题，计算过程很清晰，但是实现起来还是比较麻烦的。接下来简要介绍一下代码的思路：

1、首先，对于每一次输入，将每一个自变量的值存储起来，注：将逆波兰式的多项式使用copy()进行复制，防止后续操作修改了其中的内容。

for _ in range(m):
    data = list(map(int,input().split()))
    bianliang_j = data[0]
    poly_copy_list = poly_list.copy()
    value_list = data[1:]#从自变量1到自变量n的值
    bianliang_value_dict = {}#变量值字典
    for i in range(len(value_list)):
        if i+1!=int(bianliang_j):
            x_i = 'x'+str(i+1)
            bianliang_value_dict[x_i] = str(value_list[i])
        else:
            bianliang_j_value = int(value_list[i])

2、将多项式中的不要求偏导的自变量替换成其值，这样就仅包含一个自变量，可以使用字典存储多项式。

#复制多项式，将多项式中的不要求偏导的自变量替换成其值
for i in range(len(poly_copy_list)):
    if poly_copy_list[i] in bianliang_value_dict.keys():
        poly_copy_list[i]=bianliang_value_dict[poly_copy_list[i]]
class mul_poly():#对于一个仅包含一个变量的多项式，仅存储其系数和次数即可，但是考虑到稀疏性，得用字典来存储
    def __int__(self):
        self.poly = {}#键表示的是多项式的次数，值表示系数

3、开始处理偏导，因为逆波兰式可能只有一项（数值或变量），需要判断一下。如果只有一项，直接用字典形式表示多项式；否则利用栈读取逆波兰式。

  • 在处理逆波兰式时，为了简化运算符的判断，将减法用加法、乘法、系数-1进行表示。
  • 字典形式的多项式的计算方法为： 在乘法中，两重循环多项式a和多项式b的次数项（键），进行次数（键）相加，系数（值）相乘的操作；多项式加法为，单次循环多项式b的次数（键），如果多项式a中没有，则将多项式b的键值对添加到多项式a中；否则将多项式b的系数（值）和多项式a的系数（值）作和，即可完成加法运算。
 if len(poly_copy_list)==1:#只含一个数值或变量
        temp = trans_mul_poly(poly_copy_list[0]).poly
    else:
        temp = piandao(poly_copy_list)
def piandao(poly):
    '''
    :param
        -poly: 列表形式的多项式
    :return:
    '''
    new_poly = []
    for ele in poly:#a-b = a+ （-1 *）b 减法运算变成加法和乘法
        if ele=='-':#处理减法运算
            new_poly.append('-1')
            new_poly.append('*')
            new_poly.append('+')
        else:
            new_poly.append(ele)
    poly_stack =[]
    # #创建一个多项式字典，用以记录多项式加法和乘法的计算结果
    #通过逆波兰式读取结果
    for ele in new_poly:
        if ele not in ['+','*']:#如果不是运算符，则加入poly_stack中
            poly_stack.append(ele)
        else:
            b = poly_stack.pop()
            a = poly_stack.pop()
            #a和b初始只可能是 数值（可正可负）、自变量x_1 、之后存在(x_1的多项式)
            b_mul_poly = trans_mul_poly(b)
            a_mul_poly = trans_mul_poly(a)#转换成mul_poly对象
            res = compute(a_mul_poly,b_mul_poly,ele)
            poly_stack.append(res)
    result = poly_stack.pop()
    return result.poly
def compute(a_mul_poly,b_mul_poly,ele):
    '''
    :param a_mul_poly:
    :param b_mul_poly:
    :param ele: 运算符，取值为"+"或"*"
    :return:
    '''
    if ele=='*':
        res = mul_poly()
        res.poly = {}
       #对应位置的系数相乘
        for a in a_mul_poly.poly.keys():
            for b in b_mul_poly.poly.keys():
                # 次数相加，系数相乘
                a_b_sum_cishu = a+b
                a_b_sum_xishu = a_mul_poly.poly[a]*b_mul_poly.poly[b]
                if a_b_sum_cishu not in res.poly.keys():
                    res.poly[a_b_sum_cishu] = a_b_sum_xishu
                else:
                    res.poly[a_b_sum_cishu] += a_b_sum_xishu
        return res
    else:
        # 对应位置的系数相加
        for b_cishu in b_mul_poly.poly.keys():
            if b_cishu not in a_mul_poly.poly.keys():
                a_mul_poly.poly[b_cishu] = b_mul_poly.poly[b_cishu]
            else:
                a_mul_poly.poly[b_cishu] += b_mul_poly.poly[b_cishu]
        return a_mul_poly

4、获得结果

res = 0
for key in temp.keys():#键为多项式次数，值为系数
    if key == 0:#常数项求偏导为0
        continue
    elif key == 1: #存在0的0次方
        res+=temp[key]
    else:
        res+=key*temp[key]*bianliang_j_value**(key-1)
print(int(res%(10**9+7)))

代码和结果

class mul_poly():#对于一个仅包含一个变量的多项式，仅存储其系数和次数即可，但是考虑到稀疏性，得用字典来存储
    def __int__(self):
        self.poly = {}#键表示的是多项式的次数，值表示系数
def compute(a_mul_poly,b_mul_poly,ele):
    '''
    :param a_mul_poly:
    :param b_mul_poly:
    :param ele: 运算符，取值为"+"或"*"
    :return:
    '''
    if ele=='*':
        res = mul_poly()
        res.poly = {}
       #对应位置的系数相乘
        for a in a_mul_poly.poly.keys():
            for b in b_mul_poly.poly.keys():
                # 次数相加，系数相乘
                a_b_sum_cishu = a+b
                a_b_sum_xishu = a_mul_poly.poly[a]*b_mul_poly.poly[b]
                if a_b_sum_cishu not in res.poly.keys():
                    res.poly[a_b_sum_cishu] = a_b_sum_xishu
                else:
                    res.poly[a_b_sum_cishu] += a_b_sum_xishu
        return res
    else:
        # 对应位置的系数相加
        for b_cishu in b_mul_poly.poly.keys():
            if b_cishu not in a_mul_poly.poly.keys():
                a_mul_poly.poly[b_cishu] = b_mul_poly.poly[b_cishu]
            else:
                a_mul_poly.poly[b_cishu] += b_mul_poly.poly[b_cishu]
        return a_mul_poly
def trans_mul_poly(data):#将数据转成mul_poly对象
    if isinstance(data,mul_poly):
        return data
    else:
        res = mul_poly()
        res.poly = {}
        if 'x' in data:#是x自变量
            res.poly[1] = 1
        else:#是数值
            res.poly[0]=int(float(data)%(10**9+7))
        return res

def piandao(poly):
    '''
    :param
        -poly: 列表形式的多项式
    :return:
    '''
    new_poly = []
    for ele in poly:#a-b = a+ （-1 *）b 减法运算变成加法和乘法
        if ele=='-':#处理减法运算
            new_poly.append('-1')
            new_poly.append('*')
            new_poly.append('+')
        else:
            new_poly.append(ele)
    poly_stack =[]
    # #创建一个多项式字典，用以记录多项式加法和乘法的计算结果
    #通过逆波兰式读取结果
    for ele in new_poly:
        if ele not in ['+','*']:#如果不是运算符，则加入poly_stack中
            poly_stack.append(ele)
        else:
            b = poly_stack.pop()
            a = poly_stack.pop()
            #a和b初始只可能是 数值（可正可负）、自变量x_1 、之后存在(x_1的多项式)
            b_mul_poly = trans_mul_poly(b)
            a_mul_poly = trans_mul_poly(a)#转换成mul_poly对象
            res = compute(a_mul_poly,b_mul_poly,ele)
            poly_stack.append(res)
    result = poly_stack.pop()
    return result.poly
n,m=list(map(int,input().split()))
poly_list = input().split()
for _ in range(m):
    data = list(map(int,input().split()))
    bianliang_j = data[0]
    poly_copy_list = poly_list.copy()
    value_list = data[1:]#从自变量1到自变量n的值
    bianliang_value_dict = {}#变量值字典
    for i in range(len(value_list)):
        if i+1!=int(bianliang_j):
            x_i = 'x'+str(i+1)
            bianliang_value_dict[x_i] = str(value_list[i])
        else:
            bianliang_j_value = int(value_list[i])
    #复制多项式，将多项式中的不要求偏导的自变量替换成其值
    for i in range(len(poly_copy_list)):
        if poly_copy_list[i] in bianliang_value_dict.keys():
            poly_copy_list[i]=bianliang_value_dict[poly_copy_list[i]]
    if len(poly_copy_list)==1:#只含一个数值或变量
        temp = trans_mul_poly(poly_copy_list[0]).poly
    else:
        temp = piandao(poly_copy_list)
    res = 0
    for key in temp.keys():#键为多项式次数，值为系数
        if key == 0:#常数项求偏导为0
            continue
        elif key == 1: #存在0的0次方
            res+=temp[key]
        else:
            res+=key*temp[key]*bianliang_j_value**(key-1)
    print(int(res%(10**9+7)))

8f2581094a034998a4f4bbd8a396b647.png

淡写 ╮ 青春
关注
  • 33
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
CCF CSP（CCF计算机软件能力认证）&& CCSP_pdf-2021.01.10.rar
01-10
CCF CSP（CCF计算机软件能力认证）&& CCSP_pdf-2021.01.10.rar
CSP-J模拟赛：真题复现
08-02
CSP-J（中国计算机学会青少年软件编程能力认证初级）是一项针对青少年的编程能力评估考试，旨在检验考生的编程基础和逻辑思维能力。本模拟赛名为FCC - PCS-J，旨在与CSP-J保持相似的难度水平。试卷共20页，包含45道...
CSP认证 202309-1 坐标变换（其一）
weixin_44717777的博客
09-26 538
【代码】CSP认证 202309-1 坐标变换（其一）
CSP 坐标变换（其一） C语言
qq_62143927的博客
11-22 388
对于平面直角坐标系上的坐标 (x,y)，小 P 定义了一个包含 n 个操作的序列 T=(t1,t2,⋯,tn)。其中每个操作 ti（1≤i≤n）包含两个参数 dxi 和 dyi，表示将坐标 (x,y) 平移至 (x+dxi,y+dyi) 处。输出共 m 行，其中第 j（1≤j≤m）行包含空格分隔的两个整数，表示初始坐标 (xj,yj) 经过 n 个操作后的位置。现给定 m 个初始坐标，试计算对每个坐标 (xj,yj)（1≤j≤m）依次进行 T 中 n 个操作后的最终坐标。输入共 n+m+1 行。
CSP 202309-3 梯度求解
weixin_44340652的博客
09-26 3520
比较简单的一道题，只需要把其他变量对应的数代入进去，在栈里存表达式的要求的偏导的系数和对应的指数就可以，最后就变成处理关于偏导变量的一元多次方程的导数，就比较简单了。比赛的时候没有调出来，好亏。这种解法对于变量无关的求解是可行的，实际上利用二叉树的方法更好。
CCF-CSP真题《202309-1 坐标变换（其一）》思路+python，c++，java满分题解
热门推荐
weixin_53919192的博客
09-25 1万+
本文为大家题解了CCF-CSP真题《202309-1 坐标变换（其一）》，希望对你有帮助~~
matlab代码影响-EEG-CSP-Filter-Project:EEG-CSP-Filter-Project
05-22
matlab代码影响EEG-CSP-Filter-Project 介绍 该实验的目的是根据Mu Waves解码想象的运动。 当身体静止时，Mu Wave出现的频率为7.5 Hz至12 Hz。 通过进行脑电图实验（实验对象想象执行某项任务），验证了运动皮层中Mu...
csp-html-webpack-plugin：一个插件，与HTMLWebpackPlugin结合使用时，会将CSP标签添加到HTML输出中
02-06
npm i --save-dev csp-html-webpack-plugin 基本用法 在您的webpack配置中包括以下内容： const HtmlWebpackPlugin = require ( 'html-webpack-plugin' ) ; const CspHtmlWebpackPlugin = require ( 'csp-...
2023 CSP-J2 CSP-S2 复赛 第2轮 真题讲解.pdf
10-24
【CSP-J2 CSP-S2】是中国计算机学会（CCF）组织的计算机编程能力认证，主要面向中学生，旨在提升他们的编程技能和信息学奥林匹克竞赛水平。CSP-J2是入门级，适合初级选手；CSP-S2是提高级，针对有一定基础的参赛者。...
php-csp-nonce-source:PHP的CSP（内容安全策略）随机数源
05-24
它是防止XSS的CSP 2功能之一。 如果您不知道，请参阅 。 要求 PHP 5.4或更高版本 安装 $ git clone https://github.com/kenjis/php-csp-nonce-source.git $ cd php-csp-nonce-source $ composer install 用法 您...
CSP-31补题日记--梯度求解
qq_51677674的博客
11-04 596
202309-3 csp 3-梯度求解
CCF-CSP真题《202309-3 梯度求解》思路+python，c++满分题解
weixin_53919192的博客
11-05 8431
本文介绍了CCF-CSP真题《202309-3 梯度求解》思路+python，c++满分题解，希望对你有帮助~
2023.09 CCF-CSP 认证 第三题 《梯度求解》 80分
qq_29817727的博客
09-26 1926
刚开始完全没想法，索性用导数定义求解，将自变量和自变量减0.000001带入求函数值，用两个函数值之差除以0.000001，最后结果再四舍五入。后来想到最适合求导的就是多项式形式，一个数组就是一个多项式，下标就是一项的指数，值就是一项的系数。后缀表达式求值的方法也可以用来算多项式。不过还是没AC，只有80分，不知道问题在哪。
第31次CCF计算机软件能力认证第二题《坐标转换其二》80分-＞100分攻略【2023-9-17】 C++/C
qq_73884528的博客
09-17 4286
我们可以创建一个sum数组，sum[i]储存的是第一个元素到第i个元素之和，预处理之后我们求样例中的第i个数到第j个数便可以直接是sum[j]-sum[i-1]这道题目一看十分简单，直接从将第i个数加到第j个数输出便可以完成，但是如果 n，m的数量级很大，就会出现超时现象。输入n个操作之后储存在数组arr中，在m个样例中分别模拟一遍从第i步到第j步是导致这道题最后超时的原因。给你一个数组，存在n个整数，共有m个样例，每个样例有i和j两个整数，请输出第i 个数到第j个数的和。
CCF CSP 202309-2 坐标变换（其二）
reidpa的博客
10-10 2548
利用前缀和（积）求解CCF CSP 202309-2 坐标变换（其二）
CCF CSP题解：坐标变换（其二）（202309-2）
曹无悔的博客
10-12 6010
使用前缀和的思想，求解CCF CSP认证的试题《坐标变换（其二）（202309-2）》。
Python坐标旋转 如何实现二维图形的旋转变换
我点评的博客
07-13 2485
Python坐标旋转：如何实现二维图形的旋转变换在二维图形的绘制中，旋转变换是一项非常常用的技术。通过旋转变换，可以将一个图形绕着某个点旋转一定角度，从而得到一个全新的图形。在Python编程中，实现二维图形的旋转变换也是非常简单的。本文将介绍如何使用Python实现二维图形的旋转变换，以及需要注意的一些细节。Python坐标旋转 如何实现二维图形的旋转变换在实现二维图形的旋转变换之前，我们需要明确坐标系的旋转规则。在笛卡尔坐标系中，我们通常将x轴作为原点，将y轴作为旋转角度的正方向。
CCF-CSP练习 坐标变换（其二）
Jiangtongguan的博客
11-28 1189
CCF 202309-2 坐标变换（其二）
CSP-202309-3-梯度求解
最新发布
fzy2003的博客
02-22 1004
并在每次迭代中处理这些子字符串。这种处理方式对于解析和执行基于逆波兰表示法（RPN）的算术表达式非常有效，因为它允许程序按照操作的顺序（从左到右）逐步计算表达式的结果。：从标准输入读取一个字符。这里它的作用可能是用来“吃掉”（消耗）前一个输入后留下的。是一个流类，可以像输入/输出流一样操作字符串。，然后将读取到的文本（不包括换行符）存储到之前声明的字符串变量中。（如空格、制表符等）来拆分原始字符串。，要符合导数运算的规则。循环的作用是逐个读取。由于求的是导数，这里的。常数，类似于非变量的。
csp坐标变换（其二）
11-22
假设原始矩阵中的一个点的坐标为(x, y)，则变换后的坐标为(x', y')，其中： x' = a1 * x + b1 * y + c1 y' = a2 * x + b2 * y + c2 其中a1, b1, c1, a2, b2, c2是给定的常数。 我们可以将这个变换看作是一个线性...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值