2015-2016 ACM-ICPC, NEERC, Moscow Subregional Contest

最新推荐文章于 2019-05-03 08:05:10 发布
最新推荐文章于 2019-05-03 08:05:10 发布
阅读量1k 收藏
点赞数
分类专栏： 比赛总结 文章标签： 比赛总结
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ok_again/article/details/49593461
版权

A-Anagrams

不知道题意。

//#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<vector>
#include<cmath>
#include<queue>
#include<stack>
#include<set>
#include<map>
#define xx first
#define yy second
#define LL long long
#define MP make_pair
#define INF 0x3f3f3f3f
#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1|1
#define CLR(a, b) memset(a, b, sizeof(a))

using namespace std;

int main()
{
    LL m;
    scanf("%I64d", &m);
    m --;
    vector<LL> v;
    for(LL tmp = 1; tmp * tmp <= m; tmp ++)
    {
        if(m % tmp) continue;
        v.push_back(tmp);
        if(m / tmp != tmp) v.push_back(m / tmp);
    }
    sort(v.begin(), v.end());
    for(int i = 0; i < v.size(); i ++)
    {
        printf("%I64d ", v[i]);
    }
    return 0;
}


C- Colder-Hotter

一个交互题，空间一点，告诉你当前猜的点相对于之前猜的点是否离所求点更近。显然x，y不相关。直接分别二分答案就好了。

//#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<vector>
#include<cmath>
#include<queue>
#include<stack>
#include<set>
#include<map>
#define xx first
#define yy second
#define LL long long
#define MP make_pair
#define INF 0x3f3f3f3f
#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1|1
#define CLR(a, b) memset(a, b, sizeof(a))

using namespace std;

int main()
{
    int x, y = 0, op;
    int l = 0, r = 1000000000;
    printf("%d %d\n", l, y);
    cout.flush();
    scanf("%d", &op);
    while(l < r)
    {
        printf("%d %d\n", r, y);
        cout.flush();
        scanf("%d", &op);
        int mid = (l + r) >> 1;
        if(op == 0) r = mid;
        else l = mid + 1;
        printf("%d %d\n", l, y);
        cout.flush();
        scanf("%d", &op);
    }
    x = l;

    l = 0, r = 1000000000;
    printf("%d %d\n", x, l);
    cout.flush();
    scanf("%d", &op);
    while(l < r)
    {
        printf("%d %d\n", x, r);
        cout.flush();
        scanf("%d", &op);
        int mid = (l + r) >> 1;
        if(op == 0) r = mid;
        else l = mid + 1;
        printf("%d %d\n", x, l);
        cout.flush();
        scanf("%d", &op);
    }
    y = l;
    printf("A %d %d\n", x, y);
    cout.flush();
}


D- Delay Time

知道题意即可。

//#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<vector>
#include<cmath>
#include<queue>
#include<stack>
#include<set>
#include<map>
#define xx first
#define yy second
#define LL long long
#define MP make_pair
#define INF 0x3f3f3f3f
#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1|1
#define CLR(a, b) memset(a, b, sizeof(a))

using namespace std;

int main()
{
    double h1, h2, t1, t2;
    while(scanf("%lf%lf%lf%lf", &h2, &t2, &h1, &t1) != EOF)
    {
        double a = h1 - h2, b = - 2 * h1 * t2 + 2 * h2 * t1, c = h1 * t2 * t2 - h2 * t1 * t1;
        double x1 = (-b + sqrt(b * b - 4 * a * c)) / (2 * a), x2 = (-b - sqrt(b * b - 4 * a * c)) / (2 * a);
        printf("%.6f\n", min(x1, x2));
    }
    return 0;
}

E- Entertainment

大概考虑每个节点位置打架的情况，然后i和j打架，是可以把i和j独立提出来的。没具体做。

G-Garden Gathering

据队友计算，题目描述的距离计算和欧几里得距离相差不超过3？然后我们就枚举了凸包上各个直径一端的10*10的格子。实际上我们交了一下直接凸包直径的两个点也是可以AC的，正确性不详。

#include<map>
#include<vector>
#include<math.h>
#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;

typedef long long LL;
const int maxn = 200100;
const int mx = 1e7;
const double inf = 1e20;

LL sqr(LL x)
{
    return x * x;
}

struct Point
{
    LL x, y;
    Point() {}
    Point(LL x, LL y): x(x), y(y) {}
    void input()
    {
        scanf("%I64d%I64d", &x, &y);
        x += mx, y += mx;
    }
} pnt[maxn], res[maxn], q[maxn];

LL mult(Point sp, Point ep, Point op)
{
    return (sp.x - op.x) * (ep.y - op.y) - (ep.x - op.x) * (sp.y - op.y);
}
bool operator<(const Point &l, const Point &r)
{
    return l.y < r.y || (l.y == r.y && l.x < r.x);
}
int graham(Point pnt[], int n, Point res[])
{
    int i, len, k = 0, top = 1;
    sort(pnt, pnt + n);
    if(n == 0) return 0;
    res[0] = pnt[0];
    if(n == 1) return 1;
    res[1] = pnt[1];
    if(n == 2) return 2;
    res[2] = pnt[2];
    for(i = 2; i < n; i++)
    {
        while(top && mult(pnt[i], res[top], res[top - 1]) >= 0) top--;
        res[++top] = pnt[i];
    }
    len = top;
    res[++top] = pnt[n - 2];
    for(i = n - 3; i >= 0; i--)
    {
        while(top != len && mult(pnt[i], res[top], res[top - 1]) >= 0) top--;
        res[++top] = pnt[i];
    }
    return top;
}

map<LL, int> mp;
vector<int> tp[maxn];

LL gao(Point a)
{
    return a.x * 100000000ll + a.y;
}

LL dist(Point a, Point b)
{
    return sqr(a.x - b.x) + sqr(a.y - b.y);
}

double dist2(Point a, Point b)
{
    LL mi = min(abs(a.x - b.x), abs(a.y - b.y));
    LL mx = max(abs(a.x - b.x), abs(a.y - b.y));
    return 0.0 + mx + sqrt(2.0) * mi - mi;
}

void solve(Point p[], int n)
{
    double res = -inf;
    int j = 1;
    int ans1 = -1, ans2 = -1;
    for(int i = 0; i < n; i++)
    {
        while(fabs(mult(p[(j + 1) % n], p[(i + 1) % n], p[i])) >
                fabs(mult(p[j], p[(i + 1) % n], p[i]))) j = (j + 1) % n;
        int idx = mp[gao(p[j])], idi = mp[gao(p[i])], idi1 = mp[gao(p[(i + 1) % n])];
        for(int k = 0; k < tp[idx].size(); k++)
        {
            int v = tp[idx][k];
            double dis = dist2(q[v], p[i]);
            if(dis > res)
            {
                res = dis;
                ans1 = v, ans2 = idi;
            }
            dis = dist2(q[v], p[(i + 1) % n]);
            if(dis > res)
            {
                res = dis;
                ans1 = v, ans2 = idi1;
            }
        }
    }
    printf("%d %d\n", ans1 + 1, ans2 + 1);
}

int main()
{
    int n;
    while(scanf("%d", &n) != EOF)
    {
        mp.clear();
        for(int i = 0; i < n; i++)
        {
            pnt[i].input();
            q[i] = pnt[i];
            mp[gao(pnt[i])] = i;
            tp[i].clear();
        }
        for(int i = 0; i < n; i++)
        {
            for(int j = pnt[i].x - 5; j <= pnt[i].x + 5; j++)
            {
                for(int k = pnt[i].y - 5; k <= pnt[i].y + 5; k++)
                {
                    if(mp.count(gao(Point(j, k))) != 0) tp[i].push_back(mp[gao(Point(j, k))]);
                }
            }
        }
        int m = graham(pnt, n, res);
        res[m] = res[0];
        solve(res, m);
    }
}

H- Hashing

这题因为a[i]的范围只有256，所以可以想到dp[i]的前驱不会在i-256之前，不然可以中间凭空产生一轮。于是就dp打法好了。

//#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<vector>
#include<cmath>
#include<queue>
#include<stack>
#include<set>
#include<map>
#define xx first
#define yy second
#define LL long long
#define MP make_pair
#define INF 0x3f3f3f3f
#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1|1
#define CLR(a, b) memset(a, b, sizeof(a))

using namespace std;

const int maxn = 100100;

int a[maxn], b[maxn][266];
int n;

LL dp[maxn][266];

void solve()
{
    CLR(dp, -1);
    dp[0][0] = 0;
    b[0][0] = -1;
    LL ans = 0;
    for(int i = 1; i <= n; i ++)
    {
        for(int j = 0; j < 256; j ++) if(dp[i - 1][j] != -1)
            {
                int k = (j + 1) % 256;
                if(dp[i - 1][j] + (a[i] ^ (b[i - 1][j] + 1)) > dp[i][k])
                {
                    dp[i][k] = dp[i - 1][j] + (a[i] ^ (b[i - 1][j] + 1));
                    b[i][k] = b[i - 1][j] + 1;
                }
                if(dp[i - 1][j] > dp[i][j])
                {
                    dp[i][j] = dp[i - 1][j];
                    b[i][j] = b[i - 1][j];
                }
            }
    }
    for(int i = 0; i < 256; i ++)
        ans = max(ans, dp[n][i]);
    printf("%I64d\n", ans);
}

int main()
{
    while(scanf("%d", &n) != EOF)
    {
        for(int i = 1; i <= n; i ++)
        {
            scanf("%X", &a[i]);
        }
        solve();
    }
    return 0;
}

I- Illegal or Not?

水题。

//#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<vector>
#include<cmath>
#include<queue>
#include<stack>
#include<set>
#include<map>
#define xx first
#define yy second
#define LL long long
#define MP make_pair
#define INF 0x3f3f3f3f
#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1|1
#define CLR(a, b) memset(a, b, sizeof(a))

using namespace std;

int cnt[2000];

pair<int,int> mp[2000];

int main(){
    int n;
    while(scanf("%d",&n)!=EOF){
        for(int i=0;i<n;i++){
            int u,v;scanf("%d%d",&u,&v);
            mp[i]=MP(u,v);
        }
        sort(mp,mp+n);
        memset(cnt,0,sizeof(cnt));
        for(int i=0;i<n;i++){
            for(int j=mp[i].first;j<=mp[i].second;j++) cnt[j]=1;
        }
        for(int i = 1; i <= 1826; i ++)
        {
            cnt[i] += cnt[i - 1];
        }
        bool ok = true;
        for(int i = 180; i <= 1826; i ++)
        {
            int tmp = cnt[i] - cnt[i - 180];
            if(tmp > 90) ok = false;
        }
        if(ok) puts("Yes");
        else puts("No");
    }
    return 0;
}

K- King's Rout

题意是让求是得小id尽量靠前，其实就是倒着拓扑的最大字典序。

#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<vector>
#include<cmath>
#include<queue>
#include<stack>
#include<set>
#include<map>
#define xx first
#define yy second
#define LL long long
#define MP make_pair
#define INF 0x3f3f3f3f
#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1|1
#define CLR(a, b) memset(a, b, sizeof(a))

using namespace std;

const int maxn = 200200;

vector<int> G[maxn];
int du[maxn];
int ans[maxn];

int n, m;

void solve()
{
    int len = n;
    priority_queue<int> Q;
    for(int i = 1; i <= n; i ++)
    {
        if(du[i] == 0) Q.push(i);
    }
    while(!Q.empty())
    {
        int u = Q.top();
        Q.pop();
        ans[len --] = u;
        for(int i = 0; i < G[u].size(); i ++)
        {
            int v = G[u][i];
            du[v] --;
            if(du[v] == 0) Q.push(v);
        }
    }
    for(int i = 1; i <= n; i ++)
        printf("%d%c", ans[i], i == n ? '\n' : ' ');
}

int main()
{
    while(cin >> n >> m)
    {
        CLR(du, 0);
        for(int i = 0; i <= n; i ++)
        {
            G[i].clear();
        }
        for(int i = 0; i < m; i ++)
        {
            int a, b;
            scanf("%d%d", &a, &b);
            G[b].push_back(a);
            du[a] ++;
        }
        solve();
    }
    return 0;
}



ok_again
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【训练记录】2015-2016 ACM-ICPC, NEERC, Northern Subregional Contest
执子之手,与子偕老
03-27 247
trac 补题 I题 给出m个(ai,bi,ci)，要求bi的排名在ai和ci之间 保证一定有合法的排名顺序符合要求 要求构造一个排名顺序 使得至少满足m / 2个三元组的关系 n,m<=1e5 题解 感谢wxh大佬 我们先求一个类似拓扑序的东西，要求bi不能同时出现在ai和ci的前面。（因为合法，所以有解） 按拓扑序倒着做，每个三元组在最后一个元素处考虑。那么最后一个元素要么是ai，...
2015-2016 ACM-ICPC, NEERC, Moscow Subregional Contest H题： Hashing [基础DP]
Asuna_acmer
10-24 1108
给出N个16进制的数，从中选出一个序列，问Σ j^(a[i]) 最大是多少，a[I]是选出来的数，j是这个数在序列中是第J个（从0开始计数）
2015-2016 ACM-ICPC, NEERC, Moscow Subregional Contest（K. King's Rout）（拓扑排序）
piaocoder
06-02 696
King's Rout 题目链接： http://codeforces.com/gym/100792/problem/K 解题思路： 将顺序反过来，然后再求拓扑排序。注意：最后将结果倒着输出。 AC代码： #include using namespace std; const int N = 200005; int n,m; int indegree[N]; priority_
2015-2016 ACM-ICPC, NEERC, Moscow Subregional Contest A
ACM, deep love
08-29 946
A. Anagrams time limit per test1 second memory limit per test512 megabytes inputstandard input outputstandard output Consider the positional numeral system with a given base b. A positive integer
Gym - 100792A Anagrams （2015-2016 ACM-ICPC, NEERC, Moscow Subregional Contest)
床前明月光
09-22 570
手推规律 题意是 ： 在 B 进制下 找到所有的 K， 满足所有 K 的十进制下的整数倍的一个数 M ，转化成 B 进制后对应的数位重新排列的数转化成十进制还是 K 的整数倍 推出来的规律 就是 给定的 n 减去 1 的所有因子 #include #include #include #include #include #include #include #include
2017-2018 ACM-ICPC, NEERC, Southern Subregional Contest G. Orientation of Edges
mMingfunnyTree的博客
10-21 706
G. Orientation of Edges time limit per test3 seconds memory limit per test256 megabytes inputstandard input outputstandard output Vasya has a graph containing both directed (oriented) and undirect
2013-2014 ACM-ICPC, NEERC, Moscow Subregional Contest （2013区域赛练习）
Nicolas
10-29 4058
比赛链接：http://codeforces.com/gym/100257 比赛出了A,B,H,I,   队友在比赛中恶搞K题TLE，导致F题没时间调试，赛后加了一句flag = 0，F题就AC了，一个小细节没注意。 F题 是一半模拟  一半DP， 代码在下面。 #include #include #include #include #include #include #
2015-2016 ACM-ICPC Northeastern European Regional Contest 标程
08-23
【标题】"2015-2016 ACM-ICPC Northeastern European Regional Contest 标程" 提供的是一个编程竞赛的参考资料，这是一场由ACM（Association for Computing Machinery）主办的国际大学生程序设计竞赛（International...
Gym - 101411H Hotel in Ves Lagos 数位DP 2009-2010 ACM-ICPC, NEERC, Western Subregional Contest
J. Cole
07-19 681
http://codeforces.com/gym/101411/attachments Problem H. Hotel in Ves Lagos Input le: hotel.in Output le: hotel.out Time limit: 1 second Memory limit: 256 megabytes A new hotel is being bui
2015-2016 ACM-ICPC, Central Europe Regional Contest (CERC 15)F
Soul
05-03 570
题意：给你F[1,i]和F[i,1] 接着有递推式F[i, j] = a ∗ F[i, j − 1] + b ∗ F[i − 1, j] + c.让你计算F[n,n] 题解：这题F[1,i]的贡献很显然是,F(i,1)的贡献同理 对于c的贡献我们每个点都计算很显然不好求我们可以做如下操作 并且那么 我们解得并且那么我们就可以得出以下式子 然后打个表就可以O(n)计算每个点的贡献 ...
2015-2016 ACM-ICPC, NEERC, Moscow Subregional Contest K题：King's Rout [topo排序]
Asuna_acmer
10-24 928
给出N个点，M条有向边，求字典序最小的topo排序，注意有重边，且不一定连通。
2015-2016 ACM-ICPC, NEERC, Moscow Subregional Contest C. Colder-Hotter
Mr.Phoebe的专栏
10-22 1153
交互题首先三分x坐标，然后因为三分不准确，所以在附近震荡求精确值。 其次同样的方法求出y坐标。注意，询问次数的上限是500。 每次询问的时候，(x,y)(x,y)的两个坐标必须在[0,1E9][0,1E9]之间。// whn6325689 // Mr.Phoebe // http://blog.csdn.net/u013007900 #include <algori
2015-2016 ACM-ICPC, NEERC, Moscow Subregional Contest K
ACM, deep love
08-29 771
K. King’s Rout time limit per test4 seconds memory limit per test512 megabytes inputstandard input outputstandard output The great rout will be held this evening in the palace of his majesty Nassa
2015-2016 ACM-ICPC, NEERC, Moscow Subregional Contest G题： Garden Gathering [线段树/最小曼哈顿距离生成树]
Asuna_acmer
10-24 1570
在求解曼哈顿最小距离生成树的时候，有一个求解在曼哈顿距离意义下的最近点对的过程，和这个原理相同，可以求解在这张图意义下的最远点对。
2015-2016 ACM-ICPC, NEERC, Moscow Subregional Contest A题：Anagrams [打表/规律题]
Asuna_acmer
10-24 867
观察样例发现有一定规律，打表找规律进行求解。
2015-2016 ACM-ICPC, NEERC, Moscow Subregional Contest C题：Colder-Hotter [三分/交互题]
Asuna_acmer
10-24 854
判断程序首先生成一个坐标 X,Y，你可以进行询问，每一次询问，他都会返回0/1，如果你的点比上一个点更逼近生成坐标，则会返回1，否则0；至多500次询问。
2015-2016 ACM-ICPC, NEERC, Moscow Subregional Contest I题：Illegal or Not? [暴力题]
Asuna_acmer
10-24 758
给出N个线段，问你1到1826范围内，是否有连续的一段（长度固定为180），含有其余线段的部分总长超过90（同一块不重复Count）
2016-2017 ACM-ICPC, NEERC, Moscow Subregional Contest Problem L. Lazy Coordinator
10-03 189
题目来源：http://codeforces.com/group/aUVPeyEnI2/contest/229511 时间限制：1s 空间限制：512MB 题目大意： 给定一个n 随后跟着2n行输入 "+ t":表示在t时刻获得了一样东西 "- t":表示在t时刻使用了一样东西 求每件东西等待时间的期望（得到的东西无先后顺序） 数据范围： 1 ≤ n ≤ 100 000 t ≤ 1e9 ...
ACM ICPC 2015 Moscow Subregional Russia, Moscow, Dolgoprudny, October, 18, 2015 G. Garden Gathering
anmob303090的博客
12-25 212
Problem G. Garden Gathering Input file: standard input Output file: standard output Time limit: 3 seconds Memory limit: 512 megabytes Many of you may have been to St. Petersburg, but have you vis...
上海交大ACM-ICPC标准代码库：算法与数据结构
"上海交大ACM-ICPC模板是由上海交通大学计算机科学与工程系的Hao Yuan在2003年10月23日编写的，它包含了一个标准的代码库，专为参加ACM国际大学生程序设计竞赛（ACM-ICPC）的团队准备。这个模板涵盖了算法和数据结构...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值