Topcoder SRM 607 div1题解

好久没来写了，继续继续。。。

Easy（250pts）：

／／前方请注意，样例中带有zyz，高能预警。。。

题目大意：给你一个字符串，中间有一些是未知字符，请你求出这个字符串的回文子串个数的期望值。数据满足字符最多2500个。

我们考虑每一个子串，它对答案的贡献度就是它是回文串的概率，那么我们扫一遍就可以了，

这样做时间复杂度O(n^3)，显然过不去。

我们考虑一下对于一个子串，在判断其是回文串的时候，我们一定是从中间往两边扫的，那么其实中间这些子串我们已经统计过答案了，

也就是说，我们通过枚举中间点来统计答案就可以了，

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

 #include <bits/stdc++.h>
 using namespace std;
 string s;
 double ans=0.0;
 int n;
 class PalindromicSubstringsDiv1
 {
     public:
     double expectedPalindromes(vector <string> S1, vector <string> S2)
     {
         for (int i=;i<S1.size();i++) s+=S1[i];
         for (int i=;i<S2.size();i++) s+=S2[i];
         n=s.length();
         for (int i=;i<n;i++)
         {
 //i means the middle point of the substring
             double now=1.0;
             int lx=i-,rx=i+;
             while (lx>=&&rx<n)
             {
                 if (s[lx]=='?'&&s[rx]=='?') now=now*1.0/26.0;
                 else if (s[lx]!='?'&&s[rx]!='?'&&s[lx]==s[rx]) now=now*1.0;
                 else if (s[lx]!='?'&&s[rx]!='?') now=0.0;
                 else now=now*1.0/26.0;
                 ans+=now;
                 --lx;++rx;
             }
             now=1.0,lx=i,rx=i+;
             while (lx>=&&rx<n)
             {
                 if (s[lx]=='?'&&s[rx]=='?') now=now*1.0/26.0;
                 else if (s[lx]!='?'&&s[rx]!='?'&&s[lx]==s[rx]) now=now*1.0;
                 else if (s[lx]!='?'&&s[rx]!='?') now=0.0;
                 else now=now*1.0/26.0;
                 ans+=now;
                 --lx,++rx;
             }
         }
         ans+=1.0*n;
         return ans;
     }
 };

Medium（475pts）：

题目大意：有一串数字（0～9）围成了一个环，每一次可以选取一段区间，然后同时＋1或者－1，（0 －1变成了9，9 ＋1变成了0）求现在到目标的最少操作次数。数据满足最多2500个元素。

这题怎么就475分了啊。。。感觉这么难。。。

容易观察到，结果只在％10意义下有用，所以先处理出差％10的余数。

接下来需要一个观察：如果两个区间一个是＋操作，一个是－操作，那么一定可以做到这两个区间不相交。

然后考虑dp，f[i][j][k]表示当前在第i位，区间已经改变了j，而k则代表是+操作还是-操作。

这样时间复杂度是O(n^3)的，可以通过div2那个题。

然后我就跑去看官方题解了，然后没看懂。。。

大概的感受就是，观察出其实一个区间的操作改变不会很多，就只有－10～10以内，然后判一下就好了。

时间复杂度O(n^2)，带一个常数，代码如下：

 #include <bits/stdc++.h>
 #define Maxn 2507
 #define Maxm 5507
 #define inf 200000007
 using namespace std;
 string S,T;
 int n;
 int d[Maxn];
 int f[Maxn][Maxm][];
 bool vis[Maxn][Maxm][];
 class CombinationLockDiv1
 {
     int tryit(int pos, int x, int dir)
     {
 //pos means which number it is dealing with now
 //x means the addition of the interval
 //dir means the interval is to add or to minus
         if (vis[pos][x][dir]) return f[pos][x][dir];
         vis[pos][x][dir]=true;
         if (pos==n)
         {
             f[pos][x][dir]=;
             return f[pos][x][dir];
         }
         f[pos][x][dir]=inf;
         for (int newdir=;newdir<=;newdir++)
         {
             for (int y=max(x-,);y<=min(x+,);y++)
             {
                 if (newdir==&&((d[pos]-y%+)%!=)) continue;
                 if (newdir==&&((d[pos]+y)%!=)) continue;
                 int z;
                 if (newdir!=dir) z=y; else z=max(y-x,);
                 f[pos][x][dir]=min(f[pos][x][dir],z+tryit(pos+,y,newdir));
             }
         }
         return f[pos][x][dir];
     };
     public:
     int minimumMoves(vector <string> P, vector <string> Q)
     {
         for (int i=;i<P.size();i++) S+=P[i];
         for (int i=;i<Q.size();i++) T+=Q[i];
         n=S.size();
         for (int i=;i<n;i++) d[i]=(S[i]-T[i]+)%;
         memset(vis,false,sizeof(vis));
         memset(f,,sizeof(f));
         return tryit(,,);
     }
 };

Hard（1000pts）：

题目大意：有n个轮子，半径间隔完全相等地一横排排在一条直线上，有个起点和终点完全对称（到最近的轮子距离也相同，也在x轴上），现在有根绳子，可以任意地从S开始环绕轮子，然后到T。这样的绳子显然有无数多条，给定k，求第k短的长度。数据满足n<=50，k<=10^18。

这题的第一步非常难，也非常关键。（然而cyand1317表示并不难。。。）

所有的绳子都可以划分成四种的拼凑，第一种是从起点到上半部分，第二种是轮子的上半部分到下一个轮子的上半部分，第三种是轮子的上半部分到下一个轮子的下半部分，第四种是包围一个轮子半圈（轮子的上半部分到轮子的下半部分）。

然后我们发现，第一种对于所有绳子都恰好有两段，于是我们只需要考虑后三段就可以了，表示成一个三元组(x,y,z)。

我们先dp预处理出每一个状态的方案数，我们需要四维x,y,z以及一个数字表示方向。

然而实际上不需要，第四种情况的奇偶性就可以判断方向，然后直接O(n^3)的dp就可以了，

最后我们需要二分答案，然后来判定。

需要注意的是，本题数据这么大，显然是存不下的，我们需要设定一个inf，当数大于inf的时候，直接不参与计算。

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

 #include <bits/stdc++.h>
 #define inf (1LL<<60)
 using namespace std;
 double A,B,R;
 int n;
 long long combination[][];
 long long f[][][][];
 class PulleyTautLine
 {
     long long calc(long long n, long long k)
     {
         k=min(k,n-k);
         if (k==) return ;
         if (k==) return n;
         if (k==&&0.5*n*(n-)<1.1*inf) return 1LL*n*(n-)/;
         if (k==&&1.0/*n*(n-)*(n-)<1.1*inf) return 1LL*n*(n-)*(n-)/;
         if (k<&&n<) return combination[n][k];
         return inf;
     }
     long long tryit(double len)
     {
         long long res=;
         for (int i=;i<;i++)
             for (int j=;j<;j++)
             {
 //number of moves A&B
 //number of moves R
                 if (f[i][j][n-][]>)
                 {
                     for (int k=;k<=i;k++)
                     {
 //number of moves A
                         double L=k*A+(i-k)*B+j*R;
                         if (L>len) continue;
 //max number of circles
                         long long cir=(long long)((len-L)/2.0/R);
                         long long cnt1=calc(i,k),cnt2=calc(cir+i+,i+);
                         if (cnt2>inf/cnt1/f[i][j][n-][]) return inf;
                         res+=1LL*cnt1*cnt2*f[i][j][n-][];
                         if (res>inf) return inf;
                     }
                 }
             }
         return res;
     }
     public:
     double getLength(int d, int r, int N, long long k)
     {
         n=N;
         A=d,B=sqrt((double)d*d-4.0*r*r)+2.0*r*asin(2.0*r/d),R=r*acos(-1.0);
         double L=sqrt((double)d*d-(double)r*r)+r*asin((double)r/d);
         if (n==) return (k-)/*2.0*R+2.0*L;
         memset(combination,,sizeof(combination));
         for (int i=;i<=;i++)
         {
             combination[i][]=;
             for (int j=;j<=;j++)
                 combination[i][j]=min(inf,combination[i-][j]+combination[i-][j-]);
         }
         memset(f,,sizeof(f));
         f[][][][]=;
         for (int i=;i<;i++)
             for (int j=;j<;j++)
                 for (int k=;k<n;k++)
                     for (int p=;p<=;p++)
                     {
 //there are three kinds of moves
 //one is to change the direction
 //the other two are move forward (become nearer or farer)
                         if (p==) f[i][j+][k][]=min(inf,f[i][j+][k][]+f[i][j][k][p]);
                         if (j%==&&k<n-) f[i+][j][k+][]=min(inf,f[i+][j][k+][]+f[i][j][k][p]);
                         if (j%==&&k>) f[i+][j][k-][]=min(inf,f[i+][j][k-][]+f[i][j][k][p]);
                     }
         double left=0.0,right=1000.0*A,mid;
         for (int i=;i<=;i++)
         {
             mid=(double)(left+right)/;
             if (tryit(mid)>=k) right=mid; else left=mid;
         }
         return mid+2.0*L;
     }
 };