2017杭电ACM集训队单人排位赛 - 2 题解

　　1001，水题，直接模拟即可。比赛中开局连wa三发，因为把int写成了bool..

　　1002，积分题，比赛中找到了下面这个积分公式，

　　但是并没什么用，，因为带入以后存在误差，估计是展开了以后出现了误差。然后用自适应simpson即可。大白书上的模板不怎么好用（虽然能过），优化版的模板如下（本题AC代码）：

 #include<iostream>
 #include<cstdio>
 #include<string>
 #include<cstring>
 #include<map>
 #include<set>
 #include<queue>
 #include<stack>
 #include<ctime>
 #include<algorithm>
 #include<cmath>
 #include<vector>
 #include<list>
 #include<fstream>
 #include<sstream>
 #include<cassert>
 #include<bitset>
 #define showtime printf(stderr,"time = %.15f\n",clock() / (double)CLOCKS_PER_SEC)
 #pragma comment(linker, "/STACK:1024000000,1024000000")
 using namespace std;
 typedef long long ll;
 typedef long long LL;
 typedef unsigned long long ull;
 #define MP make_pair
 #define PII pair<int,int>
 #define PFI pair<double,int>
 #define PLL pair<ll,ll>
 #define lson l,mid,rt<<1
 #define rson mid+1,r,rt<<1|1
 //freopen("data.in","r",stdin);
 //freopen("data.out","w",stdout);
 typedef vector<long long> vec;
 typedef vector<vec> mat;
 inline int popcnt(int x){return __builtin_popcount(x); }
 inline int clz(int x){return __builtin_clz(x);} //末尾的 0，即对 lowbit 取log
 inline int clz(LL x){return __builtin_clzll(x);}
 inline int lg2(int x){ return !x ? - : -clz(x);}
 inline int lg2(LL x){ return !x ? - : -clz(x);}
 inline int __lcm(int x, int y){ return x / __gcd(x, y) * y; }
 const double eps = 1e-;
 const double PI = acos(-.);
 const double E = 2.71828182845904523536;
 const int MOD = (int)1e9+;
 const int INF = 0x3f3f3f3f;
 const ll INFLL = 0x3f3f3f3f3f3f3f3f;
 const ull BAS = ;
 const int M = 1e5 + ;
 const int N = 1e5 + ; 
 
 double v1, v2, x, k;
 
 double f(double t){
     // 表达式
     return k / (((x-v2*t)*(x-v2*t)) + (t*v1) * (t*v1));
 }
 double simpson(double l,double r){ // simpson公式
     return 1.0 / 6.0 * (r - l) * (f(l) +  * f((l+r)/2.0) + f(r));
 }
 double integral(double l,double r){
     double mid = (l + r) / 2.0;
     double ret = simpson(l,r);  // 二分逼近
     if(fabs(ret - simpson(l,mid)-simpson(mid,r)) < eps)
         return ret;
     else
         return integral(l,mid) + integral(mid,r);
 }
 /*
                     k
 ---------------------
 (x-v2*t)^2 + (t*v1)^2
 */
 int main(){
     int T;
     cin >> T;
     while(T --){
         cin >> v1 >> v2 >> x >> k;
         printf("%.2f\n", integral(, 1e18));
     }
     return ;
 }

1002

　　

　　1003，用dfs不能过，因为有环，那么谁先更新谁后更新对答案有偏差，因此采用优先队列的dij来做。代码如下：

 #include <bits/stdc++.h>
 #define t_mid (l+r>>1)
 #define ls (o<<1)
 #define rs (o<<1|1)
 #define lson ls,l,t_mid
 #define rson rs,t_mid+1,r
 using namespace std;
 const int N = 1e5 + ;
 typedef long long ll;
 typedef pair<int,int> pii;
 const int mod = 1e9 + ;
 
 int T;
 int n, m;
 int a[N];
 vector<pii> G[N];
 
 int main()
 {
     scanf("%d",&T);
     while(T--)
     {
         scanf("%d%d",&n,&m);
         priority_queue<pii,vector<pii>,greater<pii> > Q;
         for(int i=;i<=n;i++) {scanf("%d",a+i); Q.push(pii(a[i], i)); G[i].clear();}
         for(int i=;i<=m;i++)
         {
             int x, y, z;
             scanf("%d%d%d",&x,&y,&z);
             G[x].push_back(pii(y,z));
             G[y].push_back(pii(x,z));
         }
         while(!Q.empty())
         {
             pii p = Q.top(); Q.pop();
             int u1 = p.second;
             for(pii pp : G[u1])
             {
                 int u2 = pp.first;
                 int v = pp.second;
                 if(a[v] > a[u1] + a[u2])
                 {
                     a[v] = a[u1] + a[u2];
                     Q.push(pii(a[v], v));
                 }
             }
         }
         for(int i=;i<=n;i++) printf("%d%c",a[i],i==n?'\n':' ');
     }
     return ;
 }

1003

　　1004，水题。

　　1005，3！枚举一下3种字符的排列顺序，得到此时的目标串，然后和原串匹配一下得到在目标串中的连续的最长的子串，这个长度就是不需要动的牌，然后所有情况比较得到最优解即可。需要是连续的是因为每次只能把牌放到最前和最后，不难证明可以成立。同时这个匹配的方法可以dp，也可以暴力。这个dp的转移还是需要注意一下的。代码如下：

 #include <bits/stdc++.h>
 #define t_mid (l+r>>1)
 #define ls (o<<1)
 #define rs (o<<1|1)
 #define lson ls,l,t_mid
 #define rson rs,t_mid+1,r
 using namespace std;
 const int N = 1e5 + ;
 typedef long long ll;
 typedef pair<int,int> pii;
 const int mod = 1e9 + ;
 
 int T;
 char s[];
 char t[];
 int cnt[];
 char need[][];
 char str[];
 int ans;
 
 int dp[][];
 void solve()
 {
     // s -> str
     //printf("%s -- %s\n",s+1,str+1);
     for(int l=;l<=;l++)
     {
         for(int r=l+;r<=;r++)
         {
             int temp = ;
             for(int i=;i<=;i++)
             {
                 if(s[i] == str[l+temp])
                 {
                     temp++;
                 }
             }
             if(temp == r - l + ) ans = max(ans, r - l + );
         }
     }
     /*memset(dp,0,sizeof dp);
     for(int i=1;i<=13;i++)
     {
         for(int j=1;j<=13;j++)
         {
             if(s[i] == str[j])
             {
                 dp[i][j] = dp[i-1][j-1] + 1;
             }
             else dp[i][j] = dp[i-1][j];
             ans = max(ans, dp[i][j]);
         }
     }*/
 }
 
 int main()
 {
     // 3 1 2
     //printf("%d %d %d ?\n",'a','1','A');
     scanf("%d",&T);
     while(T--)
     {
         scanf("%s",s+);
         memcpy(t,s,sizeof t);
         sort(t+,t++);
         memset(cnt,,sizeof cnt);
         memset(need,,sizeof need);
         int now = ;
         int p = ;
         for(;;now++)
         {
             if(!isdigit(t[now])) break;
             need[][++p] = t[now];
         }
         cnt[] = now - ;
         p = ;
         for(;;now++)
         {
             if(t[now] < 'A' || t[now] > 'Z') break;
             need[][++p] = t[now];
         }
         cnt[] = p;
         p = ;
         for(;now<=;now++)
         {
             need[][++p] = t[now];
         }
         cnt[] = p;
 
         ans = ;
         memset(str,,sizeof str);
         strcat(str+,need[]+); strcat(str+,need[]+); strcat(str+,need[]+);
         solve();
         memset(str,,sizeof str);
         strcat(str+,need[]+); strcat(str+,need[]+); strcat(str+,need[]+);
         solve();
         memset(str,,sizeof str);
         strcat(str+,need[]+); strcat(str+,need[]+); strcat(str+,need[]+);
         solve();
         memset(str,,sizeof str);
         strcat(str+,need[]+); strcat(str+,need[]+); strcat(str+,need[]+);
         solve();
         memset(str,,sizeof str);
         strcat(str+,need[]+); strcat(str+,need[]+); strcat(str+,need[]+);
         solve();
         memset(str,,sizeof str);
         strcat(str+,need[]+); strcat(str+,need[]+); strcat(str+,need[]+);
         solve();
         printf("%d\n",-ans);
     }
     return ;
 }

1005

　　1006，做这题前可以先做一下hdu2045。在该题中两个颜色相同的位置（称之为分隔处）把这个串分成了两部分，这两个相同颜色的位置假设颜色已经固定了（最后只要把答案再乘以k即可），那么剩余的有（k-1）种颜色可选择，设f[i]为长度为i的合理串的种数，那么这个状态可以从以下两个状态转移过来：

　　1.长度为i-1的合理的串，那么其最后一个颜色一定与分隔处不同，那么第i个位置只剩下了（k-2）种选择，贡献为（k-2）*f[i-1]。

　　2.长度为i-1的不合理的串，那么前i-2个必须合理，否则不能转移到i处，同时不可能是i-2和i-1处的颜色不同（如果不同也无法转移到i处），只能是i-1处和分隔处的颜色相同才行，那么i这个地方有（k-1）种选择，贡献为（k-1）*f[i-2]。

　　综上可得，f[i] = f[i-1]*(k-2) + f[i-2]*(k-1)（可以发现这种推算f的方式和hdu2045中类似）。边界处手算一下即可。得到了以后就可以做了。假设分隔位置为l和r，那么新的两部分的长度为别为Len1=|r-l|-1，Len2=n-|r-l|-1。那么最后的答案为k*f[Len1]*f[Len2] % mod。

　　同时，还有别的方法推f数组，每次扩张一个新长度时，只有k-1种选择（因为不能和分隔处颜色相同），所以总次数为(k-1)^i，这其中有重复的，计算方法如下：如果i-1处和分隔处颜色相同，那么i这个位置一定不会和相邻位置颜色相同；当i-1处和分隔处颜色不同，这时才有可能i的颜色和i-1处的重合，这种情况的总数是，前i-1个位置的正确总数，即f[i-1]，那么f[i] = (k-1)^i - f[i-1]。后面的计算方法类似。

　　代码如下（第一种推算f数组的方法）：

 #include <bits/stdc++.h>
 #define t_mid (l+r>>1)
 #define ls (o<<1)
 #define rs (o<<1|1)
 #define lson ls,l,t_mid
 #define rson rs,t_mid+1,r
 using namespace std;
 const int N = 1e5 + ;
 typedef long long ll;
 typedef pair<int,int> pii;
 const int mod = 1e9 + ;
 
 int n,m,k;
 int f[N];
 
 int main()
 {
     while(scanf("%d%d%d",&n,&m,&k) == )
     {
         f[] = k-;
         f[] = (ll)(k-) * (k-) % mod;
         for(int i=;i<=n;i++)
         {
             f[i] = ((ll)(k-)*f[i-] + (ll)(k-)*f[i-]) % mod;
         }
         while(m--)
         {
             int l, r;
             scanf("%d%d",&l,&r);
             int ans = (ll)k*f[abs(r-l)-] % mod * (f[n-abs(r-l)-]) % mod;
             printf("%d\n",ans);
         }
     }
     return ;
 }

1006

　　1007，分奇数和偶数作为起点进行扫描，维护遇到的最小的前缀和并更新答案即可。

　　1008，结论题。如果两点是相邻的则能追到，否则不行。理由是如果距离大于等于2，走的人走哪里，打断下一条路即可。

　　1009，分情况讨论即可。注意即使一开始全部相同，也必须要交换（也就是说要满足，只能换相同的两个字母）。

　　1010，因为位数少，直接暴力即可。如果位数多，可以考虑数位dp。