Infinite Tree

Infinite Tree

题意：

题解：

参考博客
看了好一阵子才明白。。。emm。
我们先按照题意画出一部分树

我们先不考虑复杂度，这题应该怎么做？
题目给了每个点的权值w[i]，问一个点到所有的节点路径长度*点权之和最小是多少，很明显是树形dp
dp[i]表示以i为根的子树到i的w和
sum[i]表示乘上距离之后的答案
dep[i]表示深度，now为当前节点，son为子节点
则有：

dp[now]= w[now]
sum[now]=0
dp[now]+=dp[son]
sum[now]+=sum[son]+(dep[son]-dep[now])*sum[son]

但是以now为根并不一定是最佳答案，所以我们还要不断的换根，求出最佳答案
如果将now为根转移到son为根，我们不用重新算一遍，只需要在之前的基础上

sum[now]-=sum[son]+(dep[son]-dep[now])*dp[son]
dp[now]-=dp[son]
sum[son]+=sum[now]+(dep[son]-dep[now])*dp[now]
dp[son]+=dp[now]

这样就OK了
但是！
题目是要求u到i！的距离，i！的增长速度很快，树的增长也是很快，如果全建出来肯定TLE了，所以我们没办法将整棵树建立，只能选择性建立，这要用到虚树
我们将阶乘点当做关键点，保留关键点及其lca，然后建立数就行
现在又有一个新问题，lca怎么计算？
我们首先考虑a！和(a+1)!的dfn谁大？
因为后者的因子一定包含前者的因子，所以除以mindiv后，（a+1）！的深度肯定更大，所以这些阶乘数的dfn是随a值从小到大的，这样我们只需要考虑相邻两个点的lca即可
我们列一个表格记录阶乘数分解后有多少个质数

我们根据上面的表格来列出相邻的LCA
2!和3 ! : 1，深度为1
3!和4 ! : 6，深度为3
4!和5 !: 1，深度为1
5!和6 !: 15，深度为3
6!和7 !: 1，深度为1
我们可以得出，对于a！和(a+1)!，LCA就是从大到小公共的质因子的乘积，遇到不同的就停止，深度是相同的个数+1
例如5！和6！：
5！分解后：5 3 2 2 2
6！：5 3 3 2 2 2 2
从大到小，一样的是5和3 ，（从第三位开始不一样，停止）
lca就是15，深度就是3

可以得到dep[lca((i+1)!,i!)] = sum(maxdiv(i+1),n)
sum(maxidv(i+1),n)为原本i！中大于等于maxdiv(i+1)的因子个数
这样我们就可以快速算出LCA
但是还是不够快，如果对于每个数都扫一次的话，还是很慢。所以，需要一个快速地查找求和，修改的算法，那就是用到了线段树或树状数组

代码：

#include<bits/stdc++.h>
#define ll long long
#define inf 1ll<<60
using namespace std;
const int MAXN=1e5+10;
int num[MAXN],w[MAXN<<1],d[MAXN<<1],stk[MAXN];
int ldfn[MAXN],rdfn[MAXN],dep[MAXN],lcad[MAXN],m;
int mndv[MAXN],pcnt=0;
ll dp1[MAXN<<1],dp2[MAXN<<1],ans;
vector<int> vir[MAXN<<1];
ll tr[MAXN<<2];//注意开long long
void Build(int root,int l,int r)
{
    tr[root]=0;
    if(l==r) return;
    int mid=l+r>>1;
    Build(root<<1,l,mid);
    Build(root<<1|1,mid+1,r);
}
void Change(int root,int l,int r,int x)
{
    if(l==r){
        tr[root]++;
        return;
    }
    int mid=l+r>>1;
    if(x<=mid) Change(root<<1,l,mid,x);
    else Change(root<<1|1,mid+1,r,x);
    tr[root]=tr[root<<1]+tr[root<<1|1];
}//x是插入的质数，要将其计数+1
int Query(int root,int x,int l,int r)
{              
    if(l>=x) return tr[root];
    int mid=l+r>>1;
    if(x<=mid) return Query(root<<1,x,l,mid)+Query(root<<1|1,x,mid+1,r);
    else if(x>mid) return Query(root<<1|1,x,mid+1,r);
}//查找当前质数的个数
void build()
{//^不等于，相当于!=
    dep[1]=1;
    for(int i=2;i<=m;i++)
    {
        dep[i]=dep[i-1];
        int j=i;
        while(j^mndv[j]) j/=mndv[j];
        lcad[i]=Query(1,j,1,m)+1;
        for(j=i;j^1;dep[i]++,j/=mndv[j]) Change(1,1,m,mndv[j]);
    }
    int top=0,tot=m;stk[++top]=1;
    for(int i=2;i<=m;i++){
        if(top==1||lcad[i]==dep[stk[top]]){
            stk[++top]=i;continue;
        }
        while(top>1&&lcad[i]<=dep[stk[top-1]]){
            vir[stk[top-1]].push_back(stk[top]);
            top--;
        }//建虚树的基本操作，不会的建议去学习一下
        if(lcad[i]^dep[stk[top]]){
            dep[++tot]=lcad[i];
            w[tot]=0;
            vir[tot].push_back(stk[top]);
            stk[top]=tot;
        }
        stk[++top]=i;
    }
    while(top>1){
        vir[stk[top-1]].push_back(stk[top]);
        top--;
    }
}//原理同上，供参考
void dfs1(int x,int fa)
{
    dp1[x]=w[x];
    dp2[x]=0;
    for(int i=0;i<vir[x].size();i++){
        int son=vir[x][i];
        if(son==fa) continue;
        dfs1(son,x);
        dp1[x]+=dp1[son];
        dp2[x]+=dp2[son]+(dep[son]-dep[x])*dp1[son];
    }
}
void dfs2(int x,int fa)
{
    ans=min(ans,dp2[x]);
    for(int i=0;i<vir[x].size();i++){
        int son=vir[x][i];
        if(son==fa) continue;
        ll x1=dp1[x],x2=dp2[x],son1=dp1[son],son2=dp2[son];
        dp2[x]-=dp2[son]+(dep[son]-dep[x])*dp1[son];
        dp1[x]-=dp1[son];
        dp2[son]+=dp2[x]+(dep[son]-dep[x])*dp1[x];
        dp1[son]+=dp1[x];
        dfs2(son,x);
        dp1[x]=x1,dp2[x]=x2,dp1[son]=son1,dp2[son]=son2;
    }
}//树形dp+换根，非重点，且是模板一套的问题，上面已经分析
int main()
{
    mndv[1]=1;
    for(int i=2;i<MAXN;i++)
        if(!mndv[i])
            for(int j=i;j<MAXN;j+=i)
                if(!mndv[j]) mndv[j]=i;//预处理出每个数的mindiv，之后分解时可以用
    while(~scanf("%d",&m)){
        for(int i=1;i<=m;i++)
            scanf("%d",&w[i]);
        for(int i=0;i<=m*2;i++){
            vir[i].clear();
            dp1[i]=dp2[i]=0;
        }
        Build(1,1,m);
        build();
        dfs1(1,0);
        ans=dp2[1];
        dfs2(1,0);
        printf("%lld\n",ans);
    }
}

#include<bits/stdc++.h>
#define lowbit(x) x&-x
using namespace std;
typedef long long ll;
const int MAX = 2e5 + 10;
//建立虚树点数tot < 2n, 空间开两倍

int n, w[MAX];
ll ans;

//树状数组
int c[MAX];
void upd(int p, int k) { for (; p <= n; p += lowbit(p)) c[p] += k; }
int query(int p) { int res = 0; for (; p; p -= lowbit(p)) res += c[p]; return res; }

int mindiv[MAX];
void sieve(int siz) {//筛mindiv
    for (int i = 2; i <= siz; i++)
        if (!mindiv[i])
            for (int j = i; j <= siz; j += i)
                if (!mindiv[j])
                    mindiv[j] = i;
}

int lcadep[MAX], dep[MAX];
int st[MAX], top, tot;//stack, top, tot:虚树点数
vector<int> g[MAX];//虚树
void add_edge(int u, int v) { g[u].push_back(v), g[v].push_back(u); }

void buildVirtualTree() {
    tot = n;
    st[top = 1] = 1;
    for (int i = 2; i <= n; i++) {
        dep[i] = dep[i - 1] + 1; 
        int j = i;
        for (; j != mindiv[j]; j /= mindiv[j]) dep[i]++;
        lcadep[i] = query(n) - query(j - 1);
        for (j = i; j != 1; j /= mindiv[j]) upd(mindiv[j], 1);
    }
    //建树
    for (int i = 2; i <= n; i++) {
        while (top > 1 && dep[st[top - 1]] >= lcadep[i])
            add_edge(st[top - 1], st[top]), top--;
        if (dep[st[top]] != lcadep[i]) 
        {
            dep[++tot] = lcadep[i];
            add_edge(tot, st[top]);
            st[top] = tot;
        }
        st[++top] = i;
    }
    while (top > 1)
    {
        add_edge(st[top - 1], st[top]);
        top--;
    }
}

void dfs(int u, int fa) {
    ans += 1ll * w[u] * dep[u];//ans最开始是rt = 1时的答案
    for (auto &v: g[u])
        if (v != fa) {
            dfs(v, u);
            w[u] += w[v];
        }
}

void dfs2(int u, int fa) {//如果rt移动之后答案变小就一直移动下去，直到答案不在变小
    for (auto &v: g[u])
        if (v != fa) {
            //rt从u转移到v的代价
            //+(w[1] - w[v]) - w[v]
            if (w[1] - 2 * w[v] < 0) {
                ans += 1ll * (w[1] - 2 * w[v]) * (dep[v] - dep[u]);//一步的代价*距离
                dfs2(v, u);
            }
        }
}

void init() {
    ans = top = 0;
    for (int i = 1; i <= tot; i++) 
    {
        g[i].clear();
        c[i] = w[i] = lcadep[i] = dep[i] = 0;
    }
}

int main() {

    sieve(1e5);
    while (~scanf("%d", &n)) {
        init();
        for (int i = 1; i <= n; i++) scanf("%d", &w[i]);
        buildVirtualTree();
        int rt = 1;
        dfs(rt, 0);
        dfs2(rt, 0);
        printf("%lld\n", ans);
    }

    return 0;
}