ACM/ICPC亚洲区大概总共多少名额？
Posted
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了ACM/ICPC亚洲区大概总共多少名额？相关的知识，希望对你有一定的参考价值。
RT.
还有，全球总决赛先现在一般有多少只队伍参赛？
5. slot的分配重大变革，和去年后半段教练投票的方案2相同
所有大陆5站赛区按排名排队，第一名的学校获得一个slot。
然后是第二名，第三名。。。学校不重复计算。
如果名额剩余的数量小于同名次的学校数，没有定怎么搞，可能是黄金雄决定，或者按这些学校第二好成绩之类的来定。
比如说 5站比赛，清华拿2个冠军，上交拿2个，中山拿1个，那么这一轮就这三个学校拿走3个slot
然后每站的第二名，清华1，上交1个，复旦1个，北大1个，电子科大1个，那么清华上交就不算了，复旦，北大，电子科大各获1个slot；
依次计算，直到剩余名额不够分配同档学校时，再做一些处理。
6. 大陆地区学校去其他分赛区获得冠亚军获得 slot 在大陆地区的 slot 中分配。
7. 外国（地区）学校在大陆地区比赛获得 slot 有优惠（黄金雄的意思是学校前15名）。 参考技术A 中国大陆一般5场，每场第一名自动获得一个WF的名额，其余要综合看别的赛区的名次，反正要有金牌才有希望，还有一些学校去台湾，日本东南亚等赛区，相对竞争比较小。每年中国WF最多也就是有20支左右队伍，算是非常非常多的国家了，WF一般有150左右的队伍，但是强国还是俄罗斯，他们的数学太NB了，美国波兰等等都比较厉害，中国上交算是比较稳定强校了。 参考技术B 名额不固定，根据参加比赛的学校数量以及各学校成绩决，一般情况下，亚洲区的中国五个区域赛区每个至少有一个名额，其他名额根据剩余学校的成绩进行对比选出。
赛事由各大洲区域预赛和全球总决赛两个阶段组成。决赛安排在每年的3-5月举行，而区域预赛一般安排在上一年的9-12月举行。原则上一个大学在一站区域预赛最多可以有3支队伍，但只能有一支队伍参加全球总决赛。
入围世界总决赛名额（WF Slots）分为参与名额（Participation Slots）、奖牌名额（Medal Bonus Slots）和其他红利名额（Other Bonus Slots）三类。其中参与名额是从ICPC总部分配给各大洲区的参与名额（ParticipationSlots）中，由各大洲洲区主席确定并分配给洲子赛区的部分，其中各预赛区第一名自动获得参加全球总决赛的资格；奖牌名额是ICPC总部根据上一年度总决赛结果直接分配给获得奖牌的特定学校的名额；其他红利名额是各大洲区主席从ICPC总部争取到的额外奖励名额。
全球总决赛第一名将获得奖杯一座。另外，成绩靠前的参赛队伍也将获得金、银和铜牌。而解题数在中等以下的队伍会得到确认但不会进行排名。
区域赛一般分别按10%，20%，30%的比例颁发金，银，铜奖，即一般情况（120队伍）有12支队伍获金牌，24支队伍获银牌，36支队伍获铜牌，其余为优胜奖。
2010年亚洲区域赛中国大陆5大赛区由阿里巴巴公司赞助，获得金牌的选手可以享受绿色通道，进入阿里巴巴实习或参加工作。
2012年亚洲区域赛中国大陆5大赛区由华为公司赞助，有奖金(冠5000、亚3000、季2000，非冠亚季的金牌1200，FB（First Blood，指全场第一个解答出某道题） 800，最佳女队800，顽强拼搏500)。顽强拼搏是全场最后一个AC，且只AC1道题的队伍。
总决赛前十名的队伍将得到高额奖学金：第一名奖金为12000美元，第二名奖金为6000美元，第三名奖金为3000美元，第四名至第十名将各得到l500美元。除此之外还将承认北美冠军、欧洲冠军、南太平洋冠军及亚洲冠军。
2014ACM/ICPC亚洲区鞍山赛区现场赛题解报告
此文章可以使用目录功能哟↑(点击上方[+])
练习了一下前年鞍山赛区的区域赛题,感觉整个人状态都不对,各种低级错误频出,诸如数组开小了,中间结果爆int了等等,看来还是得多练...
链接→2014ACM/ICPC亚洲区鞍山赛区现场赛——题目重现
Problem 1002 Chat
Accept: 0 Submit: 0
Time Limit: 2000/1000 MS (Java/Others) Memory Limit : 262144/262144 K (Java/Others)
Problem Description
As everyone knows, DRD has no girlfriends. But as everyone also knows, DRD’s friend ATM’s friend CLJ has many potential girlfriends. One evidence is CLJ’s chatting record.
CLJ chats with many girls all the time. Sometimes he begins a new conversation and sometimes he ends a conversation. Sometimes he chats with the girl whose window is on the top.
You can imagine CLJ’s windows as a queue. The first girl in the queue is the top girl if no one is “always on top ”.
Since CLJ is so popular, he begins to assign a unique positive integer as priority for every girl. The higher priority a girl has, the more CLJ likes her. For example, GYZ has priority 109, and JZP has priority 108 while Sister Soup has priority 1, and Face Face has priority 2.
As a famous programmer, CLJ leads a group to implement his own WM(window manager). The WM will log CLJ’s operations. Now you are supposed to implement the log system. The general logging format is “Operation #X: LOGMSG.”, where X is the number of the operation and LOGMSG is the logging message.
There are several kinds of operations CLJ may use:
1.Add u: CLJ opens a new window whose priority is u, and the new window will be the last window in the window queue. This operation will always be successful except the only case in which there is already a window with priority u. If it is successful, LOGMSG will be “success”. Otherwise LOGMSG will be “same priority”.
2.Close u: CLJ closes a window whose priority is u. If there exists such a window, the operation will be successful and LOGMSG will be “close u with c”, where u is the priority and c is the number of words CLJ has spoken to this window. Otherwise, LOGMSG will be “invalid priority”. Note that ANY window can be closed.
3.Chat w: CLJ chats with the top window, and he speaks w words. The top window is the first window in the queue, or the “always on top” window (as described below) instead if there exists. If no window is in the queue, LOGMSG will be “empty”, otherwise the operation can be successful and LOGMSG will be “success”.
4.Rotate x: CLJ performs one or more Alt-Tabs to move the x-th window to the first one in the queue. For example, if there are 4 windows in the queue, whose priorities are 1, 3, 5, 7 respectively and CLJ performs “Rotate 3”, then the window’s priorities in the queue will become 5, 1, 3, 7. Note that if CLJ wants to move the first window to the head, this operation is still considered “successful”. If x is out of range (smaller than 1 or larger than the size of the queue), LOGMSG will be “out of range”. Otherwise LOGMSG should be “success”.
5.Prior: CLJ finds out the girl with the maximum priority and then moves the window to the head of the queue. Note that if the girl with the maximum priority is already the first window, this operation is considered successful as well. If the window queue is empty, this operation will fail and LOGMSG must be “empty”. If it is successful, LOGMSG must be “success”.
6.Choose u: CLJ chooses the girl with priority u and moves the window to the head of the queue.This operation is considered successful if and only if the window with priority u exists. LOGMSG for the successful cases should be “success” and for the other cases should be “invalid priority”.
7.Top u: CLJ makes the window of the girl with priority u always on top. Always on top is a special state, which means whoever the first girl in the queue is, the top one must be u if u is always on top. As you can see, two girls cannot be always on top at the same time, so if one girl is always on top while CLJ wants another always on top, the first will be not always on top any more, except the two girls are the same one. Anyone can be always on top. LOGMSG is the same as that of the Choose operation.
8.Untop: CLJ cancels the “always on top” state of the girl who is always on top. That is, the girl who is always on top now is not in this special state any more. This operation will fail unless there is one girl always on top. If it fails, LOGMSG should be “no such person”, otherwise should be “success”.
As a gentleman, CLJ will say goodbye to every active window he has ever spoken to at last, “active” here means the window has not been closed so far. The logging format is “Bye u: c” where u is the priority and c is the number of words he has ever spoken to this window. He will always say good bye to the current top girl if he has spoken to her before he closes it.
Input
The first line contains an integer T (T ≤ 10), denoting the number of the test cases.
For each test case, the first line contains an integer n(0 < n ≤ 5000), representing the number of operations. Then follow n operations, one in a line. All the parameters are positive integers below 10^9.
Output
Output all the logging contents.
Sample Input
1
18
Prior
Add 1
Chat 1
Add 2
Chat 2
Top 2
Chat 3
Untop
Chat 4
Choose 2
Chat 5
Rotate 2
Chat 4
Close 2
Add 3
Prior
Chat 2
Close 1
Sample Output
Operation #1: empty.
Operation #2: success.
Operation #3: success.
Operation #4: success.
Operation #5: success.
Operation #6: success.
Operation #7: success.
Operation #8: success.
Operation #9: success.
Operation #10: success.
Operation #11: success.
Operation #12: success.
Operation #13: success.
Operation #14: close 2 with 8.
Operation #15: success.
Operation #16: success.
Operation #17: success.
Operation #18: close 1 with 11.
Bye 3: 2
Hint
This problem description does not relate to any real person in THU.
Problem Idea
解题思路:
【题意】
对窗口队列进行8种操作(对应的要输出反馈信息):
①Add u:往窗口队列末尾加入一个优先级为u的窗口,若窗口队列中已经存在优先级为u的窗口,反馈信息为"same priority",且不进行该操作;否则,反馈信息为"success"
②Close u:将窗口队列中优先级为u的窗口关闭,若窗口队列中不存在优先级为u的窗口,反馈信息为"invalid priority",且不进行该项操作;否则,反馈信息为"close u with c",其中,u表示关闭窗口的优先级,c表示CLJ在该窗口说的词数(word)
③Chat w:CLJ在top window内说了w个词(word),top window = “always on top” window(优先)/the first window in the queue,即若存在"置顶窗口",则top window为置顶窗口,否则为窗口队列中的第一个窗口,当窗口队列为空时,不进行该操作,且反馈信息为"empty";否则反馈信息为"success"
④Rotate x:将窗口队列中的第x个窗口移动到窗口队列的最前面,当x小于1或大于窗口队列中的窗口数时,反馈信息为"out of range",且不进行该操作;否则反馈信息为"success"
⑤Prior:将窗口队列中优先级最高的窗口移动到窗口队列的最前面,显然,当窗口队列为空时,该操作无效,反馈信息为"empty";否则反馈信息为"success"
⑥Choose u:将窗口队列中优先级为u的窗口移动到窗口队列的最前面,当窗口队列中不存在优先级为u的窗口时,该操作无效,反馈信息为"invalid priority";否则反馈信息为"success"
⑦Top u:将窗口队列中优先级为u的窗口标记为"置顶"窗口,但在窗口队列中的位置不变,当窗口队列中不存在优先级为u的窗口时,该操作无效,反馈信息为"invalid priority";否则反馈信息为"success"
⑧Untop:取消"置顶"窗口的"置顶"状态,若当前没有窗口被"置顶",则该操作无效,反馈信息为"no such person";否则反馈信息为"success"
最终,CLJ要跟那些说过话的且还未被关闭的窗口say goodbye,若存在"置顶"窗口,优先say goodbye,其余按照窗口队列顺序即可
【类型】
巨型模拟题(巨型,只是因为太麻烦,操作超级多)
【分析】
此题用什么方法都好,只要细节考虑清楚就可以,毕竟人家本来就没有打算在时限上卡你
需注意的细节有:
⑴say goodbye要先对 always on top 的人说
⑵对没有说过话的不要说 goodbye
⑶一个窗口中说过的词数可能会爆int
⑷always on top只是一种状态,它不会改变一个窗口在窗口队列中的位置
⑸关闭窗口时,若关闭的是"always on top"窗口,要记得将"是否存在置顶窗口"的标记清空
暂时就这么几点,欢迎补充
【时间复杂度&&优化】
O(n^2)
题目链接→HDU 5071 Chat
Source Code
/*Sherlock and Watson and Adler*/
#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<queue>
#include<stack>
#include<math.h>
#include<vector>
#include<map>
#include<set>
#include<list>
#include<bitset>
#include<cmath>
#include<complex>
#include<string>
#include<algorithm>
#include<iostream>
#define eps 1e-9
#define LL long long
#define PI acos(-1.0)
#define bitnum(a) __builtin_popcount(a)
using namespace std;
const int N = 5005;
const int M = 100005;
const int inf = 1000000007;
const int mod = 1000000007;
map<int,int> m;
list<int> l;
int p,top;
__int64 ans[N];
void Add(int u)
if(m[u])
puts("same priority.");
return ;
puts("success.");
m[u]=p++;
l.push_back(u);
void Close(int u)
if(!m[u])
puts("invalid priority.");
return ;
printf("close %d with %I64d.\\n",u,ans[m[u]]);
m[u]=0;
l.remove(u);
if(top==u)
top=0;
void Chat(int w)
if(l.empty())
puts("empty.");
return ;
puts("success.");
if(top)
ans[m[top]]+=w;
else
ans[m[l.front()]]+=w;
void Rotate(int x)
if(x<1||x>l.size())
puts("out of range.");
return ;
puts("success.");
list<int>::iterator it;
int i;
for(i=1,it=l.begin();it!=l.end()&&i<x;it++,i++);
//printf("%d\\n",*it);
int tmp=*it;
l.erase(it);
l.push_front(tmp);
void Prior()
if(l.empty())
puts("empty.");
return ;
int i,x,Max=0;
list<int>::iterator it;
for(i=1,it=l.begin();it!=l.end();it++,i++)
if(*it>Max)
Max=*it,x=i;
Rotate(x);
void Choose(int u)
if(!m[u])
puts("invalid priority.");
return ;
int x;
list<int>::iterator it;
for(x=1,it=l.begin();it!=l.end();it++,x++)
if(*it==u)
break;
Rotate(x);
void Top(int u)
if(!m[u])
puts("invalid priority.");
return ;
puts("success.");
top=u;
void Untop()
if(!top)
puts("no such person.");
return ;
puts("success.");
top=0;
char s[10];
int main()
int t,n,i,u,w,x;
scanf("%d",&t);
while(t--)
p=1;top=0;
m.clear();
l.clear();
memset(ans,0,sizeof(ans));
scanf("%d",&n);
for(i=1;i<=n;i++)
printf("Operation #%d: ",i);
scanf("%s",s);
if(!strcmp(s,"Add"))
scanf("%d",&u);
Add(u);
else if(!strcmp(s,"Close"))
scanf("%d",&u);
Close(u);
else if(!strcmp(s,"Chat"))
scanf("%d",&w);
Chat(w);
else if(!strcmp(s,"Rotate"))
scanf("%d",&x);
Rotate(x);
else if(!strcmp(s,"Prior"))
Prior();
else if(!strcmp(s,"Choose"))
scanf("%d",&u);
Choose(u);
else if(!strcmp(s,"Top"))
scanf("%d",&u);
Top(u);
else if(!strcmp(s,"Untop"))
Untop();
if(top&&ans[m[top]])
printf("Bye %d: %I64d\\n",top,ans[m[top]]);
list<int>::iterator it;
for(it=l.begin();it!=l.end();it++)
if(*it!=top&&ans[m[*it]])
printf("Bye %d: %I64d\\n",*it,ans[m[*it]]);
return 0;
Problem 1004 Galaxy
Accept: 0 Submit: 0
Time Limit: 2000/1000 MS (Java/Others) Memory Limit : 262144/262144 K (Java/Others)
Special Judge
Problem Description
Good news for us: to release the financial pressure, the government started selling galaxies and we can buy them from now on! The first one who bought a galaxy was Tianming Yun and he gave it to Xin Cheng as a present.
To be fashionable, DRD also bought himself a galaxy. He named it Rho Galaxy. There are n stars in Rho Galaxy, and they have the same weight, namely one unit weight, and a negligible volume. They initially lie in a line rotating around their center of mass.
Everything runs well except one thing. DRD thinks that the galaxy rotates too slow. As we know, to increase the angular speed with the same angular momentum, we have to decrease the moment of inertia.
The moment of inertia I of a set of n stars can be calculated with the formula
where wi is the weight of star i, di is the distance form star i to the mass of center.
As DRD’s friend, ATM, who bought M78 Galaxy, wants to help him. ATM creates some black holes and white holes so that he can transport stars in a negligible time. After transportation, the n stars will also rotate around their new center of mass. Due to financial pressure, ATM can only transport at most k stars. Since volumes of the stars are negligible, two or more stars can be transported to the same position.
Now, you are supposed to calculate the minimum moment of inertia after transportation.
Input
The first line contains an integer T (T ≤ 10), denoting the number of the test cases.
For each test case, the first line contains two integers, n(1 ≤ n ≤ 50000) and k(0 ≤ k ≤ n), as mentioned above. The next line contains n integers representing the positions of the stars. The absolute values of positions will be no more than 50000.
Output
For each test case, output one real number in one line representing the minimum moment of inertia. Your answer will be considered correct if and only if its absolute or relative error is less than 1e-9.
Sample Input
2
3 2
-1 0 1
4 2
-2 -1 1 2
Sample Output
0
0.5
Problem Idea
解题思路:
【题意】
有n个质量相同(1个单位重量),体积可以忽略的星球(质点),最初在一条直线上,围绕n个点的质心旋转
为了使得惯性矩尽可能小,现在可移动k个星球的位置
问最小的惯性矩I为多少
【类型】
贪心+公式推导->暴力
【分析】
由于每个星球的质量都是1个单位重量,故上述公式中的wi=1
di表示的是每个星球和质心的距离,我们现在知道每个星球的位置,但质心位置还不知道
由n个点的质心计算公式可得质心位置
化简后的惯性矩计算公式
有没有觉得很熟悉╮(╯_╰)╭
跟方差计算公式很像,而方差表示的是点的离散程度,所以要使惯性矩尽可能小,我们必然也需要选取尽可能接近的点
即必定是直线上连续的点
此外,要移动的k个点必然是移动到质心位置,只有这样这k个点对惯性矩的贡献为0
于是,此题就转化成从n个点中选取n-k个点,使得它们的方差*n尽可能小
所以我们将最初的n个点从小到大排序之后,每n-k个点求一次惯性矩,取最小的即可
但是考虑到每n-k个点求一次惯性矩的时间复杂度还是有点大,所以我们要进行一次优化
即必须找到
的惯性矩与
的惯性矩的关系
于是将惯性矩公式继续化简
这样相邻两次惯性矩的计算就有了关联
而我们只需预处理出
和
即可
特判n==k的情况,这种没有多余星球剩下,故输出0即可
【时间复杂度&&优化】
O(nlogn)
题目链接→HDU 5073 Galaxy
Source Code
/*Sherlock and Watson and Adler*/
#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<queue>
#include<stack>
#include<math.h>
#include<vector>
#include<map>
#include<set>
#include<bitset>
#include<cmath>
#include<complex>
#include<string>
#include<algorithm>
#include<iostream>
#define eps 1e-9
#define LL long long
#define PI acos(-1.0)
#define bitnum(a) __builtin_popcount(a)
using namespace std;
const int N = 50005;
const int M = 100005;
const int inf = 1000000007;
const int mod = 1000000007;
__int64 s[N];
int main()
int t,n,k,i,j;
__int64 f,h;
double ans;
scanf("%d",&t);
while(t--)
f=h=0;
scanf("%d%d",&n,&k);
for(i=1;i<=n;i++)
scanf("%I64d",&s[i]);
if(n==k)
puts("0.0000000000");
continue;
sort(s+1,s+n+1);
for(i=1;i<=n-k;i++)
f+=s[i]*s[i],h+=s[i];
for(j=1,ans=1.0*f-1.0*h*h/(n-k);i<=n;i++,j++)
f=f-s[j]*s[j]+s[i]*s[i];
h=h-s[j]+s[i];
ans=min(ans,1.0*f-1.0*h*h/(n-k));
printf("%.10f\\n",ans);
return 0;
Problem 1005 Hatsune Miku
Accept: 0 Submit: 0
Time Limit: 2000/1000 MS (Java/Others) Memory Limit : 262144/262144 K (Java/Others)
Problem Description
Hatsune Miku is a popular virtual singer. It is very popular in both Japan and China. Basically it is a computer software that allows you to compose a song on your own using the vocal package.
Today you want to compose a song, which is just a sequence of notes. There are only m different notes provided in the package. And you want to make a song with n notes.
Also, you know that there is a system to evaluate the beautifulness of a song. For each two consecutive notes a and b, if b comes after a, then the beautifulness for these two notes is evaluated as score(a, b).
So the total beautifulness for a song consisting of notes a1, a2, . . . , an, is simply the sum of score(ai, ai+1) for 1 ≤ i ≤ n - 1.
Now, you find that at some positions, the notes have to be some specific ones, but at other positions you can decide what notes to use. You want to maximize your song’s beautifulness. What is the maximum beautifulness you can achieve?
Input
The first line contains an integer T (T ≤ 10), denoting the number of the test cases.
For each test case, the first line contains two integers n(1 ≤ n ≤ 100) and m(1 ≤ m ≤ 50) as mentioned above. Then m lines follow, each of them consisting of m space-separated integers, the j-th integer in the i-th line for score(i, j)( 0 ≤ score(i, j) ≤ 100). The next line contains n integers, a1, a2, . . . , an (-1 ≤ ai ≤ m, ai ≠ 0), where positive integers stand for the notes you cannot change, while negative integers are what you can replace with arbitrary notes. The notes are named from 1 to m.
Output
For each test case, output the answer in one line.
Sample Input
2
5 3
83 86 77
15 93 35
86 92 49
3 3 3 1 2
10 5
36 11 68 67 29
82 30 62 23 67
35 29 2 22 58
69 67 93 56 11
42 29 73 21 19
-1 -1 5 -1 4 -1 -1 -1 4 -1
Sample Output
270
625
Problem Idea
解题思路:
【题意】
有m种音符,对于任意两个连续音符a和b,假如b在a后,那么这两个音符的魅力值为score(a,b)
现有一个音符序列,已经知道某些位置的音符,要求补全整个音符序列后的魅力值最大
问魅力值为多少
【类型】
动态规划(DP)
【分析】
显然,此题局部最优并不能保证整体最优(例如我们已经知道某个位置的音符,但并不能确定它前一个音符一定是哪个,因为你虽然做到此处最优,但整体并不一定是最优的),故贪心是不可取的
所以我们从动态规划入手
令dp[i][j]表示对于第i个音符,以音符j结尾的音符序列的最大魅力值
那么转移方程为
①当位置i和位置i-1的音符s[i],s[i-1]已知时
这种情况下,因为音符已经固定,所以直接计算即可,dp[i][s[i]]=dp[i-1][s[i-1]]+score(s[i-1],s[i])
②当位置i的音符s[i]已知,位置i-1的音符s[i-1]未知时
s[i-1]可能是m种音符里的任意一种,故dp[i][s[i]]=maxdp[i-1][k]+score(k,s[i]),k∈[1,m]
③当位置i的音符s[i]未知,位置i-1的音符s[i-1]已知时
s[i]可能是m种音符里的任意一种,故dp[i][k]=maxdp[i-1][s[i-1]]+score(s[i-1],k),k∈[1,m]
④当位置i和位置i-1的音符s[i],s[i-1]未知时
s[i]和s[i-1]均可能是m种音符里的任意一种,能构成m*m种搭配,dp[i][k]=maxdp[i-1][j]+score(j,k),j,k∈[1,m]
最终只要挑出最大的dp[n][]即可
【时间复杂度&&优化】
O(N*M*M)
Source Code
/*Sherlock and Watson and Adler*/
#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<queue>
#include<stack>
#include<math.h>
#include<vector>
#include<map>
#include<set>
#include<bitset>
#include<cmath>
#include<complex>
#include<string>
#include<algorithm>
#include<iostream>
#define eps 1e-9
#define LL long long
#define PI acos(-1.0)
#define bitnum(a) __builtin_popcount(a)
using namespace std;
const int N = 55;
const int M = 100005;
const int inf = 1000000007;
const int mod = 1000000007;
int s[N][N],a[2*N],dp[2*N][N];
int main()
int t,n,m,i,j,k,Max;
scanf("%d",&t);
while(t--)
memset(dp,0,sizeof(dp));
scanf("%d%d",&n,&m);
for(i=1;i<=m;i++)
for(j=1;j<=m;j++)
scanf("%d",&s[i][j]);
for(i=1;i<=n;i++)
scanf("%d",&a[i]);
for(i=2;i<=n;i++)
if(a[i]!=-1)
if(a[i-1]!=-1)
dp[i][a[i]]=dp[i-1][a[i-1]]+s[a[i-1]][a[i]];
else
for(j=1;j<=m;j++)
dp[i][a[i]]=max(dp[i][a[i]],dp[i-1][j]+s[j][a[i]]);
else
if(a[i-1]!=-1)
for(j=1;j<=m;j++)
dp[i][j]=max(dp[i][j],dp[i-1][a[i-1]]+s[a[i-1]][j]);
else
for(j=1;j<=m;j++)
for(k=1;k<=m;k++)
dp[i][k]=max(dp[i][k],dp[i-1][j]+s[j][k]);
/*Max=0;
for(j=1;j<=m;j++)
Max=max(Max,dp[i][j]);
printf("%d\\n",Max);*/
Max=0;
for(i=1;i<=m;i++)
Max=max(Max,dp[n][i]);
printf("%d\\n",Max);
return 0;
Problem 1009 Osu!
Accept: 0 Submit: 0
Time Limit: 2000/1000 MS (Java/Others) Memory Limit : 262144/262144 K (Java/Others)
Special Judge
Problem Description
Osu! is a very popular music game. Basically, it is a game about clicking. Some points will appear on the screen at some time, and you have to click them at a correct time.
Now, you want to write an algorithm to estimate how diffecult a game is.
To simplify the things, in a game consisting of N points, point i will occur at time ti at place (xi, yi), and you should click it exactly at ti at (xi, yi). That means you should move your cursor from point i to point i+1. This movement is called a jump, and the difficulty of a jump is just the distance between point i and point i+1 divided by the time between ti and ti+1. And the difficulty of a game is simply the difficulty of the most difficult jump in the game.
Now, given a description of a game, please calculate its difficulty.
Input
The first line contains an integer T (T ≤ 10), denoting the number of the test cases.
For each test case, the first line contains an integer N (2 ≤ N ≤ 1000) denoting the number of the points in the game. Then N lines follow, the i-th line consisting of 3 space-separated integers, ti(0 ≤ ti < ti+1 ≤ 10^6), xi, and yi (0 ≤ xi, yi ≤ 10^6) as mentioned above.
Output
For each test case, output the answer in one line.
Your answer will be considered correct if and only if its absolute or relative error is less than 1e-9.
Sample Input
2
5
2 1 9
3 7 2
5 9 0
6 6 3
7 6 0
10
11 35 67
23 2 29
29 58 22
30 67 69
36 56 93
62 42 11
67 73 29
68 19 21
72 37 84
82 24 98
Sample Output
9.2195444573
54.5893762558
Hint
In memory of the best osu! player ever Cookiezi.
Problem Idea
解题思路:
【题意】
一个游戏
在ti秒时,需点击屏幕(xi,yi)位置
游戏的难度定义:max任意相邻两次点击的距离/时间间隔
即
【类型】
暴力
【分析】
此题没有什么悬念,暴力就可以了
唯一需要注意的一点是,如果一开始坐标是用int型来定义的话,求距离时别因为爆int而出错就可以了
【时间复杂度&&优化】
O(N)
题目链接→HDU 5078 Osu!
Source Code
/*Sherlock and Watson and Adler*/
#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<queue>
#include<stack>
#include<math.h>
#include<vector>
#include<map>
#include<set>
#include<bitset>
#include<cmath>
#include<complex>
#include<string>
#include<algorithm>
#include<iostream>
#define eps 1e-9
#define LL long long
#define PI acos(-1.0)
#define bitnum(a) __builtin_popcount(a)
using namespace std;
const int N = 1005;
const int M = 100005;
const int inf = 1000000007;
const int mod = 1000000007;
struct node
int t,x,y;
s[N];
double distant(node a,node b)
return sqrt(1.0*(a.x-b.x)*(a.x-b.x)+1.0*(a.y-b.y)*(a.y-b.y));
int main()
int t,n,i;
double Max;
scanf("%d",&t);
while(t--)
Max=0;
scanf("%d",&n);
for(i=0;i<n;i++)
scanf("%d%d%d",&s[i].t,&s[i].x,&s[i].y);
if(i)
Max=max(Max,distant(s[i],s[i-1])/(s[i].t-s[i-1].t));
printf("%.10f\\n",Max);
return 0;
以上是关于ACM/ICPC亚洲区大概总共多少名额？的主要内容，如果未能解决你的问题，请参考以下文章
第43届ACM-ICPC亚洲区域赛（北京）结束 课工场“全场最快解题奖”由清华大学队获得
2014ACM/ICPC亚洲区西安站 F题 color (组合数学，容斥原理)