2015ACM/ICPC亚洲区沈阳站 Solution

A - Pattern String

留坑。

B - Bazinga

题意：找一个最大的i，使得前i - 1个字符串中至少不是它的子串

思路：暴力找，如果有一个串已经符合条件，就不用往上更新

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

 #define N 510

 int t, n;
 int vis[N];
 string s[N];

 int main()
 {
     ios::sync_with_stdio(false);
     int t;
     cin >> t;
     for(int cas = ; cas <= t; ++cas)
     {
         cin >> n;
         memset(vis, , sizeof vis);
         for(int i = ; i <= n; ++i) cin >> s[i];
         int ans = -;
         for(int i = ; i <= n; ++i)
         {
             for(int j  = i + ; j <= n; ++j)
             {
                 if(!vis[j])
                 {
                     int tmp = s[j].find(s[i]);
                     if(tmp == -)
                     {
                         vis[j] = ;
                         ans = max(ans, j);
                     }
                     else break;
                 }
             }
         }
         cout << "Case #" << cas << ": " << ans << endl;
     }
     return ;
 }

C - Minimum Cut-Cut

留坑。

D - Pagodas

题意：刚开始集合里有a, b 两个数，每次能从集合中选出 x + y  或者 x - y 放进集合中，并且放过的不能放，不能放的输游戏

思路：考虑$gcd(x, y), 每次产生的新数肯定是gcd(x, y)的倍数$ 所以能放的数总数只有 gcd(x, y) 的倍数的个数

 #include<bits/stdc++.h>

 using namespace std;

 int gcd(int a, int b)
 {
     return b ==  ? a : gcd(b, a % b);
 }

 int n, a, b;

 int main()
 {
     int t;
     scanf("%d", &t);
     for(int cas = ; cas <= t; ++cas)
     {
         scanf("%d %d %d", &n, &a, &b);
         int g = gcd(a, b);
         int tmp = n / g;
         printf("Case #%d: ", cas);
         puts(tmp &  ? "Yuwgna" : "Iaka");
     }
     return ;
 }

E - Efficient Tree

留坑。

F - Frogs

题意：有n只青蛙，长度为m的环，每只青蛙固定步数往前跳，跳到一个点标记一下，求最后有多少点被标记

思路：先将m分解因子，对于每一个arr[i]都和m求gcd，然后将gcd的倍数标记一次，代表需要统计一次它的倍数。最后遍历一边每个因子，求出它被多用几次或者少用几次的和即可。

 #include<bits/stdc++.h>

 using namespace std;

 #define ll long long
 #define N 10010

 ll gcd(ll a, ll b)
 {
     return b ==  ?  a :  gcd(b, a % b);
 }

 int n, m;
 int vis[N], used[N];
 ll arr[N];
 vector<int>vec;

 int main()
 {
     int t;
     scanf("%d", &t);
     for(int cas = ; cas <= t; ++cas)
     {
         scanf("%d %d", &n, &m);
         memset(vis, , sizeof vis);
         memset(used, , sizeof used);
         vec.clear();
         for(int i = ; i * i <= m; ++i)
         {
             if(m % i == )
             {
                 vec.push_back(i);
                 if(i * i != m) vec.push_back(m / i);
             }
         }
         sort(vec.begin(), vec.end());
         int tot = vec.size();
         tot--;
         for(int i = ; i <= n; ++i)
         {
             scanf("%lld", arr + i);
             ll x = gcd(arr[i], m);
             for(int j = ; j < tot; ++j)
             {
                 if(vec[j] % x == ) vis[j] = ;
             }
         }
         ll ans = ;
         for(int i = ; i < tot; ++i)
         {
             if(vis[i] != used[i])
             {
                 ll tmp = (m - ) / vec[i];
                 ans += tmp * (tmp + ) /  * vec[i] * (vis[i] - used[i]);
                 for(int j = i + ; j < tot; ++j)
                 {
                     if(vec[j] % vec[i] == )
                     {
                         used[j] += vis[i] - used[i];
                     }
                 }
             }
         }
         printf("Case #%d: %lld\n", cas, ans);
     }
     return ;
 }

G - Game of Flying Circus

题意：翻译啊翻译

思路：分类讨论

1)在1-2相遇   即v1=v2  输出Yes

2)在2-3相遇，利用二分计算出相遇点，算一下到4的时间，判断

3)在3-4相遇，利用二分计算出相遇点，算一下到1的时间，判断

4)一定No

 #include<bits/stdc++.h>

 using namespace std;

 const double eps = 1e-;

 double T, v1, v2;

 int sgn(double x)
 {
     if(fabs(x) < eps) return ;
     else return x >  ?  : -;
 }

 int main()
 {
     int t;
     scanf("%d", &t);
     for(int cas = ; cas <= t; ++cas)
     {
         scanf("%lf %lf %lf", &T, &v1, &v2);
         printf("Case #%d: ", cas);
         if(sgn(v1 - v2) == ) puts("Yes");
         else if(sgn( * v1 * v1 - v2 * v2) > )//2-3
         {
             double l = , r = 300.0;
             while(r - l > eps)
             {
                 double mid = (l + r) / 2.0;
                 double dis1 = sqrt(mid * mid + 300.0 * 300.0);
                 double t1 = dis1 / v1;
                 double dis2 = mid + 300.0;
                 double t2 = dis2 / v2;
                 if(sgn(t1 - t2) > )
                 {
                     l = mid;
                 }
                 else
                 {
                     r = mid;
                 }
             }
             double x = (l + r) / 2.0;
             double dis1 = x + 600.0;
             double t1 = dis1 / v1;
             double dis2 = 600.0 - x;
             double t2 = dis2 / v2 + T;
             puts(sgn(t1 - t2) <=  ? "Yes" : "No");
         }
         else if(sgn( * v1 - v2) > )//3-4
         {
             double l = , r = 300.0;
             while(r - l > eps)
             {
                 double mid = (l + r) / 2.0;
                 double dis1 = sqrt(mid * mid + 300.0 * 300.0);
                 double t1 = dis1 / v1;
                 double dis2 = 900.0 - mid;
                 double t2 = dis2 / v2;
                 if(sgn(t1 - t2) > )
                 {
                     r = mid;
                 }
                 else
                 {
                     l = mid;
                 }
             }
             double y = (l + r) / 2.0;
             double dis1 = sqrt((300.0 - y) * (300.0 - y) + 300.0 * 300.0) + 900.0;
             double t1 = dis1 / v1;
             double dis2 = y + 300.0;
             double t2 = dis2 / v2 + T;
             puts(sgn(t1 - t2) <=  ? "Yes" : "No");
         }
         else puts("No");
     }
     return ;
 }

H - Chessboard

留坑。

I - Triple

题意：二元组$A<a, b>$ 三元组 $B<c, d, e> A * B = {<a, c, d> | <a, b> \in A , <c, d, e> \in B and b = e}$ 求有多少集合满足TOP(C)

思路：枚举B，对于每个B，我们考虑符合条件的最高的a, 因为有多个a，那么小的a肯定不会放到集合里面，

对于最大的a，我们判断二维BIT中右下角有的最大值，是否大于它本身，不是的话它就应该放进TOP(C)

要多考虑一下当前的(c, d) 有多个点的情况

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

 #define N 100010
 #define pii pair <int, int>
 #define ll long long

 int t, n, m;
 struct A
 {
     int a, b;
     void scan()
     {
         scanf("%d%d", &a, &b);
     }
     bool operator < (const A &r) const
     {
         return b == r.b ? a < r.a : b < r.b;
     }
 }a[N];

 struct B
 {
     int c, d, e;
     void scan()
     {
         scanf("%d%d%d", &c, &d, &e);
     }
 }b[N];

 pii pos[N];  

 struct BIT
 {
     int a[][];

     void Init()
     {
         memset(a, , sizeof a);
     }

     void update(int x, int y, int val)
     {
         for (int i = x; i; i -= i & -i)
             for (int j = y; j; j -= j & -j)
                 a[i][j] = max(a[i][j], val);
     }

     int query(int x, int y)
     {
         int res = ;
         for (int i = x; i < ; i += i & -i)
             for (int j = y; j < ; j += j & -j)
                 res = max(res, a[i][j]);
         return res;
     }
 }bit; 

 int main()
 {
     scanf("%d", &t);
     for (int kase = ; kase <= t; ++kase)
     {
         printf("Case #%d: ", kase);
         scanf("%d%d", &n, &m);
         for (int i = ; i <= n; ++i) a[i].scan();
         for (int i = ; i <= m; ++i) b[i].scan();
         sort(a + , a +  + n);
         memset(pos, , sizeof pos);
         for (int i = n; i >= ; --i)
         {
             int b = a[i].b;
             if (!pos[b].first)
             {
                 pos[b].first = a[i].a, ++pos[b].second;
                 continue;
             }
             if (i != n)
             {
                 if (b == a[i + ].b && a[i].a == pos[b].first)
                     ++pos[b].second;
             }
         }
         bit.Init();
         for (int i = ; i <= m; ++i)
         {
             if (pos[b[i].e].first == ) continue;
             bit.update(b[i].c, b[i].d, pos[b[i].e].first);
         }
         ll res = ;
         for (int i = ; i <= m; ++i)
         {
             int x = b[i].c, y = b[i].d;
             if(!pos[b[i].e].first) continue;
             int Max = max(bit.query(x, y + ), bit.query(x + , y));
             bool flag = true;
             if (Max >= pos[b[i].e].first) flag = false;
             Max = bit.query(x, y); if (Max != pos[b[i].e].first) flag = false;
             if (flag) res += pos[b[i].e].second;
         }
         printf("%lld\n", res);
     }
     return ;
 }

J - John's Fences

留坑。

K - Kykneion asma

留坑。

L - Number Link

留坑。

M - Meeting

题意：有多个集合，集合里两个点的距离都是$t-i$ 1 和 n  要到一个地方汇合，使得最大距离最小，求汇合点

思路：考虑暴力连边的边数最大有${\sum_{i = 1}^{i = m} S_i} ^2$ 没法解决

考虑将一个集合里所有点向另一个点连权值为$t_i$的边，再从这个点向集合里所有点连权值为0的边

再对1和n分别跑最短路，枚举中间点，更新答案

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

 #define N 2000010
 #define ll long long
 #define INFLL 0x3f3f3f3f3f3f3f3f

 int t, n, m;
 int arr[N];

 struct Edge
 {
     int to, nx; ll w;
     Edge() {}
     Edge(int to, int nx, ll w) : to(to), nx(nx), w(w) {}
 }edge[N << ]; 

 int head[N], pos;

 void Init()
 {
     memset(head, -, sizeof head);
     pos = ;
 }

 void addedge(int u, int v, int w)
 {
     edge[++pos] = Edge(v, head[u], w); head[u] = pos;
 }

 struct node
 {
     int u; ll w;
     node () {}
     node (int u, ll w) : u(u), w(w) {}
     bool operator < (const node &r) const
     {
         return w > r.w;
     }
 };

 ll dist[][N];
 bool used[N];

 void Dijkstra(int st, int id)
 {
     for (int i = ; i <= n + m; ++i) dist[id][i] = INFLL, used[i] = ;
     priority_queue <node> q;
     q.emplace(st, );
     dist[id][st] = ;
     while (!q.empty())
     {
         int u = q.top().u; q.pop();
         if (used[u]) continue;
         used[u] = ;
         for (int it = head[u]; ~it; it = edge[it].nx)
         {
             int v = edge[it].to;
             if (!used[v] && dist[id][v] > dist[id][u] + edge[it].w)
             {
                 dist[id][v] = dist[id][u] + edge[it].w;
                 q.emplace(v, dist[id][v]);
             }
         }
     }
 }

 int main()
 {
     scanf("%d", &t);
     for (int kase = ; kase <= t; ++kase)
     {
         printf("Case #%d: ", kase);
         scanf("%d%d", &n, &m);
         Init();
         for (int i = , tot, w; i <= m; ++i)
         {
             scanf("%d%d", &w, &tot);
             for (int j = ; j <= tot; ++j) scanf("%d", arr + j);
             for (int j = ; j <= tot; ++j) addedge(arr[j], i + n, w);
             for (int j = ; j <= tot; ++j) addedge(i + n, arr[j], );
         }
         Dijkstra(, );
         Dijkstra(n, );
         vector <int> v;
         ll Min = INFLL;
 //        for (int i = 1; i <= n; ++i) cout << dist[0][i] << " " << dist[1][i] << endl;
         for (int i = ; i <= n; ++i) Min = min(Min, max(dist[][i], dist[][i]));
         if (Min == INFLL) puts("Evil John");
         else
         {
             for (int i = ; i <= n; ++i) if (max(dist[][i], dist[][i]) == Min)
                 v.push_back(i);
             printf("%lld\n", Min);
             for (int i = , len = v.size(); i < len; ++i) printf("%d%c", v[i], " \n"[i == len - ]);
         }
     }
     return ;
 }

C=A∗B={⟨a,c,d⟩∣⟨a,b⟩∈A, ⟨c,d,e⟩∈B and b=e}