2014ACM/ICPC亚洲区鞍山站 清华命题

A http://acm.hdu.edu.cn/showproblem.php?pid=5070

先跳过。

B http://acm.hdu.edu.cn/showproblem.php?pid=5071

维护一个聊天队列，有8种操作，每次操作完要打印对应的信息，认真读题，按题意模拟，一维数组模拟队列就可以，5000操作，交换删除等on暴力复杂度也不会超时。

 #include<cstdio>
 #include<cstring>
 #include<map>
 using namespace std;
 const int M=;
 char a[M];
 char b[M][M]={"","Add","Close","Chat","Rotate","Prior","Choose","Top","Untop"};
 map<int,int> mp;
 int sta[],top,cnt,x;
 void success(){
     puts("success.");
 }
 void invalid(){
     puts("invalid priority.");
 }
 void Empty(){
     puts("empty.");
 }
 void solve1(){
     for(int i=;i<cnt;i++){
         if(sta[i]==x){
             puts("same priority.");
             return ;
         }
     }
     sta[cnt++]=x;
     success();
 }
 void solve2(){
     for(int i=;i<cnt;i++){
         if(sta[i]==x){
             if(top==x) top=-;
             for(int j=i;j<cnt-;j++){
                 sta[j]=sta[j+];
             }
             cnt--;
             printf("close %d with %d.\n",x,mp[x]);
             mp.erase(x);
             return ;
         }
     }
     invalid();
 }
 void solve3(){
     if(!cnt){
         Empty();
         return ;
     }
     if(top!=-){
         mp[top]+=x;
         success();
         return ;
     }
     mp[sta[]]+=x;
     success();
 }
 void solve4(int id){
     if(id<||id>cnt){
         puts("out of range.");
         return ;
     }
     int tmp=sta[id-];
     for(int i=id-;i>;i--){
         sta[i]=sta[i-];
     }
     sta[]=tmp;
     success();
 }
 void solve5(){
     if(!cnt){
         Empty();
         return ;
     }
     int id=;
     for(int i=;i<cnt;i++){
         if(sta[i]>sta[id]){
             id=i;
         }
     }
     solve4(id+);
 }
 void solve6(){
     for(int i=;i<cnt;i++){
         if(sta[i]==x){
             solve4(i+);
             return ;
         }
     }
     invalid();
 }
 void solve7(){
     for(int i=;i<cnt;i++){
         if(sta[i]==x){
             top=x;
             success();
             return ;
         }
     }
     invalid();
 }
 void solve8(){
     if(top!=-){
         top=-;
         success();
         return ;
     }
     puts("no such person.");
 }
 int main(){
     int t,n;
     while(~scanf("%d",&t)){
         while(t--){
             scanf("%d",&n);
             int cas=;
             top=-,cnt=;
             mp.clear();
             while(n--){
                 scanf("%s",a);
                 int id=;
                 for(int i=;i<=;i++){
                     if(!strcmp(a,b[i])){
                         id=i;
                         break;
                     }
                 }
                 if(id!=&&id!=){
                     scanf("%d",&x);
                 }
                 printf("Operation #%d: ",cas++);
                 if(id==){
                     solve1();
                 }
                 else if(id==){
                     solve2();
                 }
                 else if(id==){
                     solve3();
                 }
                 else if(id==){
                     solve4(x);
                 }
                 else if(id==){
                     solve5();
                 }
                 else if(id==){
                     solve6();
                 }
                 else if(id==){
                     solve7();
                 }
                 else{
                     solve8();
                 }
             }
             if(top!=-&&mp[top]){
                 printf("Bye %d: %d\n",top,mp[top]);
             }
             for(int i=;i<cnt;i++){
                 if(top!=sta[i]&&mp[sta[i]]){
                     printf("Bye %d: %d\n",sta[i],mp[sta[i]]);
                 }
             }
         }
     }
     return ;
 }

C http://acm.hdu.edu.cn/showproblem.php?pid=5072

输入n个数，n<=10^5,其中选出3个数，满足两两之间互质，或者两两之间都不互质，问有多少种不同的选法。

解法：暴力n^3，然后加3次gcd判断，统计。明显超时，但可以用来测测。

根据 模型请参考 《算法竞赛入门经典 训练指南》  p105 问题6，大白书。

那个模型是这样的，给定空间n个点n==1000，没有3点共线，每两个点之间都用红色或黑色边连接，求3条边同色的三角形个数。

那么对于这个题，我们可以把每个数当做三角形的点，数与数之间互质当做红边，不互质当做黑边，那么就是这个问题了。

三角形这个题，可以求反面，求出非单色三角形，就可以用总数扣去得到答案。对于非单色三角形，必然有两个点连的两条边不同色。

所以对每个点，如果有ai条红色边，就有n-1-ai条蓝色边，ai*（n-1-ai）就是该点形成的非单色三角形，因为一个三角形会算两次，（必然有两个点连的两条边不同色）。所以除二。

对于上面这个题，一样的方法，对每个数，求出有多少个互质的，假设求出来是bi，那么不互质的就是（n-1-bi），那么这个数能贡献的答案就是bi*（n-1-bi），因为每种情况会重复算一次，所以最后答案除2就是不合法的情况，用总数减去就是题目所求。

问题只剩下如何求bi，多少个互质的，然后就是二进制暴力质因子，容斥原理++--，理解一下。

 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #define mt(a,b) memset(a,b,sizeof(a))
 using namespace std;
 typedef long long LL;
 const int M=1e5+;
 int pri[M],mark[M],pricnt;//mark[i]存i的最小因子，素数时mark[i]==i
 void sieve_primes() { //筛素数
     pricnt=;
     mt(mark,);
     mark[]=mark[]=;
     for(int i=; i<M; i++) {
         if(!mark[i]) pri[pricnt++]=mark[i]=i;
         for(int j=; pri[j]*i<M; j++) {
             mark[i*pri[j]]=pri[j];
             if(!(i%pri[j])) break;
         }
     }
 }
 int fac[];
 int find_fac_before_sieve(int n) { //筛完素数后用，n<M
     int cnt=;
     while(mark[n]!=) {
         fac[cnt++]=mark[n];
         n/=mark[n];
     }
     return cnt;
 }
 int num[M];
 int lf;
 void dfs(int now,int sum){
     if(now==lf){
         num[sum]++;
         return ;
     }
     dfs(now+,sum);
     dfs(now+,sum*fac[now]);
 }
 LL help;
 void dfs_ans(int now,int sum,int cnt){
     if(now==lf){
 //        if(!cnt) return ;
         if(cnt&) help-=num[sum];
         else      help+=num[sum];
         return ;
     }
     dfs_ans(now+,sum,cnt);
     dfs_ans(now+,sum*fac[now],cnt+);
 }
 int a[M];
 int main(){
     sieve_primes();
     int t,n;
     while(~scanf("%d",&t)){
         while(t--){
             scanf("%d",&n);
             for(int i=;i<n;i++){
                 scanf("%d",&a[i]);
             }
             mt(num,);
             for(int i=;i<n;i++){
                 lf=find_fac_before_sieve(a[i]);
                 lf=unique(fac,fac+lf)-fac;
                 dfs(,);
             }
             LL ans=;
             for(int i=;i<n;i++){
                 lf=find_fac_before_sieve(a[i]);
                 lf=unique(fac,fac+lf)-fac;
                 help=;
                 dfs_ans(,,);
                 if(a[i]==) help--;
                 ans+=help*(n--help);
             }
             printf("%lld\n",1LL*n*(n-)*(n-)/-ans/);
         }
     }
     return ;
 }

D http://acm.hdu.edu.cn/showproblem.php?pid=5073

输入一维数轴上n个坐标，每个点重量是1，可以允许最多移动k个点，允许移动到同一个位置，问如何移动使得（每个点到重心的距离的平方）的和最小。

因为重量都是1，所以重心就会落在n个坐标的平均值位置。

一个先决条件是，k个点一定都要移动，那么剩下n-k个点去求那个权值。

因为移动的k个点可以都移动到剩下点的重心去，那么他们对权值的贡献就是零，相当于直接删去。

还有一个条件是，为了使得大家距离重心更近，那么肯定留下的n-k个点要连续，这样肯定比离散的距离重心近。

所以我们将坐标排序，枚举起点，求长度为n-k这一段的权值，最后取最小值。

问题就需要尽快的求出一个连续段的权值。

对于距离平方求和，就是（Xi-Xavg）^2=Xi^2-2*Xi*Xavg+Xavg^2     (L<=i<=R)

求均值预处理前n项和即可，第一项就预处理前n项平方和。

 #include<cstdio>
 #include<algorithm>
 using namespace std;
 const int M=5e4+;
 int a[M];
 int main(){
     int t,n,m;
     while(~scanf("%d",&t)){
         while(t--){
             scanf("%d%d",&n,&m);
             for(int i=;i<n;i++){
                 scanf("%d",&a[i]);
             }
             if(n==m){
                 puts("");
                 continue;
             }
             sort(a,a+n);
             double sum=,sum2=;
             int cnt=n-m;
             for(int i=;i<cnt;i++){
                 sum+=a[i];
                 sum2+=1.0*a[i]*a[i];
             }
             double ans=sum2-*(sum/cnt)*sum+sum/cnt*sum;
             for(int i=cnt;i<n;i++){
                 sum+=a[i];
                 sum-=a[i-cnt];
                 sum2+=1.0*a[i]*a[i];
                 sum2-=1.0*a[i-cnt]*a[i-cnt];
                 double now=sum2-*(sum/cnt)*sum+sum/cnt*sum;
                 ans=min(ans,now);
             }
             printf("%.10f\n",ans);
         }
     }
     return ;
 }

E http://acm.hdu.edu.cn/showproblem.php?pid=5074

输入n个数的序列，序列的得分是ai和ai+1之间贡献的，也就是有n-1个得分。数字一定是1到m的，输入会给出m*m的矩阵，即矩阵mat【i】【j】 表示 i 在 j 前面的得分。序列中值为1到m的是必须选择该值，值为-1的是你可以在1到m中任意选一个放在该位置，最后要求序列可能得到的最大分数。

解法：若枚举，如果n个都是-1，每一个有1到m种情况，总情况数就是m的n次方，50^100，观察发现，有最优子结构性质，即dp【n】【m】表示前n个以m为结尾所能得到的最大分数。

 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #define mt(a,b) memset(a,b,sizeof(a))
 using namespace std;
 const int M=;
 int dp[M<<][M],a[M][M],b[M<<];
 int main(){
     int t,n,m;
     while(~scanf("%d",&t)){
         while(t--){
             scanf("%d%d",&n,&m);
             for(int i=;i<=m;i++){
                 for(int j=;j<=m;j++){
                     scanf("%d",&a[i][j]);
                 }
             }
             for(int i=;i<=n;i++){
                 scanf("%d",&b[i]);
             }
             mt(dp,-);
             if(b[]==-){
                 for(int j=;j<=m;j++){
                     dp[][j]=;
                 }
             }
             else{
                 dp[][b[]]=;
             }
             for(int i=;i<n;i++){
                 for(int j=;j<=m;j++){
                     if(dp[i][j]==-) continue;
                     if(b[i+]>){
                         dp[i+][b[i+]]=max(dp[i+][b[i+]],dp[i][j]+a[j][b[i+]]);
                         continue;
                     }
                     for(int k=;k<=m;k++){
                         dp[i+][k]=max(dp[i+][k],dp[i][j]+a[j][k]);
                     }
                 }
             }
             int ans=;
             for(int j=;j<=m;j++){
                 ans=max(ans,dp[n][j]);
             }
             printf("%d\n",ans);
         }
     }
     return ;
 }

I   http://acm.hdu.edu.cn/showproblem.php?pid=5078

输入n个点，每个点有时间t，坐标x，y。定义相邻两点之间的难度为距离/时间差，求最大的难度。

解法：按照定义算相邻两个的难度，取最大值。

 #include<cstdio>
 #include<cmath>
 #include<algorithm>
 using namespace std;
 const int M=1e3+;
 struct G{
     double t,x,y;
 }g[M];
 double f(G a,G b){
     return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y))/(b.t-a.t);
 }
 int main(){
     int t,n;
     while(~scanf("%d",&t)){
         while(t--){
             scanf("%d",&n);
             for(int i=;i<n;i++){
                 scanf("%lf%lf%lf",&g[i].t,&g[i].x,&g[i].y);
             }
             double ans=f(g[],g[]);
             for(int i=;i<n;i++){
                 ans=max(ans,f(g[i-],g[i]));
             }
             printf("%.10f\n",ans);
         }
     }
     return ;
 }