BestCoder 1st Anniversary

5/6

这场打得好惨啊，不过学了新姿势，有收获就行，继续被虐orz。。。。

 

题A hdu 5310

题意：可以一个买，可以一次买m个，价格分别为p和q，问你最少花多少钱买n个？

题解：水题，就三种情况！

 

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

#define lson l, m, rt*2
#define rson m + 1, r, rt*2+1
#define xx first
#define yy second

typedef pair<int,int> pii;
typedef long long ll;
typedef unsigned long long ull;

const ll inf = 1LL << 60;

int main() {
//  freopen("case.in", "r", stdin);
  int T;
  cin >> T;
  while (T--) {
    int n, m, p, q;
    scanf("%d%d%d%d", &n, &m, &p, &q);
    ll res = inf;
    res = min(res, 1ll * n * p);
    res = min(res, 1ll * (n + m - 1) / m * q);
    res = min(res, 1ll * n / m * q + 1ll * (n % m) * p) ;
    printf("%I64d\n", res);
  }
  return 0;
}

 

题B hdu 5311

题意：给你一个串，问你能不能由三个子串组成“anniversary”？

题解：数据量小，想怎么暴力就怎么暴力，暴力枚举两个位置，将一个串分成三个部分，然后暴力将“anniversary”也暴力枚举两个位置分成三个部分，然后看每一部分是否有对应的子串，看起来好暴力，可就是过了(/▽╲)

 

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

#define lson l, m, rt*2
#define rson m + 1, r, rt*2+1
#define xx first
#define yy second

typedef pair<int,int> pii;
typedef long long ll;
typedef unsigned long long ull;

const int maxn = 1e2 + 10;
char s[maxn], t[maxn], tmp[3][maxn];
char str[maxn][3][20];
int cnt;

void init() {
  strcpy(t, "anniversary");
  cnt = 0;
  for (int i = 1; i < 11; i++)
    for (int j = i + 1; j < 11; j++) {
      for (int k = 0; k < i; k++) str[cnt][0][k] = t[k];
      for (int k = i; k < j; k++) str[cnt][1][k - i] = t[k];
      for (int k = j; k < 11; k++) str[cnt][2][k - j] = t[k];
      str[cnt][0][i] = str[cnt][1][j] = str[cnt][2][11] = 0;
//      cout << str[cnt][0] << str[cnt][1] << str[cnt][2] << endl;
      cnt++;
    }
}

bool check() {
  int n = strlen(s);
  for (int i = 1; i < n; i++)
    for (int j = i + 1; j < n; j++) {
      for (int k = 0; k < i; k++) tmp[0][k] = s[k];
      for (int k = i; k < j; k++) tmp[1][k - i] = s[k];
      for (int k = j; k < n; k++) tmp[2][k - j] = s[k];
      tmp[0][i] = tmp[1][j - i] = tmp[2][n - j] = 0;
//      cout << tmp[0] << ' ' << tmp[1] << ' ' << tmp[2] << endl;
      for (int k = 0; k < cnt; k++) {
        bool ok = true;
        for (int l = 0; l < 3 && ok; l++)
          if (!strstr(tmp[l], str[k][l])) ok = false;
        if (ok) return true;
      }
    }
  return false;
}

int main() {
//  freopen("case.in", "r", stdin);
  init();
  int T;
  cin >> T;
  while (T--) {
    scanf("%s", s);
    check() ? puts("YES") : puts("NO");
  }
  return 0;
}

 

题C hdu 5312

题意：给你一个序列，第i个元素是3 * n * （n - 1） + 1，然后问你最少需要多少个元素组成m？

题解：本来这道题应该打表找规律，但是贪心错了就不想做了(/▽╲)！

官方题解的做法是：先看一个行不行，再看两个行不行，都不行就找（m - ans） % 6 == 0，为什么可以这样呢？因为可以写成6 * （n * （n - 1）/ 2） + 1，注意到这个n * （n - 1）/ 2，有个神结论：任何一个数都可以用不超过三个三角形数表示，那么假设答案是k（k >= 3），然后就成为6 * （k个三角形数之和） + k = m，显然只要（m - k） % 6 == 0，得到一个数，他肯定可以被k个三角形数表示出来，所以这个结论是对的。

 

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

#define lson l, m, rt*2
#define rson m + 1, r, rt*2+1
#define xx first
#define yy second

typedef pair<int,int> pii;
typedef long long ll;
typedef unsigned long long ull;

const int maxi = 1e9;
vector<int> v;

void init() {
  for (int i = 1;; i++) {
    int temp = 3 * i * (i - 1) + 1;
    v.push_back(temp);
    if (temp > maxi) break;
  }
//  cout << v.size() << endl;
}

bool check1(int x) {
  if (*lower_bound(v.begin(), v.end(), x) == x) {
    puts("1"); return true;
  }
  return false;
}

bool check2(int x) {
  int i = 0, j = v.size() - 1;
  while (i <= j) {
    while (i <= j && v[i] + v[j] > x) --j;
    if (i > j) break;
    if (v[i] + v[j] == x) { puts("2"); return true; }
    ++i;
  }
  return false;
}

int main() {
//  freopen("case.in", "r", stdin);
  init();
  int T;
  cin >> T;
  while (T--) {
    int n;
    scanf("%d", &n);
    if (!check1(n) && !check2(n)) {
      for (int i = 3; i <= 8; i++) if ((n - i) % 6 == 0) {
        printf("%d\n", i); break;
      }
    }
  }
  return 0;
}

 

题D hdu 5313

题意：给你一个图，然后问你最多可以添加多少条边形成一个完全二分图？

题解：这道题我想的方法是背包，然而超时了，因为O（n ^ 2）太大了，正解是biset优化。说下思路：

首先将一个连通子图染色0和1，然后记录这个0和1的数量，然后将每个连通块都记录下来，接下来问题就化成怎么将点组合到左边使得左边和右边的个数差异最小，因为最后假设左边有x个，右边有n - x个，然后答案就是x * （n - x）- m；所以这个差异最小的时候这个数值最大，这个显然可以用0-1背包来做，但是复杂度太大了，虽然侥幸一点的背包能过，但是还是学习正解好了，怎么用biset来优化这个东西呢？

开一个biset表示第i位表示这一个位是可以组成的，然后对于一个（x，y），如果选的是x的话，那么就是biset << x，如果选的是y的话，那么就是biset << y，然后只需要把这两个结果都或起来即可，一开始注意初始化第0个位置为1，联系一下dp的做法即可。其实之前做的一个浙大校赛有一道哈弗曼编码类似的，也是同样的优化思路。

 

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

#define lson l, m, rt*2
#define rson m + 1, r, rt*2+1
#define xx first
#define yy second

typedef pair<int,int> pii;
typedef long long ll;
typedef unsigned long long ull;

const int maxn = 1e4 + 100, maxm = 1e5 + 100;
int n, m, e, head[maxn], color[maxn];
ll res, dp[2][maxn];

struct Edge {
  int v, nx;
} edges[maxm];

void init() {
  e = 0;
  memset(head, -1, sizeof head);
}

void add_edge(int u, int v) {
  edges[e] = (Edge){v, head[u]};
  head[u] = e++;
}

void dfs(int u, int& c1, int& c2) {
  if (color[u] == 1) c1++; else c2++;
  for (int i = head[u]; ~i; i = edges[i].nx) {
    int v = edges[i].v;
    if (color[v] == -1) {
      color[v] = 3 - color[u];
      dfs(v, c1, c2);
    }
  }
}

vector<pii> p;

void slove() {
  memset(color, -1, sizeof color);
  p.clear();
  for (int i = 1; i <= n; i++) if (color[i] == -1) {
    int c1 = 0, c2 = 0;
    color[i] = 1;
    dfs(i, c1, c2);
    p.push_back(make_pair(c1, c2));
  }
  bitset<10010> b;
  b[0] = 1;
  for (int i = 0; i < (int)p.size(); i++) {
    b = (b << p[i].xx) | (b << p[i].yy);
  }
  int ans = 0;
  for (int i = 1; i <= n; i++) if (b[i])
    ans = max(ans, i * (n - i));
  cout << ans - m << endl;
}

int main() {
//  freopen("case.in", "r", stdin);
  int T;
  cin >> T;
  while (T--) {
    init();
    scanf("%d%d", &n, &m);
    for (int i = 0; i < m; i++) {
      int u, v;
      scanf("%d%d", &u, &v);
      add_edge(u, v); add_edge(v, u);
    }
    slove();
  }
  return 0;
}

 

题E hdu 5314

题意：给你一颗树，找有多少对点满足最大值-最小值 <= D?

题解：显然树分治，听说可以用LCT水，然而并不会，所以只能用树分治。做的时候也是差不多想到正解了，但是错估复杂度了，没敢往下写，GG。。。。。

对于跨过重心的点对（u，v），有两种方法统计：

（1）常规做法：记录所有点到重心的最大值和最小值到一个vector中，然后先对x排个序，对于（xi，yi）找j < i，满足xi - yj <= D并且xi - yi <= D，因为可以确定xi一定是最大值的，但是最小值可能是yi，可能是yj，统计的时候可以先离散化，然后用树状数组即可。这是O（nlog²n）的做法，一下是少个log的做法：

 

（2）只需要对最小值由小到大排个序，然后对于当前点对（xi，yi）（其中xi是最小值，yi是最大值）统计（yi - D，0）的数量即可。为什么可以这样做呢？

首先我们分析为什么不能够这样做？因为对了x排序，找x >= yi - D的数量即保证了对于当前的点对的yi作为最大值，x作为最小值的点对满足。有可能存在x <= xj，然后yj比这个yi更大，也就是yj可能作为最大值使得这个东西不满足，等等，这个yj - xj是一定满足的（不满足的不加进vector中），那么不就不存在任何问题了，也就是如果这个yi作为最大值，那么一定满足，如果不作为最大值，那么找到yj作为最大值对应的xj肯定满足，所以并不需要树状数组离散化之后再来统计。这个完美地利用了点对的特点降了一个log。

 

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

#define lson l, m, rt*2
#define rson m + 1, r, rt*2+1
#define xx first
#define yy second

typedef pair<int,int> pii;
typedef long long ll;
typedef unsigned long long ull;

const int maxn = 1e5 + 100;
int n, D, e, head[maxn];

struct Edge {
  int v, nx;
} edges[maxn * 2];

void init() {
  e = 0;
  memset(head, -1, sizeof head);
}

void add_edge(int u, int v) {
  edges[e] = (Edge){v, head[u]};
  head[u] = e++;
}

int sz[maxn], vis[maxn];

void dfs_s(int u, int p) {
  sz[u] = 1;
  for (int i = head[u]; ~i; i = edges[i].nx) {
    int v = edges[i].v;
    if (v == p || vis[v]) continue;
    dfs_s(v, u);
    sz[u] += sz[v];
  }
}

int dp[maxn], val[maxn];

void dfs_t(int& s, int u, int p, int cnt) {
  dp[u] = 0;
  for (int i = head[u]; ~i; i = edges[i].nx) {
    int v = edges[i].v;
    if (v == p || vis[v]) continue;
    dfs_t(s, v, u, cnt);
    dp[u] = max(dp[u], sz[v]);
  }
  dp[u] = max(dp[u], cnt - sz[u]);
  if (s == -1 || dp[u] < dp[s]) s = u;
}

struct Tree {
  int C[maxn], sz;
  inline int lowbit(int x) {
    return x & (-x);
  }
  void init(int sz) {
    this->sz = sz + 1;
    for (int i = 0; i <= this->sz; i++) C[i] = 0;
  }
  void update(int x, int d) {
    while (x <= sz) {
      C[x] += d;
      x += lowbit(x);
    }
  }
  int sum(int x) {
    int ret = 0;
    while (x > 0) {
      ret += C[x];
      x -= lowbit(x);
    }
    return ret;
  }
} T;

vector<pii> x;
int c;

void dfs_c(int u, int p, int MAX, int MIN) {
  MAX = max(val[u], MAX);
  MIN = min(val[u], MIN);
  x.push_back(make_pair(MAX, MIN));
  for (int i = head[u]; ~i; i = edges[i].nx) {
    int v = edges[i].v;
    if (v == p || vis[v]) continue;
    dfs_c(v, u, max(MAX, val[v]), min(MIN, val[v]));
  }
}

ll cal(int u, int p, int MIN, int MAX) {
  x.clear();
  dfs_c(u, p, MIN, MAX);
  sort(x.begin(), x.end());
  vector<int> tmp;
  for (int i = 0; i < (int)x.size(); i++) tmp.push_back(x[i].yy);
  sort(tmp.begin(), tmp.end());
  tmp.erase(unique(tmp.begin(), tmp.end()), tmp.end());
  T.init(tmp.size());
  ll ret = 0;
  for (int i = 0; i < (int)x.size(); i++) {
    int xx = x[i].xx, yy = x[i].yy;
    if (xx - yy <= D) {
      int id = lower_bound(tmp.begin(), tmp.end(), xx - D) - tmp.begin();
      ret += i - T.sum(id);
    }
    int id = lower_bound(tmp.begin(), tmp.end(), yy) - tmp.begin() + 1;
    T.update(id, 1);
  }
  return ret;
}

ll slove(int u) {
  dfs_s(u, -1);
  int cnt = sz[u], t = u;
  u = -1;
  dfs_t(u, t, -1, cnt);
  vis[u] = 1;
  ll ret = 0;
  ret += cal(u, -1, val[u], val[u]);
  for (int i = head[u]; ~i; i = edges[i].nx) {
    int v = edges[i].v;
    if (vis[v]) continue;
    ret -= cal(v, u, val[u], val[u]);
  }
  for (int i = head[u]; ~i; i = edges[i].nx) {
    int v = edges[i].v;
    if (vis[v]) continue;
    ret += slove(v);
  }
  return ret;
}

void gao() {
  scanf("%d%d", &n, &D);
  for (int i = 1; i <= n; i++) scanf("%d", val + i);
  init();
  for (int i = 1; i < n; i++) {
    int u, v;
    scanf("%d%d", &u, &v);
    add_edge(u, v); add_edge(v, u);
  }
  memset(vis, 0, sizeof vis);
  ll res = slove(1);
  printf("%I64d\n", res * 2);
}

int main() {
// freopen("case.in", "r", stdin);
  int T;
  cin >> T;
  while (T--) gao();
  return 0;
}

 

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

#define lson l, m, rt*2
#define rson m + 1, r, rt*2+1
#define xx first
#define yy second

typedef pair<int,int> pii;
typedef long long ll;
typedef unsigned long long ull;

const int maxn = 1e5 + 100;
int n, D, e, head[maxn];

struct Edge {
  int v, nx;
} edges[maxn * 2];

void init() {
  e = 0;
  memset(head, -1, sizeof head);
}

void add_edge(int u, int v) {
  edges[e] = (Edge){v, head[u]};
  head[u] = e++;
}

int sz[maxn], vis[maxn];

void dfs_s(int u, int p) {
  sz[u] = 1;
  for (int i = head[u]; ~i; i = edges[i].nx) {
    int v = edges[i].v;
    if (v == p || vis[v]) continue;
    dfs_s(v, u);
    sz[u] += sz[v];
  }
}

int dp[maxn], val[maxn];

void dfs_t(int& s, int u, int p, int cnt) {
  dp[u] = 0;
  for (int i = head[u]; ~i; i = edges[i].nx) {
    int v = edges[i].v;
    if (v == p || vis[v]) continue;
    dfs_t(s, v, u, cnt);
    dp[u] = max(dp[u], sz[v]);
  }
  dp[u] = max(dp[u], cnt - sz[u]);
  if (s == -1 || dp[u] < dp[s]) s = u;
}

pii S[maxn];
int c;

void dfs_c(int u, int p, int MAX, int MIN) {
  MAX = max(val[u], MAX);
  MIN = min(val[u], MIN);
  if (MAX - MIN <= D) S[c++] = make_pair(MIN, MAX);
  for (int i = head[u]; ~i; i = edges[i].nx) {
    int v = edges[i].v;
    if (v == p || vis[v]) continue;
    dfs_c(v, u, max(MAX, val[v]), min(MIN, val[v]));
  }
}

ll cal(int u, int p, int MIN, int MAX) {
  c = 0;
  dfs_c(u, p, MIN, MAX);
  sort(S, S + c);
  ll ret = 0;
  for (int i = 0; i < c; i++) {
    int p = lower_bound(S, S + c, make_pair(S[i].yy - D, 0)) - S;
    ret += i - p;
  }
  return ret;
}

ll slove(int u) {
  dfs_s(u, -1);
  int cnt = sz[u], t = u;
  u = -1;
  dfs_t(u, t, -1, cnt);
  vis[u] = 1;
  ll ret = 0;
  ret += cal(u, -1, val[u], val[u]);
  for (int i = head[u]; ~i; i = edges[i].nx) {
    int v = edges[i].v;
    if (vis[v]) continue;
    ret -= cal(v, u, val[u], val[u]);
  }
  for (int i = head[u]; ~i; i = edges[i].nx) {
    int v = edges[i].v;
    if (vis[v]) continue;
    ret += slove(v);
  }
  return ret;
}

void gao() {
  scanf("%d%d", &n, &D);
  for (int i = 1; i <= n; i++) scanf("%d", val + i);
  init();
  for (int i = 1; i < n; i++) {
    int u, v;
    scanf("%d%d", &u, &v);
    add_edge(u, v); add_edge(v, u);
  }
  memset(vis, 0, sizeof vis);
  ll res = slove(1);
  printf("%I64d\n", res * 2);
}

int main() {
//  freopen("case.in", "r", stdin);
  int T;
  cin >> T;
  while (T--) gao();
  return 0;
}