树的深度优先遍历：数字转换

题目描述

如果一个数 x 的约数之和 y（不包括他本身）比他本身小，那么 x 可以变成 y，y 也可以变成 x。

例如，4 可以变为 3，1 可以变为 7。

限定所有数字变换在不超过 n 的正整数范围内进行，求不断进行数字变换且不出现重复数字的最多变换步数。

输入格式

输入一个正整数 n。

输出格式

输出不断进行数字变换且不出现重复数字的最多变换步数。

数据范围

$1\le n\le 50000$

输入样例

7

输出样例

3

样例解释

一种方案为：4→3→1→7。

算法思想

根据题目描述，$y$是$x$的约数之和（不包含$x$）。对于任意一个$x$来说，它的约数之和是固定的、不会发生变化，那么对于每一个$x$而言，只有一个$y$与之对应，如果在$y$与$x$之间连一条边，表示$y$是$x$父结点，那么$x$只有一个父结点。推而广之，如果把$1-n$之间所有可以转换的数用边连接起来，那么就可以构成一堆树组成的森林。根据上述性质，题目就变成了在边权为1的森林中，求树的最长路径。

算法实现

1. 预处理出每个数的约数之和sum[i]
2. 使用邻接表存储树，如果i < sum[i]，那么将i加入到sum[i]的链表中。注意不要将0加入到树中，因为限定所有数字变换在不超过 n 的正整数范围内进行。
3. 对于1~n的每个数，如果是树的根结点，则求该树的最长路径。

时间复杂度

因为预处理出每个数的约数之和sum[i]，循环次数为$n+\frac{n}{2}+\frac{n}{2}...+1=n\times (1+\frac{1}{2}+\frac{1}{3}+....+\frac{1}{n})$，是一个调和级数，因此时间复杂度$O(nlogn)$。

代码实现

#include <iostream>
#include <cstring>
using namespace std;
const int N = 50010;
int n;
int h[N], e[N], ne[N], idx; 
int sum[N], st[N];
int ans;
void add(int a, int b)
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx ++;
}

int dfs(int u)
{
    int d1 = 0, d2 = 0;
    for(int i = h[u]; ~i; i = ne[i])
    {
        int v = e[i];
        int d = dfs(v) + 1;
        if(d >= d1) d2 = d1, d1 = d;
        else if(d > d2) d2 = d;
    }
    ans = max(ans, d1 + d2);
    return d1;
}

int main()
{
    cin >> n;
    //求每个数的约数之和
    for(int i = 1; i <= n; i ++)
    {
        //枚举倍数
        for(int j = 2; j <= n / i; j ++)
            //累加j * i的约数
            sum[j * i] += i;
    }
    //建树
    memset(h, -1, sizeof h);
    //注意从2开始，因为`1`的约数之和为0（不包含1本身）
    //不满足题目要求：限定所有数字变换在不超过n的正整数范围内进行。
    for(int i = 2; i <= n; i ++)
    {
        if(sum[i] < i)
        {
            add(sum[i], i);
            st[i] = true; //标记i不是根结点
        }
    }
    //找最长路径
    for(int i = 1; i <= n; i ++)
    {
        //只搜索根结点
        if(!st[i]) dfs(i);
    }    
    cout << ans << endl;    
    return 0;
}