Codeforces Round #584 (Div. 1 + Div. 2)

最新推荐文章于 2024-10-21 16:28:31 发布
最新推荐文章于 2024-10-21 16:28:31 发布
阅读量222 收藏
点赞数
原文链接：http://www.cnblogs.com/Itst/p/11546180.html
版权

Contest Page

A

sol 每次选最小的，然后把它的所有倍数都删掉。 
#include<bits/stdc++.h>
using namespace std;

int read(){
    int a = 0; char c = getchar(); bool f = 0;
    while(!isdigit(c)){f = c == '-'; c = getchar();}
    while(isdigit(c)){
        a = a * 10 + c - 48; c = getchar();
    }
    return f ? -a : a;
}

set < int > num;

int main(){
    int N , cnt = 0; cin >> N;
    for(int i = 1 ; i <= N ; ++i){int a; cin >> a; num.insert(a);}
    while(!num.empty()){
        ++cnt; int val = *num.begin();
        for(int i = val ; i <= 100 ; i += val)
            if(num.find(i) != num.end()) num.erase(i);
    }
    cout << cnt;
    return 0;
}

B

sol 因为$lcm(2,3,4,5)=120$，所以在所有灯都开始闪了之后$120sec$之后到达的状态一定一致。所以暴力做$>125$轮即可。 
#include<bits/stdc++.h>
using namespace std;

int num[1003] , N , A[1003] , B[1003];

int main(){
    cin >> N;
    for(int i = 1 ; i <= N ; ++i){
        char c = getchar(); while(!isdigit(c)) c = getchar();
        num[i] = c - '0';
    }
    for(int i = 1 ; i <= N ; ++i) cin >> A[i] >> B[i];
    int ans = 0; for(int i = 1 ; i <= N ; ++i) ans += num[i];
    for(int i = 1 ; i <= 250 ; ++i){
        for(int j = 1 ; j <= N ; ++j)
            if(i >= B[j] && (i - B[j]) % A[j] == 0)
                num[j] ^= 1;
        int sum = 0; for(int j = 1 ; j <= N ; ++j) sum += num[j];
        ans = max(ans , sum);
    }
    cout << ans; return 0;
}

C

sol 枚举$i \in [0 , 8]$，先将$\leq i$的所有数都染$1$，然后将最后染$1$的位置之后的所有数值为$i+1$的位置染$1$，最后把剩下的数染$2$，check是否合法即可。 
#include<bits/stdc++.h>
using namespace std;

int T; bool vis[200003];

int main(){
    ios::sync_with_stdio(0);
    for(cin >> T ; T ; --T){
        int L; string s; cin >> L >> s; bool getans = 0;
        for(int i = 0 ; i < 9 && !getans ; ++i){
            memset(vis , 0 , sizeof(bool) * (s.size()));
            int mx = 0 , pre = -1; bool flg = 1;
            for(int j = 0 ; j < s.size() ; ++j)
                if(s[j] - '0' <= i){
                    if(mx > s[j] - '0'){flg = 0; break;}
                    pre = j; mx = max(mx , s[j] - '0'); vis[j] = 1;
                }
            if(!flg) continue;
            for(int j = pre + 1 ; j < s.size() ; ++j)
                if(s[j] - '0' == i + 1) vis[j] = 1;
            mx = 0;
            for(int j = 0 ; j < s.size() ; ++j)
                if(!vis[j]){
                    if(mx > s[j] - '0'){flg = 0; break;}
                    mx = s[j] - '0';
                }
            if(flg){
                getans = 1;
                for(int i = 0 ; i < s.size() ; ++i) putchar(vis[i] ? '1' : '2');
            }
        }
        if(!getans) putchar('-');
        putchar('\n');
    }
    return 0;
}

D

sol 对于$a=i,b=j$连边$(i,j)$，对于每一个连通块一定是先选择一条边，然后一直选择恰好有一端被标记过的边直到所有点被标记，那么一个连通块的贡献是$sz-1$。并查集实现连通块即可。 
#include<bits/stdc++.h>
using namespace std;

const int _ = 1e5 + 7;
int N , K , fa[_] , sz[_];
int find(int x){return fa[x] == x ? x : (fa[x] = find(fa[x]));}

int main(){
    cin >> N >> K; for(int i = 1 ; i <= N ; ++i) sz[fa[i] = i] = 1;
    for(int i = 1 ; i <= K ; ++i){
        int p , q; cin >> p >> q;
        p = find(p); q = find(q);
        if(p == q) continue;
        fa[p] = q; sz[q] += sz[p];
    }
    for(int i = 1 ; i <= N ; ++i) if(fa[i] == i) K -= sz[i] - 1;
    cout << K; return 0;
}

E1

sol 发现在最优情况下只有最大值最大的$n$行有意义，拿出来暴力即可。 
#include<bits/stdc++.h>
using namespace std;

int read(){
    int a = 0; char c = getchar(); bool f = 0;
    while(!isdigit(c)){f = c == '-'; c = getchar();}
    while(isdigit(c)){
        a = a * 10 + c - 48; c = getchar();
    }
    return f ? -a : a;
}

#define PII pair < int , int >
int T , N , M , arr[13][2003] , mx[2003] , id[2003];

int mat[5][5] , ans;

void dfs(int x){
    if(x > N || x > M){
        int sum = 0;
        for(int i = 0 ; i < N ; ++i){
            int mx = 0;
            for(int j = 0 ; j < N ; ++j)
                mx = max(mx , mat[i][j]);
            sum += mx;
        }
        ans = max(ans , sum); return;
    }
    for(int i = 0 ; i < N ; ++i){
        for(int j = 0 ; j < N ; ++j)
            mat[(i + j) % N][x - 1] = arr[j + 1][id[x]];
        dfs(x + 1);
    }
}

int main(){
    for(cin >> T ; T ; --T){
        cin >> N >> M; ans = 0; memset(mx , 0 , sizeof(mx)); memset(mat , 0 , sizeof(mat));
        for(int i = 1 ; i <= N ; ++i){
            for(int j = 1 ; j <= M ; ++j){
                cin >> arr[i][j];
                mx[j] = max(mx[j] , arr[i][j]);
            }
        }
        for(int i = 1 ; i <= M ; ++i) id[i] = i;
        sort(id + 1 , id + M + 1 , [&](int A , int B){return mx[A] > mx[B];});
        dfs(1); cout << ans << endl;
    }
    return 0;
}

E2

sol 在上面假设的基础上，我们发现$n$比较小，考虑状压。

但是最大值必须要每一列都确定了才是确定的，似乎有后效性。那么我们考虑在某一列位置确定的时候钦定某些位置当作最大值计算贡献，那么答案显然和原来的答案是一样的。

这样就可以状压了：设$f_{i,j}$表示前$i$列中集合为$j$的位置被钦定产生贡献，对于新来的一列先计算出所有旋转方案中钦定某些位置的最大贡献然后子集转移。复杂度$O(T(2^NN^2+3^N)$。 
#include<bits/stdc++.h>
using namespace std;

int arr[13][2003] , mx[2003] , id[2003] , dp[1 << 12] , val[1 << 12] , Mx[1 << 12] , N , M , T;

int main(){
    for(cin >> T ; T ; --T){
        cin >> N >> M; memset(dp , 0 , sizeof(dp)); memset(mx , 0 , sizeof(mx));
        for(int i = 0 ; i < N ; ++i)
            for(int j = 0 ; j < M ; ++j){
                cin >> arr[i][j]; mx[j] = max(mx[j] , arr[i][j]);
            }
        for(int j = 0 ; j < M ; ++j) id[j] = j;
        sort(id , id + M , [&](int p , int q){return mx[p] > mx[q];});
        for(int i = 0 ; i < min(N , M) ; ++i){
            memset(Mx , 0 , sizeof(Mx));
#define lowbit(x) ((x) & -(x))
            for(int j = 0 ; j < N ; ++j)
                for(int k = 1 ; k < 1 << N ; ++k){
                    val[k] = val[k - lowbit(k)] + arr[(j + (int)log2(lowbit(k) + 0.1)) % N][id[i]];
                    Mx[k] = max(Mx[k] , val[k]);
                }
            for(int k = (1 << N) - 1 ; k >= 0 ; --k){
                int s = k; while(s){dp[k] = max(dp[k] , dp[s ^ k] + Mx[s]); s = (s - 1) & k;}
            }
        }
        cout << dp[(1 << N) - 1] << endl;
    }
    return 0;
}

F

sol 对于每条边以其编号位数为权值跑最短路，建出最短路DAG，那么每个点的答案只有可能由最短路DAG上的路径构成。

然后按照DAG拓扑序求出答案。对于每个点找到其在DAG上的所有前驱，两两比较数字串字典序大小。总串长度不长，可以通过建Trie树把每个点对应的串放上去然后求LCA比较字典序。VP的时候没想很多写了个比较麻烦的做法：

对于已求出的每个点确定其最短路转移的唯一前驱，这样就把最短路DAG变成了最短路树。那么二分第一个字符不相同的位置$mid$，然后在最短路树上倍增求出两个字符串的长度为$mid$的前缀的哈希值check，最后通过倍增得到对应位置的两个字符判断哪一个小。 
#include<bits/stdc++.h>
using namespace std;

int read(){
    int a = 0; char c = getchar(); bool f = 0;
    while(!isdigit(c)){f = c == '-'; c = getchar();}
    while(isdigit(c)){
        a = a * 10 + c - 48; c = getchar();
    }
    return f ? -a : a;
}

#define PII pair < int , int >
const int _ = 1e5 + 7 , MOD = 1e9 + 7 , MOD2 = 1e9 + 9;
priority_queue < PII > q;
vector < PII > Edge[_];
int logg10[_] , dis[_] , N , M , jump[_][20] , val[_] , ans[_]; long long faid[_];

int gethash(int x , int len , int id){
    int now;
    if(len > dis[x]){now = val[x]; len -= dis[x];}
    else{
        for(int i = 19 ; i >= 0 ; --i) if(dis[jump[x][i]] >= len) x = jump[x][i];
        now = val[jump[x][0]]; len -= dis[jump[x][0]]; id = faid[x];
    }
    while(logg10[id] != len - 1) id /= 10;
    for(int i = 0 ; i < len ; ++i) now = 1ll * now * 10 % MOD2;
    return (now + id) % MOD2;
}

int getch(int x , int len , int id){
    if(len > dis[x]) len -= dis[x];
    else{
        for(int i = 19 ; i >= 0 ; --i) if(dis[jump[x][i]] >= len) x = jump[x][i];
        len -= dis[jump[x][0]]; id = faid[x];
    }
    while(logg10[id] != len - 1) id /= 10;
    return id % 10;
}

bool cmp(int p , int q , int idp , int idq){
    if(!p) return 1;
    int L = 1 , R = logg10[idp] + 1 + dis[p];
    while(L < R){
        int mid = (L + R) >> 1;
        gethash(p , mid , idp) != gethash(q , mid , idq) ? R = mid : L = mid + 1;
    }
    return getch(p , L , idp) > getch(q , L , idq);
}

void done(int x , int pre , int nid){
    ans[x] = ans[pre]; for(int i = 0 ; i <= logg10[nid] ; ++i) ans[x] = ans[x] * 10ll % MOD;
    val[x] = val[pre]; for(int i = 0 ; i <= logg10[nid] ; ++i) val[x] = val[x] * 10ll % MOD2;
    ans[x] = (ans[x] + nid) % MOD; val[x] = (val[x] + nid) % MOD2;

    faid[x] = nid; jump[x][0] = pre;
    for(int i = 1 ; jump[x][i - 1] ; ++i) jump[x][i] = jump[jump[x][i - 1]][i - 1];
}

void dijk(){
    memset(dis , 0x3f , sizeof(dis)); dis[0] = dis[1] = 0; q.push(PII(0 , 1));
    while(!q.empty()){
        PII t = q.top(); q.pop();
        if(dis[t.second] != -t.first) continue;

        int now = 0 , nid = 0;
        for(auto p : Edge[t.second])
            if(dis[p.first] + logg10[p.second] + 1 == dis[t.second])
                if(cmp(now , p.first , nid , p.second)){
                    now = p.first; nid = p.second;
                }
        
        if(now) done(t.second , now , nid);
        
        for(auto p : Edge[t.second])
            if(dis[p.first] > dis[t.second] + logg10[p.second] + 1){
                dis[p.first] = dis[t.second] + logg10[p.second] + 1;
                q.push(PII(-dis[p.first] , p.first));
            }
    }
}

int main(){
#ifndef ONLINE_JUDGE
    freopen("in","r",stdin);
    freopen("out","w",stdout);
#endif
    N = read(); M = read(); logg10[0] = -1;
    for(int i = 1 ; i <= M ; ++i) logg10[i] = logg10[i / 10] + 1;
    for(int i = 1 ; i <= M ; ++i){
        int p = read() , q = read();
        Edge[p].push_back(PII(q , i)); Edge[q].push_back(PII(p , i));
    }
    dijk();
    for(int i = 2 ; i <= N ; ++i) printf("%d\n" , ans[i]);
    return 0;
}

G1

sol 考虑将序列分成若干个极小块，每一块中包含若干种颜色且其他块中不包含这些颜色。那么每一个块的贡献就是块长减去出现次数最多的数字数量。

求出这个极小块直接从左往右扫一遍维护当前块已经出现的颜色和如果当前颜色形成极小块块长是多少就可以了。 
#include<bits/stdc++.h>
using namespace std;

int read(){
    int a = 0; char c = getchar(); bool f = 0;
    while(!isdigit(c)){f = c == '-'; c = getchar();}
    while(isdigit(c)){
        a = a * 10 + c - 48; c = getchar();
    }
    return f ? -a : a;
}

const int _ = 2e5 + 3;
int arr[_] , f[_] , nxt[_] , sz[_] , N , Q , ans;
vector < int > ch[_];

int main(){
    N = read(); Q = read();
    for(int i = 1 ; i <= N ; ++i) ++sz[arr[i] = read()];
    set < int > in; int cnt = 0 , tar = 0;
    for(int i = 1 ; i <= N ; ++i){
        if(in.find(arr[i]) == in.end()){
            in.insert(arr[i]); tar += sz[arr[i]];
        }
        if(tar == ++cnt){
            int mx = 0;
            for(auto t : in) mx = max(mx , sz[t]);
            ans += tar - mx; in.clear(); cnt = 0; tar = 0; 
        }
    }
    cout << ans;
    return 0;
}

G2

sol 我们把G1中的贪心思路变得更加可维护一些：

对于某种颜色记录其最开始和最后出现的位置$(p,q)$，那么在数轴上它代表一条线段$[p,q]$，权值为其出现次数。

这些线段可以把$[1,N]$分为若干个极小的部分，满足两个部分之间没有线段相交。答案就是$N-$所有部分的最大权值。

E.g 对于序列$3,3,1,2,1,2$，颜色$1,2,3$分别对应线段$[3,5],[4,6],[1,2]$，可以发现将原序列分为了$[1,2]$和$[3,6]$两个部分，两个部分的最大权值都是$2$，所以答案就是$6-2-2=2$。

我们对于$\frac{i}{2} , i \in [1,2N+1]$这些位置为下标建立线段树，那么如果我们把线段$[p,q]$在线段树上看作区间$[p,q]$中的点权值$+1$的话，一个极小的部分会表现为：这个部分的左邻居和右邻居的权值都是$0$，而中间没有权值为$0$的点。

这样我们把一条线段的贡献放在线段的左端点上，相当于每一个点有一个价值，然后在线段树上维护：区间$min$、当前区间中最靠左的$min$左边的所有价值的$max$、当前区间中最靠右的$min$右边的所有价值的$max$、当前整个区间的价值的$max$和区间的答案，就可以在线段树上进行pushup更新出整个序列中每个部分的最大价值和。

而修改只要做区间权值$\pm 1$、单点价值修改这两个操作。在线段树上打一个标记就能实现。 
#include<bits/stdc++.h>
using namespace std;

int read(){
    int a = 0; char c = getchar(); bool f = 0;
    while(!isdigit(c)){f = c == '-'; c = getchar();}
    while(isdigit(c)){
        a = a * 10 + c - 48; c = getchar();
    }
    return f ? -a : a;
}

const int _ = 2e5 + 11;
struct DATA{
    int mn , mx , lftmx , rhtmx , sum , mrk;
    DATA(){mn = 0; lftmx = rhtmx = sum = mrk = 0;}
    friend DATA merge(DATA &p , DATA &q){
        DATA t; t.mx = max(p.mx , q.mx);
        if(p.mn == q.mn){
            t.lftmx = p.lftmx; t.rhtmx = q.rhtmx;
            t.mn = p.mn; t.sum = p.sum + q.sum + max(p.rhtmx , q.lftmx);
        }
        else if(p.mn < q.mn){t.mn = p.mn; t.sum = p.sum; t.lftmx = p.lftmx; t.rhtmx = max(p.rhtmx , q.mx);}
        else{t.mn = q.mn; t.sum = q.sum; t.lftmx = max(p.mx , q.lftmx); t.rhtmx = q.rhtmx;}
        return t;
    }

    void mark(int x){mrk += x; mn += x;}
};
namespace segt{
    DATA now[_ << 3];

#define mid ((l + r) >> 1)
#define lch (x << 1)
#define rch (x << 1 | 1)
    
    void down(int x){now[lch].mark(now[x].mrk); now[rch].mark(now[x].mrk); now[x].mrk = 0;}

    void M1(int x , int l , int r , int L , int R , int val){
        if(l >= L && r <= R) return now[x].mark(val);
        down(x); if(mid >= L) M1(lch , l , mid , L , R , val);
        if(mid < R) M1(rch , mid + 1 , r , L , R , val);
        now[x] = merge(now[lch] , now[rch]);
    }

    void M2(int x , int l , int r , int tar , int val){
        if(l == r){now[x].mx = val; return;}
        down(x); mid >= tar ? M2(lch , l , mid , tar , val) : M2(rch , mid + 1 , r , tar , val);
        now[x] = merge(now[lch] , now[rch]);
    }
}
int N , Q , arr[_]; set < int > pos[_];

int main(){
#ifndef ONLINE_JUDGE
    freopen("in","r",stdin);
    freopen("out","w",stdout);
#endif
    N = read(); Q = read(); for(int i = 1 ; i <= N ; ++i) pos[arr[i] = read()].insert(i);
    for(int i = 1 ; i <= 200000 ; ++i)
        if(pos[i].size()){
            segt::M2(1 , 1 , 2 * N + 1 , 2 * (*pos[i].begin()) , pos[i].size());
            segt::M1(1 , 1 , 2 * N + 1 , 2 * (*pos[i].begin()) , 2 * (*--pos[i].end()) , 1);
        }
    printf("%d\n" , N - segt::now[1].sum);
    while(Q--){
        int p = read() , x = read() , t = arr[p];

        if(pos[t].size() != 1)
            if(p == *pos[t].begin()){
                segt::M2(1 , 1 , 2 * N + 1 , 2 * p , 0);
                segt::M2(1 , 1 , 2 * N + 1 , 2 * (*++pos[t].begin()) , pos[t].size() - 1);
                segt::M1(1 , 1 , 2 * N + 1 , 2 * p , 2 * (*++pos[t].begin()) - 1 , -1);
            }
            else{
                if(p == *--pos[t].end())
                    segt::M1(1 , 1 , 2 * N + 1 , 2 * (*----pos[t].end()) + 1 , 2 * (*--pos[t].end()) , -1);
                segt::M2(1 , 1 , 2 * N + 1 , 2 * (*pos[t].begin()) , pos[t].size() - 1);
            }
        else{
            segt::M2(1 , 1 , 2 * N + 1 , 2 * p , 0);
            segt::M1(1 , 1 , 2 * N + 1 , 2 * p , 2 * p , -1);
        }
        
        pos[t].erase(p); pos[arr[p] = x].insert(p);

        if(pos[x].size() != 1)
            if(p == *pos[x].begin()){
                segt::M2(1 , 1 , 2 * N + 1 , 2 * p , pos[x].size());
                segt::M2(1 , 1 , 2 * N + 1 , 2 * (*++pos[x].begin()) , 0);
                segt::M1(1 , 1 , 2 * N + 1 , 2 * p , 2 * (*++pos[x].begin()) - 1 , 1);
            }
            else{
                if(p == *--pos[x].end())
                    segt::M1(1 , 1 , 2 * N + 1 , 2 * (*----pos[x].end()) + 1 , 2 * (*--pos[x].end()) , 1);
                segt::M2(1 , 1 , 2 * N + 1 , 2 * (*pos[x].begin()) , pos[x].size());
            }
        else{
            segt::M2(1 , 1 , 2 * N + 1 , 2 * p , 1);
            segt::M1(1 , 1 , 2 * N + 1 , 2 * p , 2 * p , 1);
        }
        printf("%d\n" , N - segt::now[1].sum);
    }
    return 0;
}

H

sol 注意到$E=t(1-v)$（这里应该写积分，这样写相当于直接微元法考虑速度相同的一段），设$v_0 = v-1$，那么$E=t(1-(v_0+1)) = -v_0t = -S$，也就是说在这种情况下 人走过的距离和能量是相反数。当然为了计算的正确，所有传送带的速度都$+1$，其中没有传送带的地方认为是$s_i=0$的传送带。此时$v_0 \in [-1,1]$。

那么如果消耗$\Delta E$的能量， 人走过的距离就是$\Delta E$，那么如果使用能量的这段时间走过了速度为$v_i$、长度为$l_i$的传送带，时间就一定是$\frac{l_i - \Delta E}{v_i}$，和中间的分配无关。那么我们可以认为在同一段传送带上能量的分配是均匀的，也就是能量和路程呈一次函数关系。

到这里不难发现能量放在速度更低的位置比放在更高的位置一定更优，因为更低的位置分母更小，更多的能量加入可以提供更小的时间。

我们以路程为$x$轴、能量为$y$轴，可以画出一个函数图像。这个图像的每一段都是一次函数，这意味着我们只需要关注拐点，也就是传送带之间的交点位置。我们需要这个图像满足以下条件：

1、任何时刻纵坐标不小于$0$；
2、满足上述的贪心条件；
3、因为人的速度在$[-1,1]$内，所以两个拐点之间的直线斜率有一定的限制。

考虑得到限制3中的斜率。因为消耗能量的速度$v_0 \in [-1,1]$，所以$\frac{\Delta E}{\frac{(l - \Delta E)}{v}} \in [-1,1]$，解一下可以解出$\Delta E \in [\frac{l}{1-v} , \frac{l}{1+v}]$。

我们已经将问题转化成了一个更加可做的问题，接下来开始构造函数。

首先我们用最节省能量的方法走过所有的传送带。注意到当传送带速度为$1$时可以无限保存能量，但因为传送带速度至少为$1$，所以后面的过程中这些能量也会用在自己身上，所以我们可以认为速度为$1$的传送带不需要节省能量。

接下来我们按照传送带速度从小到大考虑每个传送带，并尽可能将能量用在上面。这里会受到上面图像条件中1,3的约束，对于3比较好维护，对于1，我们在某个位置使用了$\Delta E$的能量，那么在这个位置以及之后的所有位置能量都会减少$\Delta E$，也就是说我们减少的量最多不能超过当前位置之后的所有位置的能量最小值。

不难发现这需要我们进行区间减法和区间取min操作，可以用线段树实现。 
#include<bits/stdc++.h>
using namespace std;

#define ld long double
#define PDI pair < ld , int > 
const int _ = 4e5 + 3;
map < int , ld > nval; vector < int > pos; int N , L; ld ubd[_] , sum[_] , E[_]; vector < PDI > seg;

namespace segt{
    ld mn[_ << 2] , mrk[_ << 2];

#define mid ((l + r) >> 1)
#define lch (x << 1)
#define rch (x << 1 | 1)

    void mark(int x , ld val){mn[x] += val; mrk[x] += val;}
    void down(int x){mark(lch , mrk[x]); mark(rch , mrk[x]); mrk[x] = 0;}

    void init(int x , int l , int r){
        if(l == r) (void)(mn[x] = sum[l]);
        else{init(lch , l , mid); init(rch , mid + 1 , r); mn[x] = min(mn[lch] , mn[rch]);}
    }

    void modify(int x , int l , int r , int L , int R , ld val){
        if(l >= L && r <= R) return mark(x , val);
        down(x); if(mid >= L) modify(lch , l , mid , L , R , val);
        if(mid < R) modify(rch , mid + 1 , r , L , R , val);
        mn[x] = min(mn[lch] , mn[rch]);
    }

    ld qry(int x , int l , int r , int L , int R){
        if(l >= L && r <= R) return mn[x];
        down(x);
        ld mn = 1e18; if(mid >= L) mn = qry(lch , l , mid , L , R);
        if(mid < R) mn = min(mn , qry(rch , mid + 1 , r , L , R));
        return mn;
    }
}using namespace segt;

int main(){
    scanf("%d %d" , &N , &L);
    for(int i = 1 ; i <= N ; ++i){
        int X , Y; ld val; scanf("%d %d %Lf" , &X , &Y , &val);
        pos.push_back(X); pos.push_back(Y); nval[X] = val;
    }
    pos.push_back(0); pos.push_back(L); sort(pos.begin() , pos.end());
    pos.resize(unique(pos.begin() , pos.end()) - pos.begin());
    for(int i = 1 ; i < pos.size() ; ++i){
        ld val = nval[pos[i - 1]] + 1; seg.push_back(PDI(val , i));
        sum[i] = sum[i - 1] - (E[i] = val != 1 ? (pos[i] - pos[i - 1]) / (1.0 - val) : 0);
        ubd[i] = (pos[i] - pos[i - 1]) / (val + 1.0) - E[i];
    }
    segt::init(1 , 1 , seg.size()); sort(seg.begin() , seg.end());
    for(auto t : seg){
        int id = t.second; ld mn = min(ubd[id] , segt::qry(1 , 1 , seg.size() , id , seg.size()));
        E[id] += mn; segt::modify(1 , 1 , seg.size() , id , seg.size() , -mn);
    }
    ld ans = 0;
    for(int i = 1 ; i < pos.size() ; ++i) ans += (pos[i] - pos[i - 1] - E[i]) / (nval[pos[i - 1]] + 1);
    cout << fixed << setprecision(11) << ans; return 0;
}

转载于:https://www.cnblogs.com/Itst/p/11546180.html

weixin_30615767
关注
Contest 2050 and Codeforces Round #718 (Div. 1 + Div. 2)
我的故事用酒换
04-24 212
2021.4.23 A 题意：给一个数n，判断n能否被2050*10^k中取的数相加得到。 题解：每个相加的数都是2050的倍数，所以直接判断n能否被2050整除得到，可以的话直接加上商的位数和。 #include <cstdio> #include <iostream> #include <algorithm> #define ll long long using namespace std; int main() { ll t,n; sca
Codeforces Round #758 (Div.1 + Div. 2)
weixin_45446715的博客
12-13 1780
Codeforces Round #758 (Div.1 + Div. 2) Problem A & Problem B & (Problem C) A. Find Array 从来都没有见过一个如此水的 Div 1 A题 就是让你从小到大的输出n个数字 唯一要注意的就是a[i]的取值范围 #include<bits/stdc++.h> using namespace std; int main(){ int t; cin>>t; while(t--){ i
Codeforces Round #831 (Div. 1 + Div. 2) problem C
m0_61710136的博客
10-30 250
Codeforces Round #831 (Div. 1 + Div. 2) Problem C
Codeforces Round 857 (Div. 1 + Div. 2) 2A - 2D
Linux_dow的博客
03-11 415
Codeforces Round 857 (Div. 1 + Div. 2) 2A - 2D
Codeforces Round 965 (Div. 2) 8.10
2301_81692739的博客
08-11 929
看题得认真，不能迷糊，不然太费时间。
Codeforces Round 972（Div.2）A+B
YGGP的博客
09-16 939
Codeforces Round 972（Div.2）A+B
Codeforces Round #854 by cybercats (Div. 1 + Div. 2)
m0_62289613的博客
02-28 2147
Codeforces Round #854 by cybercats (Div. 1 + Div. 2)
Codeforces Round #763 (Div. 2)
m0_56005735的博客
01-24 583
codeforces Round #763 (Div. 2)1.A - Robot Cleaner.2.B - Game on Ranges.3.C - Balanced Stone Heaps
Codeforces Round 980 (Div. 2)
s1379659220的博客
10-21 968
其实就是判断排序后以每个点为最大值的时候所需要的柠檬水杯数是否大于给定的k举个例子序列为1 2 3 4,k=5假设1为最大值那么只能选1 1 1 1,此时选不满5个假设2为最大值那么可以选1 2 2 2,此时可以选满5个,但是最坏情况下小于2号位置的所有位置会被多选择一次,所以输出k+(2-1)假设L为最大值的时候可以选满k个则输出k+(L-1)O(n)遍历即可(赛时写了个二分其实没必要)
Codeforces Round #816 (Div. 2)
AC__dream的博客
09-24 612
Codeforces Round #816 (Div. 2)
Codeforces Round #723 (Div. 2).md
10-13
Codeforces Round #723 (Div. 2).md
Codeforces Round #627 (Div. 3) C. Frog Jumps（思维）
01-20
开始位置在0，问能否跳到n+1位置 每步只能跳d 在1——n每个位置有方向，L,R，求d的最小值 思路： 只用找相邻两个R之间的最大值即可 代码： #include #include #include #include #include #include #include #...
Codeforces Round #627 (Div. 3) B. Yet Another Palindrome Problem
01-03
就是把所有相等的数放到一个vector里，如果他出现大于2次，看最远的间距是否大于2即可，找到一个就可以 代码： #include #include #include #include #include #include #include #include #include #include #...
yolo算法-电线杆数据集-1493张图像带标签-.zip
11-17
yolo算法-电线杆数据集-1493张图像带标签-.zip；yolo算法-电线杆数据集-1493张图像带标签-.zip；yolo算法-电线杆数据集-1493张图像带标签-.zip
yolo算法-电线杆数据集-7255张图像带标签-杆顶.zip
11-17
yolo算法-电线杆数据集-7255张图像带标签-杆顶.zip；yolo算法-电线杆数据集-7255张图像带标签-杆顶.zip；yolo算法-电线杆数据集-7255张图像带标签-杆顶.zip；yolo算法-电线杆数据集-7255张图像带标签-杆顶.zip
pillow_avif_plugin-1.2.1-cp37-cp37m-win32.whl.rar
11-17
python whl离线安装包 pip安装失败可以尝试使用whl离线安装包安装 第一步 下载whl文件，注意需要与python版本配套 python版本号、32位64位、arm或amd64均有区别 第二步 使用pip install XXXXX.whl 命令安装，如果whl路径不在cmd窗口当前目录下，需要带上路径 WHL文件是以Wheel格式保存的Python安装包， Wheel是Python发行版的标准内置包格式。 在本质上是一个压缩包，WHL文件中包含了Python安装的py文件和元数据，以及经过编译的pyd文件， 这样就使得它可以在不具备编译环境的条件下，安装适合自己python版本的库文件。 如果要查看WHL文件的内容，可以把.whl后缀名改成.zip，使用解压软件（如WinRAR、WinZIP）解压打开即可查看。 为什么会用到whl文件来安装python库文件呢？ 在python的使用过程中，我们免不了要经常通过pip来安装自己所需要的包， 大部分的包基本都能正常安装，但是总会遇到有那么一些包因为各种各样的问题导致安装不了的。 这时我们就可以通过尝试去Python安装包大全中（whl包下载）下载whl包来安装解决问题。
【地震】基于matlab时域有限差分FDTD模拟地震盾构【含Matlab源码 9186期】.mp4
11-17
Matlab领域上传的视频均有对应的完整代码，皆可运行，亲测可用，适合小白； 1、代码压缩包内容 主函数：main.m； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开main.m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主； 4.1 博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作
中国高质量发展指标体系-最新发布.zip
最新发布
11-17
中国高质量发展指标体系-最新发布.zip
codeforces round #792 (div. 1 + div. 2)
06-06
codeforces round #792 (div. 1 + div. 2) 是 Codeforces 竞赛平台上的一场比赛，包括两个级别：div. 1 和 div. 2。这场比赛通常会有多个问题需要参赛者解决，每个问题都有不同的难度等级。参赛者需要在规定的时间内...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值