8.6 正睿暑期集训营 Day3

最新推荐文章于 2024-06-27 16:54:43 发布
最新推荐文章于 2024-06-27 16:54:43 发布
阅读量137 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/SovietPower/p/9431266.html
版权

目录

2018.8.6 正睿暑期集训营 Day3

时间：5h(实际)
期望得分：...
实际得分：...
rating-93 _(:зゝ∠)_

比赛链接

A 亵渎(DP)

题目链接

贪心不对啊，根本不知道该以什么策略。。
最优情况下亵渎应是最后用，此时所有元素都应在1~x内。
f[i][j]表示前i个元素全部变到1~j内（每个整数）的最小花费。则f[i][j]=min(f[i-1][j-1],f[i-1][j])+cost(i->j)。初始时除0全为INF，因为新的j只能从j-1转移。
注意除1外显然不能从0转移。

略错的思路（答案应该一样）：
DP，f[i][j]表示当前i个，构成阶梯长为j。
我们还要知道用哪些数构成了阶梯。假设用i放到j的话，那么前i-1个要么也构成了阶梯，要么被减到和i一样。
那么就有两种转移：f[i][j]=min(f[i-1][j-1],f[i-1][j])+cost(i->j)。（不管怎样i都是要削成j的）
在枚举所有i时更新答案就可以了。之前预处理后缀和。
事实上只在最后更新答案就可以，原因见上。。

#include <cstdio>
#include <cctype>
#include <algorithm>
#define gc() getchar()
typedef long long LL;
const int N=5005;

int n,A[N];
LL P,Q,R,f[N];

inline int read()
{
    int now=0;register char c=gc();
    for(;!isdigit(c);c=gc());
    for(;isdigit(c);now=now*10+c-'0',c=gc());
    return now;
}

int main()
{
    n=read(); LL ans=0;
    for(int i=1; i<=n; ++i) ans+=(A[i]=read());
    std::sort(A+1,A+1+n);
    P=read(), Q=read(), R=read(), ans*=Q;

    f[0]=0;
//  for(int i=1; i<=n; ++i) f[i]=1e15;
    for(int i=1; i<=n; ++i)
    {
        LL ai=A[i];
        f[i]=f[i-1]+(ai>i?Q*(ai-i):P*(i-ai)), f[0]=1e15;//一维得特判一下f[i]。。
        for(int j=i-1; j; --j)
            f[j]=std::min(f[j-1],f[j])+(ai>j?Q*(ai-j):P*(j-ai));
    }
    for(int i=1; i<=n; ++i)
        ans=std::min(ans,f[i]+R);
    printf("%lld\n",ans);

    return 0;
}

B 绕口令(KMP)

题目链接

一个环删掉一段，剩下的一段也是连续的。它当中不含有相邻的相同字符。如果原串中存在相邻的相同字符，则在这里把环切开，最后会把环切若干段，合法的剩下的段显然是某一段的一部分。
然后判断在合法的段中是否有长\(x\)的合法长度（若存在，则删\(n-x\)个是可以的），即长\(x\)首尾字母不同的段。而再删一段后首尾字母相同就是一段前后缀相同。
判断前后缀是否相同可以直接用KMP/Hash。如果有长为\(l\)的相同前后缀长度，则\(n-l+1\)位置是非法的。拆环为链每次只删后缀就是正确的了。
如果不存在相邻的相同字符，把整个串求一遍就行了。

#include <cstdio>
#include <cstring>
#include <algorithm>
const int N=2e6+5;

bool ok[N];
char s[N],t[N];

void Calc(int l)
{
    static int fail[N];
    static bool ban[N];

//  fail[0]=fail[1]=0;
    for(int i=1,j=0; i<l; ++i)
    {
        while(j && t[j]!=t[i]) j=fail[j];
        fail[i+1]=t[i]==t[j]?++j:0;
    }
    for(int i=fail[l]; i; i=fail[i]) ban[l-i+1]=1;
    for(int i=1; i<=l; ++i) if(!ban[i]) ok[i]=1;
    for(int i=fail[l]; i; i=fail[i]) ban[l-i+1]=0;
}
void Solve()
{
    int n=strlen(s+1),cnt=0,len=n<<1;
    for(int i=1; i<=n; ++i) s[i+n]=s[i];
    for(int i=1; i<len; ++i)
    {
        t[cnt++]=s[i];
        if(s[i]==s[i+1]) Calc(cnt), cnt=0;
    }
    if(cnt) Calc(cnt);
    for(int i=0; i<n; ++i) putchar(ok[n-i]+'0');//, ok[n-i]=0;//清空不完a!!
    for(int i=1; i<len; ++i) ok[i]=0;
    putchar('\n');
}

int main()
{
    int Cs=1;
    while(~scanf("%s",s+1))
         printf("Case %d:",Cs++), Solve();

    return 0;
}

C 最远点(LCT)

题目链接

动态维护森林中每个点距最远点的距离及其所在树的直径，支持增加、删除边。

LCT，维护每个点到其子树内的最远距离及次远距离。因为树的形态一直在变，用set/heap维护每个点其所有虚子树的 最长延伸距离(hp1)和答案(hp2)。
单独维护每个点左右两棵实子树的最长距离。
因为LCT的Splay形态是中序遍历的序列，即每个点x与其左右儿子不一定是连续的，所以要用x的左子树中与最右点(最深点，即一定与x相邻)相连的最长距离rdis[lson]。
ldis同理。因为一个点可能一会是左儿子一会是右儿子，所以ldis[lson]也顺便维护。
ldis[x]可以由 左子树中的某条链ldis[lson] 或是 左子树整个与x相连的这条实链+右子树或虚子树中的一条链 更新。
距离更新可能不太方便，直接维护路径上的点数，初始都为1，最后输出-1。
其中 x子树整个与fa[x]相连的实链的长度len[x] 可以直接由 len[lson]+len[rson]+1 更新。
x到最远点的距离mxdis[x]由 max{rdis[lson],ldis[rson],虚子树最大值hp1.top()}(+1)更新。
过x的最长链 = max{rdis[lson]+ldis[rson]+1, 虚子树最长链+左/右子树最长链/虚子树次长链+1}，但是ans要算上左右子树、虚子树的ans（再取max）（要整个连通块答案）。

注意hp1[x]中的最长链是要与x相连的，即如果用lson/rson更新则是ldis[rson]/rdis[lson]，用直接与其相连的点x更新则是mxdis[x]（Access与Link）。

说的比较乱。。尽量在解释清楚了。画画图就能看出来。

//2395ms    31672kb
#include <queue>
#include <cstdio>
#include <cctype>
#include <algorithm>
//#define gc() getchar()
#define MAXIN 300000
#define gc() (SS==TT&&(TT=(SS=IN)+fread(IN,1,MAXIN,stdin),SS==TT)?EOF:*SS++)
const int N=1e5+5;

char IN[MAXIN],*SS=IN,*TT=IN;
inline int read()
{
    int now=0;register char c=gc();
    for(;!isdigit(c);c=gc());
    for(;isdigit(c);now=now*10+c-'0',c=gc());
    return now;
}
namespace LCT
{
    #define lson son[x][0]
    #define rson son[x][1]
    int sk[N],fa[N],son[N][2],mxdis[N],ldis[N],rdis[N],len[N],ans[N];
    bool rev[N];
    struct Heap
    {
        std::priority_queue<int> h,d;
        inline void Delete(int x) {d.push(x);}
        inline void Insert(int x) {h.push(x);}
        inline void Fix() {while(!h.empty()&&!d.empty()&&h.top()==d.top()) h.pop(),d.pop();}
        inline int Top() {Fix(); return h.empty()?0:h.top();}
        inline int Sec()
        {
            Fix(); if(h.empty()) return 0;
            int tmp=h.top(); h.pop();
            int ans=Top(); h.push(tmp);
            return ans;
        }
    }hp1[N],hp2[N];

    inline void Init(int n){
        for(int i=1; i<=n; ++i) len[i]=ldis[i]=rdis[i]=ans[i]=1;
    }
    inline void Rev(int x){
        rev[x]^=1, std::swap(lson,rson), std::swap(ldis[x],rdis[x]);
    }
    inline void PushDown(int x){
        if(rev[x]) Rev(lson), Rev(rson), rev[x]^=1;
    }
    inline bool n_root(int x){
        return son[fa[x]][0]==x||son[fa[x]][1]==x;
    }
    void Update(int x)
    {
        int ls=lson, rs=rson, vmx=hp1[x].Top();
        len[x]=len[ls]+len[rs]+1;
        ldis[x]=std::max(ldis[ls],len[ls]+std::max(ldis[rs],vmx)+1);
        rdis[x]=std::max(rdis[rs],len[rs]+std::max(rdis[ls],vmx)+1);
        mxdis[x]=std::max(vmx,std::max(rdis[ls],ldis[rs]))+1;
        ans[x]=std::max(std::max(hp2[x].Top(),std::max(ans[ls],ans[rs])),std::max(rdis[ls]+ldis[rs]+1,vmx+1+std::max(hp1[x].Sec(),std::max(rdis[ls],ldis[rs]))));
    }
    void Rotate(int x)
    {
        int a=fa[x],b=fa[a],l=son[a][1]==x,r=l^1;
        if(n_root(a)) son[b][son[b][1]==a]=x;
        if(son[x][r]) fa[son[x][r]]=a;
        fa[a]=x, fa[x]=b, son[a][l]=son[x][r], son[x][r]=a;
        Update(a);
    }
    void Splay(int x)
    {
        int t=1,a=x; sk[1]=x;
        while(n_root(a)) sk[++t]=a=fa[a];
        while(t) PushDown(sk[t--]);
        while(n_root(x))
        {
            if(n_root(a=fa[x])) Rotate(son[a][0]==x^son[fa[a]][0]==a?x:a);
            Rotate(x);
        }
        Update(x);
    }
    void Access(int x)
    {
        for(int pre=0; x; x=fa[pre=x])
        {
            Splay(x);
            hp1[x].Insert(ldis[rson]), hp2[x].Insert(ans[rson]);
            hp1[x].Delete(ldis[pre]), hp2[x].Delete(ans[pre]);
            rson=pre, Update(x);
        }
    }
    void Make_root(int x){
        Access(x), Splay(x), Rev(x);
    }
    void Link(int x,int y)
    {
        Make_root(x), Access(y), Splay(y);
        fa[x]=y, hp1[y].Insert(mxdis[x]), hp2[y].Insert(ans[x]);
        Update(y);//y的虚子树变了 别忘更新y啊 
    }
    void Cut(int x,int y)
    {
        Make_root(x), Access(y), Splay(y);
        son[y][0]=fa[x]=0, Update(y);
    }
    void Query(int x)
    {
        Access(x), Splay(x);
        printf("%d %d\n",mxdis[x]-1,ans[x]-1);
    }
}

int main()
{
    int n=read(); LCT::Init(n);
    for(int i=1; i<n; ++i) LCT::Link(read(),read());
    for(int m=read(),opt; m--; )
        if((opt=read())==1) LCT::Link(read(),read());
        else if(opt==2) LCT::Cut(read(),read());
        else LCT::Query(read());

    return 0;
}

考试代码

A

//还没调对，应该是f[0]和f[i]的特判（初值问题），不想改了。。
#include <cstdio>
#include <cctype>
#include <algorithm>
#define gc() getchar()
typedef long long LL;
const int N=5005,M=1e6+5;

int n,A[N],tm[M];
LL P,Q,R,f[N],suf[M],suf2[M];

inline int read()
{
    int now=0;register char c=gc();
    for(;!isdigit(c);c=gc());
    for(;isdigit(c);now=now*10+c-'0',c=gc());
    return now;
}

int main()
{
//  freopen("A1.in","r",stdin);
//  freopen("A.out","w",stdout);

    n=read(); int mx=0;
    for(int i=1; i<=n; ++i) mx=std::max(mx,A[i]=read());
    std::sort(A+1,A+1+n);

    P=read(), Q=read(), R=read();
    for(int i=1; i<=n; ++i) ++suf2[A[i]];
    for(int i=1; i<=n; ++i) suf[A[i]]=Q*A[i]*suf2[A[i]];
    for(int i=mx-1; i; --i) suf[i]+=suf[i+1], suf2[i]+=suf2[i+1];

    LL res=0;
    for(int i=1; i<=n; ++i) res+=A[i];
    res*=Q;
    f[0]=1e15, f[1]=(A[1]-1)*Q;
    for(int i=2; i<=n; ++i) f[i]=1e15;
    for(int i=2; i<=n; ++i)
    {
        LL ai=A[i];
        for(int j=i-1; ~j; --j)
        {
            f[j+1]=std::min(f[j+1],f[j])+(ai>j+1?Q*(ai-j-1):P*(j+1-ai));
            res=std::min(res,R+f[j+1]+suf[j+2]-Q*(j+1)*suf2[j+2]);
        }
    }
    printf("%I64d\n",res);

    return 0;
}

B

#include <cstdio>
#include <cctype>
#include <cstring>
#include <algorithm>
#define gc() getchar()
const int N=1e6+5;

int n,sum[N];
char s[N];

bool Check(int k)
{
    if(k+1==n) return 1;
    if(!k){
        for(int i=1; i<=n; ++i) if(sum[i]) return 0;
        return 1;
    }
    for(int i=1; i<=n; ++i)
    {
        int a=i-1,b=(i+k-1)%n+1; if(!a) a=n;
        if(sum[n]-sum[i+k]==0 && s[a]!=s[b]) return 1;
    }
    return 0;
}
void Solve()
{
    n=strlen(s+1); sum[1]=0;
    for(int i=2; i<=n; ++i)
        sum[i]=sum[i-1]+(s[i]==s[i-1]);
//  sum[n+1]=sum[n]+(s[n]==s[1]);
//  for(int i=n+2; i<=n<<1; ++i) sum[i]=sum[i-1]+(s[i-n]==s[i-n-1]);
//  for(int i=1; i<=n; ++i) printf("%d:%d\n",i,sum[i]);
    for(int k=0; k<n; ++k) putchar(Check(k)+'0');
    putchar('\n');
}

int main()
{
    freopen("b2.in","r",stdin);
    freopen("b.out","w",stdout);

    int Cs=1;
    while(~scanf("%s",s+1))
         printf("Case %d:",Cs++), Solve();

    return 0;
}

C

#include <cstdio>
#include <cctype>
#include <algorithm>
//#define gc() getchar()
#define MAXIN 400000
#define gc() (SS==TT&&(TT=(SS=IN)+fread(IN,1,MAXIN,stdin),SS==TT)?EOF:*SS++)
typedef long long LL;
const int N=1e5+5,M=4e5+5;

int n,Enum,H[N],nxt[M],to[M],len[M],V,D;
bool ban[5003][5003];
char IN[MAXIN],*SS=IN,*TT=IN;

inline int read()
{
    int now=0;register char c=gc();
    for(;!isdigit(c);c=gc());
    for(;isdigit(c);now=now*10+c-'0',c=gc());
    return now;
}
inline void AddEdge(int u,int v)
{
    if(ban[u][v]) {ban[u][v]=ban[v][u]=0; return;}
    to[++Enum]=v, nxt[Enum]=H[u], H[u]=Enum;
    to[++Enum]=u, nxt[Enum]=H[v], H[v]=Enum;
}
void DFS(int x,int f,int d)
{
    if(d>D) D=d, V=x;
    for(int i=H[x],v; i; i=nxt[i])
        if((v=to[i])!=f && !ban[x][v]) DFS(v,x,d+1);
}

int main()
{
//  freopen("c2.in","r",stdin);
//  freopen("my.out","w",stdout);

    n=read();
    for(int i=1; i<n; ++i) AddEdge(read(),read());
    for(int Q=read(),u,v,opt; Q--; )
        if((opt=read())==1) AddEdge(read(),read());
        else if(opt==2) u=read(),v=read(),ban[u][v]=ban[v][u]=1;
        else
        {
            V=u=read();
            D=0, DFS(u,u,0), printf("%d ",D), D=0, DFS(V,V,0), printf("%d\n",D);
        }
    return 0;
}

转载于:https://www.cnblogs.com/SovietPower/p/9431266.html

weixin_30624825
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
2021正睿csp7连day3
P_Pqueen的博客
09-12 249
2021正瑞csp7连day3比赛时间规划考试 比赛时间规划 6.10左右开始的比赛（放学太晚了） 6.10-6.30 看了第一题，觉得不难，就直接开始写了，因为之前玩过，知道规则，大概看了一下，没有什么差别，就按照思路码了，先把红球能用完的用完，最后统一再统计一下。 6.30-6.50 先看了第二题，数据范围很小，应该是个状压，因为不太熟练，所以打算放到最后写吧 然后看第三题，暴力分给的很好，简单想了一下，是直接循环加一个判断 接着第四题又是字符串类型题目，但是感觉比较复杂，想了一个暴力算法就过了。 6.
2021正睿csp7连day2
weixin_44221747的博客
09-05 237
因为比赛时间是挨着回寝室时间，第二天早上来又直接打了十连，所以时间具体不是太清楚。 时间安排 6.05-6.35左右，读T1并码出代码，因为觉得T1很水，有把握半小时之内切掉，所以就直接码了。 6.35-7.30左右，读完T2并码完，T2的性质还是比较神奇的，推出来的时候还小小地兴奋了一下。 7.30-7.50左右，理解了一下T3T4，发现T3的40pts还是比较好写的，T4的第一档分n就到4了，爆搜的话后面再去验证（以我当时的思路会超）于是先去码了T3。 7.50-8.20左右，快速地用map组合vect
【2019正睿金华集训】0801总结(网络流)
qq_44341728的博客
08-02 166
今天终于讲了久仰其大名的网络流。 网络流基础概念： 网络流是一个有向图，其中有两个特殊点源点s和汇点t，每条边有容量c(权值），实际的流量f比容量c小。特别的，如果一条边不在图中，令该边的容量为0. 三个性质： 1.容量限制：流量小于等于容量,即f(u,v)<=c(u,v) 2.流量守恒：除了源点和汇点，每个点的总流入量等于总流出量【即无法存储量】 3.斜对称性：f(u,v)= - f(u,...
11.1 正睿停课训练 Day14
weixin_30487201的博客
11-01 106
目录 2018.11.1 正睿停课训练 Day14 A 字符串 B 取数游戏(贪心) C 魔方(模拟) 考试代码 B C 2018.11.1 正睿停课训练 Day14 时间：3.5h...
正睿OIday7
聂泽宇的blog
08-03 200
day7 今天学的简单数论，感觉比前几天轻松一点点因为原来学过的，不过还是很难，原来不会的还是不会（哭笑）原来会的反而感觉有点模糊了，诡异。 明天就要开始为期十天的欢乐爆零赛了，好紧张 ...
正睿集训笔记
weixin_33831196的博客
08-04 323
算法营 2018正睿Day1计算几何及交互 Day2交互/网络流/分治/DP Day3 Day4考试 Day5字符串数据结构 Day6期望计数 Day7图论博弈论线性代数 刷题营 Day1解题报告 Day2解题报告 Day3解题报告  ...
2019正睿Day1题目.pdf
10-15
2019正睿Day1题目 T1序列seq T2灯泡bulb T3比赛match
2019正睿Day1题解.pdf
10-15
正睿2019Day1题解 T1序列seq T2灯泡bulb T3比赛match
2019正睿Day2题目.pdf
10-15
正睿2019Day2题目 T1石头stone T2内存memory T3子集subset
2019正睿Day2题解.pdf
10-15
2019正睿Day2题解 T1石子stone T2内存memory T3子集subset
图上博弈题解1
08-03
3. **HDOJ 3094**: 这是一个砍树游戏，玩家可以砍掉任意一条边或者删除与根节点不相连的所有点和边。 Alice先手，Bob后手。这类问题可以通过转化为NIM游戏来解决，NIM游戏是一种经典的零和博弈，其胜负可以通过异或...
正睿OI DAY1
您敲代码的姿势很像菜虚鲲
07-28 548
DAY1 今天讲的是期望与概率，第一天还是刚刚找回学习的状态，有的地方还是听得不够仔细。这个老师也是很nice，讲完一个问题都会停下来，让不懂得同学自己qq私信，所以不懂也一定要问~ 收获 基本概念：期望、概率、随机变量等 期望的线性性、前缀和技巧 两个公式 need to improve 游走问题、经典问题、期望线性性问题还需要在加深理解 PPT后几个问题还要再多加思考 额外学到的 凸...
正睿OI noip2017冲刺 第一次考试T2 解题报告
syh0313的博客
08-30 2179
这题是后来比赛完才写的 之前已经说过比赛时出现了种种状况 导致就考了1个小时 所以没时间写 题目因为版权原因不能放出来 相信dalao们读代码也能读出个大概 这题一开始没有想到暴力的树形DP 而是手推了一个公式f[n]=f[n-1]*num 结果发现每种情况的num是不知道的 所以写不下去了 后面收yjq大佬指教发现可以写一个模拟建树过程的DP 在每个点我们考
正睿OI DAY15
您敲代码的姿势很像菜虚鲲
08-12 181
DAY15 今天过的好快啊啊啊！（倒数两个天） 来c班滴第3天（哈哈蛤），今天csl讲滴数位DP，还讲了第一类斯特林数、第二类斯特林数、欧拉数。 前面听课时很认真的，但是中途就有点累了，有的时候走了一点神，后面还好，总体来说还会阔以的，没有颓废多少 ...
『正睿OI 2019SC Day2』
weixin_30952103的博客
07-29 138
分治 普通分治 普通分治是指针对序列或平面问题的分治算法。 思想 普通分治的思想是指将一个序列问题或平面问题通过某种划分方式划分为若干个子问题，直到子问题规模足够小，可以直接回答，再通过合并得到原问题的解。 通常来说，我们划分的方式是某个与题目特征有关的值，例如最大值或最小值。而当不易使用特征值进行划分的时候，我们也可以直接使用中点来划分，以保证时间复杂度，再设法计算贡...
正睿OI 2017冲刺T1Wa掉有点忧伤........
syh0313的博客
08-28 620
 第一次线上正式比赛突发情况真多 先是机房网炸了 然后编译器炸了 最后只有一个小时来写T1 想了一想 码了个模拟就交了 测试先是A了 然而我并不知道这就是测试数据 于是查就交了 然后测完发现Wa了 最后发现是判断错了 if(ansa 所以说应该是 if（ansa-pb 只有在收益小的时候在尝试去增加ansa or ansb 然后改了一下就A了 郁闷.......
构建预测力：线性回归系数的计算与解读
2402_85758349的博客
06-22 791
线性回归系数的计算是构建有效预测模型的关键步骤。通过理解系数的计算方法和统计显著性，数据分析师可以更好地解释模型结果，并为决策提供科学依据。随着数据分析工具的发展，线性回归模型的构建和系数的计算变得更加容易和高效，但深入理解其背后的原理对于正确应用这一技术至关重要。本文详细介绍了线性回归系数的计算方法，包括简单线性回归和多元线性回归的情况，以及如何进行系数的统计显著性检验和解释。希望本文能够帮助读者深入理解线性回归模型的构建过程，并提高数据分析的能力。
java笔记第十二章集合
最新发布
weixin_59335007的博客
06-27 326
接口：表示集合的抽象数据类型，如 List、Set、Map 等。实现：具体实现接口的类，如 ArrayList、HashSet、HashMap 等。算法：定义在集合上的操作方法，如排序和搜索。
算法力扣刷题记录六【203移除链表元素】
danaaaa的博客
06-21 1073
删除链表节点
「动态规划」如何求最长湍流子数组的长度？
努力学习游泳的鱼的博客
06-22 727
用动态规划的思想求解最长湍流子数组的问题。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值