codeforces-div1-282-C

题意见CF282C

解法

由于每个区间只会绝对包含或者绝对分离，于是我们可以先加一个区间，其值为1 n 0，

然后把每个区间当成一个节点，建立一颗树。

如果有两个区间A，B，假如A被包含于B，于是A是B的子节点。

建立起树后，在这棵树上面进行DP。

首先对于每个节点（也就是每个区间），有一个最大的数字，首先可以保证的是得出的结果肯定是大于这个数字的。

当然每个区间的最大数字可以简单的直接用RMQ得出。

假设节点代表区间中最大的数为mx，于是对每个节点维护一个序列p0,p1,p2...

分别表示这个区间结果为 mx+0, mx+1, mx+2....的概率。

向如上所说的表示状态后，就可以找到状态转移的方法了。

具体细节建议自己推一推，大体思路就是这样，

具体的建树方法和dp的转移方法应该自己思考，

下面是我的代码。

#include <stdio.h>
#include <iostream>
#include <string.h>
#include <vector>
#include <math.h>
#include <queue>
#include <map>
#include <set>
#include <algorithm>
using namespace std;

#define FOR(i, j, k) for(int i=(j);i<=(k);i++)
#define REP(i, n) for(int i=0;i<(n);i++)
#define mst(x, y) memset(x, y, sizeof(x));
#define pii pair<int, int>
#define fr first
#define sc second
#define left myleft
#define right myright
#define ull unsigned long long
#define seed 1331
#define mod ((int)1e9+7)
#define eps 1e-8

int n, m, money[100009];
struct Node0{int l, r, mx;}tree[100009*4];
void build(int u, int l, int r){
    tree[u].l=l;tree[u].r=r;
    if(l == r) {tree[u].mx=money[l];return;}
    int mid = l+r>>1;
    build(u*2, l, mid);
    build(u*2+1, mid+1, r);
    tree[u].mx = max(tree[u*2].mx, tree[u*2+1].mx);
}
int query(int u, int l, int r){
    if(tree[u].l==l && tree[u].r==r) return tree[u].mx;
    int mid = tree[u].l+tree[u].r>>1;
    if(r <= mid) return query(u*2, l, r);
    else if(l > mid) return query(u*2+1, l, r);
    return max(query(u*2, l, mid), query(u*2+1, mid+1, r));
}
pair <pii, double> seg[5009];
bool cmp(pair <pii, double> p0, pair <pii, double> p1){
    if(p0.fr.fr == p1.fr.fr) return p0.fr.sc > p1.fr.sc;
    return p0.fr.fr < p1.fr.fr;
}

struct Node{ // 用来表述树上每个节点
    vector <Node *> son; // 维护子孙节点
    int mx, idx, now; // idx表示这个节点代表idx号区间, now是做DP时的辅助变量
    double bl, eq; // 这两个都是做DP时的辅助变量
    vector <double> p;  // 用来维护p0, p1, p2...的概率
    Node(int ii, int mm){mx = mm, idx = ii;}
    Node(){};
}*root;

void dfs0(Node *u, int& idx){  // dfs0进行建树
    while(idx<m && seg[u->idx].fr.sc >= seg[idx].fr.fr){
        Node *p = new Node(idx, query(1, seg[idx].fr.fr, seg[idx].fr.sc));
        u->son.push_back(p);
        dfs0(p, ++ idx);
    }
}

void init(Node *u, int lim){
    u->bl = u->eq = u->now = 0;
    while(u->now < u->p.size() && u->mx + u->now < lim)
        u->bl += u->p[u->now ++];
    u->eq = u->bl;
    if(u->now < u->p.size()) u->eq += u->p[u->now];
}

bool push(Node *u){
    u->bl = u->eq;
    if(u->now+1 < u->p.size()) {
        u->eq += u->p[u->now ++ + 1];
        return 1;
    }
    return 0;
}

void dfs1(Node *u){
    REP(i, u->son.size()) dfs1(u->son[i]);
    REP(i, u->son.size()) init(u->son[i], u->mx);
    bool first = 1;
    int dif = 3;
    while(1){
        double p0 = 1, p1 = 1;
        REP(i, u->son.size())
            p0 *= u->son[i]->eq, p1 *= u->son[i]->bl;

        if(first) first = 0;
        else p0 -= p1;
        u->p.push_back(p0);
        bool flag = 0;
        REP(i, u->son.size())
            flag |= push(u->son[i]);
        if(!flag && p0 < eps) dif --;
        if(!dif) break;
    }
    for(int i=u->p.size()-2;i>=0;i--){
        u->p[i+1] += u->p[i] * seg[u->idx].sc;
        u->p[i] *= (1 - seg[u->idx].sc);
    }
}

int main(){
    cin>>n>>m;
    FOR(i, 1, n) cin>>money[i];
    build(1, 1, n);
    //这之前是准备线段树来做RMQ

    REP(i, m) cin>>seg[i].fr.fr>>seg[i].fr.sc>>seg[i].sc;
    seg[m].fr.fr = 1, seg[m].fr.sc = n, seg[m].sc = 0, m++;
    sort(seg, seg+m, cmp);
    root = new Node(0, query(1, 1, n));
    int idx = 1;
    dfs0(root, idx);
    //这之前是进行建树

    //dfs1代表在建立好的树上进行DP
    dfs1(root);

    //计算答案
    double ans = 0;
    REP(i, root->p.size()) ans += root->p[i]*(root->mx + i);
    printf("%.8lf\n", ans);
    return 0;
}