POJ - 2991 Crane （段树+计算几何）

Description

ACM has bought a new crane (crane -- jeřáb) . The crane consists of n segments of various lengths, connected by flexible joints. The end of the i-th segment is joined to the beginning of the i + 1-th one, for 1 ≤ i < n. The beginning of the first segment is fixed at point with coordinates (0, 0) and its end at point with coordinates (0, w), where w is the length of the first segment. All of the segments lie always in one plane, and the joints allow arbitrary rotation in that plane. After series of unpleasant accidents, it was decided that software that controls the crane must contain a piece of code that constantly checks the position of the end of crane, and stops the crane if a collision should happen.

Your task is to write a part of this software that determines the position of the end of the n-th segment after each command. The state of the crane is determined by the angles between consecutive segments. Initially, all of the angles are straight, i.e., 180 ^o. The operator issues commands that change the angle in exactly one joint.

Input

The input consists of several instances, separated by single empty lines.

The first line of each instance consists of two integers 1 ≤ n ≤10 000 and c 0 separated by a single space -- the number of segments of the crane and the number of commands. The second line consists of n integers l1,..., ln (1 li 100) separated by single spaces. The length of the i-th segment of the crane is li. The following c lines specify the commands of the operator. Each line describing the command consists of two integers s and a (1 ≤ s < n, 0 ≤ a ≤ 359) separated by a single space -- the order to change the angle between the s-th and the s + 1-th segment to a degrees (the angle is measured counterclockwise from the s-th to the s + 1-th segment).

Output

The output for each instance consists of c lines. The i-th of the lines consists of two rational numbers x and y separated by a single space -- the coordinates of the end of the n-th segment after the i-th command, rounded to two digits after the decimal point.

The outputs for each two consecutive instances must be separated by a single empty line.

Sample Input

2 1
10 5
1 90

3 2
5 5 5
1 270
2 90

Sample Output

5.00 10.00

-10.00 5.00
-5.00 10.00

题意：有一个n节的机械手，每次让某个节点移动使得第i条边和第i+1条边的夹角是a，初始化夹角都是180度，求经过操作后最后一个节点位置

思路：相同是线段树的区间更新，由于要求的是最后一个点的坐标，我们知道向量是能够相加的，那么我们把每一个线段当成向量相加的话，就能够得到最后的坐标了，再者就是旋转的问题了，我们相同知道旋转后，第i+1后的边都会受到影响，这就是线段树的区间更新了；然后有了逆时针向量旋转的公式我们就能够得到解了。注意的地方是：我们每次储存上一次的角度，依次来推出这次须要旋转的角度，还有就是不知道会平白无故W了还多次，还是换个姿势做的

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <cmath>
#define lson(x) ((x) << 1)
#define rson(x) ((x) << 1 | 1)
using namespace std;
const int maxn = 10002;

int angle[maxn], setv[maxn<<2];
double sumx[maxn<<2], sumy[maxn<<2];

void update(int pos) {
	sumx[pos] = sumx[lson(pos)] + sumx[rson(pos)];
	sumy[pos] = sumy[lson(pos)] + sumy[rson(pos)];
}

void build(int l, int r, int pos) {
	setv[pos] = 0;
	if (l == r) {
		scanf("%lf", &sumy[pos]);
		sumx[pos] = 0;
		return;
	}
	int m = l + r >> 1;
	build(l, m, lson(pos));
	build(m+1, r, rson(pos));
	update(pos);
}

void change(int pos, int d) {
	double tmp = d * acos(-1.0) / 180;
	double x = sumx[pos]*cos(tmp) - sumy[pos]*sin(tmp);
	double y = sumx[pos]*sin(tmp) + sumy[pos]*cos(tmp);
	sumx[pos] = x;
	sumy[pos] = y;
}

void push(int pos) {
	if (setv[pos]) {
		setv[lson(pos)] += setv[pos];
		setv[rson(pos)] += setv[pos];
		change(lson(pos), setv[pos]);
		change(rson(pos), setv[pos]);
		setv[pos] = 0;
	}
}

void modify(int l, int r, int pos, int x, int y, int z) {
	if (x <= l && y >= r) {
		setv[pos] += z;
		change(pos, z);
		return;
	}
	push(pos);
	int m = l + r >> 1;
	if (x <= m)
		modify(l, m, lson(pos), x, y, z);
	if (y > m)
		modify(m+1, r, rson(pos), x, y, z);
	update(pos);
}

int main() {
	int n, q;
	int first = 1;
	while (scanf("%d%d", &n, &q) != EOF) {
		if (first)
			first = 0;
		else printf("\n");
		build(1, n, 1);
		for (int i = 1; i <= n; i++)
			angle[i] = 180;
		int a, b;
		while (q--) {
			scanf("%d%d", &a, &b);
			modify(1, n, 1, a+1, n, b-angle[a]);
			angle[a] = b;
			printf("%.2lf %.2lf\n", sumx[1], sumy[1]);
		}
	}
	return 0;
}

版权声明：本文博客原创文章，博客，未经同意，不得转载。