随机挑战总结 Part3

最新推荐文章于 2025-08-24 17:01:12 发布

原创最新推荐文章于 2025-08-24 17:01:12 发布 · 533 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#随机挑战Part3 #我太菜了

其他专栏收录该内容

14 篇文章

订阅专栏

本文记录了作者作为OIer进行随机跳题的实战过程，包括三道紫题的解题思路与代码实现，涉及二分答案、树形DP、矩阵乘法、分层图最短路及线段树维护等算法。

前言

今天纪中没有题目，所以闲的发慌又来随机跳题。
上次由于被 $d a l a o$ 们嘲讽说题目太简单了 $q w q$ ，所以这次跳的是3道紫题。
然而我的题目还是最简单的 $q w q$ 。
再次准备被 $d a l a o$ 嘲讽 $(2 / 2147483647)$ 。
主要还是太菜了。本来跳的第三题是一个分层图最短路，然后敲完样例没过，调试的我都要被恶心死了。还要跑两遍，读入字符串，而且我的方法还是会 $M L E$ 的 $q w q$ 。~~然后两位大爷为了不让我这么尴尬就让我换了一道题结果又是一道水题。~~
$\color{white}\texttt{随机跳题总结：我永远是最菜的OIer qwq}$

题目：

T1T2水的一匹，感觉要被嘲讽 $q w q$

在这里插入图片描述
$\color{red}\texttt{Link:XXY巨爷的随机跳题Part3总结}$

题解

T1 $P3554\ [POI2013]LUK-Triumphal\ arch$

一道很简单的二分答案+树形 $d p$ 的题目。码量还贼小。
难度☆☆，不知道怎么被评上紫题的。
$\color{blue}\texttt{戳我：Link}$

T2 $P 4838$ P哥破解密码

显然矩阵乘法，思路也很简单，不难想，写完结构体感觉为所欲为。
难度☆☆，不知道怎么被评上紫题的。
$\color{blue}\texttt{戳我：Link}$

（伪）T3 $P3259\ [JLOI2014]$ 路径规划

发现是分成图最短路，于是赶快去洛谷敲了一发分层图最短路的模板。
然后来做这道题，发现这不是一般的恶心啊啊啊啊啊啊啊啊啊啊啊。
难度☆☆☆☆☆，依然不知道怎么被评上紫题的~~不应该是黑题吗~~。
WA代码就不放了，改天闲的发慌再来改吧。

T3 $P1712\ [NOI2016]$ 区间

思维好题。退一番发现可以用线段树维护。然后就在线段树的标记细节上搞了比较久，最终总算是搞出来了。
难度☆☆☆，算是正常的紫题了。
$\color{blue}\texttt{戳我：Link}$

代码

T1

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

const int N=300010;
int n,x,y,tot,l,r,mid,f[N],head[N];

struct edge
{
    int to,next;
}e[N*2];

void add(int from,int to)
{
    e[++tot].to=to;
    e[tot].next=head[from];
    head[from]=tot;
}

void dp(int x,int fa)
{
    int sum=0;
    for (int i=head[x];~i;i=e[i].next)
    {
        int y=e[i].to;
        if (y!=fa)
        {
            dp(y,x);
            sum+=f[y]+1;
        }
    }
    f[x]=max(0,sum-mid);
}

int main()
{
    memset(head,-1,sizeof(head));
    scanf("%d",&n);
    for (int i=1;i<n;i++)
    {
        scanf("%d%d",&x,&y);
        add(x,y); add(y,x);
    }
    l=0; r=n-1;
    while (l<=r)
    {
        mid=(l+r)/2;
        dp(1,0);
        if (!f[1]) r=mid-1;
            else l=mid+1;
    }
    printf("%d\n",r+1);
    return 0;
}

T2

#include <cstdio>
#include <cstring>
using namespace std;
typedef long long ll;

const ll MOD=19260817;
int n,m;

struct matrix
{
    ll a[4][4];
}f,A,a;
 
matrix operator *(matrix a,matrix b)
{
    matrix c;
    memset(c.a,0,sizeof(c.a));
    for(int i=1;i<=3;i++)
        for(int j=1;j<=3;j++)
      		for(int k=1;k<=3;k++)
          		c.a[i][j]=(c.a[i][j]+a.a[i][k]*b.a[k][j])%MOD;
    return c;
}

void power(int M)
{
    for (;M;M>>=1,a=a*a)
        if (M&1) f=f*a;
}

int main()
{
    //A.a[1][3]=A.a[2][1]=A.a[3][1]=A.a[3][2]=A.a[3][3]=1;
    A.a[3][1]=A.a[1][2]=A.a[1][3]=A.a[2][3]=A.a[3][3]=1;
    scanf("%d",&m);
    while (m--)
    {
        memcpy(a.a,A.a,sizeof(A.a));
        memset(f.a,0,sizeof(f.a));
        f.a[1][1]=f.a[1][3]=1;
        scanf("%d",&n);
        power(n-1);
        printf("%lld\n",(f.a[1][1]+f.a[1][2]+f.a[1][3])%MOD);
    }
    return 0;
}

T3

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

const int N=500010,Inf=2e9;
int n,m,maxn,ans=Inf,b[N*2];

struct node
{
    int l,r,len;
}a[N];

struct Tree
{
    int l,r,maxn,lazy;
}tree[N*8];

bool cmp(node x,node y)
{
    return x.len<y.len;
}

void build(int x)
{
    if (tree[x].l==tree[x].r) return;
    int mid=(tree[x].l+tree[x].r)/2;
    tree[x*2].l=tree[x].l;
    tree[x*2].r=mid;
    tree[x*2+1].l=mid+1;
    tree[x*2+1].r=tree[x].r;
    build(x*2); build(x*2+1);
}

void pushdown(int x)
{
    if (tree[x].lazy)
    {
        tree[x*2].lazy+=tree[x].lazy;
        tree[x*2+1].lazy+=tree[x].lazy;
        tree[x*2].maxn+=tree[x].lazy;
        tree[x*2+1].maxn+=tree[x].lazy;
        tree[x].lazy=0;
    }
}

void add(int x,int l,int r)
{
    if (tree[x].l==l && tree[x].r==r)
    {
        tree[x].lazy++;
        tree[x].maxn++;
        return;
    }
    pushdown(x);
    int mid=(tree[x].l+tree[x].r)/2;
    if (r<=mid) add(x*2,l,r);
    else if (l>mid) add(x*2+1,l,r);
    else add(x*2,l,mid),add(x*2+1,mid+1,r);
    tree[x].maxn=max(tree[x*2].maxn,tree[x*2+1].maxn);
}

void del(int x,int l,int r)
{
    if (tree[x].l==l && tree[x].r==r)
    {
        tree[x].lazy--;
        tree[x].maxn--;
        return;
    }
    pushdown(x);
    int mid=(tree[x].l+tree[x].r)/2;
    if (r<=mid) del(x*2,l,r);
    else if (l>mid) del(x*2+1,l,r);
    else del(x*2,l,mid),del(x*2+1,mid+1,r);
    tree[x].maxn=max(tree[x*2].maxn,tree[x*2+1].maxn);
}

int main()
{
    scanf("%d%d",&n,&m);
    for (int i=1;i<=n;i++)
    {
        scanf("%d%d",&a[i].l,&a[i].r);
        a[i].len=a[i].r-a[i].l;
        b[2*i-1]=a[i].l; b[2*i]=a[i].r;
    }
    sort(b+1,b+1+n+n);
    int tot=unique(b+1,b+1+n+n)-b-1;
    for (int i=1;i<=n;i++)
    {
        a[i].l=lower_bound(b+1,b+1+tot,a[i].l)-b;
        a[i].r=lower_bound(b+1,b+1+tot,a[i].r)-b;
        if (a[i].r>maxn) maxn=a[i].r;
    }
    tree[1].l=1; tree[1].r=maxn;
    build(1);
    sort(a+1,a+1+n,cmp);
    for (int r=1,l=0;r<=n;r++)
    {
        add(1,a[r].l,a[r].r);
        if (tree[1].maxn>=m)
        {
            do
            {
                l++;
                del(1,a[l].l,a[l].r);
            }while (tree[1].maxn>=m);
            if (a[r].len-a[l].len<ans) ans=a[r].len-a[l].len;
        }
    }
    if (ans<Inf) printf("%d\n",ans);
        else printf("-1");
    return 0;
}