BZOJ3573: [Hnoi2014]米特运输(树上乱搞)

最新推荐文章于 2019-08-21 16:52:54 发布

weixin_34056162

最新推荐文章于 2019-08-21 16:52:54 发布

阅读量115

点赞数

Time Limit: 20 Sec Memory Limit: 128 MB
Submit: 1669 Solved: 1031
[Submit][Status][Discuss]

Description

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

存一直是一个大问题。D星上有N个城市，我们将其顺序编号为1到N，1号城市为首都。这N个城市由N-1条单向高速

通道连接起来，构成一棵以1号城市（首部）为根的树，高速通道的方向由树中的儿子指向父亲。树按深度分层：

根结点深度为0，属于第1层；根结点的子节点深度为1，属于第2层；依此类推，深度为i的结点属于第i+l层。建好

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

尽相同，其中第i个城市建有一个容量为A[i]的米特储存器。这个米特储存器除了具有储存的功能，还具有自动收

集米特的能力。如果到了晚上六点，有某个储存器处于未满的状态，它就会自动收集大气中蕴含的米特能源，在早

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

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

搜集米特，它只接受子节点传输来的米特。早上七点，城市之间启动米特传输过程，传输过程逐层递进：先是第2

层节点城市向第1层（根节点城市，即1号城市）传输，直到第1层的储存器满或第2层的储存器全为空；然后是第3

层向第2层传输，直到对于第2层的每个节点，其储存器满或其予节点（位于第3层）的储存器全为空；依此类推，

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

由于技术原因，运输方案需要满足以下条件：

(1)不能让某个储存器到了晚上六点传输结束时还处于非空但又未满的状态，这个时候储存器仍然会启动自动收集

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

空要么满；

(2)关于首都——即1号城市的特殊情况，每天早上六点到七点间1号城市中的米特储存器里的米特会自动被消耗

殆尽，即运输方案不需要考虑首都的米特怎么运走；

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

运出去给父节点，不允许储存器中残存的米特与外来的米特发生混合；

(4)运向某一个城市的若干个来源的米特数量必须完全相同，不然，这些来源不同的米特按不同比例混合之后可能

发生危险。

现在D星人已经建立好高速通道，每个城市也有了一定储存容量的米特储存器。为了满足上面的限制条件，可能需

要重建一些城市中的米特储存器。你可以，也只能，将某一座城市（包括首都）中屎来存在的米特储存器摧毁，再

新建一座任意容量的新的米特储存器，其容量可以是小数（在输入数据中，储存器原始容量是正整数，但重建后可

以是小数），不能是负数或零，使得需要被重建的米特储存器的数目尽量少。

Input

第一行是一个正整数N，表示城市的数目。接下来N行，每行一个正整数，其中的第i行表示第i个城市原来存在的米

特储存器的容量。再接下来是N-I行，每行两个正整数a，b表示城市b到城市a有一条高速通道(a≠b)。

N<500000，A[j]<10^8

Output

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

Sample Input

5
5
4
3
2
1
1 2
1 3
2 4
2 5

Sample Output

HINT

【样例解释】

一个最优解是将A[1]改成8，A[3]改成4，A[5]改成2。这样，2和3运给1的量相等，4和5运给2的量相等，且每天晚上六点的时候，1，2满，3，4，5空，满足所有限制条件。

Source

神题！！

此题有一个非常重要的性质：当一个点的权值确定之后，整棵树的权值就都确定了

盗用一下矩形方块大佬的图

那么我们可以固定一个数不变，观察此时根节点的值是多少

设$f[i]$表示当$i$号节点的权值不变时，根节点的值是多少

那么我们可以枚举每一个点，计算完成后对$f$数组排序，找出最长的权值相同的序列，然后再用总结点的数量减去它的长度，就是最终答案

但是根据数据范围不难看出，根节点的值会爆long long，

有两种解决方法：

1.考虑到所有的计算都是乘法，取log变为加法$log_x{ab}=log_x{a}+log_x{b}$

2.hash

速度差不多

反思：

刚开始的时候一直在考虑如何计算一个节点改变后整棵树的形态，但是这样的话问题就太复杂了，因此再遇到此类问题的时候一定要从宏观上去考虑，看看有没有更妙的方法

// luogu-judger-enable-o2
#include<cstdio>
#include<vector>
#include<cstring>
#include<cmath>
#include<algorithm>
#define LL long long 
using namespace std;
const int MAXN=1e6+10;
#define getchar() (p1==p2&&(p2=(p1=buf)+fread(buf,1,1<<22,stdin),p1==p2)?EOF:*p1++)
char buf[1<<22],*p1=buf,*p2=buf;
inline int read() {
    char c=getchar();int x=0,f=1;
    while(c<'0'||c>'9'){if(c=='-')f=-1;c=getchar();}
    while(c>='0'&&c<='9'){x=x*10+c-'0';c=getchar();}
    return x*f;
}
vector<int>v[MAXN];
int N;
int val[MAXN],outder[MAXN];
double f[MAXN];
void dfs(int now, double times) {
    f[now] = times + log((double)val[now]);
    for(int i = 0;i < v[now].size();i++)
        dfs(v[now][i], times + log((double)outder[now]));
}
int main() {
    #ifdef WIN32
    freopen("a.in","r",stdin);
    #endif
    N = read();
    for(int i = 1;i <= N;i++) val[i] = read();
    for(int i = 1;i <= N-1;i++) {
        int x = read(), y = read();
        outder[x]++;
        v[x].push_back(y);
    }
    dfs(1,log((double)1));
    sort(f+1,f+N+1);
    int now=0,ans=0;
    for(int i = 1;i <= N;i++)
        (f[i] - f[i-1] < 1e-8) ? ans = max(ans, ++now) : now = 1;
    printf("%d",N - ans); 
    return 0;
}

取log

// luogu-judger-enable-o2
// luogu-judger-enable-o2
#include<cstdio>
#include<vector>
#include<cstring>
#include<cmath>
#include<algorithm>
#define LL long long 
using namespace std;
const int MAXN = 1e6+10, mod = 19260817;
#define getchar() (p1==p2&&(p2=(p1=buf)+fread(buf,1,1<<22,stdin),p1==p2)?EOF:*p1++)
char buf[1<<22],*p1=buf,*p2=buf;
inline int read() {
    char c=getchar();int x=0,f=1;
    while(c<'0'||c>'9'){if(c=='-')f=-1;c=getchar();}
    while(c>='0'&&c<='9'){x=x*10+c-'0';c=getchar();}
    return x*f;
}
vector<int>v[MAXN];
int N;
int val[MAXN],outder[MAXN];
double f[MAXN];
void dfs(int now, double times) {
    f[now] = (LL)times * val[now] %mod ;
    for(int i = 0;i < v[now].size();i++)
        dfs(v[now][i], (LL)times * outder[now] % mod);
}
int main() {
    #ifdef WIN32
    freopen("a.in","r",stdin);
    #endif
    N = read();
    for(int i = 1;i <= N;i++) val[i] = read();
    for(int i = 1;i <= N-1;i++) {
        int x = read(), y = read();
        outder[x]++;
        v[x].push_back(y);
    }
    dfs(1,1);
    sort(f+1,f+N+1);
    int now=0,ans=0;
    for(int i = 1;i <= N;i++)
        (f[i] == f[i-1]) ? ans = max(ans, ++now) : now = 1;
    printf("%d",N - ans); 
    return 0;
}