2017 ACM/ICPC Asia Regional Qingdao Online Solution

A : Apple

题意：给出三个点，以及另一个点，求最后一个点是否在三个点的外接圆里面，如果在或者在边界上，输出“Rejected”，否则输出"Accepted"

思路：先求一个外接圆，得到圆心和半径，再判一下，注意精度问题，用JAVA

 import java.math.BigDecimal;
 import java.util.Scanner;

 public class Main {

     public static void main(String[] args) {
         Scanner in = new Scanner(System.in);
         int t = in.nextInt();
         for(int cas = 1; cas <= t; ++cas)
         {
             BigDecimal x1 = in.nextBigDecimal();
             BigDecimal y1 = in.nextBigDecimal();
             BigDecimal x2 = in.nextBigDecimal();
             BigDecimal y2 = in.nextBigDecimal();
             BigDecimal x3 = in.nextBigDecimal();
             BigDecimal y3 = in.nextBigDecimal();
             BigDecimal x = in.nextBigDecimal();
             BigDecimal y = in.nextBigDecimal();
             //x
             BigDecimal temp1 = y2.subtract(y1);
             BigDecimal temp2 = y3.multiply(y3).subtract(y1.multiply(y1)).add(x3.multiply(x3)).subtract(x1.multiply(x1));
             BigDecimal temp3 = y3.subtract(y1);
             BigDecimal temp4 = y2.multiply(y2).subtract(y1.multiply(y1)).add(x2.multiply(x2)).subtract(x1.multiply(x1));
             temp1 = temp1.multiply(temp2);
             temp3 = temp3.multiply(temp4);
             BigDecimal x0 = temp1.subtract(temp3);
             temp1 = x3.subtract(x1).multiply(y2.subtract(y1)).subtract(x2.subtract(x1).multiply(y3.subtract(y1)));
             temp1 = temp1.multiply(BigDecimal.valueOf(2.0));
             x0 = x0.divide(temp1);
             //y
             temp1 = x2.subtract(x1);
             temp2 = x3.multiply(x3).subtract(x1.multiply(x1)).add(y3.multiply(y3)).subtract(y1.multiply(y1));
             temp3 = x3.subtract(y1);
             temp4 = x2.multiply(x2).subtract(y1.multiply(y1)).add(y2.multiply(y2)).subtract(y1.multiply(y1));
             temp1 = temp1.multiply(temp2);
             temp3 = temp3.multiply(temp4);
             BigDecimal y0 = temp1.subtract(temp3);
             temp1 = y3.subtract(y1).multiply(y2.subtract(y1)).subtract(y2.subtract(y1).multiply(x3.subtract(x1)));
             temp1 = temp1.multiply(BigDecimal.valueOf(2.0));
             y0 = y0.divide(temp1);
             //r
             temp1 = x1.subtract(x0);
             temp2 = y1.subtract(y0);
             temp1 = temp1.multiply(temp1);
             temp2 = temp2.multiply(temp2);
             BigDecimal r = temp1.add(temp2);
             //dis
             temp1 = x.subtract(x0);
             temp2 = y.subtract(y0);
             temp1 = temp1.multiply(temp1);
             temp2 = temp2.multiply(temp2);
             BigDecimal dis = temp1.add(temp2);
             if(dis.compareTo(r) > 0)
             {
                 System.out.println("Accepted");
             }
             else
             {
                 System.out.println("Rejected");
             }
         }
     }
 }
 //3
 //-2 0 0 -2 2 0 2 -2
 //-2 0 0 -2 2 0 0 2
 //-2 0 0 -2 2 0 1 1

B：Bomberman

留坑。

C：The Dominator of Strings

题意：给出N个串，然后找出这N个串中是否有一个串包含其他所有串，如果有，输出那个串，如果没有，输出 No

思路：显然，如果答案存在，那么必定是长度最大的那个串。本来想着用KMP, 然后没想到用.find() 就可以过了。

 #include <bits/stdc++.h>

 using namespace std;

 #define N 100010

 string s[N], T;

 int t, n;

 int main()
 {
     cin.tie();
     ios::sync_with_stdio(false);
     cin >> t;
     while (t--)
     {
         cin >> n;
         int Max = , pos;
         for (int i = ; i <= n; ++i)
         {
             cin >> s[i];
             if (s[i].length() > Max)
             {
                 Max = s[i].length();
                 pos = i;
             }
         }
         int cnt = ;
         for (int i = ; i <= n; ++i)
         {
             if (i == pos) continue;
             if (s[pos].find(s[i]) != s[pos].npos)
                 cnt++;
         }
         if (cnt == n - )
             cout << s[pos] << endl;
         else cout << "No\n";
     }
     return ;
 }

KMP：

 // KMP 版本， 比.find() 还慢。。
 #include <bits/stdc++.h>

 using namespace std;

 #define N 100010

 int t, n;

 int Next[N];

 inline void pre(string x, int m)
 {
     int i, j;
     j = Next[] = -;
     i = ;
     while (i < m)
     {
         while (- != j && x[i] != x[j]) j = Next[j];
         if (x[++i] == x[++j]) Next[i] = Next[j];
         else Next[i] = j;
     }
 }

 inline bool KMP(string x, int m, string y, int n)
 {
     int i, j;
     pre(x, m);
     i = j = ;
     while (i < n)
     {
         while (- != j && y[i] != x[j]) j = Next[j];
         i++, j++;
         if (j >= m)
         {
             return true;
         }
     }
     return false;
 }

 string s[N];

 int main()
 {
     cin.tie();
     ios::sync_with_stdio(false);
     cin >> t;
     while (t--)
     {
         cin >> n;
         int Max = , pos;
         for (int i = ; i <= n; ++i)
         {
             cin >> s[i];
             if (s[i].length() > Max)
             {
                 Max = s[i].length();
                 pos = i;
             }
         }
         int cnt = , len = s[pos].length();
         for (int i = ; i <= n; ++i)
         {
             if (i == pos) continue;
             if (KMP(s[i], s[i].length(), s[pos], len))
                 cnt++;
             else
                 break;
         }
         if (cnt == n - )
             cout << s[pos] << "\n";
         else
             cout << "No\n";
     }
 }

D：The Intersection

题意：给出两个函数，用一个有理分数去逼近两函数交点的横坐标，有理分数的分母小于1e5

思路：考虑二分

分数的二分可以用一个结论

a/b < (a + c) / (b + d) < c / d

然后考虑 k = k² 那么x³ = k 那么 先去逼近k  (x - 1)³ < k <= x³   如果x³ == k  直接输出 x / 1

反之 令 l = (x - 1) / 2  r = (x) / 2  进行二分

 #include <bits/stdc++.h>

 using namespace std;

 #define ld long double
 #define ll long long 

 int t;

 inline ll GCD(ll a, ll b)
 {
     while (b ^= a ^= b ^= a %= b);
         return a;
 }

 int main()
 {
     cin.tie();
     cout.tie();
     ios::sync_with_stdio(false);
     cin >> t;
     while (t--)
     {
         ll k;
         cin >> k;
         ld K = k * k;
         ll x = ;
         while (x * x * x < K) x++;
         if (x * x * x == K)
         {
             cout << x << "/1\n";
             continue;
         }
         ll a = , b = x - , c = , d = x;
         ll e, q, tar = K;
         ld gap = x * x * x - tar;
         while (true)
         {
             ll aa = a + c, bb = b + d;
             if (aa > 1e5) break;
             ld tmp = (ld)bb * bb * bb / aa / aa / aa;
             if (fabsl(tmp - tar) < gap)
             {
                 gap = fabsl(tmp - tar);
                 q = bb;
                 e = aa;
             }
             if (tmp > tar)
             {
                 d = bb, c = aa;
             }
             else
             {
                 b = bb, a = aa;
             }
         }
         cout << q << "/" << e << "\n";
     }
     return ;
 }

E：King's Visit

留坑。

F：Pythagoras

题意：找到所有满足$x^2 + y^2 = z^2$ 的$(x, y, z)$   $(x, y, z) < 1e9$ 满足 $x <y < z 并且 (x, y, z) 互质$ 计算 $\sum {a_{y mod 2^k}}$

思路：毕达哥拉斯三元组

$x = a^2 - b^2$

$y = 2ab$

$z = a^2 + b^2$

z最大 ， x, y 大小不定 当 a, b 互质时，(x, y, z) 互质 并且 a > b

暴力枚举a, b  然后取模 (1 << 17)

计算的时候，假设 k = 2  那么 $x \equiv 1 \pmod k$ 相当于 $x \equiv 1 \pmod {1 << 17}$ $x \equiv 5 \pmod {1 << 17}$ ...

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

 #define N 200010
 #define MOD 131072
 #define ll long long
 #define INF 1000000000

 int t, k, n;
 int arr[N];
 ll ans[N];
 vector <int> fac[];

 inline bool ok(int x, int y)
 {
     for (int i = , len = fac[y].size(); i < len; ++i)
         if (x % fac[y][i] == ) return false;
     return true;
 }

 inline void Init()
 {
     for (int i = ; i * i <= (INF >> ); i += )
         fac[i].emplace_back();
     int limit = sqrt(INF >> );
     for (int i = ; i <= limit; i += )
     {
         if (fac[i].empty())
             for (int j = i; j * j <= (INF >> ); j += i)
                 fac[j].emplace_back(i);
     }
     ll cnt = ;
     for (int b = ; b * b <= (INF >> ); ++b)
     {
         for (int a = b + ; a * a + b * b <= INF; a += )
         {
             if (ok(a, b))
                 ++ans[max( * a * b, a * a - b * b) % MOD];
         }
     }
 }

 inline void Run()
 {
     Init();
     scanf("%d", &t);
     while (t--)
     {
         scanf("%d", &k); n =  << k;
         for (int i = ; i < n; ++i) scanf("%d", arr + i);
         ll sum = ;
         for (int i = ; i < n; ++i)
             for (int j = ; j * n + i < MOD; ++j)
                 sum += (ll)arr[i] * ans[j * n + i];
         printf("%lld\n", sum);
     }
 }

 int main()
 {
     #ifdef LOCAL
         freopen("Test.in", "r", stdin);
     #endif

     Run();

     return ;
 }

G：Zuma

题意：给出一个01串，若有三个相同的就可以消去，如果没有，可以发射若干个0或者若干个1使之消去，会有连锁反应，求最少的发射数

思路：我们可以先预处理一下，使得相同颜色的合并在一起。那么考虑 i, j  若第i个 与第j个 颜色相同

那么 dp[i][j] = dp[i + 1][j - 1] + max(3 - v[i] - v[j], 0) (v[] 表示这个合并后的区间内有多少个这种颜色)

还有一个区间dp通用转移方程 dp[i][j] = min(dp[i][j], dp[i][k], dp[k + 1][j])

还要考虑一个 如果 存在 i, j, k   若 v[i] + v[k] < 3 || v[k] + v[j] < 3

那么它们可能可以通过消去 区间[i + 1][k - 1] 和 [k + 1][j - 1] 来使得这三个产生连锁反应而有更优的答案

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

 #define N 210

 typedef pair <int, int> pii;

 int t, cnt;
 char s[N];
 pii arr[N];
 int dp[N][N];

 inline void Run()
 {
     scanf("%d", &t);
     for (int kase = ; kase <= t; ++kase)
     {
         printf("Case #%d: ", kase);
         scanf("%s", s + );
         cnt = ;
         for (int i = , len = strlen(s + ); i <= len; ++i)
         {
             int id = s[i] - '';
             if (i ==  || id != arr[cnt].second)
                 arr[++cnt].first = , arr[cnt].second = id;
             else
                 ++arr[cnt].first;
         }
         memset(dp, 0x3f, sizeof dp);
         for (int i = ; i <= cnt; ++i) dp[i][i] = (arr[i].first ==  ?  : );
         for (int i = ; i <= cnt; ++i)
         {
             for (int j = ; j + i -  <= cnt; ++j)
             {
                 int l = j, r = j + i - ;
                 if (arr[l].second == arr[r].second)
                     dp[l][r] = dp[l + ][r - ] + max( - arr[l].first - arr[r].first, );
                 for (int k = l; k < r; ++k)
                     dp[l][r] = min(dp[l][r], dp[l][k] + dp[k + ][r]);
                 if (arr[l].second == arr[r].second)
                     for (int k = l + ; k < r; ++k)
                     {
                         if (arr[l].second == arr[k].second && (arr[l].first + arr[k].first <  || arr[k].first + arr[r].first < ))
                             dp[l][r] = min(dp[l][r], max( - arr[l].first - arr[k].first - arr[r].first, ) + dp[l + ][k - ] + dp[k + ][r - ]);
                     }
             }
         }
         printf("%d\n", dp[][cnt]);
     }
 }

 int main()
 {
     #ifdef LOCAL
         freopen("Test.in", "r", stdin);
     #endif

     Run();

     return ;
 }

H：Chinese Zodiac

按题意输出即可

 #include <bits/stdc++.h>

 using namespace std;

 map <string, int> mp;

 inline void Init()
 {
     mp["rat"] = ;
     mp["ox"] = ;
     mp["tiger"] = ;
     mp["rabbit"] = ;
     mp["dragon"] = ;
     mp["snake"] = ;
     mp["horse"] = ;
     mp["sheep"] = ;
     mp["monkey"] = ;
     mp["rooster"] = ;
     mp["dog"] = ;
     mp["pig"] = ;
 }

 int t;

 int main()
 {
     cin.tie();
     ios::sync_with_stdio(false);
     Init(); cin >> t;
     string a, b;
     while (t--)
     {
         cin >> a >> b;
         int ans = mp[b] - mp[a];
         if (ans < ) ans += ;
         cout << ans << endl;
     }
 }

I：Smallest Minimum Cut

题意：给出一张图，然后给出两个点S, T, 要求选取一个含有最小边的一个边集，使得其流量为最大流

思路一： 可以将所有边权都乘以一个较大的数 + 1，那么本来边比较多的最大流，这样处理之后就不再是最大流，答案就是最大流%较大的数,因为这样处理之后，不会存在边数相同并且最大流相同的情况，可以分开考虑

因为最大流肯定是由若干个满流的容量组成，那么最后的最大流答案肯定是n * m + x  (m 为一个较大的数，x 为边数)

如果存在更少边使得组成最大流，那么最大流肯定是 n2 * m + x2 (易知x2 < x 那么显然n2 > n) 那么这个流肯定比上面那个大，那么这个才是答案，矛盾

如果存在更多边使得组成最大流，那么最大流肯定是n3 * m + x3 (显然 x3 > x 那么 n3 < n) 因为 m足够大，那么这个最大流肯定要小于上面那个最大流，这个不会是答案

思路二：跑一边网络流后，如果有一条路是满流的话，那么这条路可能为所求答案的其中一条路，将这条路的流量改为1，再将其他路的流量改成1e9，再跑一次网络流就可以得出所求答案。

思路一：

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

 const int maxn = 1e3 + ;
 const int INF = 0x3f3f3f3f;

 int n, m;

 struct Edge{
     int from;
     int to;
     int cap;
     int flow;
     inline Edge(){}
     inline Edge(int from,int to,int cap,int flow):from(from), to(to), cap(cap), flow(flow){}
 };

 vector<Edge>edge;
 vector<int>G[maxn];
 int vis[maxn];
 int d[maxn];
 int cur[maxn];
 int S,T;

 inline void init()
 {
     edge.clear();
     for(int i = ; i <= n; ++i)
         G[i].clear();
 }

 inline void addedge(int from,int to,int cap)
 {
     edge.push_back(Edge(from,to,cap,));
     edge.push_back(Edge(to,from,,));
     int len = edge.size();
     G[from].push_back(len - );
     G[to].push_back(len - );
 }

 inline bool bfs()
 {
     memset(d,,sizeof d);
     memset(vis,,sizeof vis);
     queue<int>q;
     q.push(S);
     d[S] = ;
     vis[S] = ;
     while(!q.empty())
     {
         int x = q.front();
         q.pop();
         for(int i = ; i < G[x].size(); ++i)
         {
             Edge &e = edge[G[x][i]];
             for(int i = ; i < G[x].size(); ++i)
             {
                 Edge &e = edge[G[x][i]];
                 if(!vis[e.to] && e.cap > e.flow)
                 {
                     vis[e.to] = ;
                     d[e.to] = d[x] + ;
                     q.push(e.to);
                 }
             }
         }
     }
     return vis[T];
 }

 inline int dfs(int x,int a)
 {
     if(x == T || a == ) return a;
     int flow = ;
     int f;
     for(int &i = cur[x]; i < G[x].size(); ++i)
     {
         Edge &e = edge[G[x][i]];
         if(d[x] +  == d[e.to] && (f = dfs(e.to, min(a, e.cap- e.flow))) > )
         {
             e.flow += f;
             edge[G[x][i] ^ ].flow -= f;
             flow += f;
             a -= f;
             if(a == ) break;
         }
     }
     return flow;
 }

 inline int dicnic()
 {
     int ans = ;
     while(bfs())
     {
         memset(cur,,sizeof cur);
         ans += dfs(S,INF);
     }
     return ans;
 }

 int main()
 {
     int t;
     scanf("%d",&t);
     while(t--)
     {
         init();
         scanf("%d %d",&n, &m);
         scanf("%d %d",&S, &T);
         for(int i = ;i <= m; ++i)
         {
             int x, y, z;
             scanf("%d %d %d",&x, &y,&z);
             addedge(x,y,z *  + );
         }
         int ans = dicnic();
         printf("%d\n",ans % );
     }
     return ;
 }

思路二：

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

 const int maxn = 1e3 + ;
 const int INF = 0x3f3f3f3f;

 int n, m;

 struct Edge {
     int from;
     int to;
     int cap;
     int flow;
     inline Edge() {}
     inline Edge(int from, int to, int cap, int flow) :from(from), to(to), cap(cap), flow(flow) {}
 };

 vector<Edge>edge;
 vector<int>G[maxn];
 int vis[maxn];
 int d[maxn];
 int cur[maxn];
 int S, T;

 inline void init()
 {
     edge.clear();
     for (int i = ; i <= n; ++i)
         G[i].clear();
 }

 inline void addedge(int from, int to, int cap)
 {
     edge.push_back(Edge(from, to, cap, ));
     edge.push_back(Edge(to, from, , ));
     int len = edge.size();
     G[from].push_back(len - );
     G[to].push_back(len - );
 }

 inline bool bfs()
 {
     memset(d, , sizeof d);
     memset(vis, , sizeof vis);
     queue<int>q;
     q.push(S);
     d[S] = ;
     vis[S] = ;
     while (!q.empty())
     {
         int x = q.front();
         q.pop();
         for (int i = ; i < G[x].size(); ++i)
         {
             Edge &e = edge[G[x][i]];
             for (int i = ; i < G[x].size(); ++i)
             {
                 Edge &e = edge[G[x][i]];
                 if (!vis[e.to] && e.cap > e.flow)
                 {
                     vis[e.to] = ;
                     d[e.to] = d[x] + ;
                     q.push(e.to);
                 }
             }
         }
     }
     return vis[T];
 }

 inline int dfs(int x, int a)
 {
     if (x == T || a == ) return a;
     int flow = ;
     int f;
     for (int &i = cur[x]; i < G[x].size(); ++i)
     {
         Edge &e = edge[G[x][i]];
         if (d[x] +  == d[e.to] && (f = dfs(e.to, min(a, e.cap - e.flow))) > )
         {
             e.flow += f;
             edge[G[x][i] ^ ].flow -= f;
             flow += f;
             a -= f;
             if (a == ) break;
         }
     }
     return flow;
 }

 inline int dicnic()
 {
     int ans = ;
     while (bfs())
     {
         memset(cur, , sizeof cur);
         ans += dfs(S, INF);
     }
     return ans;
 }

 int main()
 {
     int t;
     scanf("%d", &t);
     while (t--)
     {
         init();
         scanf("%d %d", &n, &m);
         scanf("%d %d", &S, &T);
         for (int i = ; i <= m; ++i)
         {
             int x, y, z;
             scanf("%d %d %d", &x, &y, &z);
             addedge(x, y, z);
         }
         int ans = dicnic();
         for (int i = ; i <= n; ++i)
         {
             for (int j = ; j < G[i].size(); ++j)
             {
                 int it = G[i][j];
                 if (edge[it].cap == ) continue;
                 if (edge[it].flow == edge[it].cap)
                 {
                     edge[it].cap = ;
                     edge[it].flow = ;
                 }
                 else
                 {
                     edge[it].cap = INF;
                     edge[it].flow = ;
                 }
             }
         }
         ans = dicnic();
         printf("%d\n", ans);
     }
     return ;
 }

J：Brute Force Sorting

题意：给出N个数，如果arr[i] > arr[i + 1] 那么，这连个数都要删去，删若干轮后，直到不能删，输出最终的序列

思路：可以想到，如果在第一轮中，两个数被删去了，那么在下一轮可能被删去的数就有这两个数左边邻接的一个数，右边邻接的一个数，压入队列，继续判断。

因为每个数最多入队一次，最坏的时间复杂度O(n),

 #include <bits/stdc++.h>

 using namespace std;

 #define INF 0x3f3f3f3f
 #define N 100100

 int t, n;
 int arr[N];
 int L[N], R[N], vis[N];

 queue <int> q;

 int main()
 {
     cin.tie();
     ios::sync_with_stdio(false);
     cin >> t;
     while (t--)
     {
         cin >> n;
         for (int i = ; i <= n; ++i)
         {
             cin >> arr[i];
             L[i] = i - , R[i] = i + ;
             vis[i] = ;
         }
         arr[] = ; arr[n + ] = INF;
         while (!q.empty()) q.pop();
         for (int i = ; i <= n; ++i)
         {
             if (arr[i] < arr[i - ] || arr[i] > arr[i + ])
                 q.emplace(i), vis[i] = ;
         }
         while (!q.empty())
         {
             int u = q.front(); q.pop();
             int l = L[u], r = R[u];
             R[l] = r, L[r] = l;
             if (l && r != n +  && !vis[r] && arr[l] > arr[r])
             {
                 q.emplace(l); vis[l] = ;
                 q.emplace(r); vis[r] = ;
             }
         }
         int cnt = ;
         for (int i = ; i <= n; ++i) if (!vis[i]) cnt++;
         cout << cnt << endl;
         for (int i = ; i <= n; ++i) if (!vis[i])
             cout << arr[i] << " ";
         cout << "\n";
     }
 }

K：A Cubic number and A cunbic Number

题意：给出一个素数p，判断它是不是能不能由两个不同的立方数相减得到

思路：假设p = a³ - b³ 那么根据立方差公式 p = (a - b)(a² + b² + ab)   显然 (a - b) < (a²  + b² + ab) 又p为素数 所以必然有一个为1，显然 (a - b) = 1

那么 p = (a² + b² + ab) 将a - b = 1 代入 有 p = 3a² + 3a + 1;

预处理一下即可

 #include <bits/stdc++.h>

 using namespace std;

 #define ll long long

 unordered_map <ll, bool> mp;

 const ll D = (ll)1e12;

 inline void Init()
 {
     mp.clear();
     for (ll i = ; true; ++i)
     {
         ll value =  * i * i +  * i + ;
         if (value > D) break;
         mp[value] = true;
     }
 }

 int t;
 ll p;

 int main()
 {
     Init();
     scanf("%d", &t);
     while (t--)
     {
         scanf("%lld", &p);
         puts(mp[p] ? "YES" : "NO");
     }
     return ;
 }

---

　赛后总结：

• 如果TLE了，要检查一下是否是数组开小
• 如果开了队列或栈，MLE了，检查一下是否是死循环，一直在入栈，入队
• 如果计算几何或者有浮点数精度问题的，要考虑JAVA BigDecimal
• 输出的时候一定要检查格式，末尾有没有空格
• 输出YES NO 的答案时，一定要检查大小写是否正确
• 有时候要考虑队列暴力，栈暴力，不要一提到暴力，想到的就是很暴的暴力
• 如果数论题给出数特别特殊，比如说素数，一定要考虑其性质，即它不能表示为两个数的乘积之和，1除外
• 如果出现自己认为思路正确却依然wrong answer的时候，可以考虑重新写以及思路错误两个方面，而不是一味在原来代码上更改。
• 如果模数是2的幂次，那么卡常数取模可以用&(2 ^ k - 1)
• 二分的题目不一定每次都是取中间值，可以考虑其他值