HNOI 2014 Day1 米特运输

第 3 题：米特运输(meat)，运行时限 2s，内存上限 128M，100 分。

【问题描述】

        米特是 D 星球上一种非常神秘的物质，蕴含着巨大的能量。在以米特为主要能源的 D 星

上，这种米特能源的运输和储存一直是一个大问题。

        D 星上有 N 个城市，我们将其顺序编号为 1 到 N，1 号城市为首都。这 N 个城市由 N-1

条单向高速通道连接起来，构成一棵以 1 号城市（首都）为根的树，高速通道的方向由树中的

儿子指向父亲。树按深度分层：根结点深度为 0，属于第 1 层；根结点的子节点深度为 1，属

于第 2 层；依此类推，深度为 i 的结点属于第 i+1 层。

        建好高速通道之后， 星人开始考虑如何具体地储存和传输米特资源。D由于发展程度不同，

每个城市储存米特的能力不尽相同，其中第 i 个城市建有一个容量为 A[i]的米特储存器。这个

米特储存器除了具有储存的功能，还具有自动收集米特的能力。如果到了晚上六点，有某个储

存器处于未满的状态，它就会自动收集大气中蕴含的米特能源，在早上六点之前就能收集满；

但是，只有在储存器完全空的状态下启动自动收集程序才是安全的，未满而又非空时启动可能

有安全隐患。早上六点到七点间，根节点城市（1 号城市）会将其储存器里的米特消耗殆尽。

根节点不会自动搜集米特，它只接受子节点传输来的米特。早上七点，城市之间启动米特传输

过程，传输过程逐层递进：先是第 2 层节点城市向第 1 层（根节点城市，即 1 号城市）传输，

直到第 1 层的储存器满或第 2 层的储存器全为空；然后是第 3 层向第 2 层传输，直到对于第 2

层的每个节点，其储存器满或其子节点（位于第 3 层）的储存器全为空；依此类推，直到最后

一层传输完成。传输过程一定会在晚上六点前完成。

        由于技术原因，运输方案需要满足以下条件：（1）不能让某个储存器到了晚上六点传输结

束时还处于非空但又未满的状态，这个时候储存器仍然会启动自动收集米特的程序，而给已经

储存有米特的储存器启动收集程序可能导致危险，也就是说要让储存器到了晚上六点时要么空

要么满；（2）关于首都——即 1 号城市的特殊情况， 每天早上六点到七点间 1 号城市中的米

特储存器里的米特会自动被消耗殆尽，即运输方案不需要考虑首都的米特怎么运走；（3）除了

1 号城市，每个节点必须在其子节点城市向它运输米特之前将这座城市的米特储存器中原本存

有的米特全部运出去给父节点，不允许储存器中残存的米特与外来的米特发生混合；（4）运向

某一个城市的若干个来源的米特数量必须完全相同，不然，这些来源不同的米特按不同比例混

合之后可能发生危险。

        现在 D 星人已经建立好高速通道，每个城市也有了一定储存容量的米特储存器。为了满

足上面的限制条件，可能需要重建一些城市中的米特储存器。你可以，也只能，将某一座城市

（包括首都）中原来存在的米特储存器摧毁，再新建一座任意容量的新的米特储存器，其容量

可以是小数（在输入数据中，储存器原始容量是正整数，但重建后可以是小数），不能是负数

或零，使得需要被重建的米特储存器的数目尽量少。

【输入格式】

输入文件名为meat.in。

第一行是一个正整数N，表示城市的数目。

接下来N行，每行一个正整数，其中的第i行表示第i个城市原来存在的米特储存器的容量。

再接下来是N-1行，每行两个正整数a,b表示城市b到城市a有一条高速通道(a≠b)。

【输出格式】

输出文件名为meat.out。

输出文件仅包含一行，一个整数，表示最少的被重建（即修改储存器容量）的米特储存器

的数目。

【样例输入】

5

5

4

3

2

1

1 2

1 3

2 4

2 5

【样例输出】

3

【样例解释】

一个最优解是将A[1]改成8，A[3]改成4，A[5]改成2。这样，2和3运给1的量相等，4和5运

给2的量相等，且每天晚上六点的时候，1,2满，3,4,5空，满足所有限制条件。

【数据范围】

对于20%的数据满足N≤20；

对于50%的数据满足N≤2000；

对于100%的数据满足N≤500000, A[i]≤10^8。

【本人的题解】

对于20分的数据：直接暴力枚举每个点是否需要被修改，然后检验，取最优方案即可，复杂度O(2 ^ n)。

对于50分的数据：因为我们可以保证至少有一个点不被修改，然后我们就可以枚举这个点，然后暴力判断其他点是否能在这个点不变的情况下不变，取最优方案即可，复杂度O(n ^ 2)。

对于100分的数据：我们注意到：当根节点（假定为1号节点）的值确定时，其实每个节点的值都会被确定下来，因为树的结构是确定的。这个多想想应该是可以理解的。好的，然后我们求出每个点的值不变的时候，根节点的值是多少，然后排序，取众数即可。注意，这里得到的数可能会很大，最大有 2 ^ 250000 。所以我们可以通过取对数来处理，或者是多重取模（我的程序就是这么写的）。复杂度O(n log n)。

【本人代码】

#include<cmath>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
typedef long long LL;
const int N = 500000 + 5;
const int Mod1 = 1000000007;
const int Mod2 = 1306213;
const int Mod3 = 1301551;
int n, tot, ans, head[N];
LL w[N];

struct EDGE
{
    int next, node;
}h[N << 1];

struct Information
{
    int m1, m2, m3;
    bool operator < (const Information a) const
    {
        return ((m1 < a.m1) || (m1 == a.m1 && m2 < a.m2) || (m1 == a.m1 && m2 == a.m2 && m3 < a.m3));
    }
    bool operator == (const Information a) const
    {
        return (m1 == a.m1 && m2 == a.m2 && m3 == a.m3);
    }
}f[N];

void addedge(int u, int v)
{
    h[++ tot].next = head[u], head[u] = tot;
    h[tot].node = v;
    h[++ tot].next = head[v], head[v] = tot;
    h[tot].node = u;
}

void begin()
{
    freopen("meat.in", "r", stdin);
    freopen("meat.out", "w", stdout);
    scanf("%d", &n);
    for (int i = 1; i <= n; i ++)
        scanf("%d", w + i);
    for (int i = 1; i < n; i ++)
    {
        int u, v;
        scanf("%d%d", &u, &v);
        addedge(u, v);
    }
}

void dfs(int z, int fa, LL m1, LL m2, LL m3)
{
    f[z].m1 = m1 * w[z] % Mod1;
    f[z].m2 = m2 * w[z] % Mod2;
    f[z].m3 = m3 * w[z] % Mod3;
    int tmp = 0;
    for (int i = head[z]; i; i = h[i].next)
    {
        int d = h[i].node;
        if (d == fa) continue;
        tmp ++;
    }
    for (int i = head[z]; i; i = h[i].next)
    {
        int d = h[i].node;
        if (d == fa) continue;
        dfs(d, z, m1 * tmp % Mod1, m2 * tmp % Mod2, m3 * tmp % Mod3);
    }
}

void work()
{
    dfs(1, 0, 1, 1, 1);
    sort(f + 1, f + n + 1);
    ans = 1;
    int t = 1;
    for (int i = 2; i <= n; i ++)
        if (f[i] == f[i - 1]) t ++;
            else ans = max(ans, t), t = 1;
    ans = max(ans, t);
    ans = n - ans;
}

void end()
{
    printf("%d\n", ans);
    fclose(stdin);
    fclose(stdout);
}

int main()
{
    begin();
    work();
    end();
    return 0;
}