Topcoder SRM 608 div1 题解

Easy(300pts)：

题目大意：有n个盒子，一共有S个苹果，每个盒子有多少个苹果不知道，但是知道每个盒子的苹果下限和上限。现在要至少选择X个苹果，问如果要保证无论如何都能获得至少X个苹果，至少需要选择多少个盒子。数据满足n<=50。

首先第一个方面，如果我们选择的盒子的下限大于等于X，那么显然我们一定可以获得那么多的苹果，

所以我们将盒子的下限排序，然后从大到小累加即可。

另一方面，如果我们没有选择的盒子的上限小于等于S-X，那么显然我们也一定可以获得那么多的苹果，

于是我们再按照上限排序，然后扫一遍累加即可。

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

 #include <bits/stdc++.h>
 #define Maxn 57
 using namespace std;
 int n;
 int l[Maxn],r[Maxn];
 class MysticAndCandies
 {
     public:
     int minBoxes(int C, int X, vector <int> low, vector <int> high)
     {
         n=low.size();
         for (int i=;i<=n;i++) l[i]=low[i-];
         for (int i=;i<=n;i++) r[i]=high[i-];
         sort(l+,l+n+);
         sort(r+,r+n+);
         for (int i=;i<n+-i;i++) swap(l[i],l[n+-i]),swap(r[i],r[n+-i]);
         int ans,sum1=,sum2=;
         for (int i=;i<=n;i++) sum2+=r[i];
         for (ans=;ans<=n;ans++)
         {
             sum1+=l[ans];
             sum2-=r[ans];
             if (sum1>=X||C-sum2>=X) break;
         }
         return ans;
     }
 };

Medium(600pts)：

题目大意：给出一个n个点的有向图，假设长度为L的路径一共有S条（路径可以经过重复的点多次，S也可以是无穷大），问当L非常大的时候，S的量级是L的几次方。当然，有可能S不能用L的几次方表示，那么输出-1。数据满足n<=50。

通过题面来看，就感觉这题很厉害。。。

我们先从一个环来考虑，一个环的长度为L的路径显然只有有数条，那么这个时候S就是L的一次方量级。

然后我们来考虑一个强联通分量，如果这个强联通分量不仅仅只是一个环，那么路径条数就是指数级别的了。

回到原题，我们把原图中的强联通分量全部求出来，

至少图变成了一个DAG，然后发现所有的SCC必须是环，

然后差不多dp之类的都可以做了。

由于这道题n<=50，所以根本不需要什么Tarjan，直接floyed就行了。

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

 #include <bits/stdc++.h>
 #define Maxn 57
 using namespace std;
 bool vis[Maxn][Maxn];
 int fa[Maxn],sum[Maxn],sumedge[Maxn];
 int r[Maxn],f[Maxn];
 int n;
 class BigO
 {
     public:
     int minK(vector <string> graph)
     {
         n=graph.size();
         for (int i=;i<n;i++)
             for (int j=;j<n;j++)
                 if (graph[i][j]=='Y') vis[i][j]=true; else vis[i][j]=false;
         for (int i=;i<n;i++)
             vis[i][i]=true;
         for (int k=;k<n;k++)
             for (int i=;i<n;i++)
                 for (int j=;j<n;j++)
                     if (vis[i][k]&&vis[k][j]) vis[i][j]=true;
         memset(sum,,sizeof(sum));
         for (int i=;i<n;i++)
             for (int j=;j<n;j++)
                 if (vis[i][j]&&vis[j][i])
                 {
                     fa[i]=j;
                     ++sum[j];
                     break;
                 }
         memset(sumedge,,sizeof(sumedge));
         for (int i=;i<n;i++)
             for (int j=;j<n;j++)
                 if (graph[i][j]=='Y'&&fa[i]==fa[j]&&i!=j)
                     ++sumedge[fa[i]];
         memset(r,,sizeof(r));
         memset(f,,sizeof(f));
         for (int i=;i<n;i++)
         {
 //the SCC is more than a circle
             if (sumedge[i]>sum[i]) return -;
 //the SCC is more than a point
             if (sumedge[i]!=) r[i]=;
             f[i]=r[i];
         }
         for (int T=;T<n;T++)
             for (int i=;i<n;i++)
                 for (int j=;j<n;j++)
                     if (fa[i]!=fa[j]&&graph[i][j]=='Y')
                         f[fa[j]]=max(f[fa[j]],f[fa[i]]+r[fa[j]]);
         int res=;
         for (int i=;i<n;i++)
             res=max(f[i]-,res);
         return res;
     }
 };

Hard(900pts):

题目大意：有一个机器人在x轴上，初始位置为0，它接受到了一系列指令，每次向左一个单位或者向右一个单位。如果现在在左边界上，那么就不能再往左了，向左的指令会被忽略；如果现在在右边界上，那么就不能再往右了，向右的指令会被忽略。现在对于minA<=A<=maxA,minB<=B<=maxB，求出以A为左边界，B为右边界的最终位置的总和，数据满足所有数<=5000。

这题是个神结论题，不打算多说。。。

我们假设边界都是无穷大的时候，求出出现过的最左侧位置和最右侧位置。

如果A和B分别大于等于两边边界，那么答案就是最终位置。

如果不是的话，有一个结论就是(a,b)等于(a-1,b+1)-1，然后按照差暴力就可以了。

时间复杂度O(nX+X^2)，代码如下：

 #include <bits/stdc++.h>
 #define Maxa 5007
 using namespace std;
 int ans[Maxa][Maxa];
 string s;
 long long res=;
 class OneDimensionalRobot
 {
     public:
     long long theSum(vector <string> commands1, vector <string> commands2, int minA, int maxA, int minB, int maxB)
     {
         s.clear();
         for (int i=;i<commands1.size();i++) s+=commands1[i];
         for (int i=;i<commands2.size();i++) s+=commands2[i];
         int left=,right=,pos=;
         for (int i=;i<s.length();i++)
         {
             if (s[i]=='R') ++pos; else --pos;
             if (-pos>left) left=-pos;
             if (pos>right) right=pos;
         }
         memset(ans,,sizeof(ans));
         for (int i=minA;i<=maxA;i++)
             for (int j=minB;j<=maxB;j++)
             {
                 if (i>=left&&j>=right) ans[i][j]=pos; else
                 if (i==minA||j==maxB)
                 {
                     int now=;
                     for (int k=;k<s.length();k++)
                     {
                         if (s[k]=='R') ++now; else --now;
                         if (-now>i) now=-i;
                         if (now>j) now=j;
                     }
                     ans[i][j]=now;
                 } else
                 {
                     ans[i][j]=ans[i-][j+];
                     if (left>i-||right>j) --ans[i][j];
                 }
             }
         for (int i=minA;i<=maxA;i++)
             for (int j=minB;j<=maxB;j++)
                 res+=ans[i][j];
         return res;
     }
 };