【解题报告】牡丹江现场赛之ABDIK ZOJ 3819 3820 3822 3827 3829

那天在机房做的同步赛，比现场赛要慢了一小时开始，直播那边已经可以看到榜了，所以上来就知道A和I是水题，当时机房电脑出了点问题，就慢了好几分钟，12分钟才A掉第一题。。。

A.Average Score

题目大意：给定A序列和B序列，长度分别是n和m，告诉你A序列中的n-1个数和B序列的m个数，求剩下的那个A序列中的数满足：将这个数从A序列移除，然后添加到B序列，使得A序列的平均值变小，B序列的平均值变大。求这个数的取值范围（是整数）

解题思路：求出A序列剩下的n-1个数的平均值，和B序列的平均值，答案就是这两个数之间的整数。

解题代码：

 #include<stdio.h>
 #include<math.h>
 #include<string.h>
 #include<iostream>
 #include<algorithm>
 #define FOR(i,n) for(i=0;i<(n);i++)
 #define CLR(a) memset(a,0,sizeof(a))
 #define CIN(a) scanf("%d",&a)
 using namespace std;
 int main()
 {
     int t,i;
     CIN(t);
     while(t--)
     {
         int n1,n2,s1=,s2=,a,b;
         CIN(n1);
         CIN(n2);
         for(i=;i<n1;i++)
         {
             CIN(a);
             s1+=a;
         }
         for(i=;i<n2;i++)
         {
             CIN(b);
             s2+=b;
         }
         if(s1%(n1-)==) s1=s1/(n1-)-;
         else s1=s1/(n1-);
         s2=s2/n2+;
         printf("%d %d\n",s2,s1);
     }
     return ;
 }

I.Information Entropy

然后看I感觉很高大上的样子，看了好久没看懂，但是很多人做出来又不舍得放弃，于是就静下心来慢慢看，然后发现题目的意思大概就是把给的数据带入H(x)求答案就完了。。。但是如果出现P(xi)=0的情况的话就要用那个求极限的公式带，关于这个极限，由于把高数忘得一干二净，所以不知道怎么搞，后来用几何画板把函数图像画出来，发现那个值是0，然后就简单了。。。直接套公式。。

代码：

 #include<stdio.h>
 #include<math.h>
 #include<string.h>
 #include<iostream>
 #include<algorithm>
 #define FOR(i,n) for(i=0;i<(n);i++)
 #define CLR(a) memset(a,0,sizeof(a))
 #define CIN(a) scanf("%d",&a)
 using namespace std;
 int a[];
 double (*f)(double) ;
 int main()
 {
     int t,i,x;
     char s[];
     CIN(t);
     while(t--)
     {
         scanf("%d",&x);
         scanf("%s",s);
         for(i=;i<x;i++)
         {
             scanf("%d",&a[i]);
         }
         if(strcmp(s,"bit")==)
         {
             f=log2;
         }
         else if(strcmp(s,"nat")==)
         {
             f=log;
         }
         else f=log10;
         double s=;
         for(i=;i<x;i++)
         {
             if(a[i]!=) s+=((double)a[i]/)*f((double)a[i]/);
         }
         printf("%.12f\n",-s);
     }
     return ;
 }

D.Domination

本着随波逐流的策略，就开始看过的人最多的D了。

题目大意：给定一个N*M的网格，开始随机往里面放棋子，知道任意一行任意一列都有棋子为止，求已经放置的棋子数的期望。

解题思路：概率DP，用dp[i][j][k]表示已经有i行，j列放过棋子，且总共放过k个棋子。对于某一状态，可以由四种状态扩展而来，可得状态转移方程：

转移方程：

                    if(i!=n||j!=m)dp[i][j][k]+=(1.0*i*j-(k-1))/(m*n-(k-1))*dp[i][j][k-1];//这个if是判断出前一状态已经是终点状态则不能扩展
                    dp[i][j][k]+=(1.0*i*(m-(j-1)))/(m*n-k+1)*dp[i][j-1][k-1];
                    dp[i][j][k]+=(1.0*j*(n-i+1))/(m*n-k+1)*dp[i-1][j][k-1];
                    dp[i][j][k]+=((1.0*n-i+1)*(m-j+1))/(m*n-k+1)*dp[i-1][j-1][k-1];
代码：

 #include<stdio.h>
 #include<math.h>
 #include<string.h>
 #include<iostream>
 #include<algorithm>
 #define FOR(i,n) for(i=0;i<(n);i++)
 #define CLR(a) memset(a,0,sizeof(a))
 #define CIN(a) scanf("%d",&a)
 using namespace std;
 double dp[][][];
 int main()
 {
     int t;
     int i,j,k,n,m;
     CIN(t);
     while(t--)
     {
         CIN(n);
         CIN(m);
         CLR(dp);
         dp[][][]=;
         for(i=;i<=n;i++)
         {
             for(j=;j<=m;j++)
             {
                 for(k=;k<=(i*j);k++)
                 {
                     if(i!=n||j!=m)dp[i][j][k]+=(1.0*i*j-(k-))/(m*n-(k-))*dp[i][j][k-];
                     dp[i][j][k]+=(1.0*i*(m-(j-)))/(m*n-k+)*dp[i][j-][k-];
                     dp[i][j][k]+=(1.0*j*(n-i+))/(m*n-k+)*dp[i-][j][k-];
                     dp[i][j][k]+=((1.0*n-i+)*(m-j+))/(m*n-k+)*dp[i-][j-][k-];
                     //printf("dp[%d][%d][%d]=%.12f\n",i,j,k,dp[i][j][k]);
                 }
             }
         }
         double s=;
         for(k=;k<=(n*m);k++)
         {
             s+=(dp[n][m][k]*k);
         }
         printf("%.12f\n",s);
     }
     return ;
 }

做到这里的时候是4题都是1y，感觉自己屌屌的~

B.Building Fire Stations

这题题目读完在纸上画了半天，感觉会和最长链有关，于是大胆猜测是在最长链的四分分上，然后马上就否定了，后来感觉应该是先将整个树从最长链的中间拆开，再分别求最长链取中点。不会证明，但是又没有别的题可以搞，就直接按这个方法写了，然后数组开太小RE了一次，改了交就AC了。。Orz白错了一次。

求树的最长链当时是第一次写，之前知道方法，但是没写过，没想到一次就过了。方法是先在树中随便取一点，遍历树找到距离这个点最远的点，然后这一点就是最长链的一个端点了，然后再从这个点遍历一次求出另一个端点就是最长链的另一点啦。

关于断边，则直接用了一个标记即可。

代码：

 #include<stdio.h>
 #include<math.h>
 #include<string.h>
 #include<iostream>
 #include<queue>
 #include<algorithm>
 #define FOR(i,n) for(i=0;i<(n);i++)
 #define CLR(a) memset(a,0,sizeof(a))
 #define CIN(a) scanf("%d",&a)
 using namespace std;
 #include<stdio.h>
 #include<string.h>
 #define point_MAX 200005
 #define edge_MAX 400005
 struct EDGE
 {
     int to;/*指向的点*/
     int next;/*指向的下一条邻边*/
     int w;/*权值*/
 }edge[edge_MAX];
 int len;/*边的数量*/
 int point[point_MAX];
 void init()/*初始化*/
 {
     len=;
     memset(point,,sizeof(point));
 }
 int add_edge(int a,int b,int w)/*添加由a指向b的权值为w的边*/
 {
     len++;
     edge[len].w=w;
     edge[len].to=b;
     edge[len].next=point[a];
     point[a]=len;
     return ;/*无重边，插入*/
 }
 int del_edge(int a,int b)
 {
     int i;
     for(i=point[a];edge[i].to!=b;i=edge[i].next);
     edge[i].w=;

     for(i=point[b];edge[i].to!=a;i=edge[i].next);
     edge[i].w=;

     return ;
 }
 int bo[];
 int road[];
 int zuiyuandian(int start)
 {
     int t,k,i;
     queue<int> q;
     CLR(bo);
     q.push(start);
     bo[start]=;
     while(!q.empty())
     {
         //printf("l");
         k=q.front();
         q.pop();

         for(i=point[k];i;i=edge[i].next)
         {
             if(edge[i].w!=)
                 if(bo[edge[i].to]==)
                 {
                     q.push(edge[i].to);
                     road[edge[i].to]=k;
                     bo[edge[i].to]=;
                 }
         }
     }
     return k;
 }
 int zuichang(int start)
 {
     int l,r,le,i;
     l=zuiyuandian(start);
     r=zuiyuandian(l);
     int len=;
     for(i=r;i!=l;i=road[i]) {/*printf("%d->",i);*/len++;}
     len/=;
     for(le=,i=r;le<len;i=road[i],le++);
     int a=i,b=road[i];

     del_edge(a,b);

     l=zuiyuandian(a);
     r=zuiyuandian(l);
     len=;
     for(i=r;i!=l;i=road[i]) len++;
     int ans1=len%?len/+:len/;
     len/=;
     for(le=,i=r;le<len;i=road[i],le++);
     a=i;

     l=zuiyuandian(b);
     r=zuiyuandian(l);
     len=;
     for(i=r;i!=l;i=road[i]) len++;
     int ans2=len%?len/+:len/;
     len/=;
     for(le=,i=r;le<len;i=road[i],le++);
     b=i;

     printf("%d %d %d\n",max(ans1,ans2),a,b);
 }
 int main()
 {
     int t,n,i;
     CIN(t);
     while(t--)
     {
         CIN(n);
         init();
         for(i=;i<n;i++)
         {
             int a,b;
             CIN(a);
             CIN(b);
             add_edge(a,b,);
             add_edge(b,a,);
         }
     zuichang();
     }
     return ;
 }

最后去搞H发现是一个模拟题，我想用map建立一棵树表示它然后查询但是超内存了Orz...一定是哪里姿势不够优美。。。SO，到最后也没搞出来，下次再搞了。