2021灵动冬令营Day2

A - Maya Calendar

Description

During his last sabbatical, professor M. A. Ya made a surprising discovery about the old Maya calendar. From an old knotted message, professor discovered that the Maya civilization used a 365 day long year, called Haab, which had 19 months. Each of the first 18 months was 20 days long, and the names of the months were pop, no, zip, zotz, tzec, xul, yoxkin, mol, chen, yax, zac, ceh, mac, kankin, muan, pax, koyab, cumhu. Instead of having names, the days of the months were denoted by numbers starting from 0 to 19. The last month of Haab was called uayet and had 5 days denoted by numbers 0, 1, 2, 3, 4. The Maya believed that this month was unlucky, the court of justice was not in session, the trade stopped, people did not even sweep the floor.

For religious purposes, the Maya used another calendar in which the year was called Tzolkin (holly year). The year was divided into thirteen periods, each 20 days long. Each day was denoted by a pair consisting of a number and the name of the day. They used 20 names: imix, ik, akbal, kan, chicchan, cimi, manik, lamat, muluk, ok, chuen, eb, ben, ix, mem, cib, caban, eznab, canac, ahau and 13 numbers; both in cycles.

Notice that each day has an unambiguous description. For example, at the beginning of the year the days were described as follows:

1 imix, 2 ik, 3 akbal, 4 kan, 5 chicchan, 6 cimi, 7 manik, 8 lamat, 9 muluk, 10 ok, 11 chuen, 12 eb, 13 ben, 1 ix, 2 mem, 3 cib, 4 caban, 5 eznab, 6 canac, 7 ahau, and again in the next period 8 imix, 9 ik, 10 akbal . . .

Years (both Haab and Tzolkin) were denoted by numbers 0, 1, : : : , where the number 0 was the beginning of the world. Thus, the first day was:

Haab: 0. pop 0

Tzolkin: 1 imix 0
Help professor M. A. Ya and write a program for him to convert the dates from the Haab calendar to the Tzolkin calendar.

Input

The date in Haab is given in the following format:
NumberOfTheDay. Month Year

The first line of the input file contains the number of the input dates in the file. The next n lines contain n dates in the Haab calendar format, each in separate line. The year is smaller then 5000.

Output

The date in Tzolkin should be in the following format:
Number NameOfTheDay Year

The first line of the output file contains the number of the output dates. In the next n lines, there are dates in the Tzolkin calendar format, in the order corresponding to the input dates.

Sample Input

3
10. zac 0
0. pop 0
10. zac 1995

Sample Output

3
3 chuen 0
1 imix 0
9 cimi 2801

解题思路

这题直接根据haab历去算从第一天开始到当前天一共有多少天

然后总的天数/260就是holly历的年数，因为是从0开始，所以不需要特判

后面的天数和天数对应的字符串，一个直接 %20 然后找到对应的输出即可，一个需要 %13 + 1，因为这个是从1开始计数的

AC代码

#include<iostream>
#include<string>
#include<map>

using namespace std;
map<string, int> mp;
string haab[] = {"pop", "no", "zip", "zotz", "tzec", "xul", "yoxkin", "mol", "chen", "yax", "zac", "ceh", "mac",
				  "kankin", "muan", "pax", "koyab", "cumhu", "uayet"};
				  
string holly[] = {"imix", "ik", "akbal", "kan", "chicchan", "cimi", "manik", "lamat", "muluk", "ok", "chuen", "eb", 
				  "ben", "ix", "mem", "cib", "caban", "eznab", "canac", "ahau"};
int main() {
	for(int i = 0; i <= 18; i++) mp[haab[i]] = i;
	int t, y, d;
	string m;
	char c;
	cin >> t;
	cout << t << endl;
	int cury, curd;
	string curm;
	while(t--) {
		cin >> d >> c >> m >> y;
		int sum = y * 365 + mp[m] * 20 + d;
		cury = sum / 260;
		curd = sum % 13 + 1;
		curm = holly[sum % 20];
		cout << curd << " " << curm << " " << cury << endl;
		
	}
	return 0;
}

B - Diplomatic License

Description

In an effort to minimize the expenses for foreign affairs the countries of the world have argued as follows. It is not enough that each country maintains diplomatic relations with at most one other country, for then, since there are more than two countries in the world, some countries cannot communicate with each other through (a chain of) diplomats.

Now, let us assume that each country maintains diplomatic relations with at most two other countries. It is an unwritten diplomatic “must be” issue that every country is treated in an equal fashion. It follows that each country maintains diplomatic relations with exactly two other countries.

International topologists have proposed a structure that fits these needs. They will arrange the countries to form a circle and let each country have diplomatic relations with its left and right neighbours. In the real world, the Foreign Office is located in every country’s capital. For simplicity, let us assume that its location is given as a point in a two-dimensional plane. If you connect the Foreign Offices of the diplomatically related countries by a straight line, the result is a polygon.

It is now necessary to establish locations for bilateral diplomatic meetings. Again, for diplomatic reasons, it is necessary that both diplomats will have to travel equal distances to the location. For efficiency reasons, the travel distance should be minimized. Get ready for your task!

Input

The input contains several testcases. Each starts with the number n of countries involved. You may assume that n>=3 is an odd number. Then follow n pairs of x- and y-coordinates denoting the locations of the Foreign Offices. The coordinates of the Foreign Offices are integer numbers whose absolute value is less than 1012. The countries are arranged in the same order as they appear in the input. Additionally, the first country is a neighbour of the last country in the list.

Output

For each test case output the number of meeting locations (=n) followed by the x- and y-coordinates of the locations. The order of the meeting locations should be the same as specified by the input order. Start with the meeting locations for the first two countries up to the last two countries. Finally output the meeting location for the n-th and the first country.

Sample Input

5 10 2 18 2 22 6 14 18 10 18
3 -4 6 -2 4 -2 6
3 -8 12 4 8 6 12

Sample Output

5 14.000000 2.000000 20.000000 4.000000 18.000000 12.000000 12.000000 18.000000 10.000000 10.000000
3 -3.000000 5.000000 -2.000000 5.000000 -3.000000 6.000000
3 -2.000000 10.000000 5.000000 10.000000 -1.000000 12.000000

Hint

Note that the output can be interpreted as a polygon as well. The relationship between the sample input and output polygons is illustrated in the figure on the page of Problem 1940. To generate further sample input you may use your solution to that problem. 

解题思路

这题是让求相邻两个点的中点坐标，因此直接遍历求一遍就可以了

AC代码

#include<cstdio>

using namespace std;

struct list {
	double x, y;
}first, last, pre;

int main() {
	int n;
	while(~scanf("%d", &n)) {
		printf("%d", n);
		scanf("%lf%lf", &first.x, &first.y);
		pre = first;
		for(int i = 2; i <= n; i++) {
			scanf("%lf%lf", &last.x, &last.y);
			printf(" %.6f %.6f", (last.x + pre.x) / 2, (last.y + pre.y) / 2);
			pre = last;
		}
		printf(" %.6f %.6f\n", (last.x + first.x) / 2, (last.y + first.y) / 2);
	}
	return 0;
}

C - “Accordian” Patience

Description

You are to simulate the playing of games of ``Accordian’’ patience, the rules for which are as follows:

Deal cards one by one in a row from left to right, not overlapping. Whenever the card matches its immediate neighbour on the left, or matches the third card to the left, it may be moved onto that card. Cards match if they are of the same suit or same rank. After making a move, look to see if it has made additional moves possible. Only the top card of each pile may be moved at any given time. Gaps between piles should be closed up as soon as they appear by moving all piles on the right of the gap one position to the left. Deal out the whole pack, combining cards towards the left whenever possible. The game is won if the pack is reduced to a single pile.
Situations can arise where more than one play is possible. Where two cards may be moved, you should adopt the strategy of always moving the leftmost card possible. Where a card may be moved either one position to the left or three positions to the left, move it three positions.

Input

Input data to the program specifies the order in which cards are dealt from the pack. The input contains pairs of lines, each line containing 26 cards separated by single space characters. The final line of the input file contains a # as its first character. Cards are represented as a two character code. The first character is the face-value (A=Ace, 2-9, T=10, J=Jack, Q=Queen, K=King) and the second character is the suit (C=Clubs, D=Diamonds, H=Hearts, S=Spades).

Output

One line of output must be produced for each pair of lines (that between them describe a pack of 52 cards) in the input. Each line of output shows the number of cards in each of the piles remaining after playing ``Accordian patience’’ with the pack of cards as described by the corresponding pairs of input lines.

Sample Input

QD AD 8H 5S 3H 5H TC 4D JH KS 6H 8S JS AC AS 8D 2H QS TS 3S AH 4H TH TD 3C 6S
8C 7D 4C 4S 7S 9H 7C 5D 2S KD 2D QH JD 6D 9D JC 2C KH 3D QC 6C 9S KC 7H 9C 5C
AC 2C 3C 4C 5C 6C 7C 8C 9C TC JC QC KC AD 2D 3D 4D 5D 6D 7D 8D TD 9D JD QD KD
AH 2H 3H 4H 5H 6H 7H 8H 9H KH 6S QH TH AS 2S 3S 4S 5S JH 7S 8S 9S TS JS QS KS
#

Sample Output

6 piles remaining: 40 8 1 1 1 1
1 piles remaining: 52

解题思路

这题考察是对链表得应用，因为这题需要去看前面的状态，所以需要用到三项链表

由于链表处理起来比较麻烦，因此这题采用模拟链表的做法

这题首先需要记录每一堆排的前后关系，并且还有每一堆牌的每一张牌的信息

然后从左遍历一遍，如果可以移动就去移动，每移动完需要去看这张牌移去的那一堆是否可以继续去移动

需要注意的是如果有一堆牌没了，需要删除这一堆

AC代码

#include<cstdio>

using namespace std;
const int N = 55;

char s[N][N][N];
int pre[N], last[N], mp[N], sum[N], ans[N];

int getp3(int x) {
	int p1 = pre[x], p2 = pre[p1], p3 = pre[p2];
	return p3;	
}

int getp1(int x) {
	int p1 = pre[x];
	return p1;
}

int main() {
	while(1) {
		scanf("%s", s[1][1]);
		if(s[1][1][0] == '#') break;
		last[1] = 2; sum[1] = 1; last[0] = 1;
		for(int i = 2; i <= 52; i++) {
			scanf("%s", s[i][1]);
			pre[i] = i - 1;
			last[i] = i + 1;
			sum[i] = 1;
		}
		
		for(int i = 2; i <= 52; i = last[i]) {
			int p = getp3(i);
			if(p > 0 && (s[p][sum[p]][0] == s[i][sum[i]][0] || s[p][sum[p]][1] == s[i][sum[i]][1])) {
				sum[p]++;
				s[p][sum[p]][0] = s[i][sum[i]][0];
				s[p][sum[p]][1] = s[i][sum[i]][1];
				sum[i]--;
				if(sum[i] == 0) {
					last[pre[i]] = last[i];
					pre[last[i]] = pre[i];
				}
				i = pre[p];
				continue;
			}
			p = getp1(i);
			if(p > 0 && (s[p][sum[p]][0] == s[i][sum[i]][0] || s[p][sum[p]][1] == s[i][sum[i]][1])) {
				sum[p]++;
				s[p][sum[p]][0] = s[i][sum[i]][0];
				s[p][sum[p]][1] = s[i][sum[i]][1];
				sum[i]--;
				if(sum[i] == 0) {
					last[pre[i]] = last[i];
					pre[last[i]] = pre[i];
				}
				i = pre[p];
				continue;
			}
		}
		int cnt = 0;
		for(int i = 1; i <= 52; i++) {
			if(sum[i]) ans[cnt++] = sum[i];
		}
		printf("%d piles remaining: %d", cnt, ans[0]);
		for(int i = 1; i < cnt; i++) {
			printf(" %d", ans[i]);
		}
		printf("\n");
	}
	return 0;
}

D - Broken Keyboard (a.k.a. Beiju Text)

Description

You’re typing a long text with a broken keyboard. Well it’s not so badly broken. The only problem with the keyboard is that sometimes the “home” key or the “end” key gets automatically pressed (internally). You’re not aware of this issue, since you’re focusing on the text and did not even turn on the monitor! After you finished typing, you can see a text on the screen (if you turn on the monitor). In Chinese, we can call it Beiju. Your task is to find the Beiju text.

Input

There are several test cases. Each test case is a single line containing at least one and at most 100,000 letters, underscores and two special characters ‘[’ and ‘]’. ‘[’ means the “Home” key is pressed internally, and ‘]’ means the “End” key is pressed internally. The input is terminated by end-of-file (EOF).

Output

For each case, print the Beiju text on the screen

Sample Input

This_is_a_[Beiju]_text
[[]][][]Happy_Birthday_to_Tsinghua_University

Sample Output

BeijuThis_is_a__text
Happy_Birthday_to_Tsinghua_University

解题思路

这题把每个字符都当成一个独立的单元，用数组模拟链表即可，遇到[到头，]到尾

AC代码

#include<cstdio>
#include<cstring>
#include<algorithm>

using namespace std;
const int N = 1e5 + 10;
char s[N];
int pre[N], last[N];

int main() {
	while(~scanf("%s", s + 1)) {
		int len = strlen(s + 1);
		int st = 0, ed = len - 1;
		int now = 0;
		for(int i = 0; i <= len + 1; i++) last[i] = 0;
		for(int i = 1; i <= len; i++) {
			if(s[i] != '[' && s[i] != ']') {
				last[now] = i;
				now = i;
			} else if(s[i] == '[') {
				if(s[i + 1] == ']' || s[i + 1] == '[' || i + 1 > len) continue;
				i += 1;
				int tmp = i;
				int ti = i;
				while(s[i + 1] != '[' && s[i + 1] != ']' && i + 1 <= len) {
					last[tmp] = i + 1;
					tmp = i + 1;
					i++;
				}
				last[tmp] = last[0];
				last[0] = ti;
				if(now == 0) now = tmp;
			} else {
				if(s[i + 1] == ']' || s[i + 1] == '[' || i + 1 > len) continue;
				i += 1;
				int tmp = i;
				int ti = i;
				while(s[i + 1] != '[' && s[i + 1] != ']' && i + 1 <= len) {
					last[tmp] = i + 1;
					tmp = i + 1;
					i++;
				}
				last[now] = ti;
				now = tmp;
			}
		}
		int t = 0;
		while(last[t]) {
			printf("%c", s[last[t]]);
			t = last[t];
		}
		printf("\n");
	}
	return 0;
}

E - Satellites

Description

We all love recursion! Don’t we?The radius of earth is 6440 Kilometer. There are many Satellites and Asteroids moving around the earth. If two Satellites create an angle with the center of earth, can you find out the distance between them? By distance we mean both the arc and chord distances. Both satellites are on the same orbit (However, please consider that they are revolving on a circular path rather than an elliptical path).

Input

The input file will contain one or more test cases. Each test case consists of one line containing two-integer s and a, and a string ‘min’ or ‘deg’. Here s is the distance of the satellite from the surface of the earth and a is the angle that the satellites make with the center of earth. It may be in minutes (′ ) or in degrees (◦ ). Remember that the same line will never contain minute and degree at a time.

Output

For each test case, print one line containing the required distances i.e. both arc distance and chord distance respectively between two satellites in Kilometer. The distance will be a floating-point value with six digits after decimal point.

Sample Input

500 30 deg
700 60 min
200 45 deg

Sample Output

3633.775503 3592.408346
124.616509 124.614927
5215.043805 5082.035982

解题思路

这题就是纯公式计算，直到度算弦长和对应的曲线长度

AC代码

#include<cstdio>
#include<cmath>

using namespace std;
const double r = 6440;
char st[10];
double s, a;

int main() {
	double pi = acos(-1.0);
	while(~scanf("%lf%lf%s", &s, &a, st)) {
		if(a > 180) a = 360 - a;
		if(st[0] == 'd') {
			printf("%.6f %.6f\n", 2 * pi * (r + s) * a / 360, (r + s) * sin((pi * a) / 360) * 2);
		} else {
			printf("%.6f %.6f\n", 2 * pi * (r + s) * a / (360 * 60), (r + s) * sin((pi * a) / (360 * 60)) * 2);
		}
	}
	return 0;
}

F - Fourth Point !!

Description

Given are the (x, y) coordinates of the endpoints of two adjacent sides of a parallelogram. Find the (x, y) coordinates of the fourth point.

Input

Each line of input contains eight floating point numbers: the (x, y) coordinates of one of the endpoints of the first side followed by the (x, y) coordinates of the other endpoint of the first side, followed by the (x, y) coordinates of one of the endpoints of the second side followed by the (x, y) coordinates of the other endpoint of the second side. All coordinates are in meters, to the nearest mm. All coordinates are between −10000 and +10000. Input is terminated by end of file.

Output

For each line of input, print the (x, y) coordinates of the fourth point of the parallelogram in meters, to the nearest mm, separated by a single space.

Sample Input

0.000 0.000 0.000 1.000 0.000 1.000 1.000 1.000
1.000 0.000 3.500 3.500 3.500 3.500 0.000 1.000
1.866 0.000 3.127 3.543 3.127 3.543 1.412 3.145

Sample Output

1.000 0.000
-2.500 -2.500
0.151 -0.398

解题思路

这题由于已经给出了三个点，让你去求第四个点构成平行四边形

因此需要要找出是哪三个点，然后根据平行四边形的性质直接可以求出第四个点

AC代码

#include<cstdio>
#include<cmath>
#include<algorithm>

using namespace std;

struct node {
	double x, y;
}a, b, c, d, ans; 

int main() {
	while(~scanf("%lf%lf%lf%lf%lf%lf%lf%lf", &a.x, &a.y,  &b.x, &b.y, &c.x, &c.y, &d.x, &d.y)) {
		if(a.x == c.x && a.y == c.y) {
			swap(c, d);
		} else if(b.x == c.x && b.y == c.y) {
			swap(a, b); swap(c, d);
		} else if(b.x == d.x && b.y == d.y) {
			swap(a, b);
		}
		printf("%.3f %.3f\n", b.x + c.x - a.x, b.y + c.y - a.y);
	}
	return 0;
}

G - The Circumference of the Circle

Description

To calculate the circumference of a circle seems to be an easy task - provided you know its diameter. But what if you don’t?

You are given the cartesian coordinates of three non-collinear points in the plane.
Your job is to calculate the circumference of the unique circle that intersects all three points.

Input

The input will contain one or more test cases. Each test case consists of one line containing six real numbers x1,y1, x2,y2,x3,y3, representing the coordinates of the three points. The diameter of the circle determined by the three points will never exceed a million. Input is terminated by end of file.

Output

For each test case, print one line containing one real number telling the circumference of the circle determined by the three points. The circumference is to be printed accurately rounded to two decimals. The value of pi is approximately 3.141592653589793.

Sample Input

0.0 -0.5 0.5 0.0 0.0 0.5
0.0 0.0 0.0 1.0 1.0 1.0
5.0 5.0 5.0 7.0 4.0 6.0
0.0 0.0 -1.0 7.0 7.0 7.0
50.0 50.0 50.0 70.0 40.0 60.0
0.0 0.0 10.0 0.0 20.0 1.0
0.0 -500000.0 500000.0 0.0 0.0 500000.0

Sample Output

3.14
4.44
6.28
31.42
62.83
632.24
3141592.65

解题思路

这题是已知一个圆的内接三角形的顶点，相当于一直每条边的边长，因此利用海伦公式和三角形求外接圆半径的公式可以推出来答案

AC代码

#include<cstdio>
#include<cmath>

using namespace std;
const double pi = 3.141592653589793;

double cal(double x1, double y1, double x2, double y2) {
	return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}

int main() {
	double x1, y1, x2, y2, x3, y3;
	while(~scanf("%lf%lf%lf%lf%lf%lf", &x1, &y1, &x2, &y2, &x3, &y3)) {
		double a = cal(x1, y1, x2, y2);
		double b = cal(x1, y1, x3, y3);
		double c = cal(x2, y2, x3, y3);
		double p = (a + b + c) / 2;
		double s = sqrt(p * (p - a) * (p - b) * (p - c));
		printf("%.2f\n", a * b * c / (2 * s) * pi);
	}
	return 0;
}