Codeforces Round #164 (Div. 2) E. Playlist 贪心+概率dp

题目链接：

http://codeforces.com/problemset/problem/268/E

E. Playlist

time limit per test 1 second
memory limit per test 256 megabytes
#### 问题描述
> Manao's friends often send him new songs. He never listens to them right away. Instead, he compiles them into a playlist. When he feels that his mind is open to new music, he opens the playlist and starts to listen to the songs.
>
> Of course, there are some songs that Manao doesn't particuarly enjoy. To get more pleasure from the received songs, he invented the following procedure of listening to the playlist:
>
> If after listening to some song Manao realizes that he liked it, then he remembers it and starts to listen to the next unlistened song.
> If after listening to some song Manao realizes that he did not like it, he listens to all the songs he liked up to this point and then begins to listen to the next unlistened song.
> For example, if Manao has four songs in the playlist, A, B, C, D (in the corresponding order) and he is going to like songs A and C in the end, then the order of listening is the following:
>
> Manao listens to A, he likes it, he remembers it.
> Manao listens to B, he does not like it, so he listens to A, again.
> Manao listens to C, he likes the song and he remembers it, too.
> Manao listens to D, but does not enjoy it and re-listens to songs A and C.
> That is, in the end Manao listens to song A three times, to song C twice and songs B and D once. Note that if Manao once liked a song, he will never dislike it on a subsequent listening.
>
> Manao has received n songs: the i-th of them is li seconds long and Manao may like it with a probability of pi percents. The songs could get on Manao's playlist in any order, so Manao wants to know the maximum expected value of the number of seconds after which the listening process will be over, for all possible permutations of the songs in the playlist.
#### 输入
> The first line contains a single integer n (1 ≤ n ≤ 50000). The i-th of the following n lines contains two integers, separated by a single space — li and pi (15 ≤ li ≤ 1000, 0 ≤ pi ≤ 100) — the length of the i-th song in seconds and the probability that Manao will like the song, in percents.
#### 输出
> In a single line print a single real number — the maximum expected listening time over all permutations of songs. The answer will be considered valid if the absolute or relative error does not exceed 10 - 9.
#### 样例
> **sample input**
> 3
> 150 20
> 150 50
> 100 50
>
> **sample output**
> 537.500000000

题意

有n首歌，每首听完耗时为li,喜欢它的概率为pi，每首歌至少听一遍，如果听到不喜欢听的歌，会把所有听过的喜欢听的歌都重新听一遍，问决定一个听歌的顺序使得听完歌的期望时间最大。

题解

贪心来决定听歌的顺序。

求期望用期望dp做。（全概率递推一下）

官方题解

代码

#include<cstdio>
#include<iostream>
#include<algorithm>
using namespace std;

const int maxn = 55555;

struct Node {
	double l, p;
	bool operator < (const Node& tmp) const {
		return l*p*(1 - tmp.p)>tmp.l*tmp.p*(1 - p);
	}
}nds[maxn];

int main() {
	int n;
	scanf("%d", &n);
	for (int i = 0; i < n; i++) {
		scanf("%lf%lf", &nds[i].l, &nds[i].p);
		nds[i].p /= 100;
	}
	//贪心
	sort(nds, nds + n);
	double ansExp = 0, lovedLenExp = 0;
	for (int i = 0; i < n; i++) {
		ansExp += nds[i].l;
		//第i个对答案的贡献
		ansExp += nds[i].p * 0 + (1 - nds[i].p)*lovedLenExp;
		//根据全期望公式有E[i]=pi*(E[i-1]+Li)+(1-pi)*E[i-1]=E[i-1]+pi*Li。 其中E[i]表示前i个的lovedLenExp。
		lovedLenExp += nds[i].p*nds[i].l;
	}
	printf("%.15lf\n", ansExp);
	return 0;
}

纪念版

#include<map>
#include<set>
#include<cmath>
#include<queue>
#include<stack>
#include<ctime>
#include<vector>
#include<cstdio>
#include<string>
#include<bitset>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<functional>
using namespace std;
#define X first
#define Y second
#define mkp make_pair
#define lson (o<<1)
#define rson ((o<<1)|1)
#define mid (l+(r-l)/2)
#define sz() size()
#define pb(v) push_back(v)
#define all(o) (o).begin(),(o).end()
#define clr(a,v) memset(a,v,sizeof(a))
#define bug(a) cout<<#a<<" = "<<a<<endl
#define rep(i,a,b) for(int i=a;i<(b);i++)
#define scf scanf
#define prf printf

typedef int LL;
typedef vector<int> VI;
typedef pair<int,int> PII;
typedef vector<pair<int,int> > VPII;

const int INF=0x3f3f3f3f;
const LL INFL=10000000000000000LL;
const double eps=1e-9;

const double PI = acos(-1.0);

//start----------------------------------------------------------------------

const int maxn=5e4+10;

struct Node{
    int l,p;
    bool operator < (const Node& tmp) const {
        return (100-tmp.p)*l*p>(100-p)*tmp.l*tmp.p;
    }
}nds[maxn];

int n;

int main() {
    scf("%d",&n);
    rep(i,0,n) scf("%d%d",&nds[i].l,&nds[i].p);
    sort(nds,nds+n);
    double sum=0,ans=0;
    rep(i,0,n){
        ans+=nds[i].l;
        ans+=(1-nds[i].p*1.0/100)*sum;
        sum+=nds[i].l*(nds[i].p*1.0/100);
    }
    prf("%.9lf\n",ans);
    return 0;
}

//end-----------------------------------------------------------------------