Topcoder SRM 606 div1题解

打卡！

Easy（250pts）：

题目大意：一个人心中想了一个数，另一个人进行了n次猜测，每一次第一个人都会告诉他实际的数和猜测的数的差的绝对值是多少，现在告诉你所有的猜测和所有的差，要求你判断心中所想的数是多少，如果无解输出-1，如果有多个解输出-2。数据满足n<=50，想的那个数在[1,10^9]中。

这题是不是很简单呀～

首先通过第一次我们就最多确定两个数了，

然后分别带到后面去看一下就可以了，

时间复杂度O(n)，代码如下：

 #include <bits/stdc++.h>
 using namespace std;
 int n,ans1,ans2;
 bool check1=true,check2=true;
 class EllysNumberGuessing
 {
     public:
     int getNumber(vector <int> guesses, vector <int> answers)
     {
         n=guesses.size();
         ans1=guesses[]+answers[];
         ans2=guesses[]-answers[];
         for (int i=;i<n;i++)
         {
             if (abs(ans1-guesses[i])!=answers[i]) check1=false;
             if (abs(ans2-guesses[i])!=answers[i]) check2=false;
         }
         if (ans1<||ans1>) check1=false;
         if (ans2<||ans2>) check2=false;
         if (check1&&check2) return -;
         if ((!check1)&&(!check2)) return -;
         if (check1) return ans1;
         if (check2) return ans2;
     }
 };

Medium（450pts）：

题目大意：有n个公司，每个公司去了好多好多人来比赛，每个人的名字是一个小于M的非负整数。现在要两两组队，并且尽可能有更多的组使得同一组的两个人的名字不一样，求最多能组多少对。数据满足n<=50，M<=1073741824且M是一个2的幂次，需要注意的是本题空间限制只有16MB。

矣～这题不是浙江省选期间和吕爷爷讨论的一个ACM题目嘛。。。然而空间只有16MB。。。

我们先不考虑这个16MB的限制，回到题目的本质。

假设一共有x个人，

考虑出现次数最多的一个名字，我们假设它出现了y次。

如果y<=(x+1)/2，那么答案一定就是x/2；

如果y>(x+1)/2，那么答案一定就是x-y。

于是这样原题就做完了。

考虑那个恶心的16MB，我们显然不能把所有的名字全部预处理出来，不然就爆炸啦～

我们发现我们只需要比较出现最多的数是否出现了超过一半，

这个时候我们就想到了杜教主冬令营上讲的一个并行算法题目的做法，

设当前出现次数最多的为x，出现了y次。

如果当前的数等于x，那么y加上1；

如果当前的数不等于x，如果y＝0那么x更换成新的值，不然的话y减去1.

在最后我们还需要检验一下当前的数是否超过了一半，这样我们就可以在O(n)的时间复杂度内用额外O(1)的空间复杂度完成任务。

于是顺利12MB卡过～

时间复杂度O(n)，代码如下：

 #include <bits/stdc++.h>
 using namespace std;
 int n;
 class EllysPairing
 {
     public:
     int getMax(int M, vector <int> count, vector <int> first, vector <int> mult, vector <int> add)
     {
 //now is the name apeears most while cnt represents how many times it appears
 //tot means how many people are there in all
         int now=,cnt=,tot=,t;
         n=count.size();
         for (int i=;i<n;i++)
         {
             t=first[i],tot+=count[i];
             for (int j=;j<count[i];j++)
             {
                 if (t==now) ++cnt;
                 else
                 {
                     if (cnt==) now=t,cnt=;
                     else --cnt;
                 }
                 if (j<count[i]-) t=(t*mult[i]+add[i])&(M-);
             }
         }
         cnt=;
         for (int i=;i<n;i++)
         {
             t=first[i];
             for (int j=;j<count[i];j++)
             {
                 if (t==now) ++cnt;
                 if (j<count[i]-) t=(t*mult[i]+add[i])&(M-);
             }
         }
         if (cnt<=(tot+)/) return tot/;
         return tot-cnt;
     }
 };

Hard（950pts）：

题目大意：给出三维空间中的n个点，从中选出若干个点，如果这些点都在某一个立方体的8个顶点上，那么这些点就称为一个好的组合，问一共有多少个好的组合。数据满足n<=50，n个点互不相同且一定都是整点。需要注意的是，立方体是可以旋转的。

首先我们分析一下，所有满足条件的立方体不是很多，所以最后的答案也不是很多，直接搜索即可。

考虑满足条件的立方体，它的边长一定是某两点距离的1倍或1/sqrt(2)倍或1/sqrt(3)倍。（还有可能是0）

于是我们用一个2^n的数来表示每个点是否被加入，于是直接统计答案就可以了。

复杂度O(n^4)（大概吧，反正跑得过），代码如下：

 #include <bits/stdc++.h>
 #define Maxn 57
 using namespace std;
 int n;
 long long dis[Maxn][Maxn];
 multiset<long long> st,ans;
 map<long long,bool> vis;
 class Subcube
 {
     void dfs(int x, long long state, long long len)
     {
 //x means which point is being dealed now
 //state means the situation of the point(belonged to the cubic or not)
 //len means the length of an edge of the cubic
         if (x==n)
         {
             if (!vis[state]) ans.insert(state),vis[state]=true;
         } else
         {
 //x doesn't belong to the cubic
             dfs(x+,state,len);
 //x belongs to the cubic
             for (int i=;i<n;i++)
                 if ((state>>i)%==)
                 {
                     long long r1=dis[i][x];
                     if (r1!=len&&r1!=len*&&r1!=len*) return;
                     for (int j=;j<n;j++)
                         if (((state>>j)%==)&&(j!=i))
                         {
                             long long r2=r1+dis[i][j]+dis[j][x];
                             if (r2!=*len&&r2!=*len) return;
                         }
                 }
             dfs(x+,state+(1LL<<x),len);
         }
     }
     public:
     long long getCount(vector <int> X, vector <int> Y, vector <int> Z)
     {
         n=X.size();
         st.clear();
         for (int i=;i<n;i++)
             for (int j=;j<n;j++)
                 dis[i][j]=1LL*(X[i]-X[j])*(X[i]-X[j])+1LL*(Y[i]-Y[j])*(Y[i]-Y[j])+1LL*(Z[i]-Z[j])*(Z[i]-Z[j]);
         for (int i=;i<n;i++)
             for (int j=i+;j<n;j++)
             {
                 st.insert(dis[i][j]);
                 if (dis[i][j]%==) st.insert(dis[i][j]/);
                 if (dis[i][j]%==) st.insert(dis[i][j]/);
             }
         st.insert();
         ans.clear();
         for (multiset<long long>::iterator it=st.begin();it!=st.end();it++)
             dfs(,,*it);
         return ans.size()-;
     }
 };