「NOIP 2017」解题报告

最新推荐文章于 2021-01-22 11:13:49 发布
最新推荐文章于 2021-01-22 11:13:49 发布
阅读量1.1k 收藏 3
点赞数 1
分类专栏： 学习整理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wyj_jenny/article/details/78518852
版权

整体来说 … 这次考试还是很 NOIP 的 …

D1

T3

wyj 在写最短路计数的时候还写挂了。
所以我们来复习一发最短路计数。

Luogu P1144 最短路计数
（无权图最短路计数，对于重边和自环我们无需处理
（无法到达的点，那么在 bfs 的时候就不会访问所以就一直是 num[] 的初始值。所以当题目要求我们在点无法到达的点输出什么我们把起初值赋成什么

#include <bits/stdc++.h>

using namespace std;
const int N = 1e6 + 5, mod = 1e5 + 3;

struct Edge {
    int to, next;
}e[N << 2];

int cnt = 0;
int head[N];
void add(int x, int y) {
    e[++ cnt].to = y;
    e[cnt].next = head[x];
    head[x] = cnt;
}

int d[N], num[N]; // d[] 是最短路径长度，num[] 是最短路径条数 
queue<int> q;

int main() {
    memset(head, 0, sizeof(head));
    memset(num, 0, sizeof(num));
    memset(d, 0x7f, sizeof(d)); // 一定要初始设为最大值 
    int n, m;
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= m; i ++) {
        int x, y;
        scanf("%d%d", &x, &y);
        add(x, y), add(y, x);
    }
    q.push(1);
    d[1] = 1, num[1] = 1;
    while(!q.empty()) {
        int u = q.front(); q.pop();
        for(int i = head[u]; i; i = e[i].next) {
            int v = e[i].to;
            if(d[v] < d[u]) continue; // 不往自己父亲走避免死循环 
            if(num[v] == 0) {
                d[v] = d[u] + 1;
                num[v] = num[u];
                q.push(v);
            } else if(d[v] == d[u] + 1) {
                num[v] += num[u];
                num[v] %= mod;
            }
        }
    }
    for(int i = 1; i <= n; i ++)
        printf("%d\n", num[i]);
    return 0;
}

Luogu P1608 路径统计
（有权图最短路计数

Luogu P3953 逛公园

#include <bits/stdc++.h>

using namespace std;
const int N = 1e5 + 5, inf = 1 << 30;

inline int read() {
    int ret = 0; char gc = getchar();
    while(gc < '0' || gc > '9') gc = getchar();
    while(gc >= '0' && gc <= '9') ret = ret * 10 + gc - '0', gc = getchar();
    return ret;
}

int n, m, K, p;

struct Edge {
    int to, next, w;
}e1[N << 1], e2[N << 1];

struct point {
    int id, val;
    point(int id, int val): id(id), val(val){}
    bool operator < (const point &x) const {
        return val > x.val;
    }
};

int cnt;
int head1[N], dis1[N], vis1[N], head2[N], dis2[N], vis2[N];

void add(int x, int y, int z) {
    e1[++ cnt].to = y; e1[cnt].next = head1[x]; e1[cnt].w = z; head1[x] = cnt;
    e2[cnt].to = x; e2[cnt].next = head2[y]; e2[cnt].w = z; head2[y] = cnt; 
}

priority_queue <point> q1;
void dijkstra1(int s) {
    for(int i = 1; i <= n; i ++) dis1[i] = inf;

    q1.push(point(s, 0));
    dis1[s] = 0;
    while(!q1.empty()) {
        int cur1 = q1.top().id; q1.pop();

        if(vis1[cur1]) continue;
        vis1[cur1] = 1;

        for(int i = head1[cur1]; i != - 1; i = e1[i].next) {
            int temp1 = e1[i].to;
            if(dis1[cur1] + e1[i].w < dis1[temp1]) {
                dis1[temp1] = dis1[cur1] + e1[i].w;
                q1.push(point(temp1, dis1[temp1]));
            }
        }
    }
}

priority_queue <point> q2;
void dijkstra2(int s) {
    for(int i = 1; i <= n; i ++) dis2[i] = inf;

    q2.push(point(s, 0));
    dis2[s] = 0;
    while(!q2.empty()) {
        int cur2 = q2.top().id; q2.pop();

        if(vis2[cur2]) continue;
        vis2[cur2] = 1;

        for(int i = head2[cur2]; i != - 1; i = e2[i].next) {
            int temp2 = e2[i].to;
            if(dis2[cur2] + e2[i].w < dis2[temp2]) {
                dis2[temp2] = dis2[cur2] + e2[i].w;
                if(dis2[temp2] <= K)
                    q2.push(point(temp2, dis2[temp2]));
            }
        }
    }
}

int tot;
int d[N], que[N << 1];

inline int check() {
    for(int i = 1; i <= n; i ++)
        for(int j = head1[i]; j != - 1; j = e1[j].next) {
            int v = e1[j].to;
            e1[j].w = dis1[i] + e1[j].w - dis1[v];
            if(e1[j].w == 0) d[v] ++;
        }
    for(int i = 1; i <= n; i ++)
        if(!d[i]) que[++ tot] = i;
    for(int i = 1; i <= tot; i ++) {
        int u = que[i];
        for(int j = head1[u]; j != -1; j = e1[j].next) {
            int v = e1[j].to;
            if(e1[j].w == 0) {      
                d[v] --;
                if(!d[v]) que[++ tot] = v;
            }
        }
    }
    for(int i = 1; i <= n; i ++)
        if(d[i] && dis1[i] + dis2[i] <= dis1[n] + K)
            {printf("-1\n"); return false;}
    return true;
}

int f[N][55];

void dp() {
    memset(f, 0, sizeof(f));
    f[1][0] = 1;
    for(int k = 0; k <= K; k ++) {
        for(int i = 1; i <= tot; i ++) {
            int u = que[i];
            for(int j = head1[u]; j != -1; j = e1[j].next) {
                int v = e1[j].to;
                if(e1[j].w == 0) f[v][k] = (f[v][k] + f[u][k]) % p;
            }
        }
        for(int i = 1; i <= n; i ++) {
            for(int j = head1[i]; j != -1; j = e1[j].next) {
                int v = e1[j].to;
                if(e1[j].w != 0 && k + e1[j].w <= K)
                    f[v][k + e1[j].w] = (f[v][k + e1[j].w] + f[i][k]) % p;
            }
        }
    }
}

void mem() {
    tot = 0;
    cnt = 0;
    memset(head1, -1, sizeof(head1)); memset(head2, -1, sizeof(head2));
    memset(vis1, 0, sizeof(vis1)); memset(vis2, 0, sizeof(vis2));
    memset(d, 0, sizeof(d));
}

void work() {
    n = read(), m = read(), K = read(), p = read();
    for(int i = 1; i <= m; i ++) {
        int a, b, c;
        a = read(), b = read(), c = read();
        add(a, b, c);
    }
    dijkstra1(1), dijkstra2(n);
    if(check() == 0) return ;
    dp();
    int ans = 0;
    for(int i = 0; i <= K; i ++)
        ans = (ans + f[n][i]) % p;
    printf("%d\n", ans);
}

int main() {
    int T;
    T = read();
    while(T --) mem(), work();
    return 0;
}

D2

T2

Luogu P3959 宝藏

预备知识：枚举子集的二进制写法

// 枚举 i 的子集
for (int j = i & (i - 1); j; j = i & (j - 1))

这样做就是每次不断 - 1 来枚举所有子集，它不是忽略了 i 中的 0，而是在 & i 的过程中将 0 消去了。

分析：

我们发现每层的边对应的权值都不一样，所以可以按层考虑状压 dp。

我们定义：如果状态 s 的第 k 个位置访问过，则第 k 个位置为 1。
令 f[i][s] 表示第 i 层，到状态 s 的最小花费。
接着枚举 s 子集的补集 s’，作为第 i + 1 层的点，对于 s’ 中每个点，都选择一条连向 s 中最小的边。
可以预处理出 u 到任意集合 s 中的最小的边，所以我们可以按 s 从小带大 dp。
时间复杂度为 O(3n∗n) 。

#include <bits/stdc++.h>
 #define ll long long

 using namespace std;
 const int N = 1005, s = (1 << 12) + 5, inf = 0x7fffffff;

 int a[N][N], f[N][s], w[N][s];
// f[i][s] 表示第 i 层，到状态 s 的最小花费 
// w[i][s] 表示 s 集合到 i 点的最短边
// 如果状态 s 的第 k 个位置访问过，则第 k 个位置为 1 

 int main() {
    int n, m;
    scanf("%d%d", &n, &m);
    for(int i  = 1; i <= n; i ++)
        for(int j = 1; j <= n; j ++)
            a[i][j] = inf;
    for(int i = 1; i <= m; i ++) {
        int x, y, z;
        scanf("%d%d%d", &x, &y, &z);
        if(z < a[x][y]) a[x][y] = a[y][x] = z;
    }
    int sn = (1 << n) - 1;
    for(int i = 1; i <= n; i ++)
        for(int j = 1; j <= sn; j ++) {
            w[i][j] = inf;
            for(int k = 1; k <= n; k ++) if(1 << (k - 1) & j) w[i][j] = min(w[i][j], a[i][k]);
        }
    for(int i = 1; i <= sn; i ++) {
        if(!(i & (i - 1))) continue;
        for(int j = 0; j <= n; j ++) f[j][i] = inf;
        for(int j = i & (i - 1); j; j = i & (j - 1)) {
            ll z = 0;
            for(int k = 1; k <= n; k ++) if(1 << (k - 1) & j) z += w[k][i - j];
            // i - j 是 i 的子集 j 的补集  
            // z 是子集的补集连向子集中所有点的最短边的和 
            for(int k = 1; k <= n; k ++) f[k][i] = min((ll)f[k][i], f[k - 1][i - j] + z * k);
            // f[k - 1][i - j] 是状态为子集的补集的花费，z * k 是状态为子集的花费，和起来就是状态 i 的花费 
        }
    }
    int ans = inf;
    for(int i = 1; i <= n; i ++) ans = min(ans, f[i][sn]);
    printf("%d\n", ans);
    return 0;
 }
T3

Luogu P3960 列队

我们可以用 n + 1 个 Treap 来维护。
用一个 Treap 维护最后一列的位置 treap[0]，其他 n 个 Treap 分别维护每行除最后一列剩余的位置。

然后我们发现维护每一个 Treap 只需要维护他的 root 就好了。
维护 Treap 的时候是在维护他的 root，而对于 Treap 内的每个节点 root 是在维护一个区间。

每次插入就会将根节点的区间分成
如果 k 小于等于左子树大小，左边就完全在左子树里
如果 k 大于等于 左子树大小 + 当前节点大小，那自己和左子树就都在左边
这两种情况之外，就是，v 自己，的一半在 k 左边，一半在 k 右边

还有注意因为节点维护的是一个区间，所以注意一个节点的大小不是 1 了，而是他维护的区间大小 r - l + 1

#include <bits/stdc++.h>

#define ll long long

using namespace std;
const int N = 3e5 + 5;

int n, m, q;

struct Treap {
    struct Node {
        Node *lc, *rc;
        int size, key;
        ll l, r;

        Node(ll l, ll r) : lc(NULL), rc(NULL), size(r - l + 1), l(l), r(r), key(rand()) {}

        inline void maintain() { size = (lc ? lc->size : 0) + (rc ? rc->size : 0) + r - l + 1; }

        inline int lSize() { return lc ? lc->size : 0; }

        inline long long len() {
            return r - l + 1;
        }
    } *root;

    Node *merge(Node *a, Node *b) {
        if (!a && !b) return NULL;
        if (!a) { b->maintain(); return b; }
        if (!b) { a->maintain(); return a; }

        if (a->key > b->key) {
            a->rc = merge(a->rc, b);
            a->maintain();
            return a;
        } else {
            b->lc = merge(a, b->lc);
            b->maintain();
            return b;
        }
    }

    static inline void split(Node *v, int k, Node *&l, Node *&r) {
        if (!v) { l = r = NULL; return; }

        int s = v->lSize();
        if (k <= s) {
            split(v->lc, k, l, r);
            v->lc = r;
            r = v;  
        } else if (k >= s + v->len()) {
            split(v->rc, k - s - v->len(), l, r);
            v->rc = l;
            l = v;
        } else {
            int t = k - s; // 把这个点代表的前 t 个点分裂出来 

            l = new Node(v->l, v->l + t - 1);
            r = new Node(v->l + t, v->r);

            l->lc = v->lc;
            r->rc = v->rc;

            l->maintain();
            r->maintain();

            delete v;

            return ;
        }

        v->maintain();
    }

    Node *erase(int pos) {
        Node *pred, *tmp;
        split(root, pos - 1, pred, tmp);

        Node *target, *succ;
        split(tmp, 1, target, succ);

        root = merge(pred, succ);

        return target;
    }

    void append(Node *v) {
        root = merge(root, v);
    }

} treap[N + 1];

inline void init() {
    Treap::Node *v;
    for (int i = 1; i <= n; i ++)  {
        v = new Treap::Node((long long)(i - 1) * m + 1, (long long)i * m - 1);
        treap[i].root = v;
    }

    v = new Treap::Node(m, m);
    treap[0].root = v;
    for (int i = 2; i <= n; i ++) {
        v = new Treap::Node((long long)i * m, (long long)i * m);
        treap[0].root = treap[0].merge(treap[0].root, v);
    }
}

inline long long solve(int a, int b) {
    long long ans;
    if (b == m) {
        Treap::Node *v = treap[0].erase(a);
        ans = v->l;
        treap[0].append(v);
    } else {
        Treap::Node *v = treap[a].erase(b);
        ans = v->l;
        treap[0].append(v);

        // 最右边一列的第 a 行的点要向前移动   
        Treap::Node *u = treap[0].erase(a);
        treap[a].append(u);
    }

    return ans;

    /*之前的错误写法，删最后一列的时候还要记得合并到这一行前面的 Treap 里 
    Treap::Node *pos, *pos1;

    if (b != m) pos = treap[a].erase(b);   
    pos1 = treap[0].erase(a);    
    if (b == m) pos = pos1;  
    printf("%lld\n", pos->l); // RE
    treap[0].root = treap[0].merge(treap[0].root, pos);
    */
}

int main() {
    scanf("%d%d%d", &n, &m, &q);
    init();
    for (int i = 1; i <= q; i ++) {
        int a, b;
        scanf("%d%d", &a, &b);
        printf("%lld\n", solve(a, b));
    }
    return 0;   
}
Kumii
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【竞赛资讯】NOIP和NOI的区别
weixin_47312141的博客
07-14 4099
【竞赛资讯】NOIP和NOI的区别 NoI：全国青少年信息学奥林匹克竞赛，为了向那些在中学阶段学习的青少年普及计算机科学知识，为了给学校的信息技术教育课程提供动力和新的思路，为了给那些有才华的学生提供相互交流和学习的机会、也为通过竞赛和相关的活动培养和选拔优秀计算机人才，教育部和中国科协委托中国计算机学会举办了全国青少年计算机程序设计竞赛，即全国青少年信息学奥林匹克竞赛（简称NOI）。 NoIp：全国青少年信息学奥林匹克联赛，自1995年至2018年已举办24次。每年由中国计算机学会统一组织。NOIP在同一
NOIP2017提高组 day1
BetaCatiz的博客
07-20 335
1.小凯的疑惑 题目描述 小凯手中有两种面值的金币，两种面值均为正整数且彼此互素。每种金币小凯都有无数个。在不找零的情况下，仅凭这两种金币，有些物品他是无法准确支付的。现在小 凯想知道在无法准确支付的物品中，最贵的价值是多少金币？注意：输入数据保证存在 小凯无法准确支付的商品。 输入格式 两个正整数 aaa 和 bbb，它们之间用一个空格隔开，表示小凯中金币的面值。 输出格式 一个正整数 NNN，表示不找零的情况下，小凯用手中的金币不能准确支付的最贵的物品的价值。 输入输出样例 输入 #1 3 7 输出
【NOIP2017提高组正式赛】宝藏 题解
linweitong2020的博客
01-22 297
【NOIP2017提高组正式赛】宝藏 题解 题目大意 这道题目题目大意就是说，有一个图G=(V,E)G=(V,E)G=(V,E)，求一个子图G′=(V,E′)G'=(V,E')G′=(V,E′)，满足E′=V−1E'=V-1E′=V−1，也就是一棵树。 然后每一次一条边建出来的花费就是长度乘以这条边起点的深度加一。 求最小花费。 解题方法 关键词：状态压缩动态规划 设fi,jf_{i,j}fi,j​表示现在这棵树的深度为iii，整棵树的状态（用0/10/10/1表示）为jjj时，的最小花费。 画一个图好看一
NOIP2017滚粗记
路人黑的纸巾
11-10 2470
NOIP2017 NOIP2017题解：http://blog.csdn.net/enjoy_pascal/article/details/78523496 NOIP2017提高组广东省成绩：http://blog.csdn.net/enjoy_pascal/article/details/78585598 DAY0 游记 经过去年PJ285分压线1=和上个月TG初赛64
NOIP2017年普及组_PDF 试题与解题报告.rar
09-18
首先，"NOIP2017普及组解题报告与参赛总结.pdf"和"noip2017普及组复赛解题报告.pdf"提供了对当年比赛题目的详细解答和分析，这些报告通常由资深教练或参赛者编写，包含了问题的关键思路、解题步骤以及可能的优化方案...
解题报告——noip 2017提高组
11-14
解题报告——noip 2017提高组,初赛提高组，pascal及其解析
NOIP2017普及组复赛解题报告
08-07
NOIP2017普及组复赛结题报告，多有不妥，欢迎批评指正
1.rar（noip2017测试数据）
07-06
【标题】"1.rar（noip2017测试数据）"揭示了这是一个与NOIP比赛相关的测试数据集，存放在一个名为"1.rar"的压缩文件中。NOIP全称为全国青少年信息学奥林匹克联赛（National Olympiad in Informatics in Provinces）...
NOIP2017提高组初复赛试题与题解报告
11-19
【NOIP2017提高组初复赛试题与题解报告】是针对全国青少年信息学奥林匹克联赛（NOIP）2017年提高组竞赛的一份详细解析文档。NOIP是中国计算机学会主办的一项旨在激发青少年对计算机科学兴趣、提升编程能力的比赛。...
NOIP2017提高组数据
10-25
NOIP2017提高组数据，非常好的程序设计竞赛资源，值得下载
【NOIP】一篇正式的NOIP2017总结
MEET YOU FIRST TIME
12-06 2136
NOIP2017
NOIP2017（不算是题解）
xiaoyimi的博客
07-05 1325
老年退役选手来过时口胡一波 小凯的疑惑 考场上的普遍做法就是打表吧，规律还是很好找的 很容易看出答案是a*b-a-b 时间复杂度 比16年的D1T2不知道良心多少。。。 模拟就行了，但还是需要一定的比赛经验的，写完后多拿自制数据试一试，高分还是很容易拿的 逛公园 一开始我只会做DAG的DP，不知道怎么处理环的问题，想用tarjan缩点但发现没有用，后来发现直接记忆化搜索下去就可以了...
NOIP2017 解题报告
hipamp的博客
10-04 147
D1T1 小凯的疑惑 分析 求不能用 ax+by=t(x>0,y>0)ax+by=t (x > 0, y > 0)ax+by=t(x>0,y>0) 表示的最大值 ttt。 我们不妨求最小 t0t_0t0​，满足 t≥t0t\geq t_0t≥t0​时，ttt 恒能用 ax+byax+byax+by 表示。 设 t0=ax+byt_0 = ax + byt0​=a...
【NOIP2017提高组】宝藏
ETO的博客
08-27 2214
                                                  宝藏 题目背景 NOIP2017提高组 DAY2 T2 题目描述 参与考古挖掘的小明得到了一份藏宝图，藏宝图上标出了 n 个深埋在地下的宝藏屋，也给出了这 n 个宝藏屋之间可供开发的 m 条道路和它们的长度。 小明决心亲自前往挖掘所有宝藏屋中的宝藏。但是，每个宝藏屋距离地面都很远，也就是说...
NOIP2017总结
竹摇清影照幽窗
01-24 532
文章目录DAY1小凯的疑惑分析代码时间复杂度分析代码逛公园DAY 2奶酪分析代码宝藏分析代码列队未完待续…… DAY1 小凯的疑惑 分析 都说是一道结论题，如果在考场上直接证不出来，可以先编几组数据找找规律，然后反证，用反证法就简单多了。 值得注意的一点就是要开long long 代码 #include&amp;amp;lt;bits/stdc++.h&amp;amp;gt; using namespace std...
noip2017提高组初赛（答案+选择题题目+个人分析）
热门推荐
Eirlys的博客
06-12 5万+
被学弟学妹们逼着填坑的我瑟瑟发抖... 一、单项选择题（共15 题，每题1.5 分，共计22.5 分；每题有且仅有一个正确选项） 1. 从( )年开始，NOIP 竞赛将不再支持Pascal 语言。 A. 2020 B. 2021 C. 2022 D. 2023 C 这让学Pascal的我感到了一丝不友好…. 2.在8 位二进制补码中，10101011 表示的数是十进制下的( )。 A...
迟来的解题报告——noip 2017提高组
I'm Growing
08-13 1539
题目请去洛谷上找找吧。我不复制粘贴了。 由于差不多有1年了，所以我把6道题全部都重新做了一遍。 所以题解没有看过任何网上的资料……全都是凭借当初的信息构筑起来的。 代码也按照模糊的记忆重写了（部分啦部分=v=）。。   Day1 T1：首先，看出a和b是互质的（虽然当时我并不是马上看出这一点）。 能够被支付的物品价格p满足p=ax+by，其中，x和y都是  非负  （非负！）整数。 ...
noip2017普及组
雪影
02-02 2923
过了这么久才来写博客，也是我这么一段时间都很低迷吧。。。。 老实来说，今年应该是要打提高组的。。。可还是打了普及组。。。 其实最猥琐的还是我连普及都写挂了，作为一个学了两年的人，图论，进阶dp都写过的人，才打了210分，我实在没脸。 现在来讲讲题解吧。 T1成绩 题目描述 牛牛最近学习了C++入门课程，这门课程的总成绩计算方法是： 总成绩=作业成绩×20%+小测成绩×30%+期末考试

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值