BZOJ 4030: [HEOI2015]小L的白日梦

 

4030: [HEOI2015]小L的白日梦

Time Limit: 10 Sec  Memory Limit: 256 MB
Submit: 172  Solved: 39
[Submit][Status][Discuss]

Description

 在某一天，你有了一个女性朋友。

你打算利用k天时间陪她，每天有很多种娱乐方式可供选择，你需要从中选择一种进行（一天只能进行一个项目），比如说一起去看电影、一起去主题公园，一起去逛街等等，一共n种项目。当然每个项目重复太多次你都会觉得无聊，因此第i个项目最多进行c[i]次。你虽然智商很高，但是情商堪忧，即使这些你准备的活动都是希望让她开心的，不过由于你笨拙的语言表达和过于理智的行动，可能使这些活动出现意外。经过你悉心的计算，你发现如果某一天进行了第i个项目，如果一切顺利的话她应该是很高兴的，但她会有a[i]的概率不高兴。如果她本来是很高兴的，但突然今天你让她不高兴了，她就会觉得很失落，并且对你的好感度大大下降。你希望尽可能避免这种情况发生，因此你要安排这k天之内每天进行的项目，最小化她感到失落的期望次数。

你的女性朋友十分在意你，所以她的心情只会因为你发生改变。第一天之前，因为你没有邀请她进行任何活动，所以她是不高兴的。

Input

 第一行有一个非负整数t，表示一共有t组数据。

对于每组数据，第一行有两个非负整数n,k，分别表示你准备的项目个数和你用来陪她的天数。（n<=10^5, k<=10^9）

接下来n行，每一行描述一个项目，形如“x[i]/y[i] c[i]”且三个数均为非负整数，表示进行完这个项目之后她有x[i]/y[i]的概率不高兴，并且这个项目只能进行不超过c[i]次。（x[i],y[i] <= 104,c[i] <= 10^9）

Output

一共t行，对于每组数据输出使她感到失落的最小期望次数，四舍五入保留6位小数。

Sample Input

3
1 2
0/1 3
1 2
1/1 3
1 2
1/2 3

Sample Output

0.000000
0.000000
0.250000

【样例说明】
考虑第三组数据，因为只有一个项目所以只好每天都安排这个。
在第一天之前她总是不高兴的，一共有：
第一天不高兴，第二天也不高兴、
第一天高兴，第二天不高兴、
第一天不高兴，第二天高兴、
第一天不高兴，第二天也不高兴，
这四种情况，又因为每天的项目让她高兴或者是不高兴的概率都是0.5，因此这四种情况是等概率发生的。
只有在第二种情况下，她会感到失落一次。
因此答案是(1*1+0*3)/4=0.25.

HINT

 

 对于100%的数据，n<=105，k<=109，数据组数不会太多，大概不超过10组，数据保证分数有意义并且∑c[i]>=k。

 

 

Source

 

[Submit][Status][Discuss]

 

这种网上没有题解的题，必须要写一发骗骗访问量哈~~~

我上午做这道题的时候，网上没有专门的题解，只有jiry前辈的一篇HEOI2015系列题解可做参考，所以我就无耻地抄代码啦~~~

先转一下jiry的题解内容——

【D2T1】小L的白日梦

这题我在网上找不到题解..但是为了访问量我也是只好硬上了...我的算法建立在以下假设之上：

1.一定存在最优解每一天不高兴的概率是单调不增的。

2.一定存在最优解它选取的项目是所有项目按照不高兴的概率排序后的前缀一段加上后缀一段。

3.每一次选取的项目种类只有三种可能的情况：选了1个，全部选完，其他。且处于第三种状态的至多一个。

不要问我是怎么知道这三个假设的..我连最基本的假设1都不会证明..这些全部都是在各种暴力求证之后得到了..这A的实在是6的不行..

知道了这些假设就很简单了..假设第三种状态的是取在后缀中的，那么枚举选取前缀最右端的位置，后缀最左端的位置单调不增，扫一下就好了，反过来也是一样。

我看了看这三个假设，如果是正确的话那么jiry的做法确实很棒棒，但是我只能证明第一个，好菜啊。下午Monster__Yi来嘲讽我了，“这么水的题，你都不会证明？还考什么NOI，HEOI你就可以滚粗了！” 唔唔唔，宝宝心里苦啊……

然后在小天天(Monster_Yi)的帮助下，我（ta）证明了另外两个性质，所以记录一下，趁着他还没写赶紧骗访问量，23333

 

性质1：一定存在最优解每一天不高兴的概率是单调不增的

这个性质最显然，证明方法就是列个式子，用$a_i$表示排序后第i个项目的不高兴概率，那么当前的期望值就是

$$P=(1-a_0)a_1+(1-a_1)a_2+(1-a_2)a_3+...+(1-a_{n-1})a_n$$

然后考虑交换两个项，$a_i$和$a_j$，现在的期望值变成了

$$P'=(1-a_0)a_1+...+(1-a_{i-1})a_j+(1-a_j)a_{i+1}+...+(1-a_{j-1})a_i+(1-a_i)a_{j+1}$$

根据$a_{i-1} \gt a_i \gt a_{i+1} \gt a_{j-1} \gt a_j \gt a_{j+1}$，

我们有

$$P-P'=(1-a_{i-1})a_i+(1-a_i)a_{i+1}+(1-a_{j-1})a_j+(1-a_j)a_{j+1}-(1-a_{i-1})a_j-(1-a_j)a_{i+1}-(1-a_{j-1})a_i-(1-a_i)a_{j+1}=(1-a_{i-1})(a_i-a_j)-a_{i+1}(a_i-a_j)-(1-a_{j-1})(a_i-a_j)+a_{j+1}(a_i-a_j)=(a_i-a_j)(-a_{i+1}-a_{i+1}+a_{j-1}+a_{j+1}) \lt 0$$

所以$P \lt P'$，即按照不高兴概率递减的顺序排列，期望更优。

 
性质2：一定存在最优解它选取的项目是所有项目按照不高兴的概率排序后的前缀一段加上后缀一段

这个性质也是列式子证明的。我们不妨设$A \lt B \lt C \lt D$，代表四个项目（按照不高兴概率递减的顺序排列），我们用$a,b,c,d$表示其不高兴概率，有$a\gt b\gt c\gt d$。

我们设原情况是我们从整个序列中选取了三段——[1,A]，B，[D,N]。

我们设新情况是我们从整个序列中选取了三段——[1,A]，C，[D,N]。

原情况的期望是$(1-a)b+(1-b)d$。

新情况的期望是$(1-a)c+(1-c)d$。

当新情况优于原情况，必然有$(1-a)b+(1-b)d>(1-a)c+(1-c)d$

解得$a+d>1$，这个就说，当$a+d>1$时，中间的点会往右靠，直到靠到后缀上；反之，中间的点会往前靠，直到靠到前缀上。所以，前缀和后缀中间不会有点被选中。

 

 

性质3：每一次选取的项目种类只有三种可能的情况：选了1个，全部选完，其他，且处于第三种状态的至多一个

前两个性质我们都是把所有项目拆成$c_i$个单独的项目考虑的，并且已经可以解决$\sum c_i \leq 10^6$时的问题了。现在我们考虑把相同项目看成一个连续的块，会有什么新的性质。

可喜可贺的是，这个性质不用列式子了，随便一想就能发现。

如果我们当前前缀的最后一个块（也就是最后一种项目）只选取了一个点，后缀的最前一个块选取了若干个点。

然后我们发现把后缀的一个名额送给前缀的最后一个块，会使期望值减少$delta$，使期望值变优。那么，我们可以说，在后缀的最后一个块露出尾巴（也就是被削减得只剩一个点）之前，我们每把一个后缀名额送给前缀，都会使得期望减少$delta$。所以我们定然会把后缀不断减少，直到其最前一个块只剩一个点为止，此时再削减最后一个块，产生的代价将不再是$delta$，所以不能继续无脑转移名额了。

可见，前缀和后缀的最后（前）一个块在某些情况只会选一个点，但绝不会同时选若干个点，都不是1而且都没有全选。

 

代码还是抄的jiry前辈的，毕竟我的代码功底可是非常差的。

 

#include <bits/stdc++.h>
using namespace std;
typedef long long lng;
typedef long double ldb;
struct data {
    int cnt; ldb val;
    inline data(void) {};
    inline data(int a, ldb b)
        : cnt(a), val(b) {};
    inline void read(void) {
        static int a, b; 
        scanf("%d/%d", &a, &b);
        val = (ldb)a / b;
        scanf("%d", &cnt);
    }
}A[150000], B[350000];
inline bool operator < (const data &a, const data &b) {
    return a.val > b.val;
}
int n, m, cas, tot;
inline ldb calc(void) {
    ldb ret = 1E18, sum = 0;
    lng now = 1, rem = m;
    for (int i = n; i; --i)
        sum += (B[i].cnt - 1) * B[i].val * (1 - B[i].val) + (1 - B[i].val) * B[i + 1].val, rem -= B[i].cnt;
    for (int i = 1; i <= n; ++i ) {
        rem -= B[i].cnt;
        while (now <= n && rem <= 0)
            sum -= (B[now].cnt - 1) * B[now].val * (1 - B[now].val) + (1 - B[now].val) * B[now + 1].val, rem += B[now++].cnt;
        if (rem <= 0)break;
        sum += (B[i].cnt - 1) * B[i].val * (1 - B[i].val) + (1 - B[i - 1].val) * B[i].val;
        ret = min(ret, sum + (rem - 1) * B[now - 1].val * (1 - B[now - 1].val) + (1 - B[now - 1].val) * B[now].val + (1 - B[i].val) * B[now - 1].val);
    }
    rem = m, sum = 0;
    for (int i = 1; i <= n; ++i) {
        int mn = min(rem, (lng)B[i].cnt);
        if(!mn)break; else rem -= mn, sum += (mn - 1) * B[i].val * (1 - B[i].val) + (1 - B[i - 1].val) * B[i].val;
    }
    return ret = min(ret, sum);
}
signed main(void) {
    for (scanf("%d", &cas); cas--; ) {
        scanf("%d%d", &n, &m);
        for (int i = 1; i <= n; ++i) {
            A[i].read(); if (!A[i].cnt)--i, --n;
        }
        sort(A + 1, A + n + 1); tot = 0;
        for (int i = 1; i <= n; ++i) {
            B[++tot] = data(1, A[i].val);
            if (--A[i].cnt) {
                if (A[i].cnt > 1)
                    B[++tot] = data(A[i].cnt - 1, A[i].val);
                B[++tot] = data(1, A[i].val);
            }
        }
        B[0].val = 1, B[(n = tot) + 1].val = 0;
        ldb ans = calc();
        for (int i = 1; i <= n; ++i)
            if (i < n + 1 - i)swap(B[i], B[n + 1 - i]);
        for (int i = 1; i <= n; ++i)B[i].val = 1 - B[i].val;
        ans = min(ans, calc());
        printf("%.6lf\n", (double)fabs(ans));
    }
}

 

@Author: YouSiki