SDUT 2023 summer team contest（for 22) - 13

已于 2023-08-09 11:23:18 修改
阅读量153 收藏
点赞数 2
分类专栏： 训练赛 文章标签： c++ 算法 思维 数据结构
于 2023-08-08 19:34:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73673533/article/details/132173304
版权

B - Hoppers

 题意：给你一张无向图，可以选定一个点染色，随后距离为2的点都会被染色(可以传染）。求至少需要向图中添加几条边使得选定一个点染色后可以将整个图染色。(不一定是连通图）

思路：如果一个连通块是一个二分图，那么只能染色二分图的一部；如果一个连通块不是二分图，那么这个连通块可以被完全染色。(就是看有没有奇数环，二分图一定没有奇数环）

求出连通块的数量k以及是否有非二分图连通块，如果有非二分图那么只要用k-1条边把k个连通块连成一个非二分图连通块即可。如果没有非二分图那么用k-1条边连起来后还是个二分图连通块，需要再加一条边变成非二分连通块。

所以如果有非二分图（奇数环）ans=连通块数-1

否则ans=联通块数

这里写了两种方法，一个dfs，一个二分图染色（其实都差不多）

1：二分图染色

#include <bits/stdc++.h>
using namespace std;
#define pi acos(-1)
#define xx first
#define yy second
#define endl "\n"
#define lowbit(x) x & (-x)
#define int long long
#define ull unsigned long long
#define pb push_back
typedef pair<int, int> PII;
typedef pair<double, double> PDD;
#define max(a, b) (((a) > (b)) ? (a) : (b))
#define min(a, b) (((a) < (b)) ? (a) : (b))
#define Ysanqian ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
const int N = 1e6 + 10, M = 1010, inf = 0x3f3f3f3f, mod = 18446, P = 13331;
const double eps = 1e-8;
int n, m;
bool flag;
int p[N];
int siz[N];
int st[N];
vector<int> g[N];
vector<int> now;
int find(int x)
{
  if (x != p[x])
    p[x] = find(p[x]);
  return p[x];
}
void merge(int x, int y)
{
  int a = find(x), b = find(y);
  if (a != b)
  {
    p[b] = a;
    siz[a] += siz[b];
  }
}
bool dfs(int u, int c)
{
  st[u] = c;
  for (auto ed : g[u])
  {
    if (st[ed])
    {
      if (st[ed] == c)
        return false;
    }
    else if (!dfs(ed, 3 - c))
      return false;
  }
  return true;
}
void solve()
{
  cin >> n >> m;
  for (int i = 1; i <= n; i++)
  {
    p[i] = i;
    siz[i] = 1;
  }
  for (int i = 1; i <= m; i++)
  {
    int a, b;
    cin >> a >> b;
    g[a].pb(b);
    g[b].pb(a);
    merge(a, b);
  }
  int ans = 0;
  for (int i = 1; i <= n; i++)
  {
    if (p[i] == i)
      ans++;
  }
  for (int i = 1; i <= n; i++)
  {
    if (!st[i])
    {
      if (!dfs(i, 1))
        flag = 1;
    }
  }
  if (flag)
    cout << ans - 1 << endl;
  else
    cout << ans << endl;
}
signed main()
{
  Ysanqian;
  int T;
  T = 1;
  // cin >> T;
  while (T--)
    solve();
  return 0;
}

2：dfs

#include <bits/stdc++.h>
using namespace std;
#define pi acos(-1)
#define xx first
#define yy second
#define endl "\n"
#define lowbit(x) x & (-x)
#define int long long
#define ull unsigned long long
#define pb push_back
typedef pair<int, int> PII;
typedef pair<double, double> PDD;
#define max(a, b) (((a) > (b)) ? (a) : (b))
#define min(a, b) (((a) < (b)) ? (a) : (b))
#define Ysanqian ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
const int N = 1e6 + 10, M = 1010, inf = 0x3f3f3f3f, mod = 18446, P = 13331;
const double eps = 1e-8;
int n, m;
bool flag;
int d[N];
vector<int> g[N];
void dfs(int u, int color)
{
  d[u] = color;
  for (auto ed: g[u])
  {
    if (!d[ed])
      dfs(ed, -color);
    else if (d[u] == d[ed])//临边有相同的颜色，即为非二分图，含有奇数环
      flag = 1;
  }
}
void solve()
{
  cin >> n >> m;
  for (int i = 1; i <= m; i++)
  {
    int a, b;
    cin >> a >> b;
    g[a].pb(b);
    g[b].pb(a);
  }
  int ans = 0;
  for (int i = 1; i <= n; i++)
  {
    if (!d[i])
    {
      dfs(i, 1);
      ans++;
    }
  }
  if (flag)
    cout << ans - 1 << endl;
  else
    cout << ans << endl;
}
signed main()
{
  Ysanqian;
  int T;
  T = 1;
  // cin >> T;
  while (T--)
    solve();
  return 0;
}

C - SG Coin

题意：就是给你一个字符串的哈希值，以及一个计算字符串哈希值得函数，让你再构造两个串，可以满足这个函数，且其哈希值末尾有7个0

思路：我们根据其公式得知，我们得到其哈希值，要知道其牌号，和交易字符串，而这两个我们都不知道，那么我们其实可以只有构造一个交易字符串，在不加牌号得情况下求出其暂时的哈希值（mod1e9的意义下），但是我们还是不知道其牌号，其实这时候牌号就等于其变为后七位变为0减去其目前暂时哈希值（应为最终哈希值要后7位为0），这个操作可以通过令（x/1e7+1)*1e7得到后7位全为0得情况，减去x即为牌号，下一个构造同理

#include <bits/stdc++.h>
using namespace std;
#define pi acos(-1)
#define xx first
#define yy second
#define endl "\n"
#define lowbit(x) x & (-x)
#define int long long
#define ull unsigned long long
#define pb push_back
typedef pair<int, int> PII;
typedef pair<double, double> PDD;
#define max(a, b) (((a) > (b)) ? (a) : (b))
#define min(a, b) (((a) < (b)) ? (a) : (b))
#define Ysanqian ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
const int N = 1e6 + 10, M = 1010, inf = 0x3f3f3f3f, mod = 18446, P = 13331;
const double eps = 1e-8;
int n;
string s1, s2, ans1, ans2;
int H(int last, string s)
{
  int v = last;
  for (int i = 0; i < s.length(); i++)
  {
    v = (v * 31 + s[i]) % 1000000007;
  }
  return (v * 7 ) % 1000000007;
}
void solve()
{
  s1 = "charlie-pays-to-eve-9-sg-coins";
  s2 = "icpc-sg-2018-at-nus";
  cin >> n;
  int x1 = H(n, s1);
  int g = ((int)(x1 / 1e7) + 1) * 1e7;
  cout << s1 << ' ';
  cout << g - x1 << endl;

  int x2 = H(g, s2);
  g = ((int)(x2 / 1e7) + 1) * 1e7;
  cout << s2 << ' ';
  cout << g - x2 << endl;
}
signed main()
{
  Ysanqian;
  int T;
  T = 1;
  // cin >> T;
  while (T--)
    solve();
  return 0;
}

L - Non-Prime Factors

题意：n次询问，每次询问给出一个x，求x得约数里有多少个不是质因数

思路：看到这个数据量，跑不了是预处理了，但是我们预处理所有得质因数，没次分解约数（根号n）的复杂度我们也接受不了，既然我们用筛法来求质因数了，不难想到用同一思想来与预处理答案

对于任意一个整数，它必定可以被拆成两个整数的乘积。所以我们可以枚举因数，然后把2~2e6的数的结果在n\log n时间复杂度内计算出来

#include <bits/stdc++.h>
using namespace std;
#define pi acos(-1)
#define xx first
#define yy second
#define endl "\n"
#define lowbit(x) x & (-x)
#define int long long
#define ull unsigned long long
#define pb push_back
typedef pair<int, int> PII;
typedef pair<double, double> PDD;
#define max(a, b) (((a) > (b)) ? (a) : (b))
#define min(a, b) (((a) < (b)) ? (a) : (b))
#define Ysanqian ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
const int N = 2e6 + 10, M = 1010, inf = 0x3f3f3f3f, mod = 18446, P = 13331;
const double eps = 1e-8;
int n, m, cnt;
int ans[N], prime[N];
bool st[N], p[N];
void is_prime()
{
  st[1] = 1;
  for (int i = 2; i <= N; i++)
  {
    if (!st[i])
      prime[cnt++] = i;
    for (int j = 0; prime[j] <= N / i; j++)
    {
      st[i * prime[j]] = 1;
      if (i % prime[j] == 0)
        break;
    }
  }
  for (int i = 1; i <= 2e6; i++)
  {
    if (!st[i])
      continue;
    for (int j = i; j <= 2e6; j += i) // 每个数都有其较小的约数线性筛出来
    {
      ans[j]++;
    }
  }
}
void solve()
{
  cin >> n;
  cout << ans[n] << endl;
}
signed main()
{
  Ysanqian;
  int T;
  T = 1;
  is_prime();
  cin >> T;
  while (T--)
    solve();
  return 0;
}

F - Wi Know

 题意：找到AB2B这种形式的字典序的最小子序列。
题解：我们会发现只要存在ABAB这种形式，那么一定存在A1B1A2B2使得A1和A2之间没有其余的A，B1和B2之间没有其余的B。那么，我们这样就只需要枚举每一位B1，然后找到离这个B1最近的那个B就是B2，我们找到B1前面存在的（A1）并且在B1和B2之间最小的数（A2）。

#include <bits/stdc++.h>
using namespace std;
#define pi acos(-1)
#define xx first
#define yy second
#define endl "\n"
#define lowbit(x) x & (-x)
#define int long long
#define ull unsigned long long
#define pb push_back
typedef pair<int, int> PII;
typedef pair<double, double> PDD;
#define max(a, b) (((a) > (b)) ? (a) : (b))
// #define min(a, b) (((a) < (b)) ? (a) : (b))
#define Ysanqian ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
const int N = 5e5 + 10, M = 1010, inf = 0x3f3f3f3f, mod = 18446, P = 13331;
const double eps = 1e-8;
int n, a[N];
int pos[N], nxt[N];
struct node
{
  int l, r;
  int minn = inf;
} tr[N * 4];
void pushup(node &u, node &l, node &r)
{
  u.minn = min(l.minn, r.minn);
}
void pushup(int u)
{
  pushup(tr[u], tr[u << 1], tr[u << 1 | 1]);
}
void build(int u, int l, int r)
{
  tr[u].l = l, tr[u].r = r;
  if (l == r)
    return;
  int mid = l + r >> 1;
  build(u << 1, l, mid);
  build(u << 1 | 1, mid + 1, r);
}
void modify(int u, int x, int k)
{
  if (tr[u].l == x && tr[u].r == x)
  {
    tr[u] = {x, x, k};
    return;
  }
  int mid = tr[u].l + tr[u].r >> 1;
  if (x <= mid)
    modify(u << 1, x, k);
  else
    modify(u << 1 | 1, x, k);
  pushup(u);
}
node query(int u, int l, int r)
{
  if (tr[u].l >= l && tr[u].r <= r)
    return tr[u];
  int mid = tr[u].l + tr[u].r >> 1;
  if (l > r)
  {
    node ans = {tr[u].l, tr[u].r, inf};//这里这样写确实麻烦了
    return ans;
  };
  if (r <= mid)
    return query(u << 1, l, r);
  else if (l > mid)
    return query(u << 1 | 1, l, r);
  else
  {
    node res;
    auto left = query(u << 1, l, r), right = query(u << 1 | 1, l, r);
    pushup(res, left, right);
    return res;
  }
}
/*这样写也行
int query(int u, int l, int r)
{
    if (tr[u].l >= l && tr[u].r <= r)
        return tr[u].minn;
    int mid = tr[u].l + tr[u].r >> 1;
    int minn = inf;
    if (l <= mid)
        minn = query(u << 1, l, r);
    if (r > mid)
        minn = min(minn, query(u << 1 | 1, l, r));
    return minn;
}
*/
void solve()
{
  cin >> n;
  build(1, 1, n);
  for (int i = 1; i <= n; i++)
    cin >> a[i];
  for (int i = n; i >= 1; i--)
  {
    nxt[i] = pos[a[i]];//nxt存的是每个a[i],右边第一个a[i]的位置
    pos[a[i]] = i;
  }
  PII ans = {inf, inf};
  for (int i = 1; i <= n; i++)
  {
    if (nxt[i] == 0)
      continue;
    ans = min(ans, {query(1, i + 1, nxt[i] - 1).minn, a[i]});//PII，的排序规则先看第一位， 
                                                              再看第二位
   //注意如果x，nxt(x)相邻，会出 
   //现l=4，r=3，这种情况我们需要query时返回inf
  // 把这个位置当作B1在该位置与这个字符的下一个位置B2之间查找最小的A2
    modify(1, nxt[i], a[nxt[i]]);
  //放入A2,不是A1，这里是把当前数当作A1
  }
  if (ans.xx != inf && ans.yy != inf)
    cout << ans.xx << ' ' << ans.yy << endl;
  else
    cout << -1 << endl;
}
signed main()
{
  Ysanqian;
  int T;
  T = 1;
  // cin >> T;
  while (T--)
    solve();
  return 0;
}
sdut stm32&mdk-arm单片机期末实验
06-30
sdut stm32&mdk-arm单片机期末实验
sdut-sourcesdb
03-22
雨果基金会主题 雨果使用基础6的准系统主题。 安装 按照Hugo Docs网站上的说明下载并安装当前的Hugo二进制文件。跑： $ hugo new site example 然后在您的主题目录中运行 ...使用主题/示例config.toml中的config.toml...
Sdut-Ver5.2.0
10-26
sdut客sdut客户端
stepbystep:SDUTACM训练计划
06-10
"SDUTACM训练计划"是一个面向初学者到高级选手的逐步学习路径，旨在帮助学生提升在算法竞赛（如ACM/ICPC）中的技能。这个训练计划可能包含一系列的练习题、教程和代码示例，以HTML为主要的展示形式。HTML（HyperText...
解题报告代码 sdut2107
07-29
### 解题报告：sdut2107 #### 题目概述 根据提供的代码片段来看，这是一段用于解决图论问题中的遍历算法，很可能是深度优先搜索（Depth-First Search，简称DFS）的应用场景。代码的目标是解决一个与图的遍历相关的...
C 学习（4）
search7的博客
11-05 767
C语言学习，每个模块来自工作中的？？？
C++_用 using 语句继承基类的构造函数
学海无涯
11-09 80
**默认情况下**，派生类会继承基类的所有成员，包括数据成员和函数成员，但不会继承基类的**构造函数和析构函数**，因为构造函数和析构函数的作用是创建和销毁对象，派生类通常需要有自己的构造和析构的逻辑。C++11 引入了using语句，使得派生类可以通过 using 关键字使用基类的构造函数，更方便地复用基类的构造逻辑。
STL set
hls0611的博客
11-09 108
练习题：P1059 [NOIP2006 普及组] 明明的随机数。
常用的c++特性--＞day02
m0_69093426的博客
11-06 528
C++11中为我们提供了一个模板类叫做std::enable_shared_from_this，这个类中有一个方法叫做shared_from_this()，通过这个方法可以返回一个共享智能指针，在函数的内部就是使用weak_ptr来监测this对象，并通过调用weak_ptr的lock()方法返回一个shared_ptr对象。通过打印的结果可以知道，虽然弱引用智能指针wp3、wp4、wp5监测的资源是同一个，但是它的引用计数并没有发生任何的变化，也进一步证明了weak_ptr只是监测资源，并不管理资源。
c++函数形参 返回两幅IplImage*图像
u012719076的博客
11-05 143
如果在GetImage函数中用cvCreateImage创建 p1 p2，则在调用时发现返回的数据是空的。主要是调用之前要先定义好。
GitLab 提交 C++ 技巧
nbspzs的专栏
11-08 200
在 GitLab 中提交 C++ 代码时，通常应只提交 源代码文件（例如 .cpp、.h）和 CMake 配置文件（例如 CMakeLists.txt），而不要提交通过 CMake 编译后的中间文件或构建产物。这样，当其他开发者克隆你的项目后，他们可以在自己的机器上使用 cmake 构建项目，而不需要下载编译产物。2. 跨平台兼容性：不同的开发者和平台可能会生成不同的编译产物，提交这些文件会造成不必要的冲突和问题。1. 在 .gitignore 文件中忽略编译生成的文件和目录。
西南科技大学C++作业1——组合依赖关系实验代码
m0_74312676的博客
11-05 605
合理设计类与类的组合关系，即一个类要嵌套另一个类的对象作为成员变量，根据问题的需要可以是同一个类的多个对象(可以使用对象数组)，也可以是不同类的多个不同对象。让所设计的功能发挥作用。对学生和图书进行抽象，抽象出应有的成员变量，和基本的初始化，修改等成员函数，学生可以发起借书的操作，这是一种依赖关系，在学生类中将设计相应的成员函数体现这一功能操作，合理即可，可以用输出借书是否成功的结果，有一定示意就可以。其他操作：计算得到正确答案，输入自己的题目的答案，向题库内增加题目，在题库内删除题目，查询题库的题目。
2024年华为OD机试真题-查找充电设备-C++-OD统一考试（E卷）
面试高手的博客
11-08 141
某个充电站，可提供n个充电设备只，每个充电设备均有对应的输出功率任意个充电设备组合的输出功率总和，均构成功率集合P的1个元素功率集合P的最优元素，表示最接近充电站最大输出功率pmax 的元素。每一题都含有详细的解题思路和代码注释，精编c++、JAVA、Python三种语言解法。当充电设备输出功率50、20、20组合时，其输出功率总和为90，最接近充电站最大充电输出功率，因此最优元素为90。所有充电设备的输出功率组合，均大于充电站最大充电输出功率30，此时最优元素值为0。第 2 行为每个充电设备的输出功率。
C++ | 表示移动函数move()的基本用法
brilliantgby_id的博客
11-09 192
通过函数定义可以看出，move函数没有进行移动操作，而是返回类型转换后的参数。
【C语言】浮点型数据存储 和 整型数据存储的区别
猫猫的小茶馆
11-09 227
现在计算机中的浮点数存储都是遵循IEEE754/854标准，以二进制的科学计数法存放到内存中。“指数部分”，即次高有效的e个比特，存储指数部分；最后剩下的f个低有效位的比特，存储“有效数”（significand）的小数部分（在非规约形式下整数部分默认为0，其他情况下一律默认为1）。一定要很清楚数据在计算机的存储方式，知道数据布局可以帮助优化内存访问，提高程序运行效率；确保数据类型和大小正确，避免精度损失或数据截断；对于浮点数在计算机中有两种存储的精度，即单精度和双精度，单精度是32位，双精度是64位。
C/C++语言基础--C++模板与元编程系列四(类型模板参数、整数、指针 、模板类型)
最新发布
weixin_74085818的博客
11-09 544
💇 上面案例就是很简单的案例，定义了两个案例模板，后买你定义了一个打印数据的函数；前三掌已经讲解了函数、类、变量模板以及他们的特性等等，这一小节。这个部分前三章讲过，这里就不详细讲解了，总的来说就是，不用。要注意数据如何表示，输出的时候如何输出，即可；变量指针这个当然可以，上面案例也有，这里讲解。方法是在运行的时候确定的，不是在编译期间。：进一步说明了，模板参数兼容任意类型。，模板这个东西比较新，本人是在。原因原容易找到，这个在之前的。)，只需要加个运算符重载即可。☄ 这个是最常用的，就是用。
问题排查：C++ exception with description “getrandom“ thrown in the test body
李兆龙的博客
11-06 921
确定是内核版本问题
探索 C++20：C++ 的新纪元
2404_88048702的博客
11-09 838
C++20 为开发者带来了一系列激动人心的新特性，这些特性不仅改善了编程体验，而且打开了新的可能性的大门。无论您是通过使用概念提升模板编程的安全性，或是利用协程简化异步操作，C++20 都将助您一臂之力。C++20 的未来无疑是光明的，让我们继续探索和实践，释放这一强大语言的全部潜力。祝大家在 C++20 中编写出更高效、更优雅的代码！
C语言 流程控制语句
2201_75297369的博客
11-05 487
时间：2024.11.5。
sdut-list-map--购物车
03-16
sdut-list-map--购物车是一个购物车列表和地图的应用程序。它可以让用户在购物时方便地查看他们的购物车列表和附近的商店位置。用户可以在购物车列表中添加或删除商品，并在地图上查看商店的位置和距离。这个应用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值