HGOI 20190709 题解

Problem A 紫色激情

一个序列$\{a_n\}$，求出方差最大的子序列。

其中方差 [l,r] 的定义是$S^2 = \frac{1}{n} \sum\limits_{i=l}^{r} (x_i-\bar{x})^2$

对于100%的数据满足$n \leq 10^3$

Sol : 直接推一波公式就可以前缀和优化了。

　　${ S_{l,r} }^2 = -\bar{x}^2 +\frac{\sum_{i=l}^r {x_i}^2}{n}$

时间复杂度$O(n^2)$

# include<bits/stdc++.h>
# define int long long
using namespace std;
const int N=2e3+;
int s1[N],s2[N];int n;
inline int read()
{
    int X=,w=; char c=;
    while(c<''||c>'') {w|=c=='-';c=getchar();}
    while(c>=''&&c<='') X=(X<<)+(X<<)+(c^),c=getchar();
    return w?-X:X;
}
inline void write(int x)
{
    if (x<) x=-x,putchar('-');
    if (x>) write(x/);
    putchar(x%+'');
}
signed main()
{
    n=read();
    for (int i=;i<=n;i++) {
        int t=read();
        s1[i]=s1[i-]+t;
        s2[i]=s2[i-]+t*t;
    }
    double ans=-1e9; int ansl=,ansr=;
    for (int l=;l<=n;l++)
     for (int r=l;r<=n;r++) {
      double t=-(double)(s1[r]-s1[l-])*(s1[r]-s1[l-])/(double)(r-l+)/(double)(r-l+);
      double w=(double)(s2[r]-s2[l-])/(double)(r-l+);
      if (t+w>ans) { ans=t+w; ansl=l; ansr=r;}
    }
    write(ansl);putchar(' ');write(ansr); putchar('\n');
    return ;
}

passion.cpp

Problem B 克罗地亚狂想曲

共有$n$个节点,从每个节点可以向前面一个节点连一条边，而如果和后面一个节点的连边将被忽略。

两个相连节点之间有一条连边，可以直接经过，找出一条访问的路径，使得每个节点被经过最多2次，

经过路径上点值之和最大。

对于100%的数据 ， $n \leq 3\times 10^5 $

Sol: 显然，向前连边的这个过程是没有后效性的，所以可以进行动态规划。

　　而每个节点最多只能被经过2次保证了一次转移的合法性。

　　设$f_i$表示走到节点$i$时候最大值。

　　如果当前元素没有向前连边，那么答案就从上一节点走来，$f_i = f_{i-1} + a_i$

　　如果当前元素有向前连边到$j$那么可以考虑从$j$过来在经过$j$，在走到$i$，再接下去走。

　　这等价于$j->i$的路径被累加了$2$次，那么转移方程就是$f_i = f_{j-1}  + 2 \sum\limits_{k=j}^{i} a_k$

　　然后那个$\sum$累加可以用前缀和优化掉，这样这个DP就是线性的了。

　　复杂度$O(n)$

# include <bits/stdc++.h>
# define int long long
using namespace std;
const int N=3e5+;
int from[N],f[N],s[N],n;
inline int read()
{
    int X=,w=; char c=;
    while(c<''||c>'') {w|=c=='-';c=getchar();}
    while(c>=''&&c<='') X=(X<<)+(X<<)+(c^),c=getchar();
    return w?-X:X;
}
inline void write(int x)
{
    if (x<) x=-x,putchar('-');
    if (x>) write(x/);
    putchar(x%+'');
}
signed main()
{
    n=read();
    for (int i=;i<=n;i++) {
        int t=read();
        if (t>i) continue;
        from[i]=t;
    }
    for (int i=;i<=n;i++) {
        int t=read();
        s[i]=s[i-]+t;
    }
    for (int i=;i<=n;i++) {
        f[i]=f[i-]+s[i]-s[i-];
        if (from[i]!=) f[i]=max(f[from[i]-]+*(s[i]-s[from[i]-]),f[i]);
    }
    write(f[n]);putchar('\n');
    return ;
}

rhapsody.cpp

Problem C 花之舞

给出一个字符串中，求该字符串中最大不重复双倍回文串覆盖。

对于100%的数据，$ len(s) \leq 10^3 $

Sol :  首先我们可以通过字符串Hash的做法判定一个串是不是回文串，这样只需要一遍$O(n)$的预处理，再$O(1)$判定即可。

然后我们可以$O(n^2)$枚举从$i$开始的所有双倍回文串,然后可以使用类似线段覆盖的DP做出最大不重复双倍回文串覆盖。

最终的复杂度是$O(n^2)$的。

# include<bits/stdc++.h>
# define int long long
using namespace std;
const int mo=1e9+;
const int base=;
const int N=1e3+;
int p[N],a[N],hash1[N],hash2[N],f[N];
int n;
vector<int>v[N];
inline int read()
{
    int X=,w=; char c=;
    while(c<''||c>'') {w|=c=='-';c=getchar();}
    while(c>=''&&c<='') X=(X<<)+(X<<)+(c^),c=getchar();
    return w?-X:X;
}
inline void write(int x)
{
    if (x<) x=-x,putchar('-');
    if (x>) write(x/);
    putchar(x%+'');
}
int gethash(int num,int l,int r)
{
    if (num==) return ((hash1[r]-hash1[l-]*p[r-l+]%mo)%mo+mo)%mo;
    else return ((hash2[r]-hash2[l-]*p[r-l+]%mo)%mo+mo)%mo;
}
bool check(int l,int r)
{
    if ((r-l+)&) {
        int pos=(l+r)/,len=(r-l)/;
        if (gethash(,pos,pos+len)==gethash(,n+-pos,n+-pos+len)) return ;
        else return ;
    } else {
        int pos1=(l+r)/,pos2=pos1+,len=(r-l-)/;
        if (gethash(,pos2,pos2+len)==gethash(,n+-pos1,n+-pos1+len)) return ;
        else return ;
    }
}
void fun(int pos)
{
    for (int mid=(n+-pos)/;mid>=;mid--)
     if (check(pos,pos+mid-)&&check(pos+mid,pos+*mid-)&&gethash(,pos,pos+mid-)==gethash(,pos+mid,pos+*mid-))
         v[pos].push_back(pos+*mid-);
}
signed main()
{
//    freopen("dance.in","r",stdin);
//    freopen("dance.out","w",stdout);
    n=read(); p[]=;
    for (int i=;i<=n;i++)
        a[i]=read(),p[i]=p[i-]*base%mo;
    for (int i=;i<=n;i++)
        hash1[i]=(hash1[i-]*base%mo+a[i])%mo;
    int u=;
    for (int i=n;i>=;i--) u++,hash2[u]=(hash2[u-]*base%mo+a[i])%mo;
    for (int i=;i<=n;i++) fun(i);
    for (int i=n;i>=;i--) {
         f[i]=f[i+];
         for (int j=;j<v[i].size();j++)
          f[i]=max(f[i],f[v[i][j]+]+(v[i][j]-i+));
     }
    write(f[]); putchar('\n');
    return ;
} 

dance.cpp