icpc2017南宁

于 2020-10-24 19:26:34 发布
阅读量186 收藏 1
点赞数 1
分类专栏： ACM--比赛补题 文章标签： 1024程序员节
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_49959202/article/details/109264399
版权

文章目录

icpc2017南宁

A. Abiyoyo

题意： 签到水题

**题解： ** 签到水题

代码：

#include<iostream>
#include<cstdio>
using namespace std;
int main(){
    int t,k;
    scanf("%d",&t);
    while(t--){
        scanf("%d",&k);
        for(int i=0;i<k;i++){
            printf("Abiyoyo, Abiyoyo.\n");
        }
        printf("Abiyoyo, yo yoyo yo yoyo.\n");
        printf("Abiyoyo, yo yoyo yo yoyo.\n");
    }
    return 0;
}

I. Rake It In

**题意： ** 给定一个4 * 4的方阵，a和b博弈，每次选择2 * 2的方阵，得到方阵内的数字和，然后将方阵按照逆时针旋转，之后轮到下一个人操作。如果当前是奇数次，那么要让总的和最大，为偶数次，那么要让总的和最小。问最后答案是多少。

题解： 这种规模不是很大的博弈论问题都是通过搜索来完成，可以旋转2 * 2方阵只有9种情况，因此可以搜索时枚举这9种情况，然后如果当前是奇数次，那么取最大值；如果是偶数次，那么取最小值。这种类型的题目之前在其他的区域赛中也有考过，解法类似。

代码：

#include <bits/stdc++.h>

using namespace std;

int const N = 2e5 + 10;
typedef long long LL;

int n, T, m, a[5][5];

int fun(int x, int y) {
    return a[x][y] + a[x + 1][y] + a[x][y + 1] + a[x + 1][y + 1];
}

void change(int x, int y) {
    int t = a[x][y];
    a[x][y] = a[x][y + 1];
    a[x][y + 1] = a[x + 1][y + 1];
    a[x + 1][y + 1] = a[x + 1][y];
    a[x + 1][y] = t;
}

void rechange(int x, int y) {
    int t = a[x][y];
    a[x][y] = a[x + 1][y];
    a[x + 1][y] = a[x + 1][y + 1];
    a[x + 1][y + 1] = a[x][y + 1];
    a[x][y + 1] = t;
}

int dfs(int k) {
    if (k == 2 * n) {
        int minv = 1e9 + 10;
        for (int i = 0; i < 3; ++i) {
            for (int j = 0; j < 3; ++j) {
                minv = min(minv, fun(i, j));
            }
        }
        return minv;
    }

    int minv = 1e9 + 10, maxv = -1;
    for (int i = 0; i < 3; ++i) {
        for (int j = 0; j < 3; ++j) {
            int t = fun(i, j);
            change(i, j);
            int tmp = dfs(k + 1);
            maxv = max(maxv, tmp + t);
            minv = min(minv, tmp + t);
            rechange(i, j);
        }
    }
    return (k & 1)? maxv: minv;
}

int main() {
    cin >> T;
    while(T--) {
        cin >> n;
        for (int i = 0; i < 4; ++i) 
            for (int j = 0; j < 4; ++j)
                cin >> a[i][j];
        cout << dfs(1) << endl;
    }
    return 0;
}

F. The Chosen One

题意： 给定1~n这n个数字，每次删除奇数位上的数字，问最后剩下的数字是多少. 1 < = n < = 1 0 50 1<=n<=10^{50} 1<=n<=1050。

题解： 规律题。找规律可以看出，最后剩下的数字是小于等于n的最大的2的幂次方。因此java使用大数来写。

代码：

import java.io.*;
import java.math.*;
import java.util.*;
import java.text.*;

public class Main {
    public static void main(String[] args) {
        Scanner cin = new Scanner (new BufferedInputStream(System.in));
        int T = cin.nextInt();
        while((T--) != 0) {
            BigInteger n = cin.nextBigInteger();
            BigInteger tmp = new BigInteger("2");
            System.out.println(tmp = tmp.pow(n.bitLength() - 1));
        }
    }
}

H. The Game of Life

题意： 本题是元胞自动机游戏，当前有一个网格，对于网格内的每一个细胞来说，如果其周围（8个方向）活细胞数目小于2或者大于3，那么这个细胞死亡，如果其周围活细胞数目为2，那么这个细胞保持原来的状态；如果周围活细胞数目为3，那么细胞变为存活状态。问细胞繁衍321代后，还剩下多少个活细胞。在繁衍321代的过程中，活细胞数目最多的是哪一代，活细胞数目为多少。

题解： 由于本题的数据规模很小，因此直接模拟321代即可。模拟的话，需要维护一个数组point记录当前所有的活细胞，维护数组tmp记录当前所有活细胞周围的细胞。一个细胞在tmp数组中出现多少次，就表明其周围存活的细胞有多少个。借助这个条件，可以判断一个细胞在当前这代后是否还能存活。同时，如果一个细胞不出现在tmp数组，那么这个细胞必然死亡。然后按照这个思路，去模拟即可。

模拟题一直是本人的弱项，每次看到模拟题都是很抗拒，队里面也没有人写模拟题。以后只能我硬着头皮去好好练模拟题了。加油，攻克模拟题。

代码：

#include <bits/stdc++.h>

using namespace std;

int const N = 1500;
typedef long long LL;
typedef pair<int, int> PII;

int n, T, m;
char mp[N][N];
PII point[N * N], tmp[N * N * 8];
int cnt, tot, Bounds = 500;
int dx[] = {1, 0, -1, 0, 1, 1, -1, -1}, dy[] = {0, 1, 0, -1, 1, -1, 1, -1};
int live[N][N];

void generation() {
    int res = 0;
    // 总的数目为tot：0~tot-1
    for (int i = 0, j = 0; i < tot; ) {
        while(j < tot && tmp[i] == tmp[j]) j++;
        int cur_cnt = j - i;
        if (cur_cnt < 2) {
            live[Bounds + tmp[i].first][Bounds + tmp[i].second] = 0;
        }
        else if (cur_cnt == 2) {
            if (live[Bounds + tmp[i].first][Bounds + tmp[i].second]) {
                point[res++] = tmp[i];
            }
        }
        else if (cur_cnt == 3) {
            live[Bounds + tmp[i].first][Bounds + tmp[i].second] = 1;
            point[res++] = tmp[i];
        }
        else {
            live[Bounds + tmp[i].first][Bounds + tmp[i].second] = 0;
        }
        i = j;
    }
    cnt = res;
}

int main() {
    // freopen("in.txt", "r", stdin);
    cin >> T;
    while(T--) {
        memset(live, 0, sizeof live);
        cin >> n >> m;
        cnt = 0;
        for (int i = 0; i < n; ++i) {
            scanf("%s", mp[i]);
            for (int j = 0; j < m; ++j) 
                if (mp[i][j] == '#') {
                    point[cnt++] = {i, j};
                    live[Bounds+ i][Bounds + j] = 1;
                }
        }

        int a = 0, b = cnt;
        
        for (int ger = 1; ger <= 321; ++ger) {
            tot = 0;
            for (int i = 0; i < cnt; ++i) {
                for (int j = 0; j < 8; ++j) {
                    PII cur = {point[i].first + dx[j], point[i].second + dy[j]};
                    tmp[tot++] = cur;
                }
            }
            sort(tmp, tmp + tot);
            for (int i = 0; i < cnt; ++i) {
                if (*lower_bound(tmp, tmp + tot, point[i]) != point[i]) {
                    live[Bounds + point[i].first][Bounds + point[i].second] = 0;
                }
            }
            
            generation();
            if (cnt > b) {
                a = ger;
                b = cnt;
            }
            if (!cnt) break;
        }
        cout << a << " " << b << " " << cnt << endl;
    }
    return 0;
}

J. Rearrangement

题意： 给定一个2*n的矩阵，问是否能够通过调换矩阵内元素的位置使得任意相邻位置的两个元素和不是3的倍数，如果能的话输出yes，否则输出no。

题解： 由于可以调换任意位置，因此元素初始位置没有用。本题要求相邻元素和为3的倍数，因此可以把所有元素模上3，基本这种题都这么处理。那么所有的元素就只剩下0、1、2，那么只有0和0相邻、1和2相邻会出现3的倍数。因此可以把1和2分别放在各一边，然后使用0来分割。那么考虑0的摆放位置，核心就是0怎么放。

一般这种题目都是分类讨论，讨论0的数目，从0开始讨论。

这里记0、1、2的数目分别为cnt(0)、cnt(1)、cnt(2)。

我们知道一旦cnt(0)>n，那么无论怎么摆放，都会产生3的倍数，因此cnt(0)的上限为n。

那么我们分类讨论：

当cnt(0)==0,那么无论怎么摆放1、2都会相邻，产生3的倍数，但这需要出现1和2

当cnt(0)==1,那么无论怎么摆放1、2都会相邻，但这也需要出现1和2，这个情况可以归类为第一种

当cnt(0)==2,那么cnt(1)和cnt(2)一旦其中一个为偶数，另一个也为偶数，如果是偶数，那么0无论怎么放都会使得1、2相邻

当cnt(0)>=3&&cnt(0)<=n时，无论cnt(1)和cnt(2)多少，都可以将2个0作为挡板，其他的0嵌入到1或者2的堆里，这样就不会产生3

当cnt(0)>n，那么无论0怎么放，0和0都会相邻，产生3的倍数，编写代码即可

按照如山如上的分析，我们可以知道这种题目其实也是一种套路题，从一开始的3的倍数，就有模3的特定处理。对于相邻的问题，就行分块找挡板；对于0数目的讨论，一般都是找上下界，然后逐个分析讨论。

代码：

#include <bits/stdc++.h>

using namespace std;

int const N = 2e5 + 10;
typedef long long LL;

int n, T, m, a[N];

int main() {
    // freopen("in.txt", "r", stdin);
    cin >> T;
    while(T--) {
        scanf("%d", &n);
        int cnt0 = 0, cnt1 = 0, cnt2 = 0;
        for (int i = 1;  i <= n  * 2; ++i) {
            scanf("%d", &a[i]);
            int t = a[i] % 3;
            if (t == 0) cnt0++;
            else if (t == 1) cnt1 ++;
            else if (t == 2) cnt2 ++;
        }
        int flg = 1;
        if (cnt0 <= 1 && cnt1 && cnt2) flg = 0;
        if (cnt0 == 2 && (cnt1 % 2 == 0)) flg = 0;
        if (cnt0 >= n + 1) flg = 0;
        if (flg) printf("YES\n");
        else printf("NO\n");
    }
    return 0;
}

// 0 0 0 1 1 1

L. Twice Equation

题意： 每个测试样例给定一个L，要求找到一个大于等于L的n，满足存在m，使得 2 m ( m + 1 ) = n ( n + 1 ) 2m(m+1) = n(n+1) 2m(m+1)=n(n+1)成立。 1 < = L < = 1 0 190 1<=L<=10^{190} 1<=L<=10190

题解： 分析本题可以看出，满足条件的n值非常稀疏，通过打表可以看出，n的值为：0 3 20 119 696 4059 23660 137903 803760 4684659 27304196 159140519。从上面n的式子可以看出，n满足线性递推式子的性质，使用暴力枚举线性递推的系数，系数从-100枚举到100，暴力代码如下：

#include <bits/stdc++.h>

using namespace std;

int const N = 2e5 + 10;
typedef long long LL;

int n, T, m;

int main() {
    for (int a = -100; a <= 100; ++a) {
        for (int b = -100; b <= 100; ++b) {
            for (int c = -100; c <=100; ++c) {
                for (int d = -100; d <= 100; ++d) {
                // 0 3 20 119 696 4059 23660 137903 803760 4684659 27304196 159140519
                // f[i] = a * f[i - 3] + b * f[i - 2] + c * f[i - 1] + d
                    if (696 == 3 * a + 20 * b + 119 * c + d && 119 == 3 * b + 20 * c + d && 4059 == 20 * a + 119 * b + c * 696 + d && 23660 == 4059 * c + 696 * b + 119 * a + d) {

                        if (137903 == 696 * a + 4059 * b + 23660 * c + d)
                            if (803760 == 4059 * a + 23660 * b + 137903 * c + d)
                                if (4684659 == 803760 * c + 137903 * b + 23660 * a + d)
                                    if (27304196 == 4684659 * c + 803760 * b + 137903 * a + d)
                                        if (159140519 == 27304196 * c + 4684659 * b + 803760 * a + d)
                                            cout << a << " " << b << " " << c << " " << d << endl;
                    }
                        

                }
            }
        }
    }
    return 0;
}

打出来一个式子的系数为：0 -1 6 2(当然其他的系数也可以，比如：1 -7 7 0)，所对应的式子是： f [ i ] = 6 ∗ f [ i − 1 ] − f [ i − 2 ] + 2 f[i] = 6 * f[i - 1] - f[i - 2] + 2 f[i]=6∗f[i−1]−f[i−2]+2(或者： f [ i ] = f [ i − 3 ] − 7 f [ i − 2 ] + 7 f [ i − 1 ] f[i] = f[i - 3] - 7f[i - 2] + 7f[i - 1] f[i]=f[i−3]−7f[i−2]+7f[i−1])。然后对于每一个L，暴力枚举大于等于L的第一个n。

代码：

// f[i] = 6 * f[i - 1] - f[i - 2] + 2
import java.io.*;
import java.math.*;
import java.util.*;
import java.text.*;

public class Main {
    public static void main(String[] args) {
        Scanner cin = new Scanner (new BufferedInputStream(System.in));
        int T = cin.nextInt();
        while((T--) != 0) {
            BigInteger a = new BigInteger("3");
            BigInteger b = new BigInteger("20");
            BigInteger n = cin.nextBigInteger();
            if (n.compareTo(new BigInteger("3")) <= 0) {
                System.out.println("3");
                continue;
            }
            else if (n.compareTo(new BigInteger("20")) <= 0) {
                System.out.println("20");
                continue;
            }
            for (int i = 1; i <= 10000; ++i) {
                BigInteger d = ((b.multiply(new BigInteger("6"))).subtract(a)).add(new BigInteger("2"));
                if (d.compareTo(n) >= 0) {
                    System.out.println(d);
                    break;
                }
                a = b;
                b = d;
            }
        }
    }
}

// f[i] = 7 * f[i - 1] - 7 * f[i - 2] + f[i - 3]
import java.io.*;
import java.math.*;
import java.util.*;
import java.text.*;

public class Main {
    public static void main(String[] args) {
        Scanner cin = new Scanner (new BufferedInputStream(System.in));
        int T = cin.nextInt();
        while((T--) != 0) {
            BigInteger a = new BigInteger("3");
            BigInteger b = new BigInteger("20");
            BigInteger c = new BigInteger("119");
            BigInteger n = cin.nextBigInteger();
            if (n.compareTo(new BigInteger("3")) <= 0) {
                System.out.println("3");
                continue;
            }
            else if (n.compareTo(new BigInteger("20")) <= 0) {
                System.out.println("20");
                continue;
            }
            else if (n.compareTo(new BigInteger("119")) <= 0) {
                System.out.println("119");
                continue;
            }
            for (int i = 1; i <= 10000; ++i) {
                BigInteger d = a.add(c.multiply(new BigInteger("7"))).subtract(b.multiply(new BigInteger("7")));
                if (d.compareTo(n) >= 0) {
                    System.out.println(d);
                    break;
                }
                a = b;
                b = c;
                c = d;
            }
        }
    }
}

M. The Maximum Unreachable Node Set

题意： 给的一张DAG，问这个DAG中可以选出多少个点，这些点互相不可达。

题解: 本题是有重复点的DAG的最小路径覆盖问题。固定套路：传递闭包，然后求最小路径覆盖。本题和《算法竞赛进阶指南》的捉迷藏一题一模一样，看来出题人有点懒呀。

代码：

#include <bits/stdc++.h>

using namespace std;

int n, m;
int const N = 2e2 + 10, M = 3e4 + 10;
int match[N], vis[N], d[N][N];

// 二分匹配
int find(int x) {
    for (int i = 1; i <= n; ++i) {
        if (vis[i] || !d[x][i]) continue;
        vis[i] = 1;
        if (!match[i] || find(match[i])) {
            match[i] = x;
            return true;
        }
    }
    return false;
}

int main()
{
    int T;
    cin >> T;
    while(T--) {
        cin >> n >> m;
        memset(match, 0, sizeof match);
        memset(d, 0, sizeof d);
        // 读入边
        for (int i = 1; i <= m ;++i) {
            int a, b;
            scanf("%d %d", &a, &b);
            d[a][b]  = 1;
        }

        // 传递闭包
        for(int k = 1; k <= n; ++k)
            for (int i = 1; i <= n; ++i)
                for (int j = 1; j <= n; ++j)
                    d[i][j] |= d[i][k] & d[k][j];
        
        int ans = 0;
        // 二分匹配,这里把原来的边i复用为新的边i',因为二分图内左半部分内部不会有连线
        for (int i = 1; i <= n; ++i) {
            memset(vis, 0, sizeof vis);
            if (find(i)) ans++;
        }
        cout << n - ans << endl;
    }
    return 0;
}
「已注销」
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
icpc2017南宁M The Maximum Unreachable Node Set
a free man
10-07 256
Dilworth定理 DAG最大独立集
2023河南ICPC题
09-16
环数的个数，对 998244353 取模。...Page 2 of 16河南省第十四届 ICPC 大学生程序设计竞赛The 2023 ICPC China Henan Provincial Programming Contest2023/05/21Problem C. 结对编程Input file:standard
icpc2017南宁H The Game of Life
a free man
10-07 386
范围大变化小因而暴力优化
2017 ICPC 南宁 区域赛 I Rake It In
一枚空指针的博客
03-05 788
题目链接：点击打开链接题意描述：Alice和Bob在玩一种名为“Rake It In”的游戏，起初有一个4*4的棋盘，每一格为一个1~10的整数，两人轮流行动，各自k次，行动者选择棋盘中某一个2*2的区域，将这四个元素求和，加到最终答案中，并将四个元素按逆时针旋转90度，Alice先行。Alice的目标是最大化最后的答案，Bob相反。请写一个程序计算，在两人都最聪明的情况下，最终答案为多少。解题思...
2017 ACM-ICPC 亚洲区（南宁赛区）英语阅读网络竞赛
22h's Blog
09-26 929
题目链接：2017 ACM-ICPC 亚洲区（南宁赛区）网络赛A. Weather Patterns题意：有四种天气，给你一个4*4的矩阵，a[i][j]表示从天气i转变为天气j的概率，然后又四个询问（两种），第一种是，给你两个观察序列，问你按照这个观察序列转变的概率是多少，第二种是给你i和j，表示连续若干天都是i天气或j天气的期望为多少 解析：求概率，那不就是一直乘么，求期望，那不就是几何分布的
ACM-ICPC 2017 南宁赛区现场赛 A ，Ｆ，Ｈ，Ｊ，Ｌ
布呗之路
08-16 737
Abiyoyo /* * [链接]：https://nanti.jisuanke.com/t/A1530 * * [题意]：复读机 * * [分析]： * * [tricks]: * * [时间复杂度] * * * * * * */ #include <bits/stdc++.h> #define ll long long using name...
icpc2019.pdf
04-03
icpc 基础，推荐一下！
acmicpc world final2017 数据
05-08
【标题】"acmicpc world final2017 数据"涉及的是ACM/ICPC（国际大学生程序设计竞赛）世界总决赛在2017年的比赛数据。这些数据是编程竞赛中用于测试和训练的重要资源，通常包括输入数据、输出数据以及可能的样例测试...
acm-icpc模板
05-02
acm 模板 算法 icpc 用于比赛模板下载，很全
2015 ICPC 长春pdf
11-13
2015 ICPC 长春pdf
2017 ACM-ICPC 南宁站 总结！
NYIST_TC_LYQ的博客
11-28 2576
2017 ACM-ICPC 南宁站 总结  附上榜单：http://acm.gxu.edu.cn/board-2017-regional/  滚完榜后还是有点遗憾，封榜后竟然这么多队过了6题，虽然铜牌是稳的，但没有时间去写H题，反而把M题做出来了，丧失冲银良机。  Day 25  中午到达南宁，外面在下雨，出火车站直接就是地铁站了，两站到达广西大学，然后淋着雨找体育馆报道，领完东西时间
2017 icpc 南宁区域赛 记录
lifelike
11-27 2725
总算摸到了铜牌，也算是一年的努力没有白费。。。。。。 渡劫成功。 周六： 这一天狂风暴雨，冻死人了。 第一次参加icpc，很期待参赛服的样子。 然而期望越大失望越大。。。 这真是我见过的最丑的icpc参赛服 。。 跟湖南省赛的有的一拼。。 下午热身赛，队友没来齐，写了两题后就开始测试评测机了。 然后惊奇的发现1e10都不TLE。 热身赛打完后去和队友会合，然后去食堂吃饭。（广西大学的饭票真
2017 icpc 南宁
ehdhg13455的博客
10-04 345
rerangement 构造 这种任意排列的题目应该往构造的方向去想，此题构造的思路有两个一个是想局部的形态，发现不太好弄，然后想整体，什么东西需要隔开，发现1 和 2 ，0 和 0 需要隔开。于是我们自然想到1放左边，2放右边，中间用2个0来隔开，然后把0穿插放入1和2中。 #include <bits/stdc++.h> using namespace std; int cn...
大学生创业计划书(11)三篇文件.docx
07-11
大学生创业计划书(11)三篇文件.docx
大学生创业计划书(9)三篇文件.docx
07-11
大学生创业计划书(9)三篇文件.docx
清华大学美术学院论文答辩演讲PPT模板
07-11
【作品名称】：清华大学美术学院论文答辩演讲PPT模板 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
大学生创业计划书(17)三套材料.docx
07-11
大学生创业计划书(17)三套材料.docx
BW365_EN_Col62.pdf
最新发布
07-11
BW365_EN_Col62

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值