Educational Codeforces Round 97 (Rated for Div. 2)

A：Marketing Scheme

  满足$r\ge 2\ast l$无解。

B：Reverse Binary Strings

  这题应该注重结果而不是交换的过程。我们可以发现，对于一个串来说，一定发生了下面这种情况：

1 1xxxxxx 0 0   这时候我们可以发现，交换中间这个字符串的时候，仅仅改变了 中间这个字符串,造成的影响 仅仅针对于左右两侧s[i]≠s[i+1]，而对这个中间字符相邻的关系没有任何改变！因此，我们可以统计11串和00串的个数，最终的答案是max(num0,num1)。（PS：取二者之中的较大者的原因是因为两个不一定相等，例如串110可能会造成11的数量比00的数量多一个）。

C：Chef Monocarp

  先考虑贪心，肯定尽量会往它本身的那个时刻放，剩下的往本身时刻的两边放所造成的贡献更小。但是这样会出现一个矛盾，比如时刻7有5个，时刻9有5个，这样就会造成中间位置的竞争。
  然后我们考虑到这样的竞争结果是不好预测的，无论是让给左边还是让给右边都会取决于后面其他位置的影响。前面的选择的结果会影响后面，这便可以考虑DP的解题策略了。
  我们用$f[i][j]$表示在时刻$j$放置前$i$个物品所需要的消耗，很容易得出转移方程是$f[i][j]=max(f[i][j-1],f[i-1][j-1]+abs(j-a[i]))$.即$j$时刻放物品$i$，或者$j$时刻不放物品$i$.注意，在这个表达式下，物品$i$一定放在物品$i+1$前面，因此，我们一定要通过排序，保证$t_i<t_{i+1}$!
  最后就是DP初始化的问题：一开始的合法状态必然是$f[0...n][0]=0$.

#include<bits/stdc++.h>
#define close ios::sync_with_stdio(false)
using namespace std;
int n,m,e,ans=0;
int a[210],f[410][410];
const int INF=0x3f3f3f3f;
int main()
{
    close;
    int T;cin>>T;
    while(T--)
    {
        int n;cin>>n;
        for(int i=1;i<=n;++i) cin>>a[i];
        memset(f,INF,sizeof(f));
        for(int j=0;j<=400;++j) f[0][j]=0;
        sort(a+1,a+n+1);
        for(int i=1;i<=n;++i)
            for(int j=1;j<=400;++j)
                f[i][j]=min(f[i][j-1],f[i-1][j-1]+abs(j-a[i]));
        int maxnum=INT_MAX;
        for(int j=n;j<=400;++j) maxnum=min(maxnum,f[n][j]);
        cout<<maxnum<<endl;
    }
}

D：Minimal Height Tree

  题目的限制条件是一个根结点的儿子的结点编号是呈递增的，因此我们只要贪心地将数组$a$当中尽可能长的递增序列安排到一个结点下方做他的子结点即可。

E：Make It Increasing

【前置准备：HDU5256 序列变换】
  题目大意是，给定一个数列A，让你修改数量最少的元素，使得这个数列严格递增。我们可以这么考虑，如果有$\forall i,A[i+1]>A[i]$，那么则有$A[i+1]-1\ge A[i]$，进而有$A[i+1]-(i+1)\ge A[i]-i$.我们只要得到修改后序列的最长非下降子序列的长度$len$，那么只要修改$n-len$个数，原序列就是严格上升的。
  注意这里替换的时候要使用upper_bound()函数，替换掉第一个比他大的数字！使用lower_bound()函数是错误的，例如序列A=[1,3,4,6,4,4,5]，使用lower_bound()得到的最终结果是1,3,4,5；而使用upper_bound()得到的最终结果是1,3,4,4,4,5.

#include<bits/stdc++.h>
#define close ios::sync_with_stdio(false)
using namespace std;
const int maxn=5e5+100;
int a[maxn],b[maxn];
int solve(int n)
{
    int len=1;
    b[0]=a[0];
    for(int i=1;i<n;++i)
    {
        if(a[i]>=b[len-1]) b[len++]=a[i];
        else{
            int pos=upper_bound(b,b+len,a[i])-b;
            b[pos]=a[i];
        }
    }
    return len;
}
int main()
{
    close;
    int T;cin>>T;
    for(int casenum=1;casenum<=T;++casenum)
    {
        int n;cin>>n;
        for(int i=0;i<n;++i) cin>>a[i],a[i]-=i;
        printf("Case #%d:\n%d\n",casenum,n-solve(n));
    }
}

---

  CF上这道题唯一的区别就是多了几个固定位的限制。可以把问题分情况讨论一下：
①当$k=0$时，问题退化成上面的形式，直接变换后求最长非下降子序列；
②当$k>0$时，先检查是否满足$(a[b[i+1]]-a[b[i]]-1)\ge (b[i+1]-b[i]-1)$，不满足直接输出-1；
③否则，我们将上述序列按照b划分成一个个区间，分别在区间上求最长非下降子序列。可以设置数组a和数组b的哨兵结点，然后在区间$[l,r]$上求解最长非下降子序列即可。注意：每个区间的第一个数值不能被修改！得到一个最长非下降子序列后，我们找到右端点在序列中第一个比他大的元素的位置pos，可以得知在最长非下降子序列$f[1...pos-1]$的元素可以不用被修改，$f[pos...len]$需要被修改，所以该区间需要修改$(r-l+1)-pos$个。

#include<bits/stdc++.h>
#define close ios::sync_with_stdio(false)
using namespace std;
const int maxn=5e5+100;
int a[maxn],b[maxn],f[maxn];
bool check(int k)
{
    for(int i=2;i<=k;++i)
        if((a[b[i]]-a[b[i-1]])<=(b[i]-b[i-1]-1)) return false;
    return  true;
}
int solve(int l,int r)
{
    int len=1;
    f[1]=a[l];
    for(int i=l+1;i<=r;++i)
    {
        if(a[i]>=f[len]) f[++len]=a[i];
        else{
            int pos=upper_bound(f+1,f+len+1,a[i])-f;
            if(pos!=1) f[pos]=a[i];
        }
    }
    int pos=upper_bound(f+1,f+len+1,a[r])-(f+1);
    return (r-l+1)-pos;
}
int main()
{
    close;
    int n,k;cin>>n>>k;
    for(int i=1;i<=n;++i) cin>>a[i];
    for(int i=1;i<=k;++i) cin>>b[i];
    if(k==0)
    {
        for(int i=1;i<=n;++i) a[i]-=i;
        int len=1;
        f[1]=a[1];
        for(int i=2;i<=n;++i)
        {
            if(a[i]>=f[len]) f[++len]=a[i];
            else{
                int pos=upper_bound(f+1,f+len+1,a[i])-f;
                f[pos]=a[i];
            }
        }
        cout<<n-len<<endl;
        return 0;
    }
    if(!check(k)) {cout<<-1<<endl;return 0;}
    for(int i=1;i<=n;++i) a[i]-=i;
    a[0]=INT_MIN;a[n+1]=INT_MAX;//设立哨兵结点
    b[0]=0;b[k+1]=n+1;
    int ans=0;
    for(int i=1;i<=k+1;++i)
        ans+=solve(b[i-1],b[i]);
    cout<<ans<<endl;
}

F：Emotional Fishermen

  题目大意：给定一个有$n$个正整数的序列$a$，目标是能够使排列后的数组满足：$$\frac{a_{p_i}}{ma{x}_{j=1}^{i-1}{a}_{p_j}}\notin (\frac{1}{2},2)$$问有多少种排列方案？
  先将序列$a$按照从小到大的顺序进行排列，我们用$dp[i]$表示最大值为$a_i$时的方案个数，用$pos[i]$表示从$[1...i]$中满足$2\ast a_j\le a_i$中最大的$j$.
  先考虑如何求解$pos[i]$的问题。这里我们可以采用单调栈的方法（通过模拟实现）。我们令$cur$指针指向的是对于当前的$a_i$来说满足条件的$a_j$，当$a_i$增大的时候，$cur$同样右移。
  接着我们考虑如何构造的问题。现在我们拿到了一个最大值为$a_j$的序列，然后我们试图朝这个序列添加一个最大值为$a_i$，且满足$a_i\ge a_j$.第一步，我们先将$a_i$放在当前序列从左向右看第一个空位上！这是我们构造的基础，也是我们后面正确性证明的必要条件。这时候我们就发现，这时候有$pos[i]-pos[j]-1$个数，可以放在$n-pos[j]-2$个空位上。（原来的序列有$pos[j]+1$个，$a_i$在第一个空位上，这一位也不可选；这时候会有$pos[i]-pos[j]-1$可以随意放在$a_i$后的任意空位上，一定满足条件。）因此，我们可以得出，递推方程是：$$dp[i]=\sum _{j=0}^{i-1}dp[j]\ast A_{n-pos[j]-2}^{pos[i]-pos[j]-1}$$很明显我们最终的答案是$dp[n]$,当且仅当$pos[n]=n-1$.
  现在考虑一下构造的合理性，这样的构造方式会不会造成重复计数的问题。例如我们令$a_k<a_j<a_i$，计算$dp[j]$使用了$dp[k]$，计算$dp[i]$同时使用了$dp[j],dp[k]$.但是根据我们的构造方式，能够保证不同的转移，最大值的出现次序一定是不同的，因为我们的最大值一定放在当前序列从左到右的第一个空位上，因此肯定不同。
  最后一定要令$pos[i]=-1$，这样能够使得$n-pos[0]-2=n-1,pos[i]-pos[j]-1=pos[i]$，满足实际情况。

#include<bits/stdc++.h>
#define close ios::sync_with_stdio(false)
using namespace std;
const int mod=998244353;
const int maxn=5e3+100;
typedef long long ll;
ll qpow(ll base,ll x)
{
    ll ans=1;
    while(x) {if(x&1) ans=ans*base%mod;base=base*base%mod;x>>=1;}
    return ans;
}
ll f[maxn],inv[maxn],a[maxn],pos[maxn],dp[maxn];
void Init(int n)
{
    f[0]=1;inv[0]=1;
    for(int i=1;i<=n;++i) f[i]=f[i-1]*i%mod;
    inv[n]=qpow(f[n],mod-2);
    for(int i=n-1;i>0;--i) inv[i]=inv[i+1]*(i+1)%mod;
}
ll A(ll n,ll m) {return f[n]*inv[n-m]%mod;}
int main()
{
    close;int n;cin>>n;
    for(int i=1;i<=n;++i) cin>>a[i];
    sort(a+1,a+n+1);
    Init(n);
    int cur=0;
    for(int i=1;i<=n;++i)
    {
        while(cur<n && a[i]>=2*a[cur+1]) cur++;
        pos[i]=cur;
    }
    if(pos[n]!=n-1) {cout<<0<<endl;return 0;} 
    dp[0]=1;pos[0]=-1;
    for(int i=1;i<=n;++i)
        for(int j=0;j<=pos[i];++j)
            dp[i]=(dp[i]+dp[j]*A(n-2-pos[j],pos[i]-pos[j]-1))%mod;
    cout<<dp[n]<<endl;
}