2018-2019 ACM-ICPC, Asia Xuzhou Regional Contest Solution

A. Rikka with Minimum Spanning Trees

题意：

给出一个图，求最小生成树的个数和权值

思路：

因为数据随机，只有一个MST

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

 #define ull unsigned long long
 ull k1, k2;
 const ull MOD = (ull)1e9 + ;
 int t, n, m;

 ull f()
 {
     ull k3 = k1, k4 = k2;
     k1 = k4;
     k3 ^= k3 << ;
     k2 = k3 ^ k4 ^ (k3 >> ) ^ (k4 >> );
     return k2 + k4;
 }

 struct Edge
 {
     int u, v; ull w;
     Edge() {}
     Edge(int u, int v, ull w) : u(u), v(v), w(w) {}
     bool operator < (const Edge &other) const { return w < other.w; }
 }edge[];

 int fa[];
 int find(int x) { return fa[x] ==  ? x : fa[x] = find(fa[x]); } 

 void Kruskal()
 {
     memset(fa, , sizeof fa);
     sort(edge + , edge +  + m);
     int cnt = ;
     ull res = ;
     for (int i = ; i <= m; ++i)
     {
         int u = edge[i].u, v = edge[i].v; ull w = edge[i].w;
 //        cout << i << " " << w << endl;
         int fu = find(u), fv = find(v);
         if (fu == fv) continue;
         ++cnt;
         res = (res + w) % MOD;
         fa[fu] = fv;
         if (cnt == n) break;
     }
     if (cnt != n) res = ;
     printf("%llu\n", res);
 }

 int main()
 {
     scanf("%d", &t);
     while (t--)
     {
         scanf("%d%d%llu%llu", &n, &m, &k1, &k2);
         for (int i = ; i <= m; ++i)
         {
             edge[i].u = f() % n + ;
             edge[i].v = f() % n + ;
             edge[i].w = f();
 //            cout << edge[i].u << " " << edge[i].v << " " << edge[i].w << endl;
         }
         Kruskal();
     }
     return ;
 }

G. Rikka with Intersections of Paths

题意：

给出一棵树，以及$m条简单路径，求从这些简单路径中选出k条，有多少种不同方式使得路径交至少为1$

思路：

枚举路径交的$LCA$, 对于一个点来说，它的贡献是，所有经过它的路径假设为$x$

那么有$C_x^k$ 但是对于一些路径的$LCA不是它，那么这些路径中选出k条的贡献肯定在他们所在的LCA处被计算$

所以应该被减去，也就是说假设经过它但是$LCA不是它的路径条数假设为y条$

那么需要减去$C_y^k$

最终贡献为$C_x^k - C_y^k$

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

 #define ll long long
 #define N 300010
 const ll MOD = (ll)1e9 + ;
 int t, n, m, k;
 vector <int> G[N];

 int fa[N], deep[N], sze[N], son[N], top[N];
 void DFS(int u)
 {
     sze[u] = ;
     for (auto v : G[u]) if (v != fa[u])
     {
         fa[v] = u;
         deep[v] = deep[u] + ;
         DFS(v);
         sze[u] += sze[v];
         if (!son[u] || sze[v] > sze[son[u]]) son[u] = v;
     }
 }

 void getpos(int u, int sp)
 {
     top[u] = sp;
     if (!son[u]) return;
     getpos(son[u], sp);
     for (auto v : G[u]) if (v != fa[u] && v != son[u])
         getpos(v, v);
 }

 int querylca(int u, int v)
 {
     while (top[u] != top[v])
     {
         if (deep[top[u]] < deep[top[v]]) swap(u, v);
         u = fa[top[u]];
     }
     return deep[u] > deep[v] ? v : u;
 }

 int cnt[N], tag[N];
 void add(int u)
 {
     for (auto v : G[u]) if (v != fa[u])
     {
         add(v);
         cnt[u] += cnt[v];
     }
 }

 ll fac[N], inv[N];
 ll qmod(ll base, ll n)
 {
     ll res = ;
     while (n)
     {
         if (n & ) res = (res * base) % MOD;
         base = (base * base) % MOD;
         n >>= ;
     }
     return res;
 }

 void init()
 {
     fac[] = ;
     for (int i = ; i <= ; ++i) fac[i] = (fac[i - ] * i) % MOD;
     inv[] = qmod(fac[], MOD - );
     for (int i = ; i >= ; --i) inv[i - ] = (inv[i] * i) % MOD;
 }

 ll C(int n, int m)
 {
     if (m > n) return ;
     return fac[n] * inv[m] % MOD * inv[n - m] % MOD;
 }

 int main()
 {
     init();
     scanf("%d", &t);
     while (t--)
     {
         scanf("%d%d%d", &n, &m, &k);
         for (int i = ; i <= n; ++i) G[i].clear(), son[i] = , cnt[i] = , tag[i] = ;
         for (int i = , u, v; i <= n - ; ++i)
         {
             scanf("%d%d", &u, &v);
             G[u].push_back(v);
             G[v].push_back(u);
         }
         DFS(); getpos(, );
         for (int i = , u, v; i <= m; ++i)
         {
             scanf("%d%d", &u, &v);
             int lca = querylca(u, v);
             ++tag[lca];
             ++cnt[u];
             ++cnt[v];
             --cnt[lca];
             if (fa[lca]) --cnt[fa[lca]];
         }
         add();
         ll res = ;
         for (int i = ; i <= n; ++i) res = (res + C(cnt[i], k) - C(cnt[i] - tag[i], k) + MOD) % MOD;
         printf("%lld\n", res);
     }
     return ;
 }