2019牛客多校第二场 A,B,D,E,F,G,H,J

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

A-Eddy Walker

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

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

B-Eddy Walker2

题目链接：https://blog.csdn.net/henucm/article/details/99566371

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

D-Kth Minimum Clique

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

题目大意：给出一个n个顶点的无向加权图，求第k个最小加权群。两个不同的顶点相邻时，顶点的子集称之为团()

思路：bitset优化暴力求和。将每个点的相邻点用bitset表示，然后暴力求团。由于求的是第k小，所以我们将最小的求出来，依次加边，维护优先队列，直到第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<ll,int>
#define clean(a,b) memset(a,b,sizeof(a))
using namespace std;
  
const int MAXN=1e2+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{
    ll SumW;
    bitset<MAXN> G;
    Node(ll _SumW=0,bitset<MAXN> _G=0){
        SumW=_SumW;G=_G;
    }
    friend int operator < (Node a,Node b){
        return a.SumW>b.SumW;
    }
};
bitset<MAXN> MP[MAXN];
int W[MAXN];
int n,k;
 
int main(){
    scanf("%d%d",&n,&k);
    for(int i=0;i<n;++i) scanf("%d",&W[i]);
    for(int i=0;i<n;++i){
        char S[MAXN];scanf("%s",&S);
        for(int j=0;j<n;++j){
            MP[i][j]=S[j]-'0';
        }
    }
    bitset<MAXN> Tmp;Tmp.reset();
    priority_queue<Node> que;que.push(Node(0,Tmp));//从最小的团开始找
    while(que.size()){
        Node u=que.top();que.pop();--k;
//      printf("k=%d,u=(%lld,%d)\n",k,u.SumW,u.top);
        if(k==0){
            printf("%lld\n",u.SumW);
            return 0;
        }Tmp=u.G;
        int Pos=0;
        for(int i=0;i<n;++i){//从最后一个点开始枚举
            if(Tmp[i]) Pos=i+1;
        }
        for(int j=Pos;j<n;++j){
            if(Tmp[j]==0&&((Tmp&MP[j])==Tmp)){
                Tmp[j]=1;
                que.push(Node(u.SumW+W[j],Tmp));
                Tmp[j]=0;
            }
        }
    }printf("-1\n");
}

E-MAZE

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

文少DP+线段树：https://blog.csdn.net/henu_1710252529/article/details/102637240

F-Partition problem

题目链接：https://ac.nowcoder.com/acm/contest/882/F

题目大意：2n个人，分成红队或白队，每个队n人，使得竞争价值最大化。竞争价值是不同对中没对人的竞争价值之和。（任意两人之间的竞争价值之和）。给出一个邻接矩阵，表示的是i，j之间的竞争价值。

思路：枚举第一队的人，刷新竞争价值之和。二进制每一位表示该位置的人是否在1队。然后更新价值。一个二进制枚举题目，n并不大。

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=20+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)

ll KP[MAXN][MAXN];
ll Ans;
int n;

void Solve(ll state,int cnt,int pre,ll Val){
	if(cnt==n/2){
		Ans=max(Ans,Val);
		return ;
	}
	if(n-pre-1+cnt<n/2) return ;
	for(int nxt=pre+1;nxt<n;++nxt){
		ll tempval=Val;
		for(int i=0;i<n;++i){
			if((state>>i)&1) tempval-=KP[nxt][i];
			else tempval+=KP[nxt][i];
		}Solve(state|(1ll<<nxt),cnt+1,nxt,tempval);
	}
}
int main(){
	scanf("%d",&n);n<<=1;
	for(int i=0;i<n;++i){
		for(int j=0;j<n;++j){
			scanf("%lld",&KP[i][j]);
		}
	}
	ll Val=0;
	for(int i=0;i<n;++i){
		Val+=KP[0][i];
	}Ans=0;
	Solve((1<<0),1,0,Val);
	printf("%lld\n",Ans);
}

G-Polygons

题目链接：https://ac.nowcoder.com/acm/contest/882/G

题目大意：给出n条直线，找出这n条直线，判断能够围成的多边形的数量，输出最大最小值，并输出前q个第qi大小的多边形面积。没有输出Invalid question

思路：我们用图的方法解决这道题。将所有的直线之间两两交点做成无向图。遍历每个点，每次找夹角最小的边，然后回归原点后，即可求出所求面积。

如图所示，红点表示的是线线之间的交点，绿线表示双向边。

枚举交点，找到最小回路。走完后删掉这条边(边权置为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 PII pair<int,int>
#define PLL pair<ll,ll>
#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=1e12;
const double PI=acos(-1.0);
const double EPS=1.0e-10;
//unsigned register
// ios::sync_with_stdio(false)
 
/*
最多有n^2个面积
求出交点
对于每条直线求出在这条直线上的交点
相邻的两条之间建立双向有向边
遍历每个点，取相邻的夹角最小的边
返回原点后，这条线即为所求面积。
*/
struct Point{
    int flag;
    double x,y;
    Point(double _x=0,double _y=0,int _flag=1){
        x=_x;y=_y;flag=_flag;
    }
    friend Point operator - (Point a,Point b){
        return Point(a.x-b.x,a.y-b.y);
    }
    friend double operator ^ (Point a,Point b){
        return a.x*b.y-a.y*b.x;
    }
};
struct V{
    Point str,end;
    V(Point _str=Point(0,0),Point _end=Point(0,0)){
        str=_str;end=_end;
    }
    void Input(){
        scanf("%lf%lf%lf%lf",&str.x,&str.y,&end.x,&end.y);
    }
    friend V operator - (V a,V b){
        return V(a.str-b.str,a.end-b.end);
    }
};
struct Node1{
    int v,val,nxt;
    Node1(int _v=0,int _val=1,int _nxt=0){
        v=_v;val=_val;nxt=_nxt;
    }
};
Node1 Edge[MAXN*MAXN<<2];
int Head[MAXN*MAXN],Ecnt;
V Vec[MAXN];
vector<Point> Dots;
vector<int> Line[MAXN];
int Stk[MAXN*MAXN<<2],top;
double Ans[MAXN*MAXN<<2];int tot;
int n,m;
 
void Intt(){
    clean(Head,-1);Ecnt=0;
}
void AddEdge(int u,int val,int v){
    Edge[Ecnt]=Node1(v,val,Head[u]);
    Head[u]=Ecnt++;
}
int Sgn(double x){
    if(fabs(x)<EPS) return 0;
    if(x<0) return -1;
    return 1;
}
int Parellel(V l1,V l2){
    return fabs((l1.end-l1.str)^(l2.end-l2.str))<EPS;
}
Point LineInterDot(V l1,V l2){
    if(Parellel(l1,l2)) return Point(0,0,0);
    Point p=l1.str;p.flag=1;
    double res=((l1.str-l2.str)^(l2.str-l2.end));
    res/=((l1.str-l1.end)^(l2.str-l2.end));
    p.x+=(l1.end.x-l1.str.x)*res;
    p.y+=(l1.end.y-l1.str.y)*res;
    return p;
}
int Cmp1(int a,int b){
    if(Sgn(Dots[a].x-Dots[b].x)==0) return Dots[a].y<Dots[b].y;
    return Dots[a].x<Dots[b].x;
}
int DFS(int u,int fa){
    Stk[++top]=u;
    if(Stk[top]==Stk[1]){//更新Ans
        double area=0;
        for(int i=1;i<top;++i) area+=((Dots[Stk[i]])^(Dots[Stk[i+1]]));
        Ans[++tot]=fabs(area)/2.0;
        return 1;
    }
    int can=-1;
    for(int i=Head[u];i+1;i=Edge[i].nxt){//遍历所有的相邻点，找到叉积最小的那个
        int v=Edge[i].v;
        if(v==fa||Edge[i].val==0) continue;
        if(Sgn((Dots[v]-Dots[u])^(Dots[u]-Dots[fa]))<0&&(can==-1||Sgn((Dots[v]-Dots[u])^(Dots[Edge[can].v]-Dots[u]))<0)){
            can=i;
        }
    }
    if(can==-1) return 0;
    if(DFS(Edge[can].v,u)){//返回原点
        Edge[can].val=0;
        return 1;
    }return 0;
}
int main(){
    scanf("%d",&n);Intt();
    for(int i=1;i<=n;++i) Vec[i].Input();
    for(int i=1;i<=n;++i){//第i条直线和其他直线的交点
        for(int j=i+1;j<=n;++j){
            Point v=LineInterDot(Vec[i],Vec[j]);
            if(v.flag==0) continue;
            //存在交点 i,j线段交点
            Dots.push_back(v);
            Line[i].push_back(Dots.size()-1);
            Line[j].push_back(Dots.size()-1);
        }
    }
    for(int i=1;i<=n;++i){//相邻的链接
        sort(Line[i].begin(),Line[i].end(),Cmp1);
        int len=Line[i].size();
        for(int j=0;j<len-1;++j){
            AddEdge(Line[i][j],1,Line[i][j+1]);
            AddEdge(Line[i][j+1],1,Line[i][j]);
        }
    }
    //得到一个从0开始的点集Dots，点集中的图
    //遍历每个点开始，找到最小回路
    int len=Dots.size();tot=0;
    for(int i=0;i<len;++i){
        for(int j=Head[i];j+1;j=Edge[j].nxt){
        //随机选取一个点作为起始边,向内围成一个多边形
        //删掉这个边
            int v=Edge[j].v;
            top=0;Stk[++top]=i;
            if(Edge[j].val&&DFS(v,i)){
                Edge[j].val=0;
            }
        }
    }sort(Ans+1,Ans+1+tot);
    printf("%d %.6lf %.6lf\n",tot,Ans[tot],Ans[1]);
    int m;scanf("%d",&m);
    while(m--){
        int x;scanf("%d",&x);
        if(x<=tot) printf("%.6lf\n",Ans[tot-x+1]);
        else printf("Invalid question\n");
    }
}

H-Second Large Rectangle

题目链接：https://ac.nowcoder.com/acm/contest/882/H

题目大意：给出一个n*m的01矩阵，找出第二小的全1矩阵。

思路：二维单调栈，枚举每一行，维护一个单增栈，每次记录大小。

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 l,r,h,S;
    Node(int _l=0,int _r=0,int _h=0){
		l=_l;r=_r;h=_h;
	}
    void IntS(){
        S=(r-l+1)*h;
    }
};
Node Area[MAXN][MAXN];
Pair Stk[MAXN];int top;
map<Pair,int> Vis;
char S[MAXN][MAXN];
int A[MAXN][MAXN];
int Sum[MAXN];
int n,m;


int main(){
    scanf("%d%d",&n,&m);
    for(int i=0;i<n;++i) scanf("%s",&S[i]);
    for(int i=0;i<n;++i){
        for(int j=0;j<m;++j) A[i+1][j+1]=S[i][j]-'0';
    }
    for(int i=1;i<=n;++i){
//	   	printf("i=%d\n",i); 
        for(int j=1;j<=m;++j){
            if(A[i][j]) Sum[j]++;
            else Sum[j]=0;
        }
        top=0;
        Stk[++top]=make_pair(-1,0);
        for(int j=1;j<=m;++j){
			while(top>=1&&Stk[top].first>=Sum[j]) --top;
			Area[i][j].l=Stk[top].second+1;
			Area[i][j].h=Sum[j];
			Stk[++top]=make_pair(Sum[j],j);
		}
		top=0;
		Stk[++top]=make_pair(-1,m+1);
		for(int j=m;j>=1;--j){
			while(top>=1&&Stk[top].first>=Sum[j]) --top;
			Area[i][j].r=Stk[top].second-1;
			Stk[++top]=make_pair(Sum[j],j);
		}
        for(int j=1;j<=m;++j) Area[i][j].IntS();
//        for(int j=1;j<=m;++j) printf("j=%d l=%d r=%d h=%d\n",j,Area[i][j].l,Area[i][j].r,Area[i][j].h);
    }
    int fir=0,sec=0;
    for(int i=1;i<=n;++i){
    	Vis.clear();
        for(int j=1;j<=m;++j){
            Pair temp=make_pair(Area[i][j].l,Area[i][j].h);
            if(Vis[temp]) continue;
            Vis[temp]=1;
            if(Area[i][j].S>fir){
                sec=max(fir,max(Area[i][j].S-Area[i][j].h,Area[i][j].S-(Area[i][j].r-Area[i][j].l+1)));
                fir=Area[i][j].S;
                continue;
            }
            if(Area[i][j].S>sec) sec=Area[i][j].S;
//			printf("l=%d,r=%d,h=%d,S=%d\n",Area[i][j].l,Area[i][j].r,Area[i][j].h,Area[i][j].S);
//			printf("fir=%d,sec=%d\n",fir,sec);
        }
    }printf("%d\n",sec);
}

J-Subarray

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

题目大意：有一个1e9长度的全-1数组，现在里面有不超过1e7个1，求有多少个区间数量，区间内之和>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 PII pair<int,int>
#define PLL pair<ll,ll>
#define clean(a,b) memset(a,b,sizeof(a))
using namespace std;
       
const int MAXN=1e6+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-10;
//unsigned register
// ios::sync_with_stdio(false)
 
/*
使用DP求出每段所在的连续段。
每次查询与上次查询的差距==1
从左到右枚举左端点，统计右边比当前值大的个数
*/
int L[MAXN],R[MAXN],Pre[MAXN],Nxt[MAXN];
int Sum[MAXN*30],Cnt[MAXN*30],Lazy[MAXN*30];
int n;
 
int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;++i){
        scanf("%d%d",&L[i],&R[i]);
    }
    Nxt[1]=R[1]-L[1]+1;
    for(int i=2;i<=n;++i) Nxt[i]=max(0,Nxt[i-1]-(L[i]-R[i-1]-1))+R[i]-L[i]+1;
    Pre[n]=R[n]-L[n]+1;
    for(int i=n-1;i>=1;--i) Pre[i]=max(0,Pre[i+1]-(L[i+1]-R[i]-1))+R[i]-L[i]+1;
    ll Ans=0;
    for(int i=1,base=1e7,j;i<=n;i=j+1){
//      printf("i=%d\n",i);
        j=i+1;
        //处理出来足够覆盖的区间[i,j]
        while(j<=n&&Pre[j]+Nxt[j-1]>=L[j]-R[j-1]-1) ++j;--j;
        int left=max(0,L[i]-Pre[i]),right=min(1000000000-1,R[j]+Nxt[j]);
        int pos=i,mi=INF32,mx=0;
        Sum[0]=0;
        //处理出来前缀和，并且将之加和,确定前缀和区间
        for(int k=left;k<=right;++k){
//          printf("k=%d ",k);
            if(k>=L[pos]&&k<=R[pos]) Sum[k-left+1]=Sum[k-left]+1;
            else Sum[k-left+1]=Sum[k-left]-1;
            if(k==R[pos]) ++pos;
            mi=min(mi,Sum[k-left+1]+base);
            mx=max(mx,Sum[k-left+1]+base);
            Cnt[Sum[k-left+1]+base]++;
        }//printf("\n");
        //处理出来比前缀和大的数量
        for(int k=mx-1;k>=mi;--k) Cnt[k]+=Cnt[k+1];
        Ans+=Cnt[base+1];
        //遍历前缀和，求取每个位置比该位置大的数量
        //刷新Lazy标记
        for(int k=left;k<=right;++k){
//          printf("k=%d ",k);
            int tmp=Sum[k-left+1]+base;
            Cnt[tmp+1]-=Lazy[tmp+1];
            Lazy[tmp]+=Lazy[tmp+1]+1;
            Lazy[tmp+1]=0;
            Ans+=Cnt[tmp+1];
        }
        //初始化
        for(int k=mi;k<=mx;++k) Cnt[k]=Lazy[k]=0;
    }printf("%lld\n",Ans);
}

 

永远鲜红の幼月
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
2020牛客暑期多校集训营第二场题解.pdf
01-20
### 2020牛客暑期多校集训营第二场题解 #### Gromah 题目解析 在本次解析中，我们将逐一探讨各题目的关键算法思想和技术细节。 ### A. All with Pairs (全部配对) 本题讨论了如何利用哈希表来解决一对对字符串的...
2019牛客暑期多校训练营（第二场）F-Partition problem(搜索)
cy41的博客
07-21 339
给出2*n个人，以及给出他们之间的关系数值，现在要求将这些人分成两拨，一拨有n个人，然后求 这个最大 爆搜加剪枝。 比赛的时候演了自己一个多小时。。。 我以为那种直接在包含k个1的二进制间进行转移，上一个状态和这个状态只有两个位置的二进制不同，但是这种转移只是按照二进制的字典序从小到大排列的：（转移方法：） //从n个数字中选择k个数字(k<=n); int k; int com...
2019牛客多校第二场 J subarray
binarycopycode
07-22 886
题目链接：https://ac.nowcoder.com/acm/contest/882/J 开场发现咖啡鸡过了，然后发现好像能做，然后用了树状数组2e7*logn，超时，过了20%，之后才去签H的到。 赛后看了一眼题解，发现因为是连续的，直接用数组，不用树状数组，改了一晚上一上午，答案错误，通过率从53%到76%到80%，然后就实在想不到错哪了，弃疗了。 牛逼网友链接：https://ww...
2019牛客暑期多校第二场F（爆搜）
gml1999的博客
07-22 202
https://ac.nowcoder.com/acm/contest/882/F 题意：就是给你2N个人 每个人之间都有竞争力，让你组成两个队，使这两个队之间的所有成员竞争力和最大（本队之间无竞争力） 题解：两种解法：1.起始两队都为空，爆搜的时候每个人都往两队间放一次，算出队内的成员竞争力最小时，队外的竞争和一定最大。2.a队先放一个人，其他人都放b队,预处理出第一个人和其他所有人的竞争力...
2019牛客多校第二场 F
binarycopycode
07-21 229
题目链接：https://ac.nowcoder.com/acm/contest/882/F 队友一开始读错题了，费用流半天。 结果一发搜索过了，加了一些优化剪枝。结果题解比我的还暴力，我的代码跑了1.8s 枚举每一个放在A组还是B组，然后可行性剪枝，后面还没安排的的所有放在A(B)组还不够n，return 最优化剪枝，当前状态总价值是w，sum[i]为v[i][1...n]的和，如果w+...
2019牛客多校第一场J题——Fraction Comparision（大数）
道阻且长，行则将至
07-19 431
题目传送门 大致题意： 依次输入x,a,y,b，比较x/a和y/b的大小，前者大则输出“>”，后者大则输出“<”，相等则输出“=”。 0<=x,y<=10^18 1<=a,b<=10^9 解法一（正解）： 解法二：C/C++高精度大数乘法 #include<stdio.h> #include<iostream> #include<c...
2018牛客暑期多校第二场题解
09-28
### 2018牛客暑期多校第二场题解 #### 题目一：健身计划（laofudasuan） **题目大意** 白云正在制定一个健身计划，每秒可以选择步行1米或者跑步k米（k为常数），但不能连续两秒都跑步。当白云累计行走的距离在[L,R...
2020牛客多校暑期集训营第一场题解.pdf
01-20
### 2020牛客多校暑期集训营第一场题解 #### B-SuffixArray 在构建**B-SuffixArray**时，首先要理解**C_i**的定义：对于字符串**s**中的每一个位置**i**，找到第一个与**s_i**相同且位置大于**i**的位置**j**，...
2020牛客暑期多校第一场讲课笔记版本题解1
最新发布
08-03
6. 快速幂运算(Brute Force and Exponentiation): 题目中提到了用加法表示乘法，乘法表示指数运算，并预计算B_{i,j} = 2^{W*j} * v_i，然后利用快速幂优化计算，复杂度为O(nm/W + 2^W)，其中W通常取16，可以得到足够...
2019牛客暑期多校训练营（第一场）补题记录
KineXence的博客
07-19 519
总结 总结放前面方便之后看自己总体上做的不好的地方，以便改正。 因为在实习，没有那么快开题，一进去后看到J题过的人多，就去做J，结果花了足足1小时才过。之后一直在肝B，以为是一道找规律加递归版逆元公式套过，结果没解出来。然后想套个simpson自适应来找规律，还是莫得办法。到第三个小时心态有点崩，看了概率的F，没积出来，靠，心态崩了。 总的来说，这次应该是提醒下次要全程状态在线，同时一道题如果快...
2019牛客暑期多校训练营（第二场）----J-Subarray
weixin_43702895的博客
09-05 206
首先发出题目链接： 链接：https://ac.nowcoder.com/acm/contest/882/J 来源：牛客网 涉及：分治 点击这里回到2019牛客暑期多校训练营解题—目录贴 题目如下： 代码如下： #include <iostream> #include <cstring> using namespace std; typedef long long ...
2019牛客多校训练第二场题解
dft539533的博客
07-22 110
2019牛客多校训练第二场题解 题目链接 A.Eddy Walker 打表即可发现答案为\(\frac{1}{n-1}\)，注意特判。 证明的话\(1\)~\(n-1\)会均分概率，因为对于这些数来说走法都是一样的:假设当前为\(i\)，而目前走到了\(i-1\)或者\(i+1\)，之后就相当于一条链上的随机游走了。 Code #include <bits/stdc++.h&gt...
2019牛客暑期多校训练营（第二场）J.Subarray
weixin_30825581的博客
08-02 93
题意：给你一个n表示有n段连续的1序列现在问你在总长度为0~1e9-1的范围内有多少个大于0的子段 思路:假设我们统计了当前的前缀和我们显然可以用树状数组维护一下前缀和这样我们可以nlogn算出答案但是对于1e7的数据这样处理肯定会超时所以我们考虑前缀和是一个每次变化都是1的折线 我们可以直接数组模拟lazy来求出答案 #include <bits/std...
2019牛客暑期多校训练营（第二场）E MAZE
henu_1710252529的博客
10-19 221
2019牛客暑期多校训练营（第二场）E MAZE 链接：https://ac.nowcoder.com/acm/contest/882/E 来源：牛客网 题目描述 Given a maze with N rows and M columns, where bijb_{ij}bij​ represents the cell on the i-row, j-th column. If bi,...
2019 牛客多校 第二场 H、Second Large Rectangle
JZK-Keven 的博客
07-20 781
求01矩阵中次大全1矩阵的面积（） -------------------------------- 1、首先我们知道用栈可以解决直方图中的矩形最大面积问题 2、在这个题目中，如果我们将每一行看作直方图的底，自底向上的连续 1 看成高的话，整个题目就变成了 “求 n 个直方图内所有面积的次大值”。 假设原数组是 所以预处理后原数组变成了 然后遍历行，将这一行的值看成每个位置...
原 2019牛客暑期多校训练营（第二场）补题记录
KineXence的博客
07-20 731
文章目录总结A:Eddy WalkerB:Eddy Walker 2H:Second Large Rectangle 总结 自闭场，A、B、F题都没肝出来。今天重感冒，状态不好，烦！ 直接开始补题吧。 A:Eddy Walker 先去开的它，在开题20分钟左右就去写了一个打表的dfs，根据每个数的位置出现的比例与N，M的关系应该可以推出这道题。怎料！这个dfs的算法跑当N>=3的就能跑爆，擦...
2019牛客暑期多校训练营（第一场）F.Random Point in Triangle(几何概型积分求期望)
ftx456789的博客
07-19 740
题意 给你一个三角形的三个点A(x1,y1)A(x_1,y_1)A(x1​,y1​),B(x2,y2)B(x_2,y_2)B(x2​,y2​),C(x3,y3)C(x_3,y_3)C(x3​,y3​) 在三角形ABC上找一点PPP，设E=max{SΔPAB,SΔPBC,SΔPCA}E=max\{ S_{\Delta PAB},S_{\Delta PBC},S_{\Delta PCA} \}E=ma...
2019湖南多校第二场-20190317
打过ICPC/CCPC，学习ACM算法，Linux内核，Openharmony，加油努力开心珍惜
03-17 380
（有问题欢迎提出来 文章目录A：Potato SacksB：Hedwig's LadderC：Hedwig's LadderE：What time is it anyway?F：Left-Right-WinG：The Erdös-Straus ConjectureH：Subprime Fibonacci SequenceJ：Pinemi Puzzles A：Potato Sacks Solved...
牛客暑期多校第二场题解：动态规划与环形DP应用
本资源是2018年牛客暑期多校第二场的ACM题解文档，主要涉及三个编程问题的解题思路和方法。 第一个问题是关于动态规划（Dynamic Programming，简称DP）的应用。题目名为"laofudasuan"，背景是白云健身的模拟。问题...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值