loli的毒瘤hu测 T2&&T3

最新推荐文章于 2019-03-13 16:07:18 发布

Coco_T_

最新推荐文章于 2019-03-13 16:07:18 发布

阅读量288

点赞数

分类专栏：日常hu测高斯消元文章标签：高斯消元矩阵树定理

本文链接：https://blog.csdn.net/wu_tongtong/article/details/79727351

版权

日常hu测同时被 2 个专栏收录

61 篇文章 0 订阅

订阅专栏

高斯消元

19 篇文章 0 订阅

订阅专栏

T2.tree（矩阵树定理+gauss）

这里写图片描述

分析：
这道题的爆搜真的恶心。。。
可以放出来吓吓人：

const ll p=1e9+7;
const int N=100005;
struct node{
    int x,y;
};
node t[N][31];
int n,m,Q[N],deep[N],tot=0;
ll ans=0;
map<ll,int> mp;

int fa[50];

int find(int x) {
    if (fa[x]!=x) fa[x]=find(fa[x]);
    return fa[x];
}

int pd(int x) {                         //并查集判断是否是一棵树
    for (int i=1;i<=n;i++) fa[i]=i;
    for (int i=1;i<n;i++) {
        int f1=find(t[x][i].x);
        int f2=find(t[x][i].y);
        if (f1==f2) return 0;
        fa[f1]=f2;
    }
    return 1;
}

int P[50],du[50],a[50];
struct node2{
    int y,nxt;
};
node2 e[100];
int st[50],tet=0;
bool vis[N];

void prufer(int x) {                  //prufer+hash
    int o=0;
    for (int i=1;i<=n;i++) du[i]=0,st[i]=0,vis[i]=0; tet=0;
    for (int i=1;i<n;i++) {
        int u=t[x][i].x;
        int w=t[x][i].y;
        du[u]++; du[w]++;
        tet++; e[tet].y=w; e[tet].nxt=st[u]; st[u]=tet;
        tet++; e[tet].y=u; e[tet].nxt=st[w]; st[w]=tet;
    }
    for (int o=1;o<=n-2;o++) {
        int now=0;
        for (int i=1;i<=n;i++) if (du[i]==1&&!vis[i]) {now=i;break;}
        vis[now]=1;
        for (int i=st[now];i;i=e[i].nxt) 
            if (!vis[e[i].y]) {
                du[e[i].y]--;
                a[o]=e[i].y; 
            }
    }
}

int hash(int x) {
    prufer(x);
    ll t=0;
    for (int i=1;i<=n-2;i++)
        t=t*(ll)131+a[i];
    if (mp[t]) return 0;
    mp[t]=1;
    return 1;
}

void bfs() {
    int tou,wei;
    tou=wei=0;
    hash(1);                      //原树
    Q[++wei]=1; deep[wei]=0;
    while (tou<wei) {
        tou=(tou+1)%N;
        int now=tou;
        for (int i=1;i<n;i++) {
            node way=t[now][i];
            for (int x=1;x<=n;x++)
                for (int y=x+1;y<=n;y++) {
                    if ((x==way.x&&y==way.y)||(x==way.y&&y==way.x)) continue;
                    t[now][i].x=x; t[now][i].y=y;
                    if (pd(now)) {
                        if (hash(now)) {
                            if (deep[now]+1<m) {
                                wei=(wei+1)%N;
                                for (int i=1;i<n;i++) t[wei][i]=t[now][i];
                                deep[wei]=deep[now]+1;
                            }
                            ans++; ans%=p;
                        }
                    }
                }
            t[now][i]=way;
        }
    }
}

10%保证k=n-1

显然把原树修改成某棵数需要的最小步数就是在新树种且不再原树中的边数
那么当k=n-1时，其实就是要算n个点的有编号无根树数量
有编号无根树？Prufer编码！
那么答案就是 $n^{n-2}$

20%保证k=n-2

当k=n-2时，我们只需要计算出需要的最小步数恰好为 $n-1$ 的树的个数就好了
也就是说新树的所有边都不在原树中，可以直接用矩阵树定理计算

70%

矩阵树定理计算的是每个生成树的树边权值之积的和
我们可以把原树上的边权值设为1，不在原树上的边权值设为x
那么跑矩阵树定理就会得到一个多项式， $x^k$ 前的系数就是恰好有 $k$ 条不再原树上的边的树的个数了
时间复杂度 $O(n^5)$

100%

70%算法的瓶颈主要在于求行列式的时候要做多项式乘法
考虑带n个x的值进去跑矩阵树定理，得到n个点值之后再差值求出原多项式即可
时间复杂度 $O(n^4)$

tip

给出舒老师的标程
路过的还不快来%？

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define ll long long
#define o 85
using namespace std;
const ll Mod=1e9+7;
ll ans[o];
int n,K,a[o];
ll A[o][o],F[o][o],G[o][o],B[o];
ll Abs(ll a){
    return a<0?-a:a;
}
ll ksm(ll a,ll b,ll p){
    ll answer=1;
    for(;b;b>>=1,a=a*a%p) if(b&1) answer=answer*a%p;
    return answer;
}
ll Calc(int n){ 
    ll answer=1;
    for(int i=1;i<=n;i++){
        for(int j=i+1;j<=n;j++){
            ll A=F[i][i],B=F[j][i];
            while(B){
                ll t=A/B;A%=B;swap(A,B);
                for(int k=i;k<=n;k++) F[i][k]=(F[i][k]-F[j][k]*t%Mod+Mod)%Mod;
                for(int k=i;k<=n;k++) swap(F[i][k],F[j][k]);
                answer=-answer; 
            } 
        }
        if(!F[i][i])return 0;
        answer=answer*F[i][i]%Mod;
    }
    return (answer%Mod+Mod)%Mod;
}
void GS(int n){
    for(int i=0;i<=n;i++){
        int k=i;
        for(int j=i+1;j<=n;j++) if(Abs(G[k][i])<Abs(G[j][i])) k=j;
        for(int j=0;j<=n;j++) swap(G[i][j],G[k][j]); swap(B[i],B[k]);
        ll inv=ksm(G[i][i],Mod-2,Mod);
        for(int j=0;j<=n;j++) G[i][j]=G[i][j]*inv%Mod; B[i]=B[i]*inv%Mod;
        for(int j=0;j<=n;j++){
            if(i==j||!G[j][i])continue;
            ll t=G[j][i];
            for(int k=0;k<=n;k++) G[j][k]=(G[j][k]-G[i][k]*t%Mod+Mod)%Mod;
            B[j]=(B[j]-B[i]*t%Mod+Mod)%Mod;
        }
    }
    for(int i=0;i<=n;i++) ans[i]=(B[i]*ksm(G[i][i],Mod-2,Mod)%Mod+Mod)%Mod;
}
int main(){
    freopen("tree.in","r",stdin);
    freopen("tree.out","w",stdout);
    scanf("%d%d",&n,&K);
    for(int i=2;i<=n;i++){
        scanf("%d",&a[i]);a[i]++;
        A[i][a[i]]=A[a[i]][i]=1;
    } 
    for(ll t=0;t<=n;t++){
        ll xi=t+1,zoom=1;
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++) F[i][j]=!A[i][j]? -xi:-A[i][j];
            F[i][i]=0;
            for(int j=1;j<=n;j++) if(i!=j) F[i][i]-=F[i][j];
        }
        B[t]=Calc(n-1);
        for(int i=0;i<=n;i++,zoom=zoom*xi%Mod) G[t][i]=zoom;
    }
    GS(n);
    ll answer=0;
    for(int i=0;i<=K;i++) answer=(answer+ans[i])%Mod;
    answer=(answer%Mod+Mod)%Mod;
    printf("%lld\n",answer);
    return 0;
}

T3.sequence

这里写图片描述

分析：

解法一（50%）

我们对每个查询区间维护的一个集合，按照全职从小到大一次把每个元素插入所有包含ta的查询集合中
由于是升序插入的我们只需要知道每个集合中插入顺序相邻的每两个元素的差的最小值
可以把查询区间看做二维平面上的一个点，然后用KDtree维护
时间复杂度 $O(nlogn+n\sqrt m)$

解法二（20~50%）

直接用莫队算法，维护一个平衡树来查询前驱后继，再用一个堆维护差值最小值
假设莫队是按 $l/k$ 分组的，那么时间复杂度为 $O(({n^2 \over k}+mk)logn)$ ，取 $k={m \over \sqrt m}$ 时可以得到最优复杂度 $O((n \sqrt m)logn)$

解法三（50~70%）

考虑优化解法二，瓶颈在于需要查毒，如果只删除的话，维护链表就可以做到 $O(1)$ 查询前驱后继了
假设当前这组询问的左端点都在 $[x,y]$ 之间
我们可以先用链表对每个 $r$ 求出 $a_r$ 在区间 $[y,r]$ 的前驱后继
那么接下来对每个询问 $[l,r]$ ，我们需要对 $i=l..y$ 求出 $a_i$ 在区间 $[i,r]$ 内的前驱后继
我们把同组的询问按照右端点从大到小排序，然后同样维护一个链表，那么右端点可以直接删，左端点我们每次删到 $y$ 的位置，求出答案后暴力撤销回去即可
时间复杂度 $O(n \sqrt m)$

解法六（50%）

我们对每个 $i$ ，考虑有哪些 $j$ 满足 $j > i,a_j >=a_i$ ，并且 $a_j-a_i$ 可能成为答案（ $a_j<a_i$ 的用同样方法再做一遍就可以了）
假设我们现在找到了某个可能的点对 $(i,j)$ ，下一个可能的 $j′(j′> j)$ 必须满足 $a_{j′} < a_j$
也就是说我们是要找 $i$ 后面的一个不小于 $a_i$ 的递减序列
由于数据随机，这个递减序列的长度是期望 $O(logw)$ 的
因此我们可以先找出这样的点对，然后用离线树状数组做一个二维数点就好了
寻找点对显然可以使用数据结构解决，不过还有一种更简洁的做法
设 $f_{i,j}$ 表示在 $i$ 后面且不小于 $a_i$ 的递减序列的第 $j$ 项，类似地设 $g_{i,j}$ 表示在 $i$ 后面且小于 $a_i$ 的递增序列的第 $j$ 项
令 $p=f_{i,j-1}$ ，可以发现 $f_{i,j}$ 就是 $g_p$ 中不小于 $a_i$ 且最靠前的一项
因此我们就可以直接递推求出 $f$ 和 $g$
随机数据下时间复杂度为 $O((n logw + m) log n)$

解法七（100%）

我们延续解法六的思路，尝试能否找出一些不依赖数据随机的性质
实际上，我们寻找下一个可能的 $j′$ 的时候，还需要满足 $a_{j′}-a_i<a_j-a_{j′}$
否则 $(j,j′)$ 就会优于 $(i,j′)$
可以发现，每找到一个新的 $j$ ， $a_j-a_i$ 就会减小至少一半，因此即便在非随机数据下可能的点对最多也只有 $O(n logw)$ 对
寻找点对的过程中需要查询 $[j + 1..n]$ 内第一个 $a_i<a_p<{a_i+a_j \over 2}$ 的 $p$
这个可以用可持久化线段树解决，也可以把元素从大到小插入线段树来做
时间复杂度 $O((n logw + m) log n)$