Weekly Challenges - Week 11

一拖再拖，忍无可忍，自己懒的没救了。

一周前就结束的比赛，到现在才想起来补。

最后一题貌似又遇到了splay。。。还是不会！！！shit

题目链接

Ａ题－－快速幂

 #include <cmath>
 #include <cstdio>
 #include <vector>
 #include <iostream>
 #include <algorithm>
 using namespace std;

 const int MOD = 1e9 + ;

 int mod_pow(int a, int b) {
     int res = ;
     while (b) {
         if (b & ) res = (res * (long long)a) % MOD;
         a = (a * (long long)a) % MOD;
         b >>= ;
     }
     return res;
 }

 int main() {
     /* Enter your code here. Read input from STDIN. Print output to STDOUT */
     int T;
     ios::sync_with_stdio(false);
     cin >> T;
     while (T--) {
         int t;
         cin >> t;
         cout << ( + mod_pow(, t + )) % MOD << endl;
     }
     return ;
 }

Ｂ题

如果说这题的困难之处，那就是要看出来其实这种数的个数很少。所以先把所有的范围之内的数打表出来。

 #include <cmath>
 #include <cstdio>
 #include <vector>
 #include <iostream>
 #include <algorithm>
 using namespace std;

 typedef long long LL;
 #define rep(i, n) for (int i = (1); i <= (n); i++)
 LL pw10[];
 const LL MAX_N = (LL)1e18;

 int main() {
     pw10[] = 1LL;
     rep (i, ) pw10[i] = pw10[i - ] * ;
     vector<LL> ans;
     rep (i, ) ans.push_back(i);
     int cur = , cur_len = , next = -;
     while (true) {
         if (next == -  && ans[cur] * (cur_len + ) >= pw10[cur_len]) {
             next = cur;
         }
         LL x = ans[cur] * cur_len;
         if (x >= MAX_N) break;
         if (pw10[cur_len - ] <= x && x < pw10[cur_len]) {
             ans.push_back(x);
         } else if (x >= pw10[cur_len]) {
             cur = next;
             next = -;
             cur_len++;
             continue;
         }
         cur++;
     }
     //rep (i, 25) cerr << ans[i] << endl;
     int T;
     cin >> T;
     while (T--) {
         LL A, B;
         cin >> A >> B;
         LL rgt = upper_bound(ans.begin(), ans.end(), B) - ans.begin();
         LL lft = lower_bound(ans.begin(), ans.end(), A) - ans.begin();
         LL res = rgt - lft;
         if (A == ) res++;
         cout << res << endl;
     }

     return ;
 }

Ｃ题

题意：给出Ｎ个结点的树，每个结点有一个权值，在树上有一种操作，可以任选一个结点，然后删除以该结点为根的子树。最多执行Ｋ次这种操作

　　　使得树上的权值总和最大。

首先，如果按照前序遍历访问每个结点的顺序给结点做标记，那么以某个结点为根的子树中所有结点的标记一定该结点的后面。

dfs时顺便维护一下以每个结点为根的子树中结点的个数tot[i]。

dp[i][j]表示到dfs中第ｉ个遍历的结点为止操作了ｊ次可以获得的最大权值。

这样当到达第ｉ个结点时，dp[i + 1][j] = max(dp[i + 1][j], dp[i][j] + value[i])   //不删除

　　　　　　　　　　　　dp[i + tot[i]][j + 1] = max(dp[i + tot[i]][j + 1], dp[i][j])　／／删除

 #include <cmath>
 #include <cstdio>
 #include <vector>
 #include <iostream>
 #include <algorithm>
 using namespace std;

 const int MAX_N = ;
 typedef long long LL;
 const LL INF = (LL)1e19;
 vector<int> G[MAX_N];
 int w[MAX_N], vs[MAX_N], tot[MAX_N], cnt;
 LL dp[MAX_N][];

 void dfs(int u, int fa) {
      int sz = (int)G[u].size();
      vs[++cnt] = u;
      tot[u] = ;
      if (sz == ) {
          return ;
      }
      for (int i = ; i < sz; i++) {
         int v = G[u][i];
         if (v == fa) continue;
         dfs(v, u);
         tot[u] += tot[v];
     }
 }

 void read(int &res) {
     res = ;
     int sign = ;
     char c = ' ';
     while (c < '' || c > '') {
         if (c == '-') sign = -;
         c = getchar();
     }
     while (c >= '' && c <= '') res = (res<<) + (res<<) + c - '', c = getchar();
     if (sign == -) res = -res;
 }

 int main() {
     ios::sync_with_stdio(false);
     int N, K;
     cin >> N >> K;
     //read(N); read(K);
     for (int i = ; i <= N; i++) cin >> w[i];//read(w[i]);
     for (int i = ; i <  N; i++) {
         int u, v;
         cin >> u >> v;
         //read(u), read(v);
         G[u].push_back(v);
         G[v].push_back(u);
     }
     cnt = ;
     dfs(, -);
     for (int i = ; i <= K; i++) for (int j = ; j <= N; j++) dp[j][i] = -INF;
     //for (int i = 0; i <= K; i++) dp[0][i] = 0;
     dp[][] = ;
     for (int i = ; i <= N; i++) {
         int u = vs[i];
         for (int j = ; j <= K; j++) if (dp[i][j] != -INF) {
             dp[i + ][j] = max(dp[i + ][j], dp[i][j] + w[u]);
             if (j < K)
                 dp[i + tot[u]][j + ] = max(dp[i + tot[u]][j + ], dp[i][j]);
         }
     }
     LL res = -INF;
     for (int i = ; i <= K; i++) res = max(res, dp[N + ][i]);
     cout << res << endl;

     return ;
 }

Ｄ题

题意：Ｎ种技能，第ｉ种技能有ci个人学会，有Ｔ个巫师，每个巫师有两个集合Ａ和Ｂ，他可以把一个拥有Ａ集合中的技能的人转移到集合Ｂ中的某个技能中去。

问最多可以使多少个技能至少有一个人学会。

增加一个源点和汇点，源点到Ｎ种技能连一条容量为ci的边，从Ｎ种技能到汇点连一条容量为１的边。

对于每个巫师，从Ａ集合中的技能连一条容量为１的边到该巫师，从该巫师连一条容量为１的边到Ｂ集合中的每种技能。

最大流即为答案。。。

 #include <queue>
 #include <cmath>
 #include <cstdio>
 #include <vector>
 #include <cstring>
 #include <iostream>
 #include <algorithm>
 using namespace std; 

 struct edge {
     int to, cap, rev;
     edge() {}
     edge(int _to, int _cap, int _rev):to(_to), cap(_cap), rev(_rev) {}
 };
 const int INF = 0x3f3f3f3f;
 const int MAX_V = ; // ????`
 vector<edge> G[MAX_V]; // ?????
 int level[MAX_V]; // ??????????
 int iter[MAX_V];  // ????????????????
 int Q[MAX_V]; // BFS??

 void add_edge(int from, int to, int cap) {
     G[from].push_back(edge(to, cap, G[to].size()));
     G[to].push_back(edge(from, , G[from].size() - ));
 }

 // ?????????????????
 void bfs(int s) {
     memset(level, -, sizeof(level));
     int ini = , end = ;
     Q[end++] = s;
     level[s] = ;
     while (end > ini) {
         int v = Q[ini++];
         for (int i = ; i < G[v].size(); i++) {
             edge &e = G[v][i];
             if (e.cap >  && level[e.to] < ) {
                 level[e.to] = level[v] + ;
                 Q[end++] = e.to;
             }
         }
     }
 }

 // ??????????
 int dfs(int v, int t, int f) {
     if (v == t) return f;
     for (int &i = iter[v]; i < G[v].size(); i++) {
         edge &e = G[v][i];
         if (e.cap >  && level[v] < level[e.to]) {
             int d = dfs(e.to, t, min(f, e.cap));
             if (d > ) {
                 e.cap -= d;
                 G[e.to][e.rev].cap += d;
                 return d;
             }
         }
     }
     return ;
 }

 // ??????????
 int Dinic(int s, int t) {
     int flow = ;
     for (;;) {
         bfs(s);
         if (level[t] < ) return flow;
         memset(iter, , sizeof(iter));
         int f;
         while ((f = dfs(s, t, INF)) > ) {
             flow += f;
         }
     }
 }

 int main() {
     ios_base::sync_with_stdio(false);

     int N, T;
     cin >> N >> T;
     int s = , t = N + T + ;

     for (int i = ; i <= N; i++) {
         int C;
         cin >> C;
         add_edge(s, i, C);
         add_edge(i, t, );
     }
     for (int i = ; i <= T; i++) {
         int A, B;
         cin >> A;
         for (int j = ; j <= A; j++) {
             int x;
             cin >> x;
             add_edge(x, N + i, );
         }
         cin >> B;
         for (int j = ; j <= B; j++) {
             int x;
             cin >> x;
             add_edge(N + i, x, );
         }
     }

     cout << Dinic(s, t) << endl;
     return ;
 }

 #include <queue>
 #include <cmath>
 #include <cstdio>
 #include <vector>
 #include <cstring>
 #include <iostream>
 #include <algorithm>
 using namespace std; 

 struct edge {
     int to, cap, rev;
     edge() {}
     edge(int _to, int _cap, int _rev):to(_to), cap(_cap), rev(_rev) {}
 };
 const int INF = 0x3f3f3f3f;
 const int MAX_V = ; // ????`
 vector<edge> G[MAX_V]; // ?????
 int level[MAX_V]; // ??????????
 int iter[MAX_V];  // ????????????????
 int Q[MAX_V]; // BFS??

 void add_edge(int from, int to, int cap) {
     G[from].push_back(edge(to, cap, G[to].size()));
     G[to].push_back(edge(from, , G[from].size() - ));
 }

 // ?????????????????
 void bfs(int s) {
     memset(level, -, sizeof(level));
     int ini = , end = ;
     Q[end++] = s;
     level[s] = ;
     while (end > ini) {
         int v = Q[ini++];
         for (int i = ; i < G[v].size(); i++) {
             edge &e = G[v][i];
             if (e.cap >  && level[e.to] < ) {
                 level[e.to] = level[v] + ;
                 Q[end++] = e.to;
             }
         }
     }
 }

 // ??????????
 int dfs(int v, int t, int f) {
     if (v == t) return f;
     for (int &i = iter[v]; i < G[v].size(); i++) {
         edge &e = G[v][i];
         if (e.cap >  && level[v] < level[e.to]) {
             int d = dfs(e.to, t, min(f, e.cap));
             if (d > ) {
                 e.cap -= d;
                 G[e.to][e.rev].cap += d;
                 return d;
             }
         }
     }
     return ;
 }

 // ??????????
 int Dinic(int s, int t) {
     int flow = ;
     for (;;) {
         bfs(s);
         if (level[t] < ) return flow;
         memset(iter, , sizeof(iter));
         int f;
         while ((f = dfs(s, t, INF)) > ) {
             flow += f;
         }
     }
 }

 int main() {
     ios_base::sync_with_stdio(false);

     int N, T;
     cin >> N >> T;
     int s = , t = N + T + ;

     for (int i = ; i <= N; i++) {
         int C;
         cin >> C;
         add_edge(s, i, C);
         add_edge(i, t, );
     }
     for (int i = ; i <= T; i++) {
         int A, B;
         cin >> A;
         for (int j = ; j <= A; j++) {
             int x;
             cin >> x;
             add_edge(x, N + i, );
         }
         cin >> B;
         for (int j = ; j <= B; j++) {
             int x;
             cin >> x;
             add_edge(N + i, x, );
         }
     }

     cout << Dinic(s, t) << endl;
     return ;
 }

Ｅ题