nowcoder-548C-Tachibana Kanade Loves Review

链接：https://ac.nowcoder.com/acm/contest/548/C
来源：牛客网

时间限制：C/C++ 2秒，其他语言4秒
空间限制：C/C++ 524288K，其他语言1048576K
64bit IO Format: %lld

题目描述

 

立华奏是一个刚刚开始学习 OI 的萌新。
最近，实力强大的 $\text{Q}\text{ingyu}$ 当选了 IODS 9102 的出题人。众所周知， IODS 是一场极其毒瘤的比赛。为了在这次比赛中取得好的成绩，立华奏决定学习可能考到的每一个知识点。
在 $\text{Q}\text{ingyu}$ 的博客中，立华奏得知这场比赛总共会考察选手 n 个知识点。此前，立华奏已经依靠自学学习了其中 k 个知识点。接下来，立华奏需要学习其他的知识点，每学习一个单独的知识点，需要消耗的时间为 $T_i$ 天。同时，某些知识点之间存在联系，可以加速学习的过程。经过计算，立华奏一共发现了其中 m 种联系，第 i 种联系可以表示为$(X_i,Y_i,H_i)$，其含义为“在掌握了第 $X_i$ 个知识点和第 $Y_i$ 个知识点中任意一个后，学习 $H_i$ 天即可掌握另一个知识点”。
留给立华奏的时间所剩无几，只有 t 天，因此，她想知道自己能不能在这 t 天内学习完成所有的知识点。

输入描述:

本题输入量较大，请注意使用效率较高的读入方式
输入的第一行包含四个整数 n, m, k, t，含义见上所述。

接下来一行，包含 n 个整数，依次表示 $T_1,T_2,\cdots ,T_n$

接下来一行，包含 k 个整数，表示立华奏已经学习过的知识点。如果 k=0，则此处为一空行。
接下来 m 行，每行 3 个整数 $X_i,Y_i,H_i$，描述一种联系。

输出描述:

如果立华奏能够学习完所有的知识点，输出一行 Yes。否则输出 No

示例1

输入

复制

4 3 2 5
4 5 6 7
2 3
1 2 3
1 3 2
3 4 2

输出

复制

Yes

说明

立华奏已经学习过了第 2, 3 个知识，由第 2 个关系，立华奏可以花 2 天学会知识点 1，在由关系 3， 立华奏可以 2 天学会知识点 4，因此总共需要花费 4 天，可以完成任务。

示例2

输入

复制

5 4 0 12
4 5 6 7 1

1 2 3
1 3 2
3 4 2
1 5 233

输出

复制

Yes

说明

立华奏比较菜，因此什么都没有学过。她可以选择先花 4 天的时间学会知识点 1。然后根据关系 1, 2，分别花 3, 2 天的时间学会知识点 2, 3，再根据关系 3，花 2 天的时间学会知识点 4。然后，她再单独学习知识点 5，花费1天，总共花费了 12 天 ，可以完成任务。

请注意，虽然关系 4 允许立华奏在知识点 1 的基础上学习知识点 5，但需要的时间比单独学习还要多，因此立华奏不会在知识点 1 的基础上学习知识点 5.

备注:

$0⩽k⩽n⩽{10}^6,m⩽5\times {10}^6,t⩽{10}^{18},T_i,H_i⩽{10}^3$

思路：

这就是一个最小生成树，只不过这题卡常数，因此从这题也学到了不少东西；

• 比赛时自己敲的

  C

  运行超时

  2001

  0

  1293

  C++

  #include "bits/stdc++.h"
  using namespace std;
  typedef pair<int, int> PII;
  typedef long long LL;
  const int MAXN = 1e6 + 5;
  priority_queue<PII, vector<PII>, greater<PII> > que;
  vector<PII> vp[MAXN];
  vector<int> vi;
  bool ok[MAXN];
  void add(int k) {
      for (int i = 0; i < vp[k].size(); i++) {
          que.push(vp[k][i]);
      }
      vp[k].clear();
  }
  int main() {
      int n, m, k, s;
      int a, b, c, cnt = 0;
      LL t, sum = 0;
      scanf("%d%d%d%lld", &n, &m, &k, &t);
      for (int i = 1; i <= n; i++) {
          scanf("%d", &s);
          que.push({s, i});
      }
      for (int i = 1; i <= k; i++) {
          scanf("%d", &s);
          vi.push_back(s);
      }
      for (int i = 1; i <= m; i++) {
          scanf("%d%d%d", &a, &b, &c);
          vp[a].push_back({c, b});
          vp[b].push_back({c, a});
      }
      for (int i = 0; i < vi.size(); i++) {
          int j = vi[i];
          if (ok[j] == false) {
              ok[j] = true;
              cnt++;
              add(j);
          }
      }
      while (cnt != n) {
          PII j = que.top();
          que.pop();
          if (ok[j.second] == false) {
              ok[j.second] = true;
              cnt++;
              sum += j.first;
              add(j.second);
          }
      }
      if (sum <= t) {
          puts("Yes");
      } else {
          puts("No");
      }
      return 0;
  }

  类似Prim算法每次取最短边，但是比赛的时候我连这是最小生成树都没看出来，所以用了一个优先队列来维护目前能连起来的边，如果边的两个端点都未联通，则这条边在vector里不会加入优先队列，vector和优先队列转移耗费大量时间。而且各种耗时

• 看了题解之后又经过多次修改的代码(题解链接：https://ac.nowcoder.com/discuss/173818)

  C

  答案正确

  1111

  69944

  1813

  C++

  #include "bits/stdc++.h"
  using namespace std;
  typedef long long LL;
  typedef pair<int, int> PII;
  const int MAXN = 1e6 + 5;
  const int MAXW = 3000;
  vector<PII> vec[MAXW + 5];
  int pre[MAXN], rak[MAXN];
  int n, m, k;
  int u, v, w;
  LL t;
  inline LL read() {
      char c = getchar();
      LL num = 0;
      while (!isdigit(c)) {
          c = getchar();
      }
      while (isdigit(c)) {
          num = num * 10 + (c ^ '0');
          c = getchar();
      }
      return num;
  }
  int find(int n) {
      if (pre[n] == -1) {
          return n;
      }
      return pre[n] = find(pre[n]);
  }
  bool check(int k) {
      for (w = 0; true; w++) {
          for (int i = 0; i < vec[w].size(); i++) {
              PII p = vec[w][i];
              u = find(p.first);
              v = find(p.second);
              if (u != v) {
                  t -= w;
                  if (t < 0) {
                      return false;
                  }
                  k++;
                  if (t >= (n - k) * 1LL * MAXW) {
                      return true;
                  }
                  if (rak[u] > rak[v]) {
                      pre[v] = u;
                  } else {
                      pre[u] = v;
                      if (rak[u] == rak[v]) {
                          rak[v]++;
                      }
                  }
              }
          }
      }
  }
  int main() {
      n = read(), m = read(), k = read(), t = read();;
      memset(pre, -1, sizeof(pre));
      memset(rak, 0, sizeof(rak));
      for (int i = 1; i <= n; i++) {
          w = read();
          vec[w].push_back({0, i});
      }
      for (int i = 1; i <= k; i++) {
          u = read();
          pre[u] = 0;
      }
      for (int i = 1; i <= m; i++) {
          u = read();
          v = read();
          w = read();
          vec[w].push_back({u, v});
      }
      if (check(k)) {
          puts("Yes");
      } else {
          puts("No");
      }
      return 0;
  }

  在此之前就看到过快读(read)，只是之前没有遇到像这题一样卡输入的。这题除非其他地方优化到极致，否则不用快读过不去。还有就是学到了并查集的启发式合并，之前写的并查集都只用了路径压缩来优化，才发现还可以用启发式合并来优化，而且就这题看来，用了启发式合并之后快了不少。还有就是学到了inline，之前没怎么用过这个关键字，网上查了一下说是可以提高代码效率（类似宏定义），不过关于这个inline，我试过去掉inline提交反而快了，不知道为什么。

链接：https://ac.nowcoder.com/acm/contest/548/C
来源：牛客网

时间限制：C/C++ 2秒，其他语言4秒
空间限制：C/C++ 524288K，其他语言1048576K
64bit IO Format: %lld

题目描述

立华奏是一个刚刚开始学习 OI 的萌新。
最近，实力强大的 $\text{Q}\text{ingyu}$ 当选了 IODS 9102 的出题人。众所周知， IODS 是一场极其毒瘤的比赛。为了在这次比赛中取得好的成绩，立华奏决定学习可能考到的每一个知识点。
在 $\text{Q}\text{ingyu}$ 的博客中，立华奏得知这场比赛总共会考察选手 n 个知识点。此前，立华奏已经依靠自学学习了其中 k 个知识点。接下来，立华奏需要学习其他的知识点，每学习一个单独的知识点，需要消耗的时间为 $T_i$ 天。同时，某些知识点之间存在联系，可以加速学习的过程。经过计算，立华奏一共发现了其中 m 种联系，第 i 种联系可以表示为$(X_i,Y_i,H_i)$，其含义为“在掌握了第 $X_i$ 个知识点和第 $Y_i$ 个知识点中任意一个后，学习 $H_i$ 天即可掌握另一个知识点”。
留给立华奏的时间所剩无几，只有 t 天，因此，她想知道自己能不能在这 t 天内学习完成所有的知识点。

输入描述:

本题输入量较大，请注意使用效率较高的读入方式
输入的第一行包含四个整数 n, m, k, t，含义见上所述。

接下来一行，包含 n 个整数，依次表示 $T_1,T_2,\cdots ,T_n$

接下来一行，包含 k 个整数，表示立华奏已经学习过的知识点。如果 k=0，则此处为一空行。
接下来 m 行，每行 3 个整数 $X_i,Y_i,H_i$，描述一种联系。

输出描述:

如果立华奏能够学习完所有的知识点，输出一行 Yes。否则输出 No

示例1

输入

复制

4 3 2 5
4 5 6 7
2 3
1 2 3
1 3 2
3 4 2

输出

复制

Yes

说明

立华奏已经学习过了第 2, 3 个知识，由第 2 个关系，立华奏可以花 2 天学会知识点 1，在由关系 3， 立华奏可以 2 天学会知识点 4，因此总共需要花费 4 天，可以完成任务。

示例2

输入

复制

5 4 0 12
4 5 6 7 1

1 2 3
1 3 2
3 4 2
1 5 233

输出

复制

Yes

说明

立华奏比较菜，因此什么都没有学过。她可以选择先花 4 天的时间学会知识点 1。然后根据关系 1, 2，分别花 3, 2 天的时间学会知识点 2, 3，再根据关系 3，花 2 天的时间学会知识点 4。然后，她再单独学习知识点 5，花费1天，总共花费了 12 天 ，可以完成任务。

请注意，虽然关系 4 允许立华奏在知识点 1 的基础上学习知识点 5，但需要的时间比单独学习还要多，因此立华奏不会在知识点 1 的基础上学习知识点 5.

备注:

$0⩽k⩽n⩽{10}^6,m⩽5\times {10}^6,t⩽{10}^{18},T_i,H_i⩽{10}^3$