[2016-3-23 Test]

目录

1. [BZOJ 4361] isn
2. [BZOJ 4358] permu
3. [BZOJ 3522][Poi2014] Hotel

考试三道神题a
填坑ing
目测只改了第一题

---

isn

题意

• 给出一个长度为n的序列A(A1,A2…AN)。如果序列A不是非降的，你必须从中删去一个数，这一操作，直到A非降为止。求有多少种不同的操作方案，答案模10^9+7。
• n <= 2000

分析

• 设状态$f[i][j]$表示前i个数选了j个且第i个数字必须选的不降序列的方案数
• 比较好转移 $$f[i][j] = \sum_{k<i且a[k]≤a[i]} f[k][j-1]$$
• 这个转移可以用树状数组来优化到$O(nlogn)$
• 设状态$g[i]$表示长度为i的不降序列的方案数
• 则有 $$g[i] = \sum_{j=i}^n f[j][i]$$
• 那么其他的元素可以任意排列$g[i] * fac[n-i]$
• 但是有一些不合法的序列算上了怎么破?
• 考虑容斥原理
• 如果一个合法删除的序列又删除了一次， 一定是从g[i+1]转移过来的
• 选择任意一个元素有i+1中可能
• 那么就有$ans[i] = g[i] * fac[n-i]-(i+1)*g[i+1]*fac[n-(i+1)]$

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#define maxn 2010
using namespace std;
typedef long long ll;
const int mod = 1e9+7;
int n, m;
#define lowbit(i) i & (~i+1)

int t[maxn][maxn];
void init(){memset(t, 0, sizeof t);}
void update(int type, int pos, int val){
    pos ++;
    for(int i = pos; i <= n+2; i += lowbit(i)){
        t[type][i] += val;
        if(t[type][i] >= mod)t[type][i] -= mod;
    }
}

int ask(int type, int pos){
    pos ++;
    ll ret = 0;
    for(int i = pos; i; i -= lowbit(i))
        ret += t[type][i];
    return ret % mod;
}


int a[maxn], h[maxn];

int f[maxn][maxn], g[maxn];

ll fac[maxn];

int main(){
    scanf("%d", &n);
    for(int i = 1; i <= n; i ++)
        scanf("%d", &a[i]), h[i] = a[i];
    sort(h+1, h+1+n);
    int cnt = unique(h+1, h+1+n)-h-1;
    for(int i = 1; i <= n; i ++)
        a[i] = lower_bound(h+1, h+1+cnt, a[i])-h;

    update(0, 1, 1);

    for(int i = 1; i <= n; i ++){
        for(int j = i; j >= 1; j --){
            f[i][j] = ask(j-1, a[i]);
            update(j, a[i], f[i][j]);
        }
    }


    for(int i = 1; i <= n; i ++)
        for(int j = 1; j <= i; j ++){
            g[j] += f[i][j];
            if(g[j] >= mod)g[j] -= mod;
        }
    ll ans = 0;
    fac[0] = 1;
    for(int i = 1; i <= n; i ++)
        fac[i] = fac[i-1] * i % mod;
    for(int i = n; i >= 1; i --){
        ans = (ans + g[i] * fac[n-i] % mod) % mod;
        if(i < n)ans = (ans - 1ll * g[i+1] * fac[n-(i+1)] % mod * (i+1) % mod + mod) % mod;
    }

    printf("%lld\n", ans);
    return 0;
}

permu

题意

• 给出一个长度为n的排列P(P1,P2,…Pn)，以及m个询问。每次询问某个区间[l,r]中，最长的值域连续段长度。
• 每次给定一段区间，然后询问其中最长的连续的数字子集
  Sample Input
  8 3
  3 1 7 2 5 8 6 4
  1 4
  5 8
  1 7
  Sample Output
  3 3 4
  HINT
  对于询问[1,4]，P2,P4,P1组成最长的值域连续段[1,3]；
  对于询问[5,8]，P8,P5,P7组成最长的值域连续段[4,6]；
  对于询问[1,7]，P5,P7,P3,P6组成最长的值域连续段[5,8]。
• 1<=n,m<=50000

分析

• $O(n\sqrt n logn)$的复杂度相信大家都会
• 莫队+线段树搞定
• 容易T肿么破QAQ
• 卡常大法好
• =-=一点也不优雅
• 那好吧，我们来看$O(n\sqrt n)$如何去掉log
• 瓶颈在线段树的删除操作上，如果没有删除，我们是不是可以做到$O(1)$的修改~~并查集维护
• 如何避免删除操作呢？
• 按照莫队算法给操作排个序(相当于分块)，然后每一块内的右端点是递增的，这就让我们可以只插入不删除。左边要删除怎么办！！
• 那让左端点一直呆在块尾好了，这样每次只往回插入不删除。这个也可以用另一个并查集
• 操作完怎么回复？？
• 用一个栈清空fa2数组就好啦，调整仍然$O(\sqrt n)$

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#define maxn 100010
using namespace std;

int pos[maxn], end[maxn];

struct opt{
    int id, l, r;
    bool operator<(const opt& k)const{
        if(pos[l] != pos[k.l])return pos[l] < pos[k.l];
        return r < k.r;
    }
}q[maxn];

int P[maxn], n, m, ans[maxn];

void read(int& num){
    num = 0; char ch = getchar();
    for(; ch < '!'; ch = getchar());
    for(; ch > '!'; ch = getchar())
        num = (num << 3) + (num << 1) + (ch ^ 48);
}

int fa1[maxn], fa2[maxn], vis[maxn], s[maxn];
int mx[maxn], mn[maxn];

int getfa(int *fa, int x){return fa[x] == x ? x : fa[x] = getfa(fa, fa[x]);}
int nowans, st[maxn], top, v;

void add(int u){//在右边添加
    s[u] = 1; fa1[u] = u;
    if(v = getfa(fa1, u-1))fa1[v] = u, s[u] += s[v];
    if(v = getfa(fa1, u+1))fa1[v] = u, s[u] += s[v];
    nowans = max(nowans, s[u]);
}


void add_(int u, int &res){//在左边添加，左指针指向块尾
    fa2[u] = u;
    mx[u] = mn[u] = u;
    st[++ top] = u;
    if(v = getfa(fa2, u-1))mn[u] = mn[v];
    else if(v = getfa(fa1, u-1))mn[u] -= s[v];
    if(v = getfa(fa2, u+1))mx[u] = mx[v];
    else if(v = getfa(fa1, u+1))mx[u] += s[v];
    res = max(res, mx[u] - mn[u] + 1);
    st[++ top] = mx[u]; fa2[mx[u]] = u;
    st[++ top] = mn[u]; fa2[mn[u]] = u;
}

int main(){
    read(n), read(m);
    for(int i = 1; i <= n; i ++)
        read(P[i]);
    for(int i = 1; i <= m; i ++){
        read(q[i].l), read(q[i].r);
        q[i].id = i;
    }

    int B = sqrt(n) + 1;
    for(int i = 1; i <= B; i ++){
        int L = B*(i-1)+1, R = B*i;
        R = min(R, n);
        for(int j = L; j <= R; j ++)pos[j] = i;
        end[i] = R;
        if(R == n)break;
    }

    sort(q+1, q+1+m);

    for(int i = 1; i <= m; i ++){
        int p = i, cur; nowans = 0;
        while(pos[q[i].l] == pos[q[p].l] && p <= m)p ++;
        memset(fa1, 0, sizeof fa1);
        cur = end[pos[q[i].l]];
        for(int j = i; j < p; j ++){
            while(cur < q[j].r)add(P[++ cur]);
            ans[q[j].id] = nowans;
            int lim = min(q[j].r, end[pos[q[j].l]]);
            for(int k = q[j].l; k <= lim; ++ k)
                add_(P[k], ans[q[j].id]);
            while(top)fa2[st[top --]] = 0;
        }
        i = p - 1;
    }

    for(int i = 1; i <= m; i ++)
        printf("%d\n", ans[i]);

    return 0;
}