牛客练习赛 56 E tarjan 割边

最新推荐文章于 2020-10-10 23:10:49 发布

Fighting_Peter

最新推荐文章于 2020-10-10 23:10:49 发布

阅读量164

点赞数

分类专栏：牛客网文章标签： dp 线段树 dfs

本文链接：https://blog.csdn.net/Fighting_Peter/article/details/108939888

版权

牛客网专栏收录该内容

20 篇文章 0 订阅

订阅专栏

A - 小蒟和他的乐谱

签到题，将原序列对 7 取模之后将序列扫描一遍就可以得到答案
~~不过感觉题目意思还需要理解理解~~

#define IO ios::sync_with_stdio(false);cin.tie();cout.tie(0)
#pragma GCC optimize(2)
#include<set>
#include<map>
#include<cmath>
#include<queue>
#include<string>
#include<vector>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<unordered_map>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const ll mod=998244353;
const int N=1000010;
int a[N];
int n;
int main()
{
    IO;
    int T=1;
    //cin>>T;
    while(T--)
    {
        cin>>n;
        for(int i=1;i<=n;i++) cin>>a[i];
        int res=0;
        int now=0;
        for(int i=1;i<=n;i++)
        {
            int x=(a[i]%7+7)%7;
            if(x==1||x==2||x==3||x==5||x==6) 
            {
                now++;
                res=max(res,now);
            }
            else now=0;
        }
        cout<<res<<'\n';
    }
    return 0;
}

B - 小琛和他的学校

之前打cf的时候有一个类似的题目，这次就会了hh
维护sz[u]表示u子树子节点的数量，cnt[u]表示u子树学生的总数，然后考虑每条边对答案的贡献（之前cf求的是所有代价和这题求得每条边的代价还给了一个提示）
这条边分成两个连通块 $i, j$ ，那么代价即为 $i$ 连通块的人跑到 $j$ 连通块的校区和 $j$ 连通块的人跑到 $i$ 连通块的校区注意来回路程要乘二

#define IO ios::sync_with_stdio(false);cin.tie();cout.tie(0)
#pragma GCC optimize(2)
#include<set>
#include<map>
#include<cmath>
#include<queue>
#include<string>
#include<vector>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<unordered_map>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const ll mod=998244353;
const int N=200010;
ll sz[N],cnt[N];
int n;
ll ans[2*N];
int h[N],e[2*N],ne[2*N],idx;
ll w[2*N];
void add(int a,int b,ll c)
{
    e[idx]=b;
    ne[idx]=h[a];
    w[idx]=c;
    h[a]=idx++;
}
void dfs1(int u,int fa)
{
    sz[u]=1;
    for(int i=h[u];i!=-1;i=ne[i])
    {
        int j=e[i];
        if(j==fa) continue;
        dfs1(j,u);
        sz[u]+=sz[j];
        cnt[u]+=cnt[j];
    }
}
void dfs2(int u,int fa)
{
    for(int i=h[u];i!=-1;i=ne[i])
    {
        int j=e[i];
        if(j==fa) continue;
        dfs2(j,u);
        ans[i]=ans[i^1]=2ll*(cnt[j]*(n-sz[j])+(cnt[1]-cnt[j])*sz[j])*w[i];
    }
}
int main()
{
    IO;
    int T=1;
    //cin>>T;
    while(T--)
    {
        memset(h,-1,sizeof h);
        cin>>n;
        for(int i=1;i<=n;i++) cin>>cnt[i];
           
        for(int i=1;i<n;i++)
        {
            int a,b;ll c;
            cin>>a>>b>>c;
            add(a,b,c);
            add(b,a,c);
        }
        dfs1(1,-1);
        dfs2(1,-1);
        for(int i=0;i<2*n-2;i+=2) cout<<ans[i]<<'\n';
        
    }
    
    return 0;
    
}

C - 小魂和他的数列

很明显的dp题
状态表示： $f_{(i,j)}$ 表示考虑前 $i$ 个数，以第 $i$ 个数结尾目前长度是 $j$ 的严格递增的数目
状态转移： $f_{(i,j)}=\sum_{k=1}^{i-1}f_{(k,j-1)}(a_k<a_i)$
只需要用树状数组优化转移即可。
注意离散化
~~这几天遇到了好多线段树或者树状数组优化dp的题目~~

// O(nlogn)
#define IO ios::sync_with_stdio(false);cin.tie();cout.tie(0)
#pragma GCC optimize(2)
#include<set>
#include<map>
#include<cmath>
#include<queue>
#include<string>
#include<vector>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<unordered_map>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const ll mod=998244353;
const int N=500010;
int a[N];
ll f[N][11];
int n,m;
ll tree[11][N];
vector<int> da;
int lowbit(int x)
{
    return x&-x;
}
void modify(ll tree[],int k,ll x)
{
    for(;k<=n;k+=lowbit(k)) tree[k]=(tree[k]+x)%mod;
}
ll query(ll tree[],int k)
{
    ll res=0;
    for(;k;k-=lowbit(k)) res=(res+tree[k])%mod;
    return res;
}
int find(int x)
{
    return lower_bound(da.begin(),da.end(),x)-da.begin()+1;
}
int main()
{
    IO;
    int T=1;
    //cin>>T;
    while(T--)
    {
        cin>>n>>m;
        for(int i=1;i<=n;i++) 
        {
            cin>>a[i];
            da.push_back(a[i]);
        }
        // 离散化
        sort(da.begin(),da.end());
        da.erase(unique(da.begin(),da.end()),da.end());
        //初始化
        for(int i=1;i<=n;i++) f[i][1]=1;
        
        for(int i=1;i<=n;i++)
        {
            int x=find(a[i]);
            for(int j=1;j<=m;j++)
            {
                f[i][j]+=query(tree[j-1],x-1);
                modify(tree[j],x,f[i][j]);
            }
        }
        ll res=0;
        for(int i=1;i<=n;i++) res=(res+f[i][m])%mod;
        cout<<res<<'\n';
    }
    
    return 0;
    
}

D - 小翔和泰拉瑞亚

刚开始想的是最大值不变，只要区间不会让最大值变小就施展魔法，否则不施展魔法，于是就写了个区间最小、大值区修区间修改线段树，但是很明显该贪心策略不对。

看了下题解后正解是：枚举最小值，如果枚举 $i$ 个数是最小值，那么只要施展魔法的区间包括第 $i$ 个点就施展（使之尽可能小），可以把询问拆开排序，按照扫描线的思路取±区间，枚举最值即可。

线段树只需要支持区间修改单点询问即可，由于我再写一遍就用的我错误思路的线段树

//O(nlogn)
#define IO ios::sync_with_stdio(false);cin.tie();cout.tie(0)
#pragma GCC optimize(2)
#include<set>
#include<map>
#include<cmath>
#include<queue>
#include<string>
#include<vector>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<unordered_map>
#define x first
#define y second
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const ll INF=1e17;
const int N=200010;
int a[N];
int n,m;
struct node1
{
    int l,r;
    ll mn,mx;
    ll lazy;
}tree[N<<2];
struct node2
{
    int op;
    int p;
    int l,r;
    ll w;
    bool operator <(const node2& o)const 
    {
        return p<o.p;
    }
    
}q[2*N];
void pushup(int u)
{
    tree[u].mn=min(tree[u<<1].mn,tree[u<<1|1].mn);
    tree[u].mx=max(tree[u<<1].mx,tree[u<<1|1].mx);
}
void build(int u,int l,int r)
{
    tree[u]={l,r,INF,-INF,0};
    if(l==r) 
    {
        tree[u].mn=tree[u].mx=a[l];
        return;
    }
    int mid=l+r>>1;
    build(u<<1,l,mid),build(u<<1|1,mid+1,r);
    pushup(u);
}
void pushdown(int u)
{
    if(tree[u].lazy==0) return;
    tree[u<<1].lazy+=tree[u].lazy;
    tree[u<<1|1].lazy+=tree[u].lazy;
    tree[u<<1].mx+=tree[u].lazy;
    tree[u<<1].mn+=tree[u].lazy;
    tree[u<<1|1].mx+=tree[u].lazy;
    tree[u<<1|1].mn+=tree[u].lazy;
    tree[u].lazy=0;
}
void modify(int u,int l,int r,int x)
{
    if(tree[u].l>=l&&tree[u].r<=r)
    {
        tree[u].mn+=x;
        tree[u].mx+=x;
        tree[u].lazy+=x;
        return;
    }
    pushdown(u);
    int mid=tree[u].l+tree[u].r>>1;
    if(l<=mid) modify(u<<1,l,r,x);
    if(r>mid) modify(u<<1|1,l,r,x);
    pushup(u);
}
ll query(int u,int l,int r,int op)
{
    //if(l>r) return op==1?INF:-INF;
    if(tree[u].l>=l&&tree[u].r<=r) return op==1?tree[u].mn:tree[u].mx;
    pushdown(u);
    int mid=tree[u].l+tree[u].r>>1;
    ll v=op==1?INF:-INF;
    if(l<=mid) op==1?v=min(v,query(u<<1,l,r,op)):v=max(v,query(u<<1,l,r,op));
    if(r>mid) op==1?v=min(v,query(u<<1|1,l,r,op)):v=max(v,query(u<<1|1,l,r,op));
    return v;
}
int main()
{
    IO;
    int T=1;
    //cin>>T;
    while(T--)
    {
        cin>>n>>m;
        for(int i=1;i<=n;i++) cin>>a[i];
        build(1,1,n);
        for(int i=1;i<=m;i++) 
        {
            int l,r,w;
            cin>>l>>r>>w;
            q[i]={-1,l,l,r,w};// l点加入该魔法
            q[i+m]={1,r+1,l,r,w};// r+1点删去该魔法
        }
        m=2*m;
        sort(q+1,q+1+m);
        ll  res=-INF;
        for(int i=1,j=1;i<=n;i++)
        {
            while(j<=m&&q[j].p==i)
            {
                modify(1,q[j].l,q[j].r,q[j].op*q[j].w);
                j++;
            }
            res=max(res,tree[1].mx-query(1,i,i,1));
        }
        cout<<res<<'\n';
    }
    
    return 0;
    
}

E - 小雀和他的王国

还没看，这题好像是tarjan的题，好久没写tarjan了，明天补了，熟悉熟悉板子——2020/10/07/00:17
板子题啊，求割边，缩点成树，然后求树上直径即可。1发AC

#define IO ios::sync_with_stdio(false);cin.tie();cout.tie(0)
#pragma GCC optimize(2)
#include<set>
#include<map>
#include<cmath>
#include<queue>
#include<string>
#include<vector>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<unordered_map>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const int mod=1e9+7;
const int N=200010;
int n,m;
int qmi(int a,int b,int p)
{
    int res=1;
    while(b)
    {
        if(b&1) res=1ll*res*a%p;
        b>>=1;
        a=1ll*a*a%p;
    }
    return res;
}

int h1[N],h2[N],ne[4*N],e[4*N],idx;
void add(int h[],int a,int b)
{
    e[idx]=b;
    ne[idx]=h[a];
    h[a]=idx++;
}
int dfn[N],low[N],timestamp;
bool bdg[2*N];
void tarjan(int u,int f)
{
    dfn[u]=low[u]=++timestamp;
    for(int i=h1[u];i!=-1;i=ne[i])
    {
        int j=e[i];
        if(!dfn[j])
        {
            tarjan(j,i);
            low[u]=min(low[u],low[j]);
            if(dfn[u]<low[j]) bdg[i]=bdg[i^1]=1;
        }
        else if(i!=(f^1)) low[u]=min(low[u],dfn[j]);
    }
}
int id[N],dcnt;
void dfs1(int u,int c)
{
    id[u]=c;
    for(int i=h1[u];i!=-1;i=ne[i])
    {
        int j=e[i];
        if(id[j]||bdg[i]) continue;
        dfs1(j,c);
    }
}
int dist,p;
void dfs2(int u,int fa,int d)
{
    for(int i=h2[u];i!=-1;i=ne[i])
    {
        int j=e[i];
        if(j==fa) continue;
        if(dist<d+1)
        {
            dist=d+1;
            p=j;
        }
        dfs2(j,u,d+1);
    }
    
}
int main()
{
    IO;
    int T=1;
    //cin>>T;
    while(T--)
    {
        memset(h1,-1,sizeof h1);
        memset(h2,-1,sizeof h2);
        cin>>n>>m;
        for(int i=1;i<=m;i++)
        {
            int a,b;
            cin>>a>>b;
            add(h1,a,b),add(h1,b,a);
        }
        tarjan(1,-1);
        for(int i=1;i<=n;i++)
            if(!id[i]) dfs1(i,++dcnt);

        for(int i=0;i<2*m;i+=2)
        {
            int a=e[i^1],b=e[i];
            if(id[a]==id[b]) continue;
            add(h2,id[a],id[b]),add(h2,id[b],id[a]);
        }
        dfs2(1,-1,0);
        dist=0;
        dfs2(p,-1,0);
        int res=dcnt-1-dist;
        res=1ll*res*qmi(m+1,mod-2,mod)%mod;
        cout<<res<<'\n';
    }
    return 0;
    
}

要加油哦~

Fighting_Peter

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
牛客练习赛 56 E tarjan 割边

A - 小蒟和他的乐谱签到题，将原序列对 7 取模之后将序列扫描一遍就可以得到答案不过感觉题目意思还需要理解理解#define IO ios::sync_with_stdio(false);cin.tie();cout.tie(0)#pragma GCC optimize(2)#include<set>#include<map>#include<cmath>#include<queue>#include<string>#incl
复制链接

扫一扫