2019牛客多校第四场 A,B,C,D,E,J,K

最新推荐文章于 2021-02-25 17:25:26 发布
最新推荐文章于 2021-02-25 17:25:26 发布
阅读量237 收藏
点赞数
分类专栏： 程序设计竞赛记录
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40482358/article/details/102638618
版权

A-meeting

题目链接：https://ac.nowcoder.com/acm/contest/884/A

题目大意：n个点的树。k个人分别在点Xk，求出所有人都到一个点的最短花费时间。

思路：将所有多余的树枝都砍掉，两次DFS。剩下的都是有用的。求剩下的这棵树的直径，因为直径上的两端点必定是最长的时间花费，因此两次DFS求出直径后，直接计算直径即可。

ACCode：

#include<stdlib.h>
#include<string.h>
#include<stdio.h>
#include<time.h>
#include<math.h>
// srand(unsigned)time(NULL));rand();
  
#include<map>
#include<set>
#include<deque>
#include<queue>
#include<stack>
#include<bitset>
#include<string>
#include<fstream>
#include<iostream>
#include<algorithm>
  
#define ll long long
#define Pair pair<int,int>
#define clean(a,b) memset(a,b,sizeof(a))
using namespace std;
  
const int MAXN=1e5+10;
const int INF32=0x3f3f3f3f;
const ll INF64=0x3f3f3f3f3f3f3f3f;
const ll MOD=1e9+7;
const double PI=acos(-1.0);
const double EPS=1.0e-8;
//unsigned register
// ios::sync_with_stdio(false)
 
struct Node{
    int v,val,nxt;
    Node(int _v=0,int _val=0,int _nxt=0){
        v=_v;val=_val;nxt=_nxt;
    }
};
Node Edge[MAXN<<2];
int Head[MAXN],Ecnt;
int Deep[MAXN],Val[MAXN],Sum[MAXN],Vis[MAXN];
int res,ans,n,m;
 
void Intt(){
    clean(Head,-1);Ecnt=0;
    clean(Deep,0);clean(Val,0);clean(Sum,0);
}
void AddEdge(int u,int v,int val){
    Edge[Ecnt]=Node(v,val,Head[u]);
    Head[u]=Ecnt++;
}
void DFS(int u,int fa,int dep=0){
    Vis[u]=1;
    Deep[u]=dep;
    Sum[u]=Val[u];
    for(int i=Head[u];i+1;i=Edge[i].nxt){
        int v=Edge[i].v;
        if(v==fa) continue;
        if(Edge[i].val==0) continue;
        DFS(v,u,dep+1);Sum[u]+=Sum[v];
        if(Sum[v]==0){//子节点没有贡献 ,砍掉
            Edge[i].val=0;
        }
    }
}
int main(){
    Intt();
    scanf("%d%d",&n,&m);
    for(int i=1;i<n;++i){
        int u,v;scanf("%d%d",&u,&v);
        AddEdge(u,v,1);AddEdge(v,u,1);
    }
    for(int i=1;i<=m;++i){
        int x;scanf("%d",&x);Val[x]=1;
    }DFS(1,0);//砍树
    int rt=1;
    clean(Vis,0);DFS(rt,0);//标记。
    for(int i=1;i<=n;++i){//找根
        if(Vis[i]&&Deep[i]>Deep[rt]) rt=i;
    }
//  printf("rt=%d\n",rt);
    clean(Sum,0);clean(Deep,0);clean(Vis,0);
    DFS(rt,0);//换根继续砍
    clean(Deep,0);
    DFS(rt,0); //求深度
    int d=0;
    for(int i=1;i<=n;++i) d=max(d,Deep[i]);
//  printf("d=%d\n",d);
    int Ans=d%2?d/2+1:d/2;
    printf("%d\n",Ans);
     
}

B-xor

题目链接：https://ac.nowcoder.com/acm/contest/884/B

数论队友线性基：https://ac.nowcoder.com/acm/contest/884/B

C-sequence

题目链接：https://ac.nowcoder.com/acm/contest/884/C

题目大意：给出两个序列a，b，找出找出最大的值：1≤l≤r≤n max​{min(al…r​)×sum(bl…r​)}

思路：有点类似上半年南昌邀请网络赛https://blog.csdn.net/qq_40482358/article/details/89422999

枚举最小的a[i]，确定a[i]的最小区间范围。找到范围内的最大的前缀和和最小的前缀和即可。

a[i]的最小的范围可以用单调栈来维护，从前到后和从后到前分别维护单增的栈。

ACCode：

#include<stdlib.h>
#include<string.h>
#include<stdio.h>
#include<time.h>
#include<math.h>
// srand(unsigned)time(NULL));rand();
  
#include<map>
#include<set>
#include<deque>
#include<queue>
#include<stack>
#include<bitset>
#include<string>
#include<fstream>
#include<iostream>
#include<algorithm>
  
#define ll long long
#define Pair pair<int,int>
#define clean(a,b) memset(a,b,sizeof(a))
using namespace std;
  
const int MAXN=3e6+10;
const int INF32=0x3f3f3f3f;
const ll INF64=0x3f3f3f3f3f3f3f3f;
const ll MOD=1e9+7;
const double PI=acos(-1.0);
const double EPS=1.0e-8;
//unsigned register
// ios::sync_with_stdio(false)
 
struct SegTree{
    ll Max[MAXN<<2],Min[MAXN<<2];
     
    void Build(int l,int r,int rt,ll A[]){
        if(l==r){
            Max[rt]=Min[rt]=A[l];
            return ;
        }
        int mid=(l+r)>>1;
        Build(l,mid,rt<<1,A);Build(mid+1,r,rt<<1|1,A);
        Max[rt]=max(Max[rt<<1],Max[rt<<1|1]);
        Min[rt]=min(Min[rt<<1],Min[rt<<1|1]);
    }
    ll QueryMax(int ql,int qr,int l,int r,int rt){
        if(ql<=l&&r<=qr) return Max[rt];
        int mid=(l+r)>>1;
        ll res=-INF64;
        if(ql<=mid) res=max(res,QueryMax(ql,qr,l,mid,rt<<1));
        if(qr>mid) res=max(res,QueryMax(ql,qr,mid+1,r,rt<<1|1));
        return res;
    }
    ll QueryMin(int ql,int qr,int l,int r,int rt){
        if(ql<=l&&r<=qr) return Min[rt];
        int mid=(l+r)>>1;
        ll res=INF64;
        if(ql<=mid) res=min(res,QueryMin(ql,qr,l,mid,rt<<1));
        if(qr>mid) res=min(res,QueryMin(ql,qr,mid+1,r,rt<<1|1));
        return res;
    }
};
SegTree Seg;//,SegMin;
ll A[MAXN],B[MAXN];
ll Min[MAXN][2],SumB[MAXN];
int Stk[MAXN],Index[MAXN],top;
int n;
 
int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;++i) scanf("%lld",&A[i]);
    for(int i=1;i<=n;++i) scanf("%lld",&B[i]);
    top=0;
    for(int i=1;i<=n;++i){
        while(top>0&&A[i]<Stk[top]) --top;
        if(top==0) Min[i][0]=1;
        else Min[i][0]=Index[top]+1;
        Stk[++top]=A[i];Index[top]=i;
    }
    top=0;
    for(int i=n;i>=1;--i){
        while(top>0&&A[i]<Stk[top]) --top;
        if(top==0) Min[i][1]=n;
        else Min[i][1]=Index[top]-1;
        Stk[++top]=A[i];Index[top]=i;
    }
    for(int i=2;i<=n+1;++i) SumB[i]=SumB[i-1]+B[i-1];SumB[1]=0;
    Seg.Build(1,n+1,1,SumB);
    ll Ans=-INF64;
    for(int i=1;i<=n;++i){//对于每个点，求出他的影响区间，如果该点为负数，左右找打最小的前缀和，正数找到最大的Sum
        int l=Min[i][0],r=Min[i][1];
        l++;r++;//区间向后移动一位 
        l--;//查询区间[l-1,i][i,r]; 
        ll Suml,Sumr;
        if(A[i]<0){
            Suml=Seg.QueryMax(l,i+1,1,n+1,1);
            Sumr=Seg.QueryMin(i+1,r,1,n+1,1);
        }
        else{
            Suml=Seg.QueryMin(l,i+1,1,n+1,1);
            Sumr=Seg.QueryMax(i+1,r,1,n+1,1);
        }
        //printf("l=%d r=%d\n",l,r);
        //printf("Suml=%lld Sumr=%lld\n",Suml,Sumr);
        Suml=SumB[i]-Suml;Sumr=Sumr-SumB[i];
        //printf("Suml=%lld Sumr=%lld\n",Suml,Sumr);
		Ans=max(Ans,1ll*(Suml+Sumr)*A[i]);
        //printf("Ans=%lld\n",Ans);
    }printf("%lld\n",Ans);
}

D-triples I

题目链接：https://ac.nowcoder.com/acm/contest/884/D

数论队友：https://blog.csdn.net/henucm/article/details/97758303

E-triples II

题目链接：https://ac.nowcoder.com/acm/contest/884/E

数论队友：https://blog.csdn.net/henucm/article/details/102639665

J-free

题目链接：https://ac.nowcoder.com/acm/contest/884/J

题目大意：一个图，可以走k次近道。稳到达终点的最小花费。

思路：分层最短路板子题

ACCode：

#include<stdlib.h>
#include<string.h>
#include<stdio.h>
#include<time.h>
#include<math.h>
// srand(unsigned)time(NULL));rand();
  
#include<map>
#include<set>
#include<deque>
#include<queue>
#include<stack>
#include<bitset>
#include<string>
#include<fstream>
#include<iostream>
#include<algorithm>
  
#define ll long long
#define Pair pair<int,int>
#define clean(a,b) memset(a,b,sizeof(a))
using namespace std;
  
const int MAXN=1e3+10;
const int INF32=0x3f3f3f3f;
const ll INF64=0x3f3f3f3f3f3f3f3f;
const ll MOD=1e9+7;
const double PI=acos(-1.0);
const double EPS=1.0e-8;
//unsigned register
// ios::sync_with_stdio(false)
 
 
struct Node{
    int v,val,nxt;
    Node(int _v=0,int _val=0,int _nxt=0){
        v=_v;val=_val;nxt=_nxt;
    }
};
Node Edge[MAXN<<2];
int Head[MAXN],Ecnt;
int Vis[MAXN][MAXN],Dis[MAXN][MAXN];
int n,m,S,T,k;
 
void Intt(){
    clean(Head,-1);Ecnt=0;
    clean(Vis,0);clean(Dis,INF32);
}
void AddEdge(int u,int v,int val){
    Edge[Ecnt]=Node(v,val,Head[u]);
    Head[u]=Ecnt++;
}
#define Piii pair<int,Pair>
#define M_P(a,b,c) make_pair(a,make_pair(b,c))
void Dijkstra(){
    Dis[S][0]=0;
    priority_queue<Piii> que;que.push(M_P(0,S,0));
    while(que.size()){
        while(Vis[que.top().second.first][que.top().second.second]&&que.size()>0) que.pop();
        Pair p=que.top().second;
        Vis[p.first][p.second]=1;
        for(int i=Head[p.first];i+1;i=Edge[i].nxt){//同层查找
            int v=Edge[i].v;
            if(Vis[v][p.second]==0&&Dis[v][p.second]>Dis[p.first][p.second]+Edge[i].val){
                Dis[v][p.second]=Dis[p.first][p.second]+Edge[i].val;
                que.push(M_P(-Dis[v][p.second],v,p.second));
            }
            if(p.second+1<=k&&Vis[v][p.second+1]==0&&Dis[v][p.second+1]>Dis[p.first][p.second]){
                Dis[v][p.second+1]=Dis[p.first][p.second];
                que.push(M_P(-Dis[v][p.second+1],v,p.second+1));
            }
        }
    }
}
int main(){
    Intt();
    scanf("%d%d%d%d%d",&n,&m,&S,&T,&k);
    for(int i=1;i<=m;++i){
        int u,v,val;scanf("%d%d%d",&u,&v,&val);
        AddEdge(u,v,val);AddEdge(v,u,val);
    }Dijkstra();
    int Ans=INF32;
    for(int i=0;i<=k;++i){
        Ans=min(Ans,Dis[T][i]);
    }printf("%d\n",Ans);
}

K-number

题目链接：https://ac.nowcoder.com/acm/contest/884/K

题目大意：给出一串数字，判断有多少个字符串是300的倍数。

思路：求出前缀之和%3的余数。求出对应的个数。从后向前遍历字符串，cnt表示连续0的个数。

当出现一个不为0的数时，判断该位前面有多少个相同的数（相同的数表示中间相差的有3的倍数）加上后面0的个数组成数量。

ACCode：

#include<stdlib.h>
#include<string.h>
#include<stdio.h>
#include<time.h>
#include<math.h>
// srand(unsigned)time(NULL));rand();
  
#include<map>
#include<set>
#include<deque>
#include<queue>
#include<stack>
#include<bitset>
#include<string>
#include<fstream>
#include<iostream>
#include<algorithm>
  
#define ll long long
#define Pair pair<int,int>
#define clean(a,b) memset(a,b,sizeof(a))
using namespace std;
  
const int MAXN=1e5+10;
const int INF32=0x3f3f3f3f;
const ll INF64=0x3f3f3f3f3f3f3f3f;
const ll MOD=1e9+7;
const double PI=acos(-1.0);
const double EPS=1.0e-8;
//unsigned register
// ios::sync_with_stdio(false)
 
char S[MAXN];
int Sum[MAXN];
int A[4][MAXN];
 
int main(){
    scanf("%s",S+1);
    int len=strlen(S+1);//printf("len=%d\n",len);
    for(int i=1;i<=len;++i){
        Sum[i]=Sum[i-1]+S[i]-'0';
        Sum[i]%=3;
    }
    A[0][0]++;
    for(int i=1;i<=len;++i){
        for(int j=0;j<=2;++j) A[j][i]=A[j][i-1];
        A[Sum[i]][i]++;
    }
//  for(int i=0;i<=2;++i){
//      for(int j=0;j<=len;++j){
//          printf(" %d",A[i][j]);
//      }printf("\n");
//  }
    ll Ans=0;
    int cnt=0;
    for(int i=len;i>=0;--i){
        if(S[i]=='0') cnt++;
        else{
            if(cnt>=2){//Ans+
                int x=Sum[i];
                int num=A[x][i];
                num-=1;
                Ans+=1ll*(cnt-1)*num;
                Ans+=(1ll+cnt)*cnt/2;
            }
            if(cnt==1) Ans++;
            cnt=0;
        }
//      printf("i=%d Ans=%lld\n",i,Ans);
    }printf("%lld\n",Ans);
}

 

永远鲜红の幼月
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2019 Multi-University Training Contest 4(2019hdu多校第四场数据与标程).rar
08-01
有2019 Multi-University Training Contest 4，hdu多校第四场的题解，数据标程，有需要的可以下载哦
2019 牛客 多校赛 第四场
JZK-Keven 的博客
07-30 289
slove 3/11 rank 346 补题 7/11 -------------------------------------------------------- https://ac.nowcoder.com/acm/contest/884#question A、meeting 求树的直径，打个标记记录合法的点 #include <bits/stdc++.h&...
2019牛客多校第四场
zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz
07-30 188
A – meeting 题意： 给一棵n个点的图（保证是树） 给k个点表示k个点上有人，每次走一条边花费1分钟，问所有人走到同一个点最少要多少分钟 分析： 假设任意两个点间距离最大值为d,则d/2向上取整就是答案 最大距离求法类似求树的直径，第一次随便找一个点bfs找到距离当前点最远的点 然后从找到的点在bfs一次找到另外一个最远的点，两个最远点之间的距离就是最大距离 比赛的时候想到了最大距离除以...
2019牛客多校第四场A/K
canxuezhinuanyang的博客
07-29 233
A.给你一张n个点n-1条边的图,和k个关键点。求一个点到所有关键点距离最大值的最小为多少。 乍一看像是对答案二分，但是考虑两个相距最远的关键点，假设他们的距离为d，那么答案肯定为(d+1)/2 如果有一点到中心点的距离超过了(d+1)/2 ，那么这个点会成为最远关键点对中的一个。矛盾。 所以题目就变成了如何求最远的两个关键点的距离。 考虑如何求树的直径，首先取一个根节点通过bfs找到离他...
2018牛客暑期多校第二场题解
09-28
### 2018牛客暑期多校第二场题解 #### 题目一：健身计划（laofudasuan） **题目大意** 白云正在制定一个健身计划，每秒可以选择步行1米或者跑步k米（k为常数），但不能连续两秒都跑步。当白云累计行走的距离在[L,R...
2020牛客暑期多校第一场讲课笔记版本题解1
08-03
6. 快速幂运算(Brute Force and Exponentiation): 题目中提到了用加法表示乘法，乘法表示指数运算，并预计算B_{i,j} = 2^{W*j} * v_i，然后利用快速幂优化计算，复杂度为O(nm/W + 2^W)，其中W通常取16，可以得到足够...
2020牛客暑期多校集训营第二场题解.pdf
01-20
### 2020牛客暑期多校集训营第二场题解 #### Gromah 题目解析 在本次解析中，我们将逐一探讨各题目的关键算法思想和技术细节。 ### A. All with Pairs (全部配对) 本题讨论了如何利用哈希表来解决一对对字符串的...
2020牛客多校暑期集训营第一场题解.pdf
01-20
### 2020牛客多校暑期集训营第一场题解 #### B-SuffixArray 在构建**B-SuffixArray**时，首先要理解**C_i**的定义：对于字符串**s**中的每一个位置**i**，找到第一个与**s_i**相同且位置大于**i**的位置**j**，...
2019牛客多校第四场 C squence 【单调栈+线段树】
几许情愁的博客
07-30 186
题目链接：https://ac.nowcoder.com/acm/contest/884/C /* 思路：构造一个单调减栈（栈里元素下标增大值增大），把序列 A 添加进去，如果当前 A[i] 比栈头元素小， 将栈头元素弹出，此时以弹出元素为最小的区间就是此时栈头元素的下标和当前 A[i] 下标即i，然后用线段 树来求出这个区间里 B 的前缀和最大的差值。 具体为：假设以当前A[i]为最小的区间...
2019牛客暑期多校训练营（第四场）
qq_27693941的博客
07-30 171
题目C sequence C sequence 题意 求max1≤l≤r≤n{min(a[l…r])×sum(b[l…r])}max_{1\le l\le r\le n}\{min(a [l…r] )×sum(b [l…r])\}max1≤l≤r≤n​{min(a[l…r])×sum(b[l…r])} 。 思路 首先通过单调队列或者单调栈可以求出a[i]作为最小值所影响的范围，再对b求前缀和以...
2019.7.27 牛客多校第四场
TieWay59的博客
07-27 374
index > 牛客多校第四场 概览 题号 标题 通过率 做法 状态 A meeting 585/2015 dp/树上半径 √- B xor 75/809 C sequence 449/2665 D triples I 445/2915 找规律 ○ E triples II 34/83 F merge 4/37 G tree
2019牛客暑期多校训练营（第四场）----E- triples II
weixin_43702895的博客
02-25 160
首先发出题目链接： 链接：https://ac.nowcoder.com/acm/contest/884/E 来源：牛客网 涉及：位运算，容斥定义，dp 点击这里回到2019牛客暑期多校训练营解题—目录贴 题目如下： 代码如下 #include <iostream> using namespace std; typedef long long ll; const int mx = 60; const ll mod = 998244353; ll C[64][64], S[64][64];
2019牛客暑期多校训练营（第四场）C sequence【线段树】【单调栈】
OOOak
07-27 273
题意: 给你2个长度为n的区间 a区间和b区间 区间的值为b区间之和乘以a区间的最小值，要你求出值最大的区间 题目链接： https://ac.nowcoder.com/acm/contest/884/C 题解： 南昌邀请赛 I题原题QAQ 记录下a数组每个点以他为最小值的区间最左边是哪个点，最右边是哪个点，用单调栈进行操作 r[i]表示右边界 l[i]表示左边界 用线段树维护前缀...
2019牛客多校 Round4
weixin_30552811的博客
07-31 69
qq 转载于:https://www.cnblogs.com/lwqq3/p/11279808.html
2020牛客暑期多校训练营（第四场）E Eliminate++ —— 线段树优化
天翼之城的博客
07-20 382
This way 题意： 给你一个长度为n的排列，你每次可以取一个长度为3的子串，然后消掉最大和最小的数，直到最终剩下一个数，问你每个数是否可能是那个数。 题解： 那么我们肯定是枚举每个数，然后查看有多少数大于他，有多少数小于它。如果这些是相同的，那么每次就可以找连续三个数使得有一个大于它，一个小于它，然后直到消到最后。 那么如果不相同，我们就可以消掉连续三个大于它或者连续三个小于它中的两个。接下来用1表示大于当前数，0表示小于。 但是不能每次只看连续的三个相同数，比如11011这个串，就可以先消掉一个0
2018牛客网暑假ACM多校训练赛（第四场）E Skyline 线段树 扫描线
weixin_30297281的博客
07-28 152
原文链接https://www.cnblogs.com/zhouzhendong/p/NowCoder-2018-Summer-Round4-E.html 题目传送门 -https://www.nowcoder.com/acm/contest/142/E 题意 　　给定二维平面上的 $n$ 个点，第 $i$ 个点的坐标是 $(x_i,y_i)$ ，第 $i$ 个点出现的概率是 $a_i\t...
2020牛客多校(第三场)
最新发布
10-02
这段代码是一个用于解决2020牛客多校（第三场）的问题的代码。它使用了C++语言，并且通过输入和输出字符数组来处理数据。代码中使用了一个变量pos来记录开始位置，左移操作是将开始位置设置为pos * x，右移操作是将...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值