Educational Codeforces Round 3

这个Education的不算Rating的，难得处女战。。。还是写个前五题的题解，纪念一下~~

 

题A

题意：给你n个u盘，每个的存储容量ai，然后让你存一个容量为m的东西，问你要多少个u盘。

题解：这个如果看成背包问题的话，就是价值为1的容量为ai的背包，然而价值都是一样的，那么就可以直接排序贪心取较大的即可。

/*zhen hao*/
#include <bits/stdc++.h>
using namespace std;

const int maxn = 1e3 + 10;
int val[maxn];

int main() {
 // freopen("case.in", "r", stdin);
  int n, m;
  cin >> n >> m;
  for (int i = 0; i < n; i++) cin >> val[i];
  sort(val, val + n);
  int sum = 0, ans = 0;
  for (int i = n - 1; i >= 0; i--) {
    sum += val[i]; ans++;
    if (sum >= m) break;
  }
  cout << ans << endl;
}

既然可以当成背包做，就有了一下版本。。

/*zhen hao*/
#include <bits/stdc++.h>
using namespace std;

const int maxn = 1e5 + 100;
int dp[maxn], val[maxn];

int main() {
  //freopen("case.in", "r", stdin);
  int n, m;
  cin >> n >> m;
  int sum = 0;
  for (int i = 1; i <= n; i++)  {
    cin >> val[i];
    sum += val[i];
  }
  for (int i = 1; i <= sum; i++)  dp[i] = maxn;
  for (int i = 1; i <= n; i++) {
    for (int j = sum; j >= val[i]; j--) {
      dp[j] = min(dp[j], dp[j - val[i]] + 1);
    }
  }
  int ans = maxn;
  for (int i = m; i <= sum; i++)  ans = min(ans, dp[i]);
  cout << ans << endl;
}

题B

题意：给你n本书，有m种种类，问你取两种不同种类有多少种方案。

题解：虽然n很大，但是m很小，所以枚举书的种类即可。。

/*zhen hao*/
#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
ll num[110];

int main() {
  //freopen("case.in", "r", stdin);
  int n, m;
  cin >> n >> m;
  for (int i = 1; i <= n; i++) {
    int v; cin >> v;
    num[v]++;
  }
  ll ans = 0;
  for (int i = 1; i <= m; i++)
    for (int j = 1; j <= m; j++)
      if (i != j) ans += num[i] * num[j];
  cout << (ans / 2) << endl;
}

题C

题意：给你n个服务器，每个服务器可以做的任务数mi，然后可以用一秒钟的时间将一个任务从一个服务器，传到另外一个服务器，问你最少需要多少时间使得所有服务器的最大值-最小值最小。

题解：这道题应该也是贪心吧，先我们给出最后的服务器应该有的结果，然后排序之后与最后的结果一一做差，最后除以2就是要花费的最短时间了，理解一下其中贪心为何成立。

/*zhen hao*/
#include <bits/stdc++.h>
using namespace std;

const int maxn = 1e5 + 100;
int val[maxn], newv[maxn];

int main() {
  //freopen("case.in", "r", stdin);
  int n, sum = 0;
  cin >> n;
  for (int i = 1; i <= n; i++) {
    cin >> val[i];
    sum += val[i];
  }
  sort(val + 1, val + 1 + n);
  int x = n - sum % n;
  for (int i = 1; i <= x; i++)  newv[i] = sum / n;
  for (int i = x + 1; i <= n; i++)  newv[i] = sum / n + 1;
  int ans = 0;
  for (int i = 1; i <= n; i++)  ans += abs(newv[i] - val[i]);
  cout << (ans / 2) << endl;
}

题D

题意：有m个货物，需要购买k个，然后要兑换相应的货币进行购买。兑换规则如下：给出每一天的英镑和美元的单价，也就是假设现在手上的是软妹币，然后5就代表5个软妹币换成一个美元，共n天。然后你可以选择任意一天进行兑换任意数量的货币，然后进行购买，现在问你最少需要多少天可以买到k个货物。

题解：这里的情况有点乱，理清一下，就是现在有n天的兑换时间，我们要选择一天兑换足够的英镑和美元，然后购买需要最少钱的m个货物中的k个货物，因为可能靠前的兑换规则兑换的少，但是时间够早，也有可能要到最后一天才可以兑换最多的货币，但是时间慢。对于这种情况一般是要枚举，但是数据量都很大，怎么枚举比较合适呢？这是这道题的难题。答案就是枚举天数，我们枚举这一天，然后看着一天是否满足，如果满足就挪到前面去，如果不满足就往后枚举，由于满足单调性，所以我们就采用二分来进行枚举。复杂度为O(nlogn)。

/*zhen hao*/
#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
const int maxn = 2e5 + 10;
const int inf = 1e8;
int n, m, k, s;
int a[maxn], b[maxn], t[maxn], v[maxn];
vector<pair<ll, pair<int, int> > > item;

bool check(int day) {
  item.clear();
  int mina = inf, minb = inf;
  int posa, posb;
  for (int i = 1; i <= day; i++) {
    if (mina > a[i]) mina = a[i], posa = i;
    if (minb > b[i]) minb = b[i], posb = i;
  }
  for (int i = 1; i <= m; i++) {
    if (t[i] == 1) item.push_back(make_pair(1ll * v[i] * mina, make_pair(i, posa)));
    else item.push_back(make_pair(1ll * v[i] * minb, make_pair(i, posb)));
  }
  sort(item.begin(), item.end());
  ll sum = 0;
  for (int i = 0; i < k; i++) sum += item[i].first;
  return s >= sum;
}

int main() {
  //freopen("case.in", "r", stdin);
  cin >> n >> m >> k >> s;
  for (int i = 1; i <= n; i++)  scanf("%d", a + i);
  for (int i = 1; i <= n; i++)  scanf("%d", b + i);
  for (int i = 1; i <= m; i++)  scanf("%d%d", t + i, v + i);
  int l = 0, r = n + 1;
  while (l + 1 < r) {
    int m = (l + r) / 2;
    if (check(m)) r = m;
    else l = m;
  }
  if (l == n) { puts("-1"); return 0; }
  printf("%d
", r);
  check(r);
  for (int i = 0; i < k; i++) printf("%d %d
", item[i].second.first, item[i].second.second);
  return 0;
}

注意上面二分的写法，这是我从cf的代码中看到的一种比较新颖的方式，我们需要的是最前面的满足条件的最前面的天数，具体做法是先让l和r都后退一步，然后如果有一种情况满足就赋值给r，然后当r前面的那个不满足的时候我们找到的r就是满足情况的最小的方式，也就是l+1<r，如果还满足会赋值给r，所以最后找到的r就是满足答案的最小值。最后还有一个细节就是check（r）之后方便输出答案。

题E

题意：给你一个图，有m条边，如果让你一定要选这条边的最小生成树的权值是多少。输出m个数作为答案。

题解：先求出最小生成树，我们可以发现如果（u，v）要加进去的话，那么形成的环里减去最大权值的一个边就可以，这也是求最小生成树贪心的想法，求这个环内最大权值用的方法就是倍增LCA，在找最近祖先的时候维护一个类似地val[i][j]，表示i这个结点到1<<j的结点中的最大权值，然后在求LCA的过程中更新答案即可。

/*zhen hao*/
#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
const int maxn = 2e5 + 100;
const int maxd = 25;
int n, m, tot;
int head[maxn], fa[maxn][maxd], val[maxn][maxd], root[maxn], dep[maxn];
ll ans[maxn];

struct Edge1 {
  int u, v, w, id;
  bool operator < (const Edge1& a) const {
    return w < a.w;
  }
};

struct Edge2 {
  int v, w, next;
};

Edge1 edge1[maxn];
Edge2 edge2[maxn<<1];

void init_tree() {
  memset(head, -1, sizeof head);
  tot = 0;
}

void add_edge(int u, int v, int w) {
  edge2[tot] = (Edge2){v, w, head[u]};
  head[u] = tot++;
}

int find_set(int rt) {
  if (rt == root[rt]) return rt;
  return root[rt] = find_set(root[rt]);
}

void bfs(int rt) {
  queue<int> q;
  q.push(rt);
  fa[rt][0] = rt;
  dep[rt] = 1;
  while (!q.empty()) {
    int u = q.front(); q.pop();
    for (int i = 1; i < maxd; i++)  fa[u][i] = fa[fa[u][i - 1]][i - 1];
    for (int i = 1; i < maxd; i++)  val[u][i] = max(val[u][i - 1], val[fa[u][i - 1]][i - 1]);
    for (int i = head[u]; ~i; i = edge2[i].next) {
      int v = edge2[i].v;
      if (v == fa[u][0])  continue;
      fa[v][0] = u;
      val[v][0] = edge2[i].w;
      dep[v] = dep[u] + 1;
      q.push(v);
    }
  }
}

int find_ans(int u, int v) {
  if (dep[u] > dep[v])  swap(u, v);
  int du = dep[u], dv = dep[v], ret = 0;
  for (int d = dv - du, i = 0; d; i++, d >>= 1) {
    if (d & 1) { ret = max(ret, val[v][i]); v = fa[v][i]; }
  }
  if (u == v) return ret;
  for (int i = maxd - 1; i >= 0; i--) {
    if (fa[u][i] == fa[v][i]) continue;
    ret = max(ret, val[u][i]);  u = fa[u][i];
    ret = max(ret, val[v][i]);  v = fa[v][i];
  }
  ret = max(ret, val[u][0]);
  ret = max(ret, val[v][0]);
  return ret;
}

int main() {
  //freopen("case.in", "r", stdin);
  cin >> n >> m;
  for (int i = 0; i < m; i++) {
    int u, v, w;
    scanf("%d%d%d", &u, &v, &w);
    edge1[i] = (Edge1){u, v, w, i};
  }

  init_tree();
  for (int i = 1; i <= n; i++)  root[i] = i;

  sort(edge1, edge1 + m);
  ll res = 0;
  for (int i = 0; i < m; i++) {
    int fu = find_set(edge1[i].u);
    int fv = find_set(edge1[i].v);
    if (fu != fv) {
      res += edge1[i].w;
      root[fv] = fu;
      add_edge(edge1[i].u, edge1[i].v, edge1[i].w);
      add_edge(edge1[i].v, edge1[i].u, edge1[i].w);
    }
  }
  bfs(1);
  for (int i = 0; i < m; i++) {
    ans[edge1[i].id] = res - find_ans(edge1[i].u, edge1[i].v) + edge1[i].w;
  }
  for (int i = 0; i < m; i++) {
    cout << ans[i] << endl;
  }
}

代码写得有点丑，将就着看。。。