BUCT20180814邀请赛 Solution

A：SUM

水。

 #include<bits/stdc++.h>

 using namespace std;

 #define N 100010
 typedef long long ll;

 int n;
 ll arr[N];
 ll sum[N];

 int main()
 {
     while(~scanf("%d",&n))
     {
         memset(sum, , sizeof sum);
         for(int i = ; i <= n; ++i)
         {
             scanf("%lld",&arr[i]);
         }
         for(int i = n; i >= ; --i)
         {
             sum[i] = sum[i + ] + arr[i] * (n - i + );
         }
         for(int i = ;i <= n; ++i)
         {
             printf("%lld%c",sum[i]," \n"[i == n]);
         }
     }
     return ;
 }

B：XOR1

思路：枚举ai, 去字典树中找最大值，取max

 #include <bits/stdc++.h>

 using namespace std;

 #define N 100010
 #define ll long long

 int tree[N * ][];
 int cnt[N * ];
 int pos;

 inline void Init()
 {
     memset(tree, , sizeof tree);
     memset(cnt, , sizeof cnt);
     pos = ;
 }

 inline void insert(int x)
 {
     bitset <> b; b = x;
     int root = ;
     for (int i = ; i >= ; --i)
     {
         int id = b[i];
         if (!tree[root][id])
             tree[root][id] = ++pos;
         root = tree[root][id];
         cnt[root]++;
     }
 }

 inline ll Find(int x)
 {
     bitset <> b; b = x;
     ll ans = ;
     int root = ;
     for (int i = ; i >= ; --i)
     {
         int id = b[i] ^ ;
         bool flag = true;
         if (!tree[root][id] || cnt[tree[root][id]] <= )
             id ^= , flag = false;
         root = tree[root][id];
         if (flag) ans += ( << i);
     }
     return ans;
 }

 int n;
 int arr[N];

 int main()
 {
     while (scanf("%d", &n) != EOF)
     {
         Init();
         for (int i = ; i <= n; ++i)
         {
             scanf("%d", arr + i);
             insert(arr[i]);
         }
         ll ans = ;
         for (int i = ; i < n; ++i)
         {
             ans = max(ans, Find(arr[i]));
         }
         printf("%lld\n", ans);
     }
     return ;
 }

C：XOR2

思路：先DFS跑出DFS序，然后配合可持久化字典树就可以对子树进行区间操作。

我们自底向上推，这样对于一棵树，它的孩子的答案都已经更新，那么先取max, 假设直系孩子有n个，那么只需要枚举n - 1个孩子以及它的子树里的点更新答案就可以。

 #include <bits/stdc++.h>

 using namespace std;

 #define N 100010
 #define ll long long

 int arr[N];

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

 int head[N], pos, cnt;

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

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

 struct Point
 {
     int fa, ord, son, id;
     int ans;
     inline bool operator < (const Point& r) const
     {
         return son - ord < r.son - r.ord;
     }
 }point[N];  

 int n;
 int ford[N]; 

 struct node
 {
     int son[], cnt;
     inline node()
     {
         memset(son, , sizeof son);
         cnt = ;
     }
 }tree[N * ]; 

 int root[N];
 int tot;

 inline void insert(int id, int x)
 {
     root[id] = ++tot;
     int pre = root[id - ];
     int now = root[id];
     tree[now] = tree[pre];
     bitset <> b; b = x;
     for (int i = ; i >= ; --i)
     {
         int index = b[i];
         tree[++tot] = tree[tree[now].son[index]];
         tree[tot].cnt++;
         tree[now].son[index] = tot;
         now = tot;
     }
 }

 inline int Find(int l, int r, int x)
 {
     int ans = ;
     l = root[l], r = root[r];
     bitset <> b; b = x;
     for (int i = ; i >= ; --i)
     {
         int index = b[i] ^ ;
         bool flag = true;
         if (tree[tree[r].son[index]].cnt - tree[tree[l].son[index]].cnt <= )
         {
             index ^= ;
             flag = false;
         }
         if (flag) ans += ( << i);
         r = tree[r].son[index]; l = tree[l].son[index];
     }
     return ans;
 }

 struct Node
 {
     int id, cnt;
     inline Node() {}
     inline Node(int id, int cnt) : id(id), cnt(cnt) {}
     inline bool operator < (const Node &r) const
     {
         return cnt < r.cnt;
     }
 };

 inline void DFS(int u)
 {
     point[u].ord = ++pos;
     point[u].id = u;
     point[u].ans = ;
     insert(pos, arr[u]);
     ford[pos] = u;
     vector <Node> vv;
     for (int it = head[u]; ~it; it = edge[it].nx)
     {
         int v = edge[it].to;
         if (v == point[u].fa) continue;
         point[v].fa = u; DFS(v);
         point[u].ans = max(point[u].ans, point[v].ans);
         vv.emplace_back(v, point[v].son - point[v].ord);
     }
     point[u].son = pos;
     int l = point[u].ord, r = point[u].son;
     if (l == r) return;
     if (l +  == r)
     {
         point[u].ans = arr[ford[l]] ^ arr[ford[r]];
         return;
     }
     point[u].ans = max(point[u].ans, Find(l - , r, arr[u]));
     sort(vv.begin(), vv.end());
     for (int i = , len = vv.size(); i < len - ; ++i)
     {
         int it = vv[i].id;
         int L = point[it].ord, R = point[it].son;
         for (int j = L; j <= R; ++j)
         {
             point[u].ans = max(point[u].ans, Find(l - , r, arr[ford[j]]));
         }
     }
 }

 int main()
 {
     while (scanf("%d", &n) != EOF)
     {
         Init();
         memset(root, , sizeof root);
         tot = ;
         for (int i = ; i <= n; ++i)
             scanf("%d", arr + i);
         for (int i = , u, v; i < n; ++i)
         {
             scanf("%d%d", &u, &v);
             addedge(u, v);
         }
         DFS();
         for (int i = ; i <= n; ++i) printf("%d%c", point[i].ans, " \n"[i == n]);
     }
     return ;
 }

D：String

思路：二分长度。在已经固定子串长度情况下可以做到o（n）枚举子串，通过map记录子串次数。

 #include<bits/stdc++.h>

 using namespace std;

 int len, k;
 string s;

 inline bool check(int mid)
 {
     map<string, int>mp;
     string tmp = "";
     for (int i = ; i < mid; ++i)
     {
         tmp += s[i];
     }
     mp[tmp]++;
     if (mp[tmp] >= k) return true;
     for (int i = mid; i < len; ++i)
     {
         tmp.erase(tmp.begin());
         tmp += s[i];
         mp[tmp]++;
         if (mp[tmp] >= k) return true;
     }
     return false;
 }

 int main()
 {
     ios::sync_with_stdio(false);
     cin.tie();
     cout.tie();
     while (cin >> k)
     {
         cin >> s;
         int ans = ;
         len = s.length();
         int l = , r = len / k;
         while (r - l >= )
         {
             int mid = (l + r) >> ;
             if (check(mid))
             {
                 ans = mid;
                 l = mid + ;
             }
             else
             {
                 r = mid - ;
             }
         }
         cout << ans << endl;
     }
     return ;
 }

E：Dirt

思路：

线段与线段：如果相交为0，否则为线段两端点与另一线段间距取min

线段与圆：如果相交为0，否则为圆心与线段间距减去半径

线段与三角形：如果相交为0，否则为线段两端点与三角形三条线段间距以及三角心三个端点与线段间距取min

圆与圆：如果相交为0，否则为两圆心间距减去两圆半径

圆与三角形：如果相交为0，否则圆心与三角形三条线段间距取min

三角形与三角形：如果相交为0，否则为三角形的三个端点到另一个三角形的三条线段的间距取min

点与线段：如果点在线段上为0，否则为点到线段间距

点与圆：如果点在圆内为0，否则为点到圆心间距减去半径

点与三角形：如果点在三角形内为0，否则为点到三角形的三个线段的间距取min

最后跑一遍最短路

 #include <bits/stdc++.h>

 using namespace std;

 #define N 1110

 const int INF = 0x3f3f3f3f;

 const double eps = 1e-;

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

 struct Point
 {
     double x, y;
     inline Point() {}
     inline Point(double _x, double _y)
     {
         x = _x;
         y = _y;
     }

     inline void scan()
     {
         scanf("%lf%lf", &x, &y);
     }

     inline bool operator == (const Point b) const
     {
         return sgn(x - b.x) ==  && sgn(y - b.y) == ;
     }

     inline Point operator - (const Point &b) const
     {
         return Point(x - b.x, y - b.y);
     }

     inline double operator ^ (const Point &b) const
     {
         return x * b.y - y * b.x;
     }

     inline double operator * (const Point &b) const
     {
         return x * b.x + y * b.y;
     }

     inline double distance(Point p)
     {
         return hypot(x - p.x, y - p.y);
     }

 };

 struct Line
 {
     Point s, e;
     inline Line() {}
     inline Line(Point _s, Point _e)
     {
         s = _s;
         e = _e;
     }

     inline void scan()
     {
         s.scan(); e.scan();
     }

     inline double length()
     {
         return s.distance(e);
     }

     inline double dispointtoline(Point p)
     {
         return fabs((p - s) ^ (e - s)) / length();
     }

     inline double dispointtoseg(Point p)
     {
         if (sgn((p - s) * (e - s)) <  || sgn((p - e) * (s - e)) < )
             return min(p.distance(s), p.distance(e));
         return dispointtoline(p);
     }

     inline bool pointonseg(Point p)
     {
         return sgn((p - s) ^ (e - s)) ==  && sgn((p - s) * (p - e)) <= ;
     }

     inline int segcrossseg(Line v)
     {
         int d1 = sgn((e - s) ^ (v.s - s));
         int d2 = sgn((e - s) ^ (v.e - s));
         int d3 = sgn((v.e - v.s) ^ (s - v.s));
         int d4 = sgn((v.e - v.s) ^ (e - v.s));
         if ((d1 ^ d2) == - && (d3 ^ d4) == -) return ;
         return (d1 ==  && sgn((v.s - s) * (v.e - e)) <= ) || (d2 ==  && sgn((v.e - s) * (v.e - e)) <= ) || (d3 ==  && sgn((s - v.s) * (s - v.e)) <= ) || (d4 ==  && sgn((e - v.s) * (e - v.e)) <= );
     }

 }line[N];

 struct Circle
 {
     Point p;
     double r;
     inline Circle() {}
     inline Circle(Point _p, double _r)
     {
         p = _p;
         r = _r;
     }

     inline void scan()
     {
         p.scan();
         scanf("%lf", &r);
     }

 }circle[N];

 struct Triangle
 {
     Point a, b, c;
     inline Triangle() {}
     inline Triangle(Point _a, Point _b, Point _c)
     {
         a = _a;
         b = _b;
         c = _c;
     }

     inline void scan()
     {
         a.scan(); b.scan(); c.scan();
     }

 }triangle[N];

 int vis[N];
 int n;
 Point S, T;

 double G[N][N];

 inline double work11(int i, int j)
 {
     if (line[i].segcrossseg(line[j]) > ) return 0.0;
     double ans = INF * 1.0;
     ans = min(ans, line[i].dispointtoseg(line[j].s));
     ans = min(ans, line[i].dispointtoseg(line[j].e));
     ans = min(ans, line[j].dispointtoseg(line[i].s));
     ans = min(ans, line[j].dispointtoseg(line[i].e));
     return ans;
 }

 inline double work12(int i, int j)
 {
     return max(0.0, line[i].dispointtoseg(circle[j].p) - circle[j].r);
 }

 inline double work13(int i, int j)
 {
     Point a = triangle[j].a, b = triangle[j].b, c = triangle[j].c;
     if (line[i].segcrossseg(Line(a, b)) > ) return 0.0;
     if (line[i].segcrossseg(Line(a, c)) > ) return 0.0;
     if (line[i].segcrossseg(Line(b, c)) > ) return 0.0;
     double ans = INF * 1.0;
     ans = min(ans, line[i].dispointtoseg(a));
     ans = min(ans, line[i].dispointtoseg(b));
     ans = min(ans, line[i].dispointtoseg(c));

     Point s = line[i].s, e = line[i].e;

     ans = min(ans, Line(a, b).dispointtoseg(s));
     ans = min(ans, Line(a, b).dispointtoseg(e));

     ans = min(ans, Line(a, c).dispointtoseg(s));
     ans = min(ans, Line(a, c).dispointtoseg(e));

     ans = min(ans, Line(b, c).dispointtoseg(s));
     ans = min(ans, Line(b, c).dispointtoseg(e));

     return ans;
 }

 inline double work22(int i, int j)
 {
     Point c1 = circle[i].p, c2 = circle[j].p;
     double r1 = circle[i].r, r2 = circle[j].r;
     return max(0.0, c1.distance(c2) - r1 - r2);
 }

 inline double work23(int i, int j)
 {
     Point p = circle[j].p; double r = circle[j].r;
     Point a = triangle[i].a, b = triangle[i].b, c = triangle[i].c;
     double ans = INF * 1.0;
     ans = min(ans, max(0.0, Line(a, b).dispointtoseg(p) - r));
     ans = min(ans, max(0.0, Line(a, c).dispointtoseg(p) - r));
     ans = min(ans, max(0.0, Line(b, c).dispointtoseg(p) - r));
     return ans;
 }

 inline double work33(int i, int j)
 {
     Point a = triangle[i].a, b = triangle[i].b, c = triangle[i].c;
     Point aa = triangle[j].a, bb = triangle[j].b, cc = triangle[j].c;

     if (Line(a, b).segcrossseg(Line(aa, bb)) > ) return 0.0;
     if (Line(a, b).segcrossseg(Line(aa, cc)) > ) return 0.0;
     if (Line(a, b).segcrossseg(Line(bb, cc)) > ) return 0.0;

     if (Line(a, c).segcrossseg(Line(aa, bb)) > ) return 0.0;
     if (Line(a, c).segcrossseg(Line(aa, cc)) > ) return 0.0;
     if (Line(a, c).segcrossseg(Line(bb, cc)) > ) return 0.0;

     if (Line(b, c).segcrossseg(Line(aa, bb)) > ) return 0.0;
     if (Line(b, c).segcrossseg(Line(aa, cc)) > ) return 0.0;
     if (Line(b, c).segcrossseg(Line(bb, cc)) > ) return 0.0;

     double ans = INF * 1.0;

     ans = min(ans, Line(a, b).dispointtoseg(aa));
     ans = min(ans, Line(a, b).dispointtoseg(bb));
     ans = min(ans, Line(a, b).dispointtoseg(cc));

     ans = min(ans, Line(a, c).dispointtoseg(aa));
     ans = min(ans, Line(a, c).dispointtoseg(bb));
     ans = min(ans, Line(a, c).dispointtoseg(cc));

     ans = min(ans, Line(b, c).dispointtoseg(aa));
     ans = min(ans, Line(b, c).dispointtoseg(bb));
     ans = min(ans, Line(b, c).dispointtoseg(cc));

     ans = min(ans, Line(aa, bb).dispointtoseg(a));
     ans = min(ans, Line(aa, bb).dispointtoseg(b));
     ans = min(ans, Line(aa, bb).dispointtoseg(c));

     ans = min(ans, Line(aa, cc).dispointtoseg(a));
     ans = min(ans, Line(aa, cc).dispointtoseg(b));
     ans = min(ans, Line(aa, cc).dispointtoseg(c));

     ans = min(ans, Line(bb, cc).dispointtoseg(a));
     ans = min(ans, Line(bb, cc).dispointtoseg(b));
     ans = min(ans, Line(bb, cc).dispointtoseg(c));

     return ans;
 }

 inline double work01(int vis, int i)
 {
     Point a = vis ? T : S;
     return (line[i].dispointtoseg(a));
 }

 inline double work02(int vis, int i)
 {
     Point a = vis ? T : S;
     Point p = circle[i].p; double r = circle[i].r;
     return max(0.0, a.distance(p) - r);
 }

 struct Polygon
 {
     int n;
     Point p[];
     Line l[];
     inline Polygon() {}
     inline Polygon(Triangle r)
     {
         n = ;
         p[] = r.a, p[] = r.b, p[] = r.c;
         l[] = Line(p[], p[]);
         l[] = Line(p[], p[]);
         l[] = Line(p[], p[]);
     }

     inline int relationpoint(Point q)
     {
         for (int i = ; i < n; ++i)
             if (p[i] == q) return ;

         for (int i = ; i < n; ++i)
             if (l[i].pointonseg(q)) return ;

         int cnt = ;
         for (int i = ; i < n; ++i)
         {
             int j = (i + ) % n;
             int k = sgn((q - p[j]) ^ (p[i] - p[j]));
             int u = sgn(p[i].y - q.y);
             int v = sgn(p[j].y - q.y);
             if (k >  && u <  && v >= ) cnt++;
             if (k <  && v <  && u >= ) cnt--;
         }
         return cnt != ;
     }
 };

 inline double work03(int vis, int i)
 {
     Point p = vis ? T : S;
     Polygon tmp = Polygon(triangle[i]);
     if (tmp.relationpoint(p) > ) return 0.0;

     double ans = INF * 1.0;

     ans = min(ans, tmp.l[].dispointtoseg(p));
     ans = min(ans, tmp.l[].dispointtoseg(p));
     ans = min(ans, tmp.l[].dispointtoseg(p));

     return ans;
 }

 bool used[N];
 double lowcost[N];

 inline void Dijkstra()
 {
     for (int i = ; i <= n + ; ++i)
     {
         lowcost[i] = INF * 1.0;
         used[i] = false;
     }
     lowcost[] = ;
     for (int j = ; j <= n + ; ++j)
     {
         int k = -;
         double Min = INF * 1.0;
         for (int i = ; i <= n + ; ++i)
         {
             if (!used[i] && lowcost[i] < Min)
             {
                 Min = lowcost[i];
                 k = i;
             }
         }

         if (k == -) break;
         used[k] = true;

         for (int i = ; i <= n + ; ++i)
         {
             if (!used[i] && lowcost[k] + G[k][i] < lowcost[i])
             {
                 lowcost[i] = lowcost[k] + G[k][i];
             }
         }
     }
 }

 int main()
 {
     #ifdef LOCAL
     freopen("Test.in", "r", stdin);
     #endif
     while (scanf("%lf%lf%lf%lf", &S.x, &S.y, &T.x, &T.y) != EOF)
     {
         scanf("%d", &n);
         for (int i = ; i <= n; ++i)
         {
             scanf("%d", vis + i);
             if (vis[i] == )
                 line[i].scan();
             else if (vis[i] == )
                 circle[i].scan();
             else
                 triangle[i].scan();
         }
         for (int i = ; i <= n; ++i)
         {
             for (int j = i + ; j <= n; ++j)
             {
                 if (vis[i] == )
                 {
                     if (vis[j] == )
                         G[i][j] = G[j][i] = work11(i, j);
                     else if (vis[j] == )
                         G[i][j] = G[j][i] = work12(i, j);
                     else if (vis[j] == )
                         G[i][j] = G[j][i] = work13(i, j);
                 }
                 else if (vis[i] == )
                 {
                     if (vis[j] == )
                         G[i][j] = G[j][i] = work12(j, i);
                     else if (vis[j] == )
                         G[i][j] = G[j][i] = work22(i, j);
                     else if (vis[j] == )
                         G[i][j] = G[j][i] = work23(i, j);
                 }
                 else if (vis[i] == )
                 {
                     if (vis[j] == )
                         G[i][j] = G[j][i] = work13(j, i);
                     else if (vis[j] == )
                         G[i][j] = G[j][i] = work23(j, i);
                     else if (vis[j] == )
                         G[i][j] = G[j][i] = work33(i, j);
                 }
             }
         }

         for (int i = ; i <= n; ++i)
         {
             if (vis[i] == )
             {
                 G[][i] = G[i][] = work01(, i);
                 G[n + ][i] = G[i][n + ] = work01(, i);
             }
             else if (vis[i] == )
             {
                 G[][i] = G[i][] = work02(, i);
                 G[n + ][i] = G[i][n + ] = work02(, i);
             }
             else if (vis[i] == )
             {
                 G[][i] = G[i][] = work03(, i);
                 G[n + ][i] = G[i][n + ] = work03(, i);
             }
         }

         G[][n + ] = G[n + ][] = S.distance(T);

         //for (int i = 0; i <= n + 1; ++i)
         //    for (int j = 0; j <= n + 1; ++j)
         //        printf("%.2f%c", G[i][j], " \n"[j == n + 1]);

         Dijkstra();
         printf("%d\n", (int)floor(lowcost[n + ]));
     }
     return ;
 }

F：Poker

水。

 #include <bits/stdc++.h>

 using namespace std;

 #define N 100010

 int n;
 int arr[N];
 int brr[N];
 int a[N];

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

 inline int lowbit(int x)
 {
     return x & (-x);
 }

 inline void update(int x, int val)
 {
     for (int i = x; i <= n; i += lowbit(i))
         a[i] += val;
 }

 inline int sum(int x)
 {
     int ans = ;
     for (int i = x; i > ; i -= lowbit(i))
         ans += a[i];
     return ans;
 }

 inline bool check(int mid, int emp)
 {
     int tot = sum(mid);
     return tot <= emp;
 }

 int main()
 {
     while (scanf("%d", &n) != EOF)
     {
         Init();
         for (int i = ; i <= n; ++i) update(i, );
         for(int i = ; i <= n; ++i)
         {
             scanf("%d",&arr[i]);
         }
         for (int i = ; i <= n; ++i)
         {
             int index = (int)floor(sqrt(n - i + ));
             int l = , r = n, id;
             while (r - l >= )
             {
                 int mid = (l + r) >> ;
                 int tot = sum(mid);
                 if (tot == index)
                     id = mid;
                 if (tot >= index)
                     r = mid - ;
                 else
                     l = mid + ;
             }
             brr[id] = arr[i];
             update(id, -);
         }
         for (int i = ; i <= n; ++i) printf("%d%c", brr[i], " \n"[i == n]);
     }
     return ;
 }

 #include<bits/stdc++.h>

 using namespace std;

 #define N 100010

 int n;
 int arr[N];
 int brr[N];

 int main()
 {
     while(~scanf("%d",&n))
     {
         for(int i = ; i <= n; ++i)
         {
             scanf("%d",&arr[i]);
         }
         vector<int>vec;
         for(int i = n; i >= ;--i)
         {
             int tmp = floor(sqrt(n - i + ));
             vec.insert(vec.begin() + tmp - , arr[i]);
         }
         for(int i = ; i < n; ++i)
         {
             printf("%d%c",vec[i]," \n"[i == n - ]);
         }
     }
     return ;
 }