2016NOIP提高组复赛山东赛区满分选手代码片段汇编

最新推荐文章于 2020-09-01 16:01:32 发布
最新推荐文章于 2020-09-01 16:01:32 发布
阅读量713 收藏 1
点赞数
分类专栏： NOIP 文章标签： noip
toy.cpp
#include <cstdio>
const int MAXN = 100005, MAXL = 13;

int n, m, dir[MAXN];
char name[MAXN][MAXL];

int f(int x){return x ? 1 : -1;}
int main(){
    int i, cur, d, s, delta;
    freopen("toy.in", "r", stdin);
    freopen("toy.out", "w", stdout);
    scanf("%d%d", &n, &m);
    for(i = 0; i < n; ++ i)
        scanf("%d%s", &dir[i], name[i]);
    for(i = 1, cur = 0; i <= m; ++ i){
        scanf("%d%d", &d, &s);
        delta = f(d ^ dir[cur]) * s;
        cur = (cur + delta + n) % n;
    } printf("%s\n", name[cur]);
    return 0;
}
problem.cpp
#include <cstdio>
#include <ctime>
const int MAXN = 2005;

int C[MAXN][MAXN], T, k;

int main(){
    freopen("problem.in", "r", stdin);
    freopen("problem.out", "w", stdout);
    int i, j, n, m;
    scanf("%d%d", &T, &k);
    for(i = 0; i <= 2000; ++ i)
        for(j = C[i][0] = 1; j <= i; ++ j)
            if((C[i][j] = C[i - 1][j] + C[i - 1][j - 1]) >= k)
                C[i][j] -= k;
    for(i = 0; i <= 2000; ++ i)
        for(j = 0; j <= i; ++ j)
            C[i][j] = (C[i][j] ? 0 : 1);
    for(i = 1; i <= 2000; ++ i)
        for(j = 1; j <= 2000; ++ j)
            C[i][j] += C[i - 1][j] + C[i][j - 1] - C[i - 1][j - 1];
    while(T --){
        scanf("%d%d", &n, &m);
        printf("%d\n", C[n][m]);
    } return 0;
}
running.cpp
#include <cstdio>
const int MAXN = 300005, MAXM = 300005, MAXLOG = 21, MAXNODE = MAXN * MAXLOG * 4;

int g[MAXN], ins1[MAXN], ins2[MAXN], del1[MAXN], del2[MAXN];
int nxt[MAXN * 2], edgeSize, nodeSize, rht[MAXNODE];
int to[MAXN * 2], w[MAXN], cnt[MAXNODE], lft[MAXNODE];
int pre[MAXN][MAXLOG], fa[MAXN], dep[MAXN], n, m, ans[MAXN];

void addEdge(int u, int v){
    nxt[++ edgeSize] = g[u];
    to[g[u] = edgeSize] = v;
}
void dfsCalc(int x){
    int p; pre[x][0] = fa[x];
    for(p = 1; (1 << p) < dep[x]; ++ p)
        pre[x][p] = pre[pre[x][p - 1]][p - 1];
    for(p = g[x]; p; p = nxt[p]){
        if(fa[x] == to[p]) continue;
        fa[to[p]] = x;
        dep[to[p]] = dep[x] + 1;
        dfsCalc(to[p]);
    }
}
void sgtIns(int &x, int l, int r, int p, int v){
    if(!x) x = ++ nodeSize;
    cnt[x] += v; if(l == r) return;
    int mid = (l + r) >> 1;
    if(p <= mid) sgtIns(lft[x], l, mid, p, v);
    else sgtIns(rht[x], mid + 1, r, p, v);
}
int merge(int u, int v){
    if(!u) return v;
    if(!v) return u;
    cnt[u] += cnt[v];
    lft[u] = merge(lft[u], lft[v]);
    rht[u] = merge(rht[u], rht[v]);
    return u;
}
void add1(int s, int t, int v){
    sgtIns(ins1[s], 1, 2 * n, v, 1);
    sgtIns(del1[t], 1, 2 * n, v, -1);
}
void add2(int s, int t, int v){
    sgtIns(ins2[s], 1, 2 * n, v + n, 1);
    sgtIns(del2[t], 1, 2 * n, v + n, -1);
}
void getLCA(const int s, const int t){
    if(s == t){
        add1(s, s, dep[s]);
        return;
    } int p, u = s, v = t;
    if(dep[u] > dep[v]){
        for(p = 18; p >= 0; -- p)
            if((dep[u] - (1 << p)) > dep[v])
                u = pre[u][p];
        if(pre[u][0] == v){
            add1(s, t, dep[s]);
            return;
        } u = pre[u][0];
    }else if(dep[v] > dep[u]){
        for(p = 18; p >= 0; -- p)
            if(dep[v] - (1 << p) > dep[u])
                v = pre[v][p];
        if(pre[v][0] == u){
            add2(t, s, dep[s]);
            return;
        } v = pre[v][0];
    }
    for(p = 18; p >= 0; -- p)
        if(pre[u][p] != pre[v][p])
            u = pre[u][p], v = pre[v][p];
    add1(s, pre[u][0], dep[s]);
    add2(t, v, 2 * dep[pre[u][0]] - dep[s]);
}
int sgtQuery(int x, int l, int r, int p){
    if(l == r) return cnt[x];
    int mid = (l + r) >> 1;
    if(p <= mid) return sgtQuery(lft[x], l, mid, p);
    return sgtQuery(rht[x], mid + 1, r, p);
}
void dfsGet(int x){
    int p;
    for(p = g[x]; p; p = nxt[p]){
        if(to[p] == fa[x]) continue;
        dfsGet(to[p]);
        ins1[x] = merge(ins1[x], ins1[to[p]]);
        ins2[x] = merge(ins2[x], ins2[to[p]]);
    }
    ans[x] = sgtQuery(ins1[x], 1, 2 * n, dep[x] + w[x]) + sgtQuery(ins2[x], 1, 2 * n, dep[x] - w[x] + n);
    ins1[x] = merge(ins1[x], del1[x]);
    ins2[x] = merge(ins2[x], del2[x]);
}
inline int getInt(){
    char x; int ret;
    while((x = getchar()) < '0' || x > '9') ;
    ret = x - '0';
    while((x = getchar()) >= '0' && x <= '9')
        ret = ret * 10 - '0' + x;
    return ret;
}
int main(){
    int i, u, v;
    freopen("running.in", "r", stdin);
    freopen("running.out", "w", stdout);
    n = getInt(), m = getInt();
    for(i = 1; i < n; ++ i){
        u = getInt(), v = getInt();
        addEdge(u, v), addEdge(v, u);
    } dep[1] = 1, dfsCalc(1);
    for(i = 1; i <= n; ++ i) w[i] = getInt();
    for(i = 1; i <= m; ++ i){
        u = getInt(), v = getInt();
        getLCA(u, v);
    } dfsGet(1);
    for(i = 1; i <= n; ++ i)
        printf("%d%c", ans[i], i == n ? '\n' : ' ');
    return 0;
}
angrybirds.cpp
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <cstring>
#include <iostream>
using namespace std;
const int MAXN = 19;

int dp[1 << 18], n, type, nxt[MAXN][MAXN];
double x[MAXN], y[MAXN];

int DP(int st){
    if(~dp[st]) return dp[st];
    int &now = dp[st], i, j, cnt = 0, *Nxt;
    now = 10000;
    for(i = 0; i < n; ++ i){
        if(st & (1 << i)) continue; ++ cnt;
        for(j = i + 1, Nxt = nxt[i]; j < n; ++ j){
            if(st & (1 << j)) continue;
            if(!Nxt[j]) continue;
            now = min(now, DP(st | Nxt[j]) + 1);
        }
    } return now = min(now, cnt);
}
void solve(){
    int i, j, t; double k, a, b;
    scanf("%d%d", &n, &type);
    for(i = 0; i < n; ++ i)
        cin >> x[i] >> y[i];
    memset(nxt, 0, sizeof(nxt));
    for(i = 0; i < n; ++ i)
        for(j = i + 1; j < n; ++ j){
            if(fabs(x[i] - x[j]) < 1e-8) continue;
            k = (y[i] - y[j]) / (x[i] - x[j]);
            a = k / x[j] - y[i] / x[i] / x[j];
            b = k - a * (x[i] + x[j]);
            if(a >= 0.0) continue;
            for(t = j + 1, nxt[i][j] = (1 << i) | (1 << j); t < n; ++ t)
                if(abs(a * x[t] * x[t] + b * x[t] - y[t]) < 1e-8)
                    nxt[i][j] |= 1 << t;
        }
    memset(dp, -1, sizeof(dp));
    dp[(1 << n) - 1] = 0;
    printf("%d\n", DP(0));
}
int main(){
    freopen("angrybirds.in", "r", stdin);
    freopen("angrybirds.out", "w", stdout);
    int t; scanf("%d", &t);
    while(t --) solve();
    return 0;
}
classroom.cpp
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;

const int N = 2003;

int dis[303][303], n, m, v, e, c[N], d[N];

double f[N][N][2], k[N];

int main() {
    freopen("classroom.in", "r", stdin);
    freopen("classroom.out", "w", stdout);
    scanf("%d%d%d%d", &n, &m, &v, &e);
    for (int i = 1; i <= n; ++i) scanf("%d", c + i);
    for (int i = 1; i <= n; ++i) scanf("%d", d + i);
    for (int i = 1; i <= n; ++i) scanf("%lf", k + i);
    int a, b, w;
    for (int i = 1; i <= v; ++i)
        for (int j = 1; j <= v; ++j)
            dis[i][j] = 500000000;
    for (int i = 1; i <= e; ++i) {
        scanf("%d%d%d", &a, &b, &w);
        dis[a][b] = min(dis[a][b], w);
        dis[b][a] = min(dis[b][a], w);
    }

    for (int i = 1; i <= v; ++i) dis[i][i] = 0;
    for (int kk = 1; kk <= v; ++kk)
        for (int i = 1; i <= v; ++i)
            for (int j = 1; j <= v; ++j)
                dis[i][j] = min(dis[i][j], dis[i][kk] + dis[kk][j]);

//  for (int i = 1; i <= n; ++i)
//      for (int j = 0; j <= m; ++j)
//          f[i][j][0] = f[i][j][1] = 100000000000000.0;

    f[1][1][1] = f[1][0][0] = 0;
    for (int i = 2; i <= n; ++i)
        for (int j = 0; j <= m; ++j) {
            if (j > i) break;
            if (j < i) {
                if (j > 0) {
                    f[i][j][0] = f[i - 1][j][1] + (1.0 - k[i - 1]) * dis[c[i - 1]][c[i]] + k[i - 1] * dis[d[i - 1]][c[i]];
                    if (j < i - 1)
                        f[i][j][0] = min(f[i][j][0], f[i - 1][j][0] + dis[c[i - 1]][c[i]]);
                } else
                    f[i][j][0] = f[i - 1][j][0] + dis[c[i - 1]][c[i]];
            }
            if (j > 0) {
                if (j > 1) {
                    f[i][j][1] =
                        f[i - 1][j - 1][1]
                        + (1.0 - k[i]) *
                            ((1.0 - k[i - 1]) * dis[c[i - 1]][c[i]] + k[i - 1] * dis[d[i - 1]][c[i]])
                        + k[i] *
                            ((1.0 - k[i - 1]) * dis[c[i - 1]][d[i]] + k[i - 1] * dis[d[i - 1]][d[i]]);
                    if (j < i)
                        f[i][j][1] = min(f[i][j][1],
                            f[i - 1][j - 1][0] + (1.0 - k[i]) * dis[c[i - 1]][c[i]] + k[i] * dis[c[i - 1]][d[i]]);
                } else
                    f[i][j][1] =
                        f[i - 1][j - 1][0] + (1.0 - k[i]) * dis[c[i - 1]][c[i]] + k[i] * dis[c[i - 1]][d[i]];
            }
        }

    double ans = f[n][0][0];
    for (int j = 1; j <= m; ++j) {
        if (j <= n)
            ans = min(ans, f[n][j][1]);
        if (j < n)
            ans = min(ans, f[n][j][0]);
    }
    printf("%.2lf\n", ans);
    return 0;
}
earthworm.cpp
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<cstring>
#include<algorithm>
using namespace std;

const int N=1e5+10;
const int M=7*1e6+10;


int n,m,q,u,v,t;
int a[N],b[M],c[M];
int t1[M],t2[M];
int lb,rb,lc,rc,la;

bool cmp(int a,int b)
{
    return a>b;
}

int check(int ti)
{
    int opt=0;
    int ans;
    if(la<=n) opt=1,ans=(ti-1)*q+a[la];
    if(lb<=rb)
    {
        if(opt==0) opt=2,ans=(ti-t1[lb])*q+b[lb];
        else
        {
            if(ans<(ti-t1[lb])*q+b[lb])
            {
                opt=2;
                ans=(ti-t1[lb])*q+b[lb];
            }
        }
    }
    if(lc<=rc)
    {
        if(opt==0||ans<(ti-t2[lc])*q+c[lc])
        {
            opt=3;
            ans=(ti-t2[lc])*q+c[lc];
        }
    }
    if(opt==1) la++;
    else if(opt==2) lb++;
    else lc++;
    return ans;
}

int main()
{
    freopen("earthworm.in","r",stdin);
    freopen("earthworm.out","w",stdout);
    scanf("%d%d%d%d%d%d",&n,&m,&q,&u,&v,&t);
    for(int i=1;i<=n;i++) scanf("%d",&a[i]);
    sort(a+1,a+n+1,cmp);
    la=lb=lc=1;
    for(int i=1;i<=m;i++)
    {
        long long now=check(i);
        b[++rb]=now*u/v;
        c[++rc]=now-b[rb];
        t1[rb]=t2[rc]=i+1;
        if(i%t==0) printf("%d ",now);
    }
    cout<<endl;
    for(int i=1;i<=n+m;i++)
    {
        int now=check(m+1);
        if(i%t==0) printf("%d ",now);
    }
    fclose(stdin);
    fclose(stdout);
    return 0;
}
Bill_Yin_Tech
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
noip2014山东提高组学生代码
11-19
noip2014复赛山东提高组学生代码，希望对大家有所帮助
NOIP2016普及组与提高组试题：NOIP2016复赛普及组试题&NOIP2016复赛提高组试题
11-20
NOIP2016普及组与提高组试题：NOIP2016复赛普及组试题&NOIP2016复赛提高组试题
NOIP 普及组 考试内容
xiaopangfeiyu的博客
08-07 6528
普及组初赛题A1、普及组复赛题A2。 （一）初赛 初赛全部为笔试，满分100分。试题由四部分组成： 1、选择题 共20题，每题1.5分，共计30分。 普及组20个都是单选题。 2、问题求解题 共2题，每题5分，共计10分。 试题给出一个叙述较为简单的问题，要求学生对问题进行分析，找到一个合适的算法，并推算出问题的解。考生给出的答案与标准答案相同，则得分；否则不得分。 3、程序阅读...
NOIP复赛复习（十）怎样才能拿到高分？
dqcsm1964的博客
11-02 2297
摘要 考场策略和程序测试是信息学竞赛中非常重要的环节，很多优秀的选手在很多比赛中总是会在这两个环节上犯下这样和那样的错误，导致得到的分数和实力不成正比，最后留下了无尽的遗憾。本文将探讨一些这两个环节上值得注意的地方，提出一些可行的方法，分享一些经验，以此希望帮助选手们在比赛中发挥水平，减少失误，告别遗憾。   前言 信息学竞赛本身是一个美好的东西，她包含着奋斗、努力、追求、
NOIP2020年山东省赛区初赛报名开始啦
weixin_39104847的博客
09-01 2152
全国青少年信息学奥林匹克联赛（简称 NOIP）是由中国计算机学会主办的一项全国青少年学科竞赛活动，通过竞赛相互交流，共同提高和从中培养、选拔信息学优秀后备人才。 信息学奥赛和奥数、物理奥赛、化学奥赛、生物奥赛，合称五大科奥赛。奥赛的含金量远超文科类的竞赛比如全国英语竞赛和新概念作文竞赛，也远超五大科其他类型的竞赛。 奥赛整体上分为三个级别:省级联赛、全国竞赛、国际竞赛。信奥如果能进国家集训队，可以直接保送清华北大。国家集训队低一级的NOI金牌和银牌也有机会。另外，更低一级的提高组省一等奖，可以参加清华北大的
NOIP 提高组取得480分以上的成绩有多难?
热门推荐
dqcsm1964的博客
11-09 1万+
不知道为什么LZ以480作为一个分界线。 我觉得NOIP一定程度上也可以反应选手（包括NOI选手）的思维水平和代码能力。 第零个分界线是1=，1=（ZJ除外）凭实力凭运气都可以拿。二者有一即可。 第一个分界线是400 有能力拿400+的选手，可以说初步达到了算法竞赛入门，不是靠运气，对程序设计有一定自己的想法，可以稳拿一等。 正常人类只要有稍微靠谱的指导+大量时间的训
2016NOIP提高组复赛试题day2
12-09
2016NOIP提高组复赛试题day2
NOIP2016 提高组 复赛 换教室
11-26
NOIP2016提高组复赛换教室
NOIP2004-2016提高组复赛历年原题&题解合集
09-04
NOIP2004-2016提高组复赛历年原题&题解合集，精心整理，希望对你有帮助
NOIP2010 提高组 复赛 题解(33页).pdf
09-18
NOIP2010 提高组 复赛 题解(33页).pdf
2016山东省NOI省队集训DAY7 题目题解数据标程 NOIP省选省队集训
04-18
2016山东省NOI省队集训DAY7 题目题解数据标程 NOIP省选省队集训
NOIP2016提高组山寨数据
11-26
NOIP2016 提高组 玩具谜题 天天爱跑步 换教室 组合数问题 蚯蚓 愤怒的小鸟
NOIP2016各省获奖名额及分数线
jz_terry的博客
12-16 8612
全国获奖总数1422人，获奖率21.07% 省份 获奖名额 获奖分数线 香港 7 300 浙江 182 300 山西 1 280 广东 181 270 重庆 23 270 江苏 138 265
NOIP提高组(2018)考试技巧及注意事项
07-24 1421
注意事项： （按照考试解题流程介绍） 考试前 1.保持好的心态 考试前不要过于紧张，可以回忆一下以前考试常用的技巧，易错点和“骗分方法等” 考试中 2.审题： 这一点非常重要，一旦审题错误或者理解错误就可能造成你花很多时间写出来的程序WA,如果检查出来了，你浪费的是时间，如果没有发现，你丢掉的是分数和前途 解决方法：写代码前先把题读懂，读...
2018NOIP 提高组 Day1
int_lyy的博客
11-14 1476
写一波NOIP的题，感觉比我们那时候难多了......可刚刚崔力说我们那一届才是出奇的难..... https://www.luogu.org/contestnew/show/12952 赛题 #A: P5019 铺设道路 说好的T1签到呢...第一题就想了好久。最后发现贪心可做。对于每一个坑，如果小于前一个，填前一个的时候它已经平了；如果大于前一个，加上超出的数值 #include &...
【NOIP 模拟题】[山东多校联合模拟赛 day1 T1] 矩形计数（暴力）
weixin_30636089的博客
08-23 131
1．矩形计数(rect.cpp/c/pas) 【问题描述】 给出圆周上的 N 个点，请你计算出以这些点中的任意四个为四个角，能构成多少个矩形。 点的坐标是这样描述的，给定一个数组v[1..N]，假设圆心为(0，0)，圆的周长 C=∑v[1..N] ，第一个点坐标为(0，C/(2π))。从第一个点开始，顺时针沿圆周走v1个单位长度，此时坐标为第二个点的坐标，再走...
noip2016普及组复赛
ojzha的博客
07-31 8332
2017.7.31 NOIP2016普及组复赛第一题：题目： 买铅笔 codevs题号：5622 时间限制: 1 s 空间限制: 256000 KB题目描述 DescriptionP老师需要去商店买n支铅笔作为小朋友们参加NOIP的礼物。她发现商店一共有 3种包装的铅笔，不同包装内的铅笔数量有可能不同，价格也有可能不同。为了公平起 见，P老师决定只买同一种包装的铅笔。商店不允许将铅笔的包装
node-v12.16.3-x86.msi
最新发布
04-25
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
2016noip提高组复赛试题
10-06
2016年NOIP提高组复赛试题是计算机科学领域的一项竞赛。这些题目旨在考察学生在算法设计和数据结构方面的能力。这些试题通常是开放性的，涉及各种不同的主题和难度级别。 NOIP提高组复赛试题的解答需要学生具备良好的编程能力和思维逻辑能力。学生需要通过分析、设计和实现算法来解决问题。试题通常涉及排序、搜索、图论、动态规划、贪心算法等内容。 在准备复赛试题时，学生需要对各种常见的算法和数据结构进行深入的学习和理解。他们还需要通过练习和解决类似的问题来提高自己的编程能力。 对于复赛试题的解答，学生需要仔细阅读题目并理解其要求。然后，他们需要分析问题的关键点和可能的解决方法。在编写代码时，他们需要考虑算法的效率和代码的可读性。 最后，学生需要进行测试和调试，确保他们的程序在各种情况下都能正确运行。他们还需要评估他们的解决方案的效果，并可能进行优化来改进性能。 总之，2016年NOIP提高组复赛试题是一项考验学生算法和编程能力的竞赛。通过高效的准备和练习，学生可以在这些试题上取得好的成绩。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值