The 10th Jimei University Programming Contest

最新推荐文章于 2024-07-17 23:24:38 发布
最新推荐文章于 2024-07-17 23:24:38 发布
阅读量560 收藏 6
点赞数 3
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zjdysq/article/details/136346520
版权
文章讨论了几个编程竞赛中的问题，包括A+B问题的枚举算法、使用Dijkstra算法求解最短路径，染色问题的组合计数，时间复杂度分析，以及并查集在兄弟校问题中的应用。
摘要由CSDN通过智能技术生成

文章目录

A. A+B问题

由于数据范围较小，所以直接从小到大枚举可能的 X X X进制，注意判断 X X X要大于题目中出现的最大值，若遇到符合题意的值就退出循环，时间复杂度 O ( 300 T ) O(300T) O(300T)

#include <bits/stdc++.h>
#define int long long
#define YES "YES"
#define NO "NO"
#define all(a) a.begin(), a.end()
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef __int128 lll;
typedef __uint128_t ulll;
typedef pair<int, int> pii;
const double eps = 1e-9;
const int N = 2e6 + 10;
const int INF = 1e16;
const int mod = 1e9 + 7;
mt19937_64 rng(std::chrono::steady_clock::now().time_since_epoch().count());
void solve()
{
    string x, y, z;
    cin >> x >> y >> z;
    for(int i = 2;i <= 300;i++)
    {
        int ans = 0;
        int t1 = 0, t2 = 0, t3 = 0;
        int p;
        for(auto c : x)
        {
            if(c >= '0' && c <= '9')
            p = c - '0';
            else
            p = c - 'A' + 10;
            ans = max(ans, p);
            t1 = t1 * i + p;
        }
        for(auto c : y)
        {
            if(c >= '0' && c <= '9')
            p = c - '0';
            else
            p = c - 'A' + 10;
            ans = max(ans, p);
            t2 = t2 * i + p;
        }
        for(auto c : z)
        {
            if(c >= '0' && c <= '9')
            p = c - '0';
            else
            p = c - 'A' + 10;
            ans = max(ans, p);
            t3 = t3 * i + p;
        }
        if(t1 + t2 == t3 && ans < i)
        {
            cout << i << '\n';
            return;
        }
    }
}
signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int t = 1;
    cin >> t;
    while (t--)
    solve();
    return 0;
}

B. 看比赛

由于每次走的路都是选择最快的路，所以每一步一定都在某条最短路上

所以先用 d i j k s t r a dijkstra dijkstra正反都跑一遍最短路，如果 d 1 [ v ] + d 2 [ u ] + w = d 1 [ n ] d1[v] + d2[u] + w = d1[n] d1[v]+d2[u]+w=d1[n]，说明 v v v和 u u u之间的路一定是最短路上的某一段，保留，通过这样的方法，我们可以删除除最短路外的其它路径，且重新构造的图为没有环的有向图

然后看如何取胜，如果某人已经到达了节点 u u u而且 u u u与 n n n相连，对这个人来说 u u u节点是他的必胜节点，所以我们从终点往起点走，如果 1 1 1节点有出现过 M M M的必胜态，则 M M M胜利，不然 I I I胜利，由于必胜态的相邻节点是必输态，所以用拓扑排序就能解决问题，时间复杂度 O ( n l o g m ) O(nlogm) O(nlogm)

#include <bits/stdc++.h>
#define int long long
#define YES "YES"
#define NO "NO"
#define all(a) a.begin(), a.end()
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef __int128 lll;
typedef __uint128_t ulll;
typedef pair<int, int> pii;
typedef vector<int> vi;
const double eps = 1e-9;
const int N = 2e6 + 10;
const int INF = 1e16;
const int mod = 1e9 + 7;
mt19937_64 rng(std::chrono::steady_clock::now().time_since_epoch().count());
void solve()
{
    int n, m;
    cin >> n >> m;
    vector<array<int, 3>> edge;
    vector<vector<pii>> e(n + 5);
    for(int i = 1;i <= m;i++)
    {
        int u, v, w;
        cin >> u >> v >> w;
        edge.push_back({u, v, w});
        e[u].push_back({v, w});
        e[v].push_back({u, w});
    }
    auto dij = [&](int x) {
        vi dis(n + 1, INF);
        vi vis(n + 1, 0);

        dis[x] = 0ll;
        priority_queue<pii, vector<pii>, greater<pii>> q;
        q.emplace(0, x);
        while (!q.empty()) {
            auto [d, u] = q.top();
            q.pop();
            if (vis[u]) continue;
            vis[u] = 1;
            for (auto [v, w]: e[u]) {
                if (dis[v] <= d + w)continue;
                dis[v] = d + w;
                q.emplace(dis[v], v);
            }
        }
        return dis;
    };
    vector<int> d1, d2;
    d1 = dij(1);
    d2 = dij(n);
    vector<vector<int>> ne(n + 5);
    vector<int> cnt(n + 5), f(n + 5);
    for(auto [u, v, w] : edge)
    {
        if(d1[v] + w + d2[u] == d1[n])
        {
            ne[u].push_back(v);
            cnt[v]++;
        }
        if(d1[u] + w + d2[v] == d1[n])
        {
            ne[v].push_back(u);
            cnt[u]++;
        }
    }
    queue<int> q;
    q.push(n);
    while(!q.empty())
    {
        int fr = q.front();
        q.pop();
        for(auto u : ne[fr])
        {
            if(f[fr] == 0)
            f[u] = 1;
            cnt[u]--;
            if(cnt[u] == 0)
            q.push(u);
        }
    }
    if(f[1] == 1)
    cout << "Little M is the winner." << '\n';
    else
    cout << "Little I is the winner." << '\n';
}
signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int t = 1;
    cin >> t;
    while (t--)
    solve();
    return 0;
}

C. 方格染色

不是我说，这第一眼也太像状压 d p dp dp了（

由于任意两个黑色方格均不相邻，把一列看成整体，最后的答案中列的情况只有三种：白白，白黑，黑白

首先，我们把相邻列有黑块的列看作整体，例如：黑白，白黑，黑白或者白黑，黑白，白黑等等，剩下的列均为白白

黑块共有 k k k个，所以它能被分成 d ( 1 ≤ d ≤ m i n ( k , n − k + 1 ) ) d(1 \leq d \leq min(k,n-k+1)) d(1≤d≤min(k,n−k+1))个整体，对于某个 d d d，其实就是在 k − 1 k - 1 k−1个空位中选择 d − 1 d-1 d−1个空位插入隔板，所以共有 C ( k − 1 , d − 1 ) C(k-1,d-1) C(k−1,d−1)种

分为一个个整体之后，再考虑剩下的白白列，由于每个黑色列整体不能相邻（若相邻的话那就是一个整体），所以剩下要考虑的就是把一个个整体和白白列放在一起，要求每个黑块整体不相邻。白白列共有 n − k n - k n−k个，所以就是在 n − k + 1 n - k + 1 n−k+1个空位中选 d d d个空位放黑块整体，共有 C ( n − k + 1 , d ) C(n - k + 1, d) C(n−k+1,d)种

由于每个黑块整体都有两种状态，如长度为 3 3 3的黑块有黑白，白黑，黑白和白黑，黑白，白黑状态，所以 d d d个整体有 2 d 2^d 2d种情况

所以答案为 ∑ d = 1 m i n ( k , n − k + 1 ) C ( k − 1 , d − 1 ) ∗ C ( n − k + 1 , d ) ∗ 2 d \sum_{d = 1}^{min(k, n - k + 1)}C(k - 1, d - 1) * C(n - k + 1, d) * 2^d ∑d=1min(k,n−k+1)​C(k−1,d−1)∗C(n−k+1,d)∗2d，注意答案取 m o d mod mod和 k = 0 k = 0 k=0和 n < k n<k n<k的特判，时间复杂度 O ( n l o g n ) O(nlogn) O(nlogn)

#include <bits/stdc++.h>
#define int long long
#define YES "YES"
#define NO "NO"
#define all(a) a.begin(), a.end()
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef __int128 lll;
typedef __uint128_t ulll;
typedef pair<int, int> pii;
typedef vector<int> vi;
const double eps = 1e-9;
const int N = 2e6 + 10;
const int INF = 1e16;
const int mod = 998244353;
mt19937_64 rng(std::chrono::steady_clock::now().time_since_epoch().count());
int fac[N], infac[N];
ll C(ll n,ll m){//n个数选m个数
  return fac[n] * infac[n - m] % mod * infac[m] % mod;
}
inline ll binpow(ll a, ll b)
{
    ll res = 1;
    while (b)
    {
        if (b & 1)
            res = res * a % mod;
        a = (ll)a * a % mod;
        b >>= 1;
    }
    return res;
}
void solve()
{
    int n, k;
    cin >> n >> k;
    if(k == 0)
    {
        cout << "1" << '\n';
        return;
    }
    if(n < k)
    {
        cout << "0" << '\n';
        return;
    }
    int ans = 0;
    for(int i = 1;i <= min(k, n - k + 1);i++) // 分几块
    {
        int t1 = C(k - 1, i - 1); // 把若干个黑色方格分成i块的分法
        int t2 = C(n - k + 1, i); // 把i块分开
        ans = (ans + t1 * t2 % mod * binpow(2, i) % mod) % mod;
    }
    cout << ans << '\n';
}
signed main()
{
    fac[0] = 1;
    infac[0] = 1;
    for (int i = 1; i <= 1e6;i++){
        fac[i] = i * fac[i - 1] % mod;
        infac[i] = binpow(fac[i], mod - 2);
}
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int t = 1;
    cin >> t;
    while (t--)
    solve();
    return 0;
}

E. 时间超限α

遍历每个评测机，小 M M M的代码在每个评测机 i i i的最大花费时间为 a [ i ] [ m i n ( k i , m ) ] a[i][min(k_i,m)] a[i][min(ki​,m)]，最后的答案就是所有的评测机最大花费时间的最大值，时间复杂度 O ( n ∑ k i ) O(n\sum{k_i}) O(n∑ki​)

#include <bits/stdc++.h>
#define int long long
#define YES "YES"
#define NO "NO"
#define all(a) a.begin(), a.end()
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef __int128 lll;
typedef __uint128_t ulll;
typedef pair<int, int> pii;
const double eps = 1e-9;
const int N = 2e6 + 10;
const int INF = 1e16;
const int mod = 1e9 + 7;
mt19937_64 rng(std::chrono::steady_clock::now().time_since_epoch().count());
int a[2005][10005];
void solve()
{
    int n;
    cin >> n;
    for(int i = 1;i <= n;i++)
    {
        cin >> a[i][1];
        for(int j = 1;j <= a[i][1];j++)
        cin >> a[i][j + 1];
    }
    int q;
    cin >> q;
    int ans = -1;
    for(int i = 1;i <= n;i++)
    {
        if(q <= a[i][1])
        ans = max(ans, a[i][q + 1]);
        else
        ans = max(ans, a[i][a[i][1] + 1]);
    }
    cout << ans << '\n';
}
signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int t = 1;
    //cin >> t;
    while (t--)
    solve();
    return 0;
}

I. 期中考试

从起始日开始循环到结束日，如果当天不用加训则计数，时间复杂度 O ( 7000 ) O(7000) O(7000)

#include <bits/stdc++.h>
#define int long long
#define YES "YES"
#define NO "NO"
#define all(a) a.begin(), a.end()
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef __int128 lll;
typedef __uint128_t ulll;
typedef pair<int, int> pii;
const double eps = 1e-9;
const int N = 2e6 + 10;
const int INF = 1e16;
const int mod = 1e9 + 7;
mt19937_64 rng(std::chrono::steady_clock::now().time_since_epoch().count());
void solve()
{
    int a, b, c;
    cin >> a >> b >> c;
    int t1, x, t2, y;
    cin >> t1 >> x >> t2 >> y;
    int cnt = 0;
    while(1)
    {
        if(x != a && x != b && x != c)
        cnt++;
        x++;
        if(x == 8)
        {
            x = 1;
            t1++;
        }
        if(t1 == t2 && x == y)
        break;
    }
    cout << cnt << '\n';
}
signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int t = 1;
    //cin >> t;
    while (t--)
    solve();
    return 0;
}

L. 兄弟校问题

先把所有城市相同的学校放入并查集，由于题目中提到，关键词要完全一致地出现，所以可以把学校名通过下划线分成前部分关键词和后部分关键词。由于不区分大小写，所以统一将大写字母转成小写字母放入 s e t set set，每次询问关键词时，把两个都含有该关键词的学校放入并查集，时间复杂度 O ( 50 n m ) O(50nm) O(50nm)

#include <bits/stdc++.h>
#define int long long
#define YES "YES"
#define NO "NO"
#define all(a) a.begin(), a.end()
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef __int128 lll;
typedef __uint128_t ulll;
typedef pair<int, int> pii;
typedef vector<int> vi;
const double eps = 1e-9;
const int N = 2e6 + 10;
const int INF = 1e16;
const int mod = 1e9 + 7;
mt19937_64 rng(std::chrono::steady_clock::now().time_since_epoch().count());
struct dsu {
    vi fa;
    dsu(int n = 1){
        fa = vi( n+1 , -1ll );
        fa[0] = 0;
    }

    int getfa(int x) {
        if (fa[x] < 0) return x;
        return fa[x] = getfa(fa[x]);
    }

    void merge(int x, int y) {
        x = getfa(x), y = getfa(y);
        if (x == y) return;
        if (fa[x] > fa[y]) swap(x, y);
        fa[x] += fa[y], fa[y] = x;
    }

    int size(int x) {
        x = getfa(x);
        return -fa[x];
    }
};
string ct[1005];
vector<set<string>> un(1005);
void solve()
{
    int n, m;
    cin >> n >> m;
    dsu d(n);
    for(int i = 1;i <= n;i++)
    {
        string t;
        cin >> t >> ct[i];
        t += '_';
        string now = "";
        for(auto c : t)
        {
            if(c >= 'A' && c <= 'Z')
            now += c - 'A' + 'a';
            else if(c == '_')
            {
                //cout << now << '\n';
                un[i].insert(now);
                now = "";
            }
            else
            now += c;
        }
    }
    for(int i = 1;i <= n;i++)
    {
        for(int j = i + 1;j <= n;j++)
        {
            if(ct[i] == ct[j])
            d.merge(i, j);
        }
    }
    while(m--)
    {
        string qq;
        cin >> qq;
        string q;
        for(auto c : qq)
        {
            if(c >= 'A' && c <= 'Z')
            q += c - 'A' + 'a';
            else
            q += c;
        }
        for(int i = 1;i <= n;i++)
        {
            if(un[i].count(q))
            {
                for(int j = i + 1;j <= n;j++)
                {
                    if(un[j].count(q))
                    d.merge(i, j);
                }
                break;
            }
        }
    }
    for(int i = 1;i <= n;i++)
    cout << d.size(i) - 1 << '\n';
}
signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int t = 1;
    //cin >> t;
    while (t--)
    solve();
    return 0;
}
木木警官
关注
  • 3
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
The 5th Central South China Programming Contes
12-04
《中央南区编程竞赛第五次盛会：数据、代码与解题报告详解》 在编程竞赛领域，"Central South ACM" 是一个重要的标签，它代表了中央南区的ACM（美国计算机协会）编程竞赛。这类比赛旨在提升参赛者的算法设计、问题...
ProgrammingContest
03-09
编程竞赛是IT行业中一个充满挑战和乐趣的领域，它涵盖了各种算法、数据结构以及高效的编程技巧。Python作为一门简洁易学、功能强大的编程语言，在编程竞赛中被广泛使用。本篇将深入探讨Python在编程竞赛中的应用，...
B. 看比赛 The 10th Jimei University Programming Contest
ashbringer233的博客
10-26 263
思路：因为直走最短路，所以我们把所有在最短路上的边都要选出来，建成新图，为此，首先用dijkstra求出1到n的最短路的长度，然后我们从n开始bfs，遍历相邻边，如果这条边的边权加上1到这条边起点的最短路距离等于1到这条边终点的最短路距离，那么就把这条边加到新图中，最后就会形成一个包含1到n的所有最短路的DAG。
The 17th Zhejiang Provincial Collegiate Programming Contest
lllllan
10-27 1433
The 17th Zhejiang Provincial Collegiate Programming Contest 题目 A B C D E F G H I J K L solved ✔ ???? - - ???? - - - ✔ - ✔ - ✔：比赛时通过；????：赛后通过；⚪：比赛时尝试了未通过；-：比赛时未尝试
The 16th Zhejiang University Programming Contest-
NYIST_TC_LYQ的博客
04-13 580
Handshakes Time Limit: 2 Seconds      Memory Limit: 65536 KB Last week, n students participated in the annual programming contest of Marjar University. Students are labeled from 1 to n. They c
The 16-th BIT Campus Programming Contest - Online Round--Easy Nim
zy98zy998的博客
01-12 548
Problem - C - Codeforceshttps://codeforces.com/gym/103401/problem/C题目大意为每人每轮最多拿m张牌，谁先取完n张牌谁胜；后手有k张魔法牌，每张魔法牌上写有数字（这里把数字放在c数组里）可以将修改上限变为牌上的数字，发动魔法牌时不能取牌。 拿牌（取石子游戏）有一个必胜策略是将n张牌的剩余个数拿到（m+1）的倍数 （先手不能发动魔法牌，所以只是个无情的拿（m+1）的倍数的机器人） 例如：10张牌，每人最多拿3张，这样的话先手必胜，下面的过
The 15th Jilin Provincial Collegiate Programming Contest
m0_53091571的博客
02-05 2016
The 15th Jilin Provincial Collegiate Programming Contest A. Random Number Checker 签到 #include <bits/stdc++.h> using namespace std; int main() { int n; cin >> n; int odd = 0, even = 0; for (int i = 1; i <= n; i ++ ) {
2019 Multi-University Training Contest 10数据标程.rar
08-22
标题中的“2019 Multi-University Training Contest 10数据标程.rar”指的是2019年举办的多所大学联合编程训练比赛的第十场竞赛的数据集和参考解程。这个压缩包通常包含了该比赛的所有题目、输入输出样例、评测标准...
Nafis' Programming Contest Judge Tool-开源
05-07
《Nafis' Programming Contest Judge Tool：开源的力量与无限可能》 编程竞赛是技术爱好者们展示才华、提升技能的重要舞台，而Nafis' Programming Contest Judge Tool正是一款专为此类活动设计的利器。这款工具以其...
java-programming-contest.zip_java programming
09-24
这个名为"java-programming-contest.zip"的压缩包显然是为准备Java编程竞赛而设计的，其中包含了一份文档——"竞赛java编程题50题(有答案).doc"。这份文档很可能包含了50个不同的编程题目，每个题目都旨在测试参赛者...
LC53最大子数组和、lc5最长回文子串、lc283移动零
m0_47536537的博客
07-14 193
请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。连续子数组 [4,-1,2,1] 的和最大，为 6。移动到数组的末尾，同时保持非零元素的相对顺序。，必须在不复制数组的情况下原地对数组进行操作。"aba" 同样是符合题意的答案。是数组中的一个连续部分。，编写一个函数将所有。LC53最大子数组和。
算法014：找到字符串中所有字母异位词
m0_62319039的博客
07-14 429
算法014：找到字符串中所有字母异位词
排序算法(4)之快速排序(1)
最新发布
wer24_25的博客
07-17 722
排序算法(4)之快速排序(1),快速排序的概念和快速排序的三种实现方式.
(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度
qq_44962949的博客
07-17 71
【代码】(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度。
代码随想录算法训练营第三十二天
weixin_44791877的博客
07-14 207
这道题自己思考ac出来了，主要是这道题需要使用二维的dp数组进行规划，由于动归是递推的，所以从结果向前思考，因此到右下角的方法只能由右下角这个格子或者左边这个格子走过来，因此右下角这个格子的方法数应该等于上一个格子的方法数加上左边这个格子的方法数。值得注意的是只有一行的或者一列的每个格子都只有1种方法，还有就是多行多列的边界格子也是只有一种方法，这个也是要初始化的。然后初始化边界的时候在障碍物之前的都初始化为1，障碍物以及障碍物之后的都初始化为0；首先几个特殊情况 当障碍物在起点或者终点的话直接返回0；
2024C++信息素养大赛-算法创意实践挑战_复赛真题（广东省）题目+参考答案和详细解析
m0_74586426的博客
07-12 866
2024C++信息素养大赛-算法创意实践挑战_复赛真题（广东省）题目+参考答案和详细解析
树与二叉树
2201_76027754的博客
07-15 760
树和二叉树
排序思想-快排
m0_58257626的博客
07-17 126
快速排序核心思想就是每次在当前区间 [left, right] 中选择出一个元素 nums[p]，然后将区间内所有大于它的元素和所有小于它的元素都放到其两侧【具体放在哪一侧取决于是升序还是降序】，然后再递归去处理两侧区间。将大于切分值的元素都放到左侧，小于切分值得元素都放到右侧。因此我们可以使用双指针分别从两端往中间搜索，分别找到左侧小于切分值的元素和右侧大于切分值的元素，交换之，直到两个指针相遇。
算法刷题笔记 KMP字符串（C++实现，并给出了求next数组的独家简单理解方式）
hanmo22357的博客
07-12 833
一道经典且较难的算法题，给出了C++代码实现，以及自己对next数组求解的独家简单的理解方式。
the 15th chinese northeast collegiate programming contest
03-16
很抱歉，作为一个语言模型，我的回答需要使用英语。不过我可以告诉你，中国东北地区的第15届大学生程序设计竞赛是一项计算机科学比赛，旨在鼓励大学生学习编程、提高编程水平。该比赛通常由东北地区的高校联合举办，吸引了来自全国各地的大学生参加。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值