GDOI模拟赛Round 1

最新推荐文章于 2024-10-18 00:00:00 发布
最新推荐文章于 2024-10-18 00:00:00 发布
阅读量93 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/GerynOhenz/p/4992989.html
版权

GDOI模拟赛Round 1

数据结构

题目描述：给出一个长度为\(n\)的序列，支持两种操作：
1、对某段区间都加上一个数
2、给出\(p、k\),求下面表示式对\((10^9+7)\)取模
\[\sum_{i=1}^{n} a_i \times max(0, k-|i-p|)\]

solution
维护某段区间 第一个数乘1+ 第二个数乘2+ …… +第\(n\)个数乘\(n\)是线段树的经典题型，把问题拆成两部分\((p-k, i),(i, p+k)\),注意一下边界就可以了。

#include <cstdio>
#include <cmath>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <ctime>
#include <set>
#include <map>
using namespace std;

typedef long long LL;
const int maxn=int(1e5)+100;
const int mod=int(1e9)+7;

struct data
{
    int x, y;
    LL value;

    void init(int _x, int _y, LL _value)
    {
        x=_x;
        y=_y;
        value=_value;
    }
};

int n, m;
LL tree[maxn*4][3];
LL add[maxn*4];
data dat;

void down(int cur, int L, int R)
{
    int mid=(L+R)>>1;
    tree[cur<<1][2]=(tree[cur<<1][2]+add[cur]*(mid-L+1)%mod)%mod;
    tree[cur<<1 | 1][2]=(tree[cur<<1 | 1][2]+add[cur]*(R-mid)%mod)%mod;

    LL tmp=add[cur]*(((LL(1+mid-L+1))*(mid-L+1)/2)%mod)%mod;
    tree[cur<<1][0]=(tree[cur<<1][0]+tmp)%mod;
    tree[cur<<1][1]=(tree[cur<<1][1]+tmp)%mod;

    tmp=add[cur]*(((LL(1+R-mid))*(R-mid)/2)%mod)%mod;
    tree[cur<<1 | 1][0]=(tree[cur<<1 | 1][0]+tmp)%mod;
    tree[cur<<1 | 1][1]=(tree[cur<<1 | 1][1]+tmp)%mod;

    add[cur<<1]=(add[cur<<1]+add[cur])%mod;
    add[cur<<1 | 1]=(add[cur<<1 | 1]+add[cur])%mod;

    add[cur]=0;
}
void update(int cur, int L, int R)
{
    if (L>dat.y || R<dat.x) return;
    if (dat.x<=L && R<=dat.y)
    {
        tree[cur][2]=(tree[cur][2]+dat.value*(R-L+1)%mod)%mod;
        LL tmp=dat.value*(((LL(1+R-L+1))*(R-L+1)/2)%mod)%mod;
        tree[cur][0]=(tree[cur][0]+tmp)%mod;
        tree[cur][1]=(tree[cur][1]+tmp)%mod;
        add[cur]=(add[cur]+dat.value)%mod;
        return;
    }
    int mid=(L+R)>>1;
    if (add[cur]!=0) down(cur, L, R);
    update(cur<<1, L, mid);
    update(cur<<1 | 1, mid+1, R);
    tree[cur][2]=(tree[cur<<1][2]+tree[cur<<1 | 1][2])%mod;
    tree[cur][0]=(tree[cur<<1][0]+tree[cur<<1 | 1][0]+tree[cur<<1 | 1][2]*(mid-L+1)%mod)%mod;
    tree[cur][1]=(tree[cur<<1 | 1][1]+tree[cur<<1][1]+tree[cur<<1][2]*(R-mid)%mod)%mod;
}
LL ask(int cur, int L, int R)
{
    if (L>dat.y || R<dat.x) return 0;
    if (dat.x<=L && R<=dat.y)
    {
        if (dat.value==2) return tree[cur][2];
        if (dat.value==0) return ((tree[cur][0]+tree[cur][2]*(L-dat.x)%mod)%mod);
        return ((tree[cur][1]+tree[cur][2]*(dat.y-R)%mod)%mod);
    }
    int mid=(L+R)>>1;
    if (add[cur]!=0) down(cur, L, R);
    return ((ask(cur<<1, L, mid)+ask(cur<<1 | 1, mid+1, R))%mod);
}
void init()
{
    scanf("%d%d", &n, &m);
    for (int i=1; i<=n; ++i)
    {
        int value;
        scanf("%d", &value);
        dat.init(i, i, value);
        update(1, 1, n);
    }
}
void solve()
{
    for (int i=1; i<=m; ++i)
    {
        int nid, p, k;
        scanf("%d", &nid);
        if (nid & 1)
        {
            scanf("%d%d", &p, &k);
            if (k==0)
            {
                printf("0\n");
                continue;
            }
            dat.init(max(p-k+1, 1), p, 0);
            LL ans=ask(1, 1, n);
            dat.init(p, min(p+k-1, n), 1);
            ans=(ans+ask(1, 1, n)+mod)%mod;
            if (p-k+1<=0)
            {
                dat.init(1, p, 2);
                ans=(ans+ask(1, 1, n)*(k-p)%mod+mod)%mod;
            }
            if (p+k-1>n)
            {
                dat.init(p, n, 2);
                ans=(ans+ask(1, 1, n)*(p+k-1-n)%mod+mod)%mod;
            }
            dat.init(p, p, 2);
            ans=(ans-ask(1, 1, n)*k%mod+mod)%mod;
            while (ans<0) ans+=mod;
            printf("%I64d\n", ans);
        }
        else
        {
            scanf("%d%d%I64d", &dat.x, &dat.y, &dat.value);
            update(1, 1, n);
        }
    }
}
int main()
{
    freopen("gdds.in", "r", stdin);
    freopen("gdds.out", "w", stdout);
    init();
    solve();
    return 0;
}

树之谜题

原题TopCoder
题目描述：有一棵\(n\)个结点的树，根的位置放了一个红色标记，其它一些结点放了黑色标记。每当一个有标记的结点，当它相邻某个结点没有标记，则可以把当前标记移到那个没有标记的结点，问红色标记能到那些点。

solution
我从这题中领悟到了爆搜的魅力。首先把这棵树看成是无根树，预处理出当\(i\)的父亲为\(j\)时，\(i\)的子树的结点数。然后再看回是有根树，求出每个结点的子树的黑色结点数。爆搜的时候还是把它看做无根树。
然后以\([prev][cur][sum]\)为状态，表示当前红色标记在\(cur\),且\(cur\)的父亲是\(prev\)，\(cur\)的子树中黑色结点数为\(sum\).
733825-20151124213710296-211130401.png

如果红色部分的黑色结点数\((total-sum)\)小于红色部分的结点数，那么搜索\([cur][prev][total-sum]\)
然后枚举\(cur\)的儿子\(i\),枚举分配\(j\)个黑色结点给它，能这样分配的条件是1、\(j\)小于\(i\)子树的结点数，2、\((sum-j)\)个黑色结点能塞进\(cur\)的其它儿子那里，即\((sum-j)\)小于\(cur\)其它儿子的子树结点数总和，满足上述条件就可以搜索\([cur][i][j]\).
因为有用状态不多，所以不会爆空间

#include <cstdio>
#include <cmath>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <ctime>
#include <set>
#include <map>
using namespace std;

const int maxn=310;

struct LINK
{
    int id, next;
};
struct data
{
    int cur, prev, sum;
};

int n;
int now, qsize;
int black[maxn], ans[maxn];
int h[maxn], size[maxn][maxn], sum[maxn];
bool vis[maxn][maxn][maxn];
data q[maxn*maxn*5];
LINK t[maxn*2];

void join(int u, int v)
{
    t[now].id=v; t[now].next=h[u]; h[u]=now++;
    t[now].id=u; t[now].next=h[v]; h[v]=now++;
}
void init()
{
    scanf("%d", &n);
    for (int i=0; i<n; ++i) h[i]=-1;
    for (int i=0; i<n; ++i)
    {
        int v;
        scanf("%d", &v);
        if (i==0) continue;
        join(i, v);
    }
    for (int i=0; i<n; ++i)
    {
        int flag;
        scanf("%d", &flag);
        if (i==0) continue;
        black[i]=flag;
    }
}
int calc_size(int prev, int cur)
{
    if (size[prev][cur]>0) return size[prev][cur];
    size[prev][cur]=1;
    for (int i=h[cur]; i>-1; i=t[i].next)
        if (t[i].id!=prev)
            size[prev][cur]+=calc_size(cur, t[i].id);
    return size[prev][cur];
}
int calc_s(int prev, int cur)
{
    sum[cur]=black[cur];
    for (int i=h[cur]; i>-1; i=t[i].next)
        if (t[i].id!=prev)
            sum[cur]+=calc_s(cur, t[i].id);
    return sum[cur];
}
void insert(int prev, int cur, int sum)
{
    if (vis[prev][cur][sum]) return;
    vis[prev][cur][sum]=true;
    q[++qsize].prev=prev;
    q[qsize].cur=cur;
    q[qsize].sum=sum;
}
void solve()
{
    for (int i=0; i<n; ++i)
        for (int j=h[i]; j>-1; j=t[j].next)
            calc_size(i, t[j].id);
    calc_s(-1, 0);

    qsize=0;
    for (int i=h[0]; i>-1; i=t[i].next)
        if (size[0][t[i].id]>sum[t[i].id])
            insert(0, t[i].id, sum[t[i].id]);

    int total=sum[0];
    ans[0]=true;
    for (int i=1; i<=qsize; ++i)
    {
        int prev=q[i].prev;
        int cur=q[i].cur;
        int s=q[i].sum;
        ans[cur]=true;
        if (total-s<size[cur][prev])
            insert(cur, prev, total-s);

        int sn=0;
        for (int j=h[cur]; j>-1; j=t[j].next)
            if (t[j].id!=prev) sn+=size[cur][t[j].id];

        for (int j=h[cur]; j>-1; j=t[j].next)
            if (t[j].id!=prev)
            {
                for (int k=0; k<=s && k<size[cur][t[j].id]; ++k)
                    if (sn-size[cur][t[j].id]>=s-k)
                        insert(cur, t[j].id, k);
            }
    }
}
int main()
{
    freopen("puzzle.in", "r", stdin);
    freopen("puzzle.out", "w", stdout);
    init();
    solve();
    for (int i=0; i<n; ++i)
        printf("%d ", ans[i]);
    return 0;
}

不公平的比赛

题目描述：M和C决定来场摔跤比赛。当然不是他们亲自对战，而是他们各派出\(n\)名勇士进行对战，不妨用\(M_i\)，表示M的标号为\(i\)的勇士，同样的\(C_i\)表示C的标号为\(i\)的勇士，其中对勇士的标号从\(0\)开始。
比赛分\(n\)场进行。
第\(i\)场比赛，先是\(M_{i-1}\)和\(C_0\)对战。如果打成平局，那么进行下一局比赛，由\(M_i\)和\(C_1\)对战。如果还是打成平局，那么再进行下一局比赛，由\(M_{i+1}\)和\(C_2\)对战，以此类推，直到决出胜负为止，也就是说，如果前$j (1 \leq j < n) \(局都是平局，则下一局将由\)M_{ (i+j-1) % n}\(和\)C_j\(对决。如果一直打到\)M_{i-2}\(和\)C_{n-1}\(都没有分出胜负，那么第\)i$场比赛平。
胜负有对战双方的力量值决定。
求出M和C各赢了多少场，以及一共进行了多少局比赛。

solution

其实就是以\(M\)为被匹配串，\(C\)为标准串，求以第\(i\)位为开头的后缀的最长公共前缀。用扩展KMP可以轻松解决。

#include <cstdio>
#include <cmath>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <ctime>
#include <set>
#include <map>
using namespace std;

const int maxn=int(1e5)+100;
typedef long long LL;

int n;
int st[maxn*2];
int str[maxn];
int ans[maxn], next[maxn];
LL s;
int sm, sc;

void init()
{
    scanf("%d", &n);
    for (int i=0; i<n; ++i) scanf("%d", &st[i]);
    for (int i=0; i<n; ++i) scanf("%d", &str[i]);
    for (int i=0; i<n; ++i) st[i+n]=st[i];
}
void solve()
{
    next[0]=n;
    for (int i=0; i<n; ++i)
        if (str[1+i]==str[i]) ++next[1];
        else break;

    for (int i=2, p=1, maxid=next[1]+1; i<n; ++i)
    {
        if (next[i-p]+i<maxid) next[i]=next[i-p];
        else
        {
            next[i]=max(maxid-i, 0);
            while (i+next[i]<n && str[next[i]]==str[i+next[i]]) ++next[i];
            if (i+next[i]>=maxid)
            {
                maxid=i+next[i];
                p=i;
            }
        }
    }

    for (int i=0; i<n; ++i)
        if (st[i]==str[i]) ++ans[0];
        else break;

    for (int i=1, p=0, maxid=ans[0]; i<n; ++i)
    {
        if (next[i-p]+i<maxid) ans[i]=next[i-p];
        else
        {
            ans[i]=max(maxid-i, 0);
            while (ans[i]<n && str[ans[i]]==st[i+ans[i]]) ++ans[i];
            if (i+ans[i]>=maxid)
            {
                maxid=i+ans[i];
                p=i;
            }
        }
    }

    for (int i=0; i<n; ++i)
    {
        if (ans[i]==n)
        {
            s+=n;
            continue;
        }
        s+=ans[i]+1;
        if (st[i+ans[i]]>str[ans[i]]) ++sm;
        else ++sc;
    }

    printf("%d %d %I64d\n", sm, sc, s);
}
int main()
{
    freopen("wrestling.in", "r", stdin);
    freopen("wrestling.out", "w", stdout);
    init();
    solve();
    return 0;
}

转载于:https://www.cnblogs.com/GerynOhenz/p/4992989.html

diebenger6280
关注
【GDOI】2018题目及题解（未写完）
_Alexander_的博客
05-05 1797
我的游记：https://blog.csdn.net/huangzihaoal/article/details/80185230 DAY1 题目 T1 农场 【题目描述】 【输入】 第一行，一个整数n。 第二行，n个整数aiaia_i 【输出】 一个数，最多可以分成几块。 【样例输入】 6 1 1 2 1 2 1 【样例输出】 2 【数据范围限制】...
GDOI模拟 装饰
PhilipsWeng的专栏
03-16 1027
题目大意有一个2∗M2 * M的彩带，彩带的每个格子都可以染上红色，蓝色，绿色中的一种颜色，一个彩带被称为合法的，当且仅当 1. 相邻两个格子的颜色不同 2. 对于每个2*2的小矩阵三种颜色都要出现 3. 整个彩带上有RR个红色格子，BB个蓝色格子，GG个绿色格子。给定M,R,B,GM,R,B,G，求可能的合法彩带数。对109+710^9 + 7取模。数据范围R+B+G=2∗M,0≤M≤100
【GDOI2016】中学生数学题 题解
Never give in.
05-16 1025
Description题目大意就是给你整数n0n_0,实数p0,kp_0,k 求一个pp，使⌊n0−kp⌋(p−p0)\lfloor n_0-kp\rfloor (p-p_0) 最大 再求p1,p2p_1,p_2，使⌊n0−kp1⌋(p1−p0)+⌊n0−kp2−⌊n0−kp1⌋⌋(p2−p0)\lfloor n_0-kp_1\rfloor (p_1-p_0)+\lfloor n_0-kp_2-
【总结】2022GDOI普及组试题与题解（缺两天的T4）
DengDuck蒟蒻之家
04-16 455
标签 2022 广东省选普及组 GDOI 试题 前往Luogu下载 Luogu下载：This Day1题解 T1 邹忌讽齐王纳谏 打卡题，建议模拟 建议使用map,时间复杂度为\(O(nlogn)\) 特判注意数据—— \[0 \leq A,B,C \]需要特判为0的情况 T2 数列游戏 首先求出前缀异或和，\(sum_1,sum_2,sum_3,.....sum_n\)， 如果一个区间\([l...
GDOI 2021游记
麻衣学姐的博客
04-12 365
GDOI 2021游记 深圳的三日游让我认识到了自己的不足。 不足： 学的东西不够多，遇见不会的题目除了暴力完全没办法。 学的不够扎实、熟练，比如说 DAY1T3 的SPFASPFASPFA。 题目的细节和坑有时候会没注意到，比如说 ModModMod 和 无向边建图。   进步： 老实分析了题目样例和坑，基础分都拿到了，但是该拿的分没有全拿完。 分析数据范围，骗部分分。   Day1： T1(stone)(stone)(stone)： 涉及知识： Nim取石游戏（博弈论） T2(rescue)(
JZOJ 5685. 【GDOI2018Day1模拟4.24】恐怖袭击
Luckfort
04-24 438
题目 有情报称H市有恐怖分子要发动一场恐怖袭击。现在已知恐怖分子的坐标是(sx,sy)，他将要发动袭击的位置是(tx,ty)。现在有n名特警，他们的位置分别是(x1,y1),(x2,y2),…,(xn,yn)。在每个单位时间内，恐怖分子和每个特警可以选择朝上下左右移动1的距离或者原地不动。因为特警完全掌握了恐怖分子的情报，每个特警可以根据恐怖分子在这个单位时间内的移动来决定自己这个单位时间内如何...
GDOI模拟赛round 1(4.11~13)训练总结
samjia2000的博客
04-14 348
虽然每天都有写，但是一轮下来还是要合起来总结一下。 贴一下每天的总结： Day1 第一题是sb题，很快就扫过了，然后看完剩下的题后，感觉最后一题不可做，然后t3是裸的点分治，但是感觉时间复杂度过不去，就想了两种分治方法，结合起来用好像很快的样子，t2让我想起了JSOI的某题，莫名有深深的恐惧感，于是就没有去想，打了暴力，t3打了1个钟，因为我的方法很多地方都十分注意常数。对拍t3点分治时问题
GDOI2018模拟赛-Round3
wohenshuai
04-09 323
a（cf100641d） 题意 众所周知罗马数字I,V,X,L,CI,V,X,L,C 分别代表1,5,10,50,100 例如XXXVII就是37(10+10+10+5+1+1) 对于广义的计算来说，一个罗马数字可以由如下得到 把它分成左右两部分aa 和bb ，假设其值为v(a)v(a) 和v(b)v(b) 如果v(a)≥v(b) ，那么v(ab)=v(a)+v(b)，否则v(ab...
GDOI2017模拟Round3总结
待成熟的葡萄
04-22 396
Day 1四道题都是HNOI拼出来的。一看第一题LCT可做，但是LCT最近才学，不怎么熟，怕时间少打不了，就决定把时间都放在这题上面，后面的直接打部分分。所以做的时候后面的题基本上没有怎么思考。 但是，令我没有想到的是一开始思考太久，然后最后一题的暴力花的时间远比想象的要多，最后只剩下一个小时来做第一题，而且我第一题还想复杂了，结果直到考试结束都没能没能成功调试出来。。。 最后得分很惨烈，然后还
GDOI 2023 游记！！
04-06
1. **经验积累**：作者提到GDOI是他们OI生涯中首次参加的两天赛事，通过这次经历认识到心态稳定的重要性。在比赛中，尤其是在遇到困难时保持冷静的心态对于解决问题至关重要。 2. **赛前准备**：作者在比赛前进行了...
选拔赛全真模拟1
08-08
8. Python的range函数：第十题中，`range(1, 11)`用于枚举从1到10的整数，包括1和11。 9. while循环理解：第十一题中，while循环的错误说法是D，因为循环在不满足条件时会结束当前循环，而不是再次进入。 10. ...
[GDOI模拟2015.12.19总结]
待成熟的葡萄
12-21 884
Summary这场相比之前做的好一些。 拿到第一题，自然而然地想到枚举次大值，然后求出答案区间，用贪心的方法从高位到低位求解，但是这样要用到可持续化Trie，我在怀疑自己是不是想复杂了，所以先放一放。 第二题，首先这肯定是一棵树，但是题目中边的有向这个条件束缚了我，让我将其当做一个拓补图来考虑，然后苦思不得其解。其实将边的不同方向用相似的方法分别处理就是正解了。 第三题，连题目都没太看懂，关于
GDOI2018
扩展の灰(Extended Ash/Cooevjnz)
05-05 750
前言该拿的分一分不失，是我本次GDOI最成功的地方Day0考前延续了在JZ腐败的习惯，直到十点半还在淦CR，突然意识到我自己可能真的完蛋了，于是删了安卓模拟器来复习模板（事实证明并没有对后面的解题起到作用但是直到心情恢复了一点）带着非常慌张的心，抱着自己带的抱枕，还是睡着了Day1早餐超级好吃直到走到了一中才发现天气热到爆炸，还好考场里面有空调，路上一直在看自己博客里面的FFT模板开考前30分钟，...
笔试强训10.17
2301_79761329的博客
10-17 712
用双层循环会超时，所以改用动态规划的思想。（核心是通过一次遍历找出符合条件的最大值和最小值，一次循环保证卖一定在买后面）。//法四：Manacher算法。//法三：hash+二分。
Leetcode 1168. 水资源分配优化
m0_51437455的博客
10-14 491
对于每个房子 i，我们有两种可选的供水方案：一种是直接在房子内建造水井，成本为 wells[i – 1] （注意 -1 ，因为 索引从0开始 ）；另一种是从另一口井铺设管道引水，数组 pipes 给出了在房子间铺设管道的成本，其中每个 pipes[j] = [house1_j, house2_j, cost_j] 代表用管道将 house1_j 和 house2_j连接在一起的成本。第二步，使用Prim算法模板或者Kruskal算法模板解除最小生成树的权值和（详情可以看下代码的注释）
计算机毕业设计Python深度学习房价预测 房源可视化 房源爬虫 二手房可视化 二手房爬虫 递归决策树模型 机器学习 深度学习 大数据毕业设计
最新发布
全网粉丝100W+、全栈领域优质创作者、B站、github、CSDN等社区技术专家、专注于高端精品毕业项目源码实战
10-18 575
计算机毕业设计Python深度学习房价预测 房源可视化 房源爬虫 二手房可视化 二手房爬虫 递归决策树模型 机器学习 深度学习 大数据毕业设计
[C++] 红黑树的实现：原理与底层解析
Kevin ’ s blog
10-14 1596
深度讲解红黑树的基础与底层代码实现。
大数据与人工智能在金融风险控制中的应用
2405_87249521的博客
10-16 1086
通过对海量数据的实时分析和智能化的预测模型，金融机构能够更准确地识别潜在风险，采取适当的防范措施，从而提升金融市场的稳定性和安全性。传统的信用评估主要依赖于财务报表和历史信用记录，而大数据技术可以结合客户的社交媒体行为、购物习惯、互联网搜索记录等非结构化数据，为风险评估提供更全面的视角。同时，AI还能够自动识别潜在的合规风险，减少人工审核的压力。大数据与人工智能在金融风险管理中有着广泛的应用场景，从信用评估、市场风险分析，到反欺诈和监管合规，都可以利用这些技术来提升风险控制的效率和准确性。
数据结构与算法——Java实现 35.求数据流中的第K大元素
m0_73983707的博客
10-13 651
设计一个找到中第k大元素的类（class）。注意是排序后的第k大元素，不是第k个不同的元素。请实现KthLargestknumsvalnumsk// 返回 4// 返回 5// 返回 5// 返回 8// 返回 8// 返回 7// 返回 7// 返回 7// 返回 8。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值