2020牛客多校第二场

于 2020-09-03 19:09:48 发布
阅读量97 收藏
点赞数
分类专栏： 2020牛客多校训练
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43555854/article/details/108364439
版权

B 计算几何 三点定圆

  • Boundary
    题意：
    给你n个点，现在确定一个点是原点，让你从n个点里选尽量多的点，让这些点在同一个圆上，问最多的点数是多少。
    n<=2000
    思路：
    注意先要判三点是否共线，然后再求圆。
    n=1的时候特判。
    因为三个点确定一个圆，有因为已经确定了一个原点，所以可以O(n^2)遍历所有的可能，得出圆心，别忘了最后更新ans的时候是res+1，因为是固定了某个点求的，更新答案的时候要把那个固定的点加上。
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const double inf = 1e20;
const double pi = acos(-1.0);
const int maxp = 1010;
const int N=2100;
//Compares a double to zero
int n,x[N],y[N];
int sgn(double x) {
    if (fabs(x) < eps) return 0;
    if (x < 0) return -1;
    else return 1;
}
struct Point {

    double x, y;
    Point() {}
    Point(double _x, double _y) {
        x = _x;
        y = _y;
    }
    bool operator == (Point b) const {
        return sgn(x - b.x) == 0 && sgn(y - b.y) == 0;
    }
    bool operator < (Point b) const {
        return sgn(x - b.x) == 0 ? sgn(y - b.y) < 0 : x < b.x;
    }
    Point operator - (const Point &b) const {
        return Point(x - b.x, y - b.y);
    }
    //点积
    double operator * (const Point &b) const {
        return x * b.x + y * b.y;
    }
    //叉积
    double operator ^ (const Point &b) const {
        return x * b.y - y * b.x;
    }
    Point operator + (const Point &b) const {
        return Point(x + b.x, y + b.y);
    }
    Point operator * (const double &k) const {
        return Point(x * k, y * k);
    }
    Point operator / (const double &k) const {
        return Point(x / k, y / k);
    }
    //逆时针旋转 90 度
    Point rotleft() {
        return Point(-y, x);
    }
    //顺时针旋转 90 度
    Point rotright() {
        return Point(y, -x);
    }
    //绕着 p 点逆时针旋转 angle
    Point rotat(Point p, double angle) {
        Point v = (*this) - p;
        double c = cos(angle), s = sin(angle);
        return Point(p.x + v.x * c - v.y * s, p.y + v.x * s + v.y * c);
    }
    double distance(Point p) {
        return hypot(x - p.x, y - p.y);
    }
}po[N];
struct Line{
    Point s, e;
    Line() {}
    Line(Point _s, Point _e) {
        s = _s;
        e = _e;
    }
    bool operator == (Line v) {
        return (s == v.s) && (e == v.e);
    }
    Point crosspoint(Line v) {
        double a1 = (v.e - v.s) ^ (s - v.s);
        double a2 = (v.e - v.s) ^ (e - v.s);
        return Point((s.x * a2 - e.x * a1) / (a2 - a1),
                     (s.y * a2 - e.y * a1) / (a2 - a1));
    }
};
struct circle{
    Point p;  //圆心
    double r; //半径
    circle(Point _p, double _r){
        p = _p;
        r = _r;
    }
    circle(double x, double y, double _r){
        p = Point(x, y);
        r = _r;
    }
    //三角形的外接圆
    //需要Point的 + / rotate() distance()以及 Line 的 crosspoint()
    //注意：先要判三点不共线
    //利用两条边的中垂线得到圆心
    //测试：UVA 12304
    circle(Point a, Point b, Point c){
        Line u = Line((a+b)/2, ((a+b)/2) + ((b-a).rotleft()));
        Line v = Line((b+c)/2, ((b+c)/2) + ((c-b).rotleft()));
        p = u.crosspoint(v);
        r = p.distance(a);
    }
};

bool sameLine(Point a, Point b, Point c){
    double ax=c.x-a.x, ay=c.y-a.y;
    double bx=c.x-b.x, by=c.y-b.y;
    if(sgn(ax*by-ay*bx)==0)return true;
    return false;
}
int main() {
    ios::sync_with_stdio(false);cin.tie(0);cout.precision(10);cout << fixed;
#ifdef LOCAL_DEFINE
    freopen("input.txt", "r", stdin);
#endif
    cin>>n;
    for(int i=1; i<=n; ++i){
        cin>>x[i]>>y[i];
        po[i]=Point(x[i], y[i]);
    }
    if(n==1) {
        cout<<1<<'\n';
        return 0;
    }
    Point bp=Point(0, 0);
    vector< pair<double, double> > cc;
    int ans=1;
    for(int i=1; i<=n; ++i){
        cc.clear();
        for(int j=i+1; j<=n; ++j){
            if(sameLine(po[i], po[j], bp)) continue;
            circle tmp=circle(bp, po[i], po[j]);
            cc.emplace_back(make_pair(tmp.p.x, tmp.p.y));
        }
        sort(cc.begin(), cc.end());
        int res=1;
        for(int i=1; i<int(cc.size()); ++i){
            if(fabs(cc[i].first-cc[i-1].first)<eps && fabs(cc[i].second-cc[i-1].second)<eps){
                ++res;
            } else{
                res=1;
            }
            ans=max(ans, res+1);
        }
    }
    cout<<ans<<'\n';

#ifdef LOCAL_DEFINE
    cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
#endif
    return 0;
}

直接用map< pair<double, double>, int>也不会被卡,代码如下：

#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const double inf = 1e20;
const double pi = acos(-1.0);
const int maxp = 1010;
const int N=2100;
//Compares a double to zero
int n,x[N],y[N];
int sgn(double x) {
    if (fabs(x) < eps) return 0;
    if (x < 0) return -1;
    else return 1;
}
struct Point {

    double x, y;
    Point() {}
    Point(double _x, double _y) {
        x = _x;
        y = _y;
    }
    bool operator == (Point b) const {
        return sgn(x - b.x) == 0 && sgn(y - b.y) == 0;
    }
    bool operator < (Point b) const {
        return sgn(x - b.x) == 0 ? sgn(y - b.y) < 0 : x < b.x;
    }
    Point operator - (const Point &b) const {
        return Point(x - b.x, y - b.y);
    }
    //点积
    double operator * (const Point &b) const {
        return x * b.x + y * b.y;
    }
    //叉积
    double operator ^ (const Point &b) const {
        return x * b.y - y * b.x;
    }
    Point operator + (const Point &b) const {
        return Point(x + b.x, y + b.y);
    }
    Point operator * (const double &k) const {
        return Point(x * k, y * k);
    }
    Point operator / (const double &k) const {
        return Point(x / k, y / k);
    }
    //逆时针旋转 90 度
    Point rotleft() {
        return Point(-y, x);
    }
    //顺时针旋转 90 度
    Point rotright() {
        return Point(y, -x);
    }
    //绕着 p 点逆时针旋转 angle
    Point rotat(Point p, double angle) {
        Point v = (*this) - p;
        double c = cos(angle), s = sin(angle);
        return Point(p.x + v.x * c - v.y * s, p.y + v.x * s + v.y * c);
    }
    double distance(Point p) {
        return hypot(x - p.x, y - p.y);
    }
}po[N];
struct Line{
    Point s, e;
    Line() {}
    Line(Point _s, Point _e) {
        s = _s;
        e = _e;
    }
    bool operator == (Line v) {
        return (s == v.s) && (e == v.e);
    }
    Point crosspoint(Line v) {
        double a1 = (v.e - v.s) ^ (s - v.s);
        double a2 = (v.e - v.s) ^ (e - v.s);
        return Point((s.x * a2 - e.x * a1) / (a2 - a1),
                     (s.y * a2 - e.y * a1) / (a2 - a1));
    }
};
struct circle{
    Point p;  //圆心
    double r; //半径
    circle(Point _p, double _r){
        p = _p;
        r = _r;
    }
    circle(double x, double y, double _r){
        p = Point(x, y);
        r = _r;
    }
    //三角形的外接圆
    //需要Point的 + / rotate() distance()以及 Line 的 crosspoint()
    //注意：先要判三点不共线
    //利用两条边的中垂线得到圆心
    //测试：UVA 12304
    circle(Point a, Point b, Point c){
        Line u = Line((a+b)/2, ((a+b)/2) + ((b-a).rotleft()));
        Line v = Line((b+c)/2, ((b+c)/2) + ((c-b).rotleft()));
        p = u.crosspoint(v);
        r = p.distance(a);
    }
};

bool sameLine(Point a, Point b, Point c){
    double ax=c.x-a.x, ay=c.y-a.y;
    double bx=c.x-b.x, by=c.y-b.y;
    if(sgn(ax*by-ay*bx)==0)return true;
    return false;
}
int main() {
    ios::sync_with_stdio(false);cin.tie(0);cout.precision(10);cout << fixed;
#ifdef LOCAL_DEFINE
    freopen("input.txt", "r", stdin);
#endif
    cin>>n;
    for(int i=1; i<=n; ++i){
        cin>>x[i]>>y[i];
        po[i]=Point(x[i], y[i]);
    }
    if(n==1) {
        cout<<1<<'\n';
        return 0;
    }
    Point bp=Point(0, 0);
    map< pair<double, double>, int> mp;
    int ans=1;
    for(int i=1; i<=n; ++i){
        mp.clear();
        for(int j=i+1; j<=n; ++j){
            if(sameLine(po[i], po[j], bp)) continue;
            circle tmp=circle(bp, po[i], po[j]);
            mp[make_pair(tmp.p.x, tmp.p.y)]++;
        }
        for(auto it : mp){
            ans=max(ans, it.second+1);
        }
    }
    cout<<ans<<'\n';

#ifdef LOCAL_DEFINE
    cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
#endif
    return 0;
}

C 无向无环图最小链覆盖所有边


题意：
给你一个无向无环图，要用最少的链覆盖所有的边，输出数量，以及每个链的链首和链尾。
思路：
从根节点做一下dfs，得到所有的叶子结点，然后第i个和第i+(len+1)/2个叶子结点配对，如果叶子节点数量是奇数就再加上一条root到中间的叶子结点的链。 

#include <bits/stdc++.h>
using namespace std;
const int N=2*(int)1e5+100;
int n,deg[N];
vector<int> G[N];
vector<int> leaf;
void dfs(int now, int pre){
    if(deg[now]==1){
        leaf.emplace_back(now);
    }
    for(int to:G[now]){
        if(to==pre) continue;
        dfs(to, now);
    }
}
int main() {
    ios::sync_with_stdio(false);cin.tie(0);cout.precision(10);cout << fixed;
#ifdef LOCAL_DEFINE
    freopen("input.txt", "r", stdin);
#endif
    cin>>n;
    for(int i=0; i<n-1; ++i){
        int u,v;
        cin>>u>>v;
        ++deg[u];
        ++deg[v];
        G[u].emplace_back(v);
        G[v].emplace_back(u);
    }
    int root=1;
    for(int i=1; i<=n; ++i){
        if(deg[i]>1){
            root=i;
            break;
        }
    }
    dfs(root, -1);
    int len=int(leaf.size());
    cout<<(len+1)/2<<'\n';
    for(int i=0; i<len/2; ++i){
        cout<<leaf[i]<<' '<<leaf[i+(len+1)/2]<<'\n';
    }
    if(len&1){
        cout<<root<<' '<<leaf[len/2]<<'\n';
    }
#ifdef LOCAL_DEFINE
    cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
#endif
    return 0;
}

D 签到

  • Duration
    题意：
    给你两个用MM：HH：SS表示的时间，现在问你他们之间差了多少秒？
    思路：
    全都化成秒，相减，取绝对值。
#include <bits/stdc++.h>

#define ll long long

using namespace std;

ll a, b, c;
ll s1 = 0, s2 = 0;
char ch1, ch2;

ll myabs(ll x) {return (x < 0 ? -x : x);}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.precision(10);
    cout << fixed;
#ifdef LOCAL_DEFINE
    freopen("input.txt", "r", stdin);
#endif

    cin >> a >> ch1 >> b >> ch2 >> c;
    s1 = a * 3600 + b * 60 + c;
    cin >> a >> ch1 >> b >> ch2 >> c;
    s2 = a * 3600 + b * 60 + c;
    cout << myabs(s2 - s1) << '\n';

#ifdef LOCAL_DEFINE
    cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
#endif
    return 0;
}

F 单调队列 线性求二维gcd

  • Fake Maxpooling
    题意：
    有一个n*m的矩阵，（i，j）的值是lcm（i，j）现在取出所有的k*k的正方形矩阵，每个正方形矩阵里面都有一个最大元素，问所有正方形的最大元素之和是多少？
    思路
    先线性求二维gcd，但这题也没卡暴力。
    然后问题模型就变成了维护所有k*k矩阵的最大值了，这是单调队列的经典题型。
#include <bits/stdc++.h>
using namespace std;
const int N=5050;
int n,m,k,a[N][N],b[N][N];
deque<int> dq;
int main() {
    ios::sync_with_stdio(false);cin.tie(0);cout.precision(10);cout << fixed;
#ifdef LOCAL_DEFINE
    freopen("input.txt", "r", stdin);
#endif
    cin>>n>>m>>k;
    memset(a, 0, sizeof(a));
    memset(b, 0, sizeof(b));
    for(int i=1; i<=n; ++i){
        for(int j=1; j<=m; ++j){
            if(!a[i][j]){
                for(int k=1; k*i<=n && k*j<=m; ++k){
                    a[i*k][j*k]=k; b[i*k][j*k]=i*j*k;
                }
            }
        }
    }
    memset(a, 0, sizeof(a));
    for(int i=1; i<=n; ++i){
        while(!dq.empty()) dq.pop_front();
        dq.push_back(0);
        for(int j=1; j<=m; ++j){
            while(!dq.empty() && j-dq.front()>=k) dq.pop_front();
            while(!dq.empty() && b[i][j]>=b[i][dq.back()]) dq.pop_back();
            dq.push_back(j);
            a[i][j]=b[i][dq.front()];
        }
    }
    long long ans=0;
    for(int j=1; j<=m; ++j){
        while(!dq.empty()) dq.pop_front();
        dq.push_back(0);
        for(int i=1; i<=n; ++i){
            while(!dq.empty() && i-dq.front()>=k) dq.pop_front();
            while(!dq.empty() && a[i][j]>=a[dq.back()][j]) dq.pop_back();
            dq.push_back(i);
            if(i>=k && j>=k) ans+=a[dq.front()][j];
        }
    }
    cout<<ans<<'\n';
#ifdef LOCAL_DEFINE
    cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
#endif
    return 0;
}
whoammiiiiii
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2020牛客暑假多校第二场A. All with Pairs
ACoder
07-13 824
big-small，kmp，AC自动机，dfs序
2020牛客多校第二场总结+反思+题解(BCDFJ)
mumei的博客
07-15 427
题目链接： 2020牛客暑期多校训练营（第二场） 题解 B题Boundary 题意 给你n个点，考虑这选一个经过原点的圆，并且这个圆经过这n个点的个数最多，求这个最多的点数。 题解 这个题的做法挺多的，可以枚举圆心或者半径，也可以枚举圆周角(题解的做法)。 时间复杂度：O(n^2logn) 首先我们需要知道一个定理：三个点可以确定一个圆。 做法一：枚举圆心或者半径 现在我们已知一个原点(0,0)，然后我们可以枚举两个点，然后求出三个点形成的圆的圆心，并记录圆心的最大出现次数， .
2020牛客暑期多校训练营（第二场)
放荡者的茶会
07-17 764
根据难度排序。 可能是最容易看懂得题解? 个人总结向。 如果有什么讲的不清楚的欢迎留言私信交流~ 文章目录D. Duration（签到）F. Fake Maxpooling（单调队列）C. Cover the Tree（dfs序+思维） D. Duration（签到） 题意： 给出两个时分秒表示的时间，问相差多少秒。 思路： 化成秒相减就可以了。 代码: #include<bits/stdc++.h> #define pb push_back #define ld long double #de
【二维线段树（二维区间GCD）】[NOI2012]魔幻棋盘
weixin_30446197的博客
07-09 178
题目描述 分析 这是经典的区间gcd（最大公约数）问题。 差分GCD gcd(a,b)gcd(a,b,c)=gcd(a,b−ka)=gcd(gcd(a,b),c)=gcd(gcd(a,b−a),c)=gcd(gcd(a,b−a),c−k(gcd(a,b−a)))=gcd(gcd(a,b−a),c−b) 所以区间[l,r]的最大公约数等于其差分和第一个数的最...
补题 2020牛客多校第二场
killer_gac的博客
08-12 179
D-Duration 题意 签到题，两个时刻求秒数差 思路 直接计算两个时刻所代表的秒数，求差 代码 #include<bits/stdc++.h> using namespace std; typedef long long ll; const int N=1e5+2; ll gcd(ll a,ll b){return b?(b,a%b):a;} ll qmi(int a,int b,int p){ll res=1;while(b){if(b&1)res=res*a%p;a=a*(
补题 2020牛客多校第三场
killer_gac的博客
08-17 218
A-Clam and Fish 题意 有四种状态： 0：没有鱼没有蛤蜊 1：没有鱼有一只蛤蜊 2：有一条鱼没有蛤蜊 3：有一条鱼和一只蛤蜊 一共有n个阶段，每个阶段做以下四项动作之一： 1.如果有蛤蜊，你可以用蛤蜊做一个鱼饵，这个鱼饵可以在后面的阶段没有鱼的时候钓到鱼 2.如果当前阶段有一条鱼，那么不用鱼饵就能得到一条鱼，你的鱼饵数量不会减少 3.如果你至少有一包鱼饵，那么可以在当前阶段用一包鱼饵钓到一条鱼，之后你的鱼饵数量减一 4.什么都不做 求能钓到的最大鱼饵数 思路 有鱼肯定先钓鱼，如果没有鱼有蛤
2020牛客暑期多校集训营第二场题解.pdf
01-20
2020牛客暑期多校集训营第二场题解.pdf
2020牛客多校暑期集训营第一场题解.pdf
01-20
2020牛客多校暑期集训营第一场题解.pdf
2020牛客暑期多校第一场讲课笔记版本题解1
08-03
6. 快速幂运算(Brute Force and Exponentiation): 题目中提到了用加法表示乘法，乘法表示指数运算，并预计算B_{i,j} = 2^{W*j} * v_i，然后利用快速幂优化计算，复杂度为O(nm/W + 2^W)，其中W通常取16，可以得到足够...
2018牛客暑期多校第二场题解
09-28
2018牛客暑期多校第二场题解
2020牛客多校第二场 B-Boundary（标程详解）
离开那天的博客
08-11 311
B-Boundary题意思路 链接 题意 给定n个二维平面上的点，问哪一个经过原点的圆的边界上包含的所给点最多 思路
2019 牛客 多校赛 第二场
JZK-Keven 的博客
07-30 305
slove 0/10 rank 补题 4/10 ------------------------------------------------------------------ https://ac.nowcoder.com/acm/contest/882#question D、Kth Minimum Clique 题意：给你n个点,每个点都有权值,给出一个n*n的矩阵表...
2020 牛客多校第二场
JZK-Keven 的博客
07-19 334
https://ac.nowcoder.com/acm/contest/5667 RK：227 Solved：3/ 11 UpSolved：10/ 11 A、All with Pairs B、Boundary 考虑同弦所对的圆周角相等，所以我们只需要先枚举一个点A，然后再枚举一个点B，计算∠ABO的大小，然后答案一定是组合数，算一下即可，不过这样存在一些方向上的问题，另一种做法就是先枚举两个点，计算这两个点与原点构成的圆的圆心，圆心的最大值一定是组合数，算一下即可得出答案 https://a..
2020牛客多校第二场（G题）Greater and Greater
Top_xiao的博客
07-17 281
题目描述：给定大小为n的序列A和大小为m的序列B，计算A中所有大小为m的子区间S，满足 Si>=Bi1<=i<=m S_{i} >= B_{i} {1 <= i <= m }Si​>=Bi​1<=i<=m f 是 a 中哪些位置的数大于等于当前数。如果大于 置为1， ans 就是哪些位置满足条件， ans[i] 代表区间 [i, i + m], 是不是满足条件。 用 bitset 搞一下， 直接暴力肯定是不行的， 然后我们考虑到每一个 b[i], 它
牛客多校2020年第二场F-Fake Maxpooling
qq_44641782的博客
07-13 226
题目大意：有一个矩阵A，其中Aij=LCM(i,j)。问在该矩阵中所有的k子矩阵的最大值的和。 解题思路：先暴力求出目标矩阵，然后利用单调栈维护最大值下标。最后将答案加上即可。 代码： #pragma GCC optimize(2) #include <bits/stdc++.h> #include <unordered_map> using namespace std; std::mt19937 rnd(233); #define pp pair<int,int> #d
2020牛客多校第二场 C
qq_45604735的博客
08-02 155
题意就是求出最少的路径，所有路径走过的边加起来就是全部边。 不难知道，最短的方法就是找到两个叶子节点相连，（设总数为叶子节点s）所以下界为ceil（s/2） 对于每一个节点，用dfs序标出序号后，将l1 -> ls/2+1… ls/2 -> ls一定是满足的. 假设s为偶数 大致证明： 对于一个非叶子节点，它儿子中包含的叶子节点序号区间为[L,R], 则： 与它左边直接相连的边一定会被 L<= s/2 ? (lL -> ls/2+L) : (lL-s/2 -> lL) 相连。
倍加福ENA58IL-R-ProfiNET手册(译文)
最新发布
07-11
本手册描述了配备PROFINET接口的Pepperl+Fuchs绝对旋转编码器如何集成到PROFINET网络中。 本手册适用于以下绝对旋转编码器类型： ■■Exx58N-...PN... ■Exx58N-。。。请注意。。。 ■■ENA58IL-...B17 ■ENA58IL-。。。B17
2020牛客多校(第三场)
10-02
这段代码是一个用于解决2020牛客多校（第三场）的问题的代码。它使用了C++语言，并且通过输入和输出字符数组来处理数据。代码中使用了一个变量pos来记录开始位置，左移操作是将开始位置设置为pos * x，右移操作是将...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值