A：SUM

水。

  1.  #include<bits/stdc++.h>
  2.  
  3.  using namespace std;
  4.  
  5.  #define N 100010
  6.  typedef long long ll;
  7.  
  8.  int n;
  9.  ll arr[N];
  10.  ll sum[N];
  11.  
  12.  int main()
  13.  {
  14.      while(~scanf("%d",&n))
  15.      {
  16.          memset(sum, , sizeof sum);
  17.          for(int i = ; i <= n; ++i)
  18.          {
  19.              scanf("%lld",&arr[i]);
  20.          }
  21.          for(int i = n; i >= ; --i)
  22.          {
  23.              sum[i] = sum[i + ] + arr[i] * (n - i + );
  24.          }
  25.          for(int i = ;i <= n; ++i)
  26.          {
  27.              printf("%lld%c",sum[i]," \n"[i == n]);
  28.          }
  29.      }
  30.      return ;
  31.  }

B：XOR1

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

  1.  #include <bits/stdc++.h>
  2.  
  3.  using namespace std;
  4.  
  5.  #define N 100010
  6.  #define ll long long
  7.  
  8.  int tree[N * ][];
  9.  int cnt[N * ];
  10.  int pos;
  11.  
  12.  inline void Init()
  13.  {
  14.      memset(tree, , sizeof tree);
  15.      memset(cnt, , sizeof cnt);
  16.      pos = ;
  17.  }
  18.  
  19.  inline void insert(int x)
  20.  {
  21.      bitset <> b; b = x;
  22.      int root = ;
  23.      for (int i = ; i >= ; --i)
  24.      {
  25.          int id = b[i];
  26.          if (!tree[root][id])
  27.              tree[root][id] = ++pos;
  28.          root = tree[root][id];
  29.          cnt[root]++;
  30.      }
  31.  }
  32.  
  33.  inline ll Find(int x)
  34.  {
  35.      bitset <> b; b = x;
  36.      ll ans = ;
  37.      int root = ;
  38.      for (int i = ; i >= ; --i)
  39.      {
  40.          int id = b[i] ^ ;
  41.          bool flag = true;
  42.          if (!tree[root][id] || cnt[tree[root][id]] <= )
  43.              id ^= , flag = false;
  44.          root = tree[root][id];
  45.          if (flag) ans += ( << i);
  46.      }
  47.      return ans;
  48.  }
  49.  
  50.  int n;
  51.  int arr[N];
  52.  
  53.  int main()
  54.  {
  55.      while (scanf("%d", &n) != EOF)
  56.      {
  57.          Init();
  58.          for (int i = ; i <= n; ++i)
  59.          {
  60.              scanf("%d", arr + i);
  61.              insert(arr[i]);
  62.          }
  63.          ll ans = ;
  64.          for (int i = ; i < n; ++i)
  65.          {
  66.              ans = max(ans, Find(arr[i]));
  67.          }
  68.          printf("%lld\n", ans);
  69.      }
  70.      return ;
  71.  }

C：XOR2

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

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

  1.  #include <bits/stdc++.h>
  2.  
  3.  using namespace std;
  4.  
  5.  #define N 100010
  6.  #define ll long long
  7.  
  8.  int arr[N];
  9.  
  10.  struct Edge
  11.  {
  12.      int to, nx;
  13.      inline Edge() {}
  14.      inline Edge(int to, int nx) : to(to), nx(nx) {}
  15.  }edge[N << ]; 
  16.  
  17.  int head[N], pos, cnt;
  18.  
  19.  inline void Init()
  20.  {
  21.      memset(head, -, sizeof head);
  22.      pos = ; cnt = ;
  23.  }
  24.  
  25.  inline void addedge(int u, int v)
  26.  {
  27.      edge[++cnt] = Edge(v, head[u]); head[u] = cnt;
  28.      edge[++cnt] = Edge(u, head[v]); head[v] = cnt;
  29.  }
  30.  
  31.  struct Point
  32.  {
  33.      int fa, ord, son, id;
  34.      int ans;
  35.      inline bool operator < (const Point& r) const
  36.      {
  37.          return son - ord < r.son - r.ord;
  38.      }
  39.  }point[N];  
  40.  
  41.  int n;
  42.  int ford[N]; 
  43.  
  44.  struct node
  45.  {
  46.      int son[], cnt;
  47.      inline node()
  48.      {
  49.          memset(son, , sizeof son);
  50.          cnt = ;
  51.      }
  52.  }tree[N * ]; 
  53.  
  54.  int root[N];
  55.  int tot;
  56.  
  57.  inline void insert(int id, int x)
  58.  {
  59.      root[id] = ++tot;
  60.      int pre = root[id - ];
  61.      int now = root[id];
  62.      tree[now] = tree[pre];
  63.      bitset <> b; b = x;
  64.      for (int i = ; i >= ; --i)
  65.      {
  66.          int index = b[i];
  67.          tree[++tot] = tree[tree[now].son[index]];
  68.          tree[tot].cnt++;
  69.          tree[now].son[index] = tot;
  70.          now = tot;
  71.      }
  72.  }
  73.  
  74.  inline int Find(int l, int r, int x)
  75.  {
  76.      int ans = ;
  77.      l = root[l], r = root[r];
  78.      bitset <> b; b = x;
  79.      for (int i = ; i >= ; --i)
  80.      {
  81.          int index = b[i] ^ ;
  82.          bool flag = true;
  83.          if (tree[tree[r].son[index]].cnt - tree[tree[l].son[index]].cnt <= )
  84.          {
  85.              index ^= ;
  86.              flag = false;
  87.          }
  88.          if (flag) ans += ( << i);
  89.          r = tree[r].son[index]; l = tree[l].son[index];
  90.      }
  91.      return ans;
  92.  }
  93.  
  94.  struct Node
  95.  {
  96.      int id, cnt;
  97.      inline Node() {}
  98.      inline Node(int id, int cnt) : id(id), cnt(cnt) {}
  99.      inline bool operator < (const Node &r) const
  100.      {
  101.          return cnt < r.cnt;
  102.      }
  103.  };
  104.  
  105.  inline void DFS(int u)
  106.  {
  107.      point[u].ord = ++pos;
  108.      point[u].id = u;
  109.      point[u].ans = ;
  110.      insert(pos, arr[u]);
  111.      ford[pos] = u;
  112.      vector <Node> vv;
  113.      for (int it = head[u]; ~it; it = edge[it].nx)
  114.      {
  115.          int v = edge[it].to;
  116.          if (v == point[u].fa) continue;
  117.          point[v].fa = u; DFS(v);
  118.          point[u].ans = max(point[u].ans, point[v].ans);
  119.          vv.emplace_back(v, point[v].son - point[v].ord);
  120.      }
  121.      point[u].son = pos;
  122.      int l = point[u].ord, r = point[u].son;
  123.      if (l == r) return;
  124.      if (l +  == r)
  125.      {
  126.          point[u].ans = arr[ford[l]] ^ arr[ford[r]];
  127.          return;
  128.      }
  129.      point[u].ans = max(point[u].ans, Find(l - , r, arr[u]));
  130.      sort(vv.begin(), vv.end());
  131.      for (int i = , len = vv.size(); i < len - ; ++i)
  132.      {
  133.          int it = vv[i].id;
  134.          int L = point[it].ord, R = point[it].son;
  135.          for (int j = L; j <= R; ++j)
  136.          {
  137.              point[u].ans = max(point[u].ans, Find(l - , r, arr[ford[j]]));
  138.          }
  139.      }
  140.  }
  141.  
  142.  int main()
  143.  {
  144.      while (scanf("%d", &n) != EOF)
  145.      {
  146.          Init();
  147.          memset(root, , sizeof root);
  148.          tot = ;
  149.          for (int i = ; i <= n; ++i)
  150.              scanf("%d", arr + i);
  151.          for (int i = , u, v; i < n; ++i)
  152.          {
  153.              scanf("%d%d", &u, &v);
  154.              addedge(u, v);
  155.          }
  156.          DFS();
  157.          for (int i = ; i <= n; ++i) printf("%d%c", point[i].ans, " \n"[i == n]);
  158.      }
  159.      return ;
  160.  }

D：String

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

  1.  #include<bits/stdc++.h>
  2.  
  3.  using namespace std;
  4.  
  5.  int len, k;
  6.  string s;
  7.  
  8.  inline bool check(int mid)
  9.  {
  10.      map<string, int>mp;
  11.      string tmp = "";
  12.      for (int i = ; i < mid; ++i)
  13.      {
  14.          tmp += s[i];
  15.      }
  16.      mp[tmp]++;
  17.      if (mp[tmp] >= k) return true;
  18.      for (int i = mid; i < len; ++i)
  19.      {
  20.          tmp.erase(tmp.begin());
  21.          tmp += s[i];
  22.          mp[tmp]++;
  23.          if (mp[tmp] >= k) return true;
  24.      }
  25.      return false;
  26.  }
  27.  
  28.  int main()
  29.  {
  30.      ios::sync_with_stdio(false);
  31.      cin.tie();
  32.      cout.tie();
  33.      while (cin >> k)
  34.      {
  35.          cin >> s;
  36.          int ans = ;
  37.          len = s.length();
  38.          int l = , r = len / k;
  39.          while (r - l >= )
  40.          {
  41.              int mid = (l + r) >> ;
  42.              if (check(mid))
  43.              {
  44.                  ans = mid;
  45.                  l = mid + ;
  46.              }
  47.              else
  48.              {
  49.                  r = mid - ;
  50.              }
  51.          }
  52.          cout << ans << endl;
  53.      }
  54.      return ;
  55.  }

E：Dirt

思路：

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

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

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

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

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

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

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

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

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

最后跑一遍最短路

  1.  #include <bits/stdc++.h>
  2.  
  3.  using namespace std;
  4.  
  5.  #define N 1110
  6.  
  7.  const int INF = 0x3f3f3f3f;
  8.  
  9.  const double eps = 1e-;
  10.  
  11.  int sgn(double x)
  12.  {
  13.      if (fabs(x) < eps) return ;
  14.      if (x < ) return -;
  15.      else return ;
  16.  }
  17.  
  18.  struct Point
  19.  {
  20.      double x, y;
  21.      inline Point() {}
  22.      inline Point(double _x, double _y)
  23.      {
  24.          x = _x;
  25.          y = _y;
  26.      }
  27.  
  28.      inline void scan()
  29.      {
  30.          scanf("%lf%lf", &x, &y);
  31.      }
  32.  
  33.      inline bool operator == (const Point b) const
  34.      {
  35.          return sgn(x - b.x) ==  && sgn(y - b.y) == ;
  36.      }
  37.  
  38.      inline Point operator - (const Point &b) const
  39.      {
  40.          return Point(x - b.x, y - b.y);
  41.      }
  42.  
  43.      inline double operator ^ (const Point &b) const
  44.      {
  45.          return x * b.y - y * b.x;
  46.      }
  47.  
  48.      inline double operator * (const Point &b) const
  49.      {
  50.          return x * b.x + y * b.y;
  51.      }
  52.  
  53.      inline double distance(Point p)
  54.      {
  55.          return hypot(x - p.x, y - p.y);
  56.      }
  57.  
  58.  };
  59.  
  60.  struct Line
  61.  {
  62.      Point s, e;
  63.      inline Line() {}
  64.      inline Line(Point _s, Point _e)
  65.      {
  66.          s = _s;
  67.          e = _e;
  68.      }
  69.  
  70.      inline void scan()
  71.      {
  72.          s.scan(); e.scan();
  73.      }
  74.  
  75.      inline double length()
  76.      {
  77.          return s.distance(e);
  78.      }
  79.  
  80.      inline double dispointtoline(Point p)
  81.      {
  82.          return fabs((p - s) ^ (e - s)) / length();
  83.      }
  84.  
  85.      inline double dispointtoseg(Point p)
  86.      {
  87.          if (sgn((p - s) * (e - s)) <  || sgn((p - e) * (s - e)) < )
  88.              return min(p.distance(s), p.distance(e));
  89.          return dispointtoline(p);
  90.      }
  91.  
  92.      inline bool pointonseg(Point p)
  93.      {
  94.          return sgn((p - s) ^ (e - s)) ==  && sgn((p - s) * (p - e)) <= ;
  95.      }
  96.  
  97.      inline int segcrossseg(Line v)
  98.      {
  99.          int d1 = sgn((e - s) ^ (v.s - s));
  100.          int d2 = sgn((e - s) ^ (v.e - s));
  101.          int d3 = sgn((v.e - v.s) ^ (s - v.s));
  102.          int d4 = sgn((v.e - v.s) ^ (e - v.s));
  103.          if ((d1 ^ d2) == - && (d3 ^ d4) == -) return ;
  104.          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)) <= );
  105.      }
  106.  
  107.  }line[N];
  108.  
  109.  struct Circle
  110.  {
  111.      Point p;
  112.      double r;
  113.      inline Circle() {}
  114.      inline Circle(Point _p, double _r)
  115.      {
  116.          p = _p;
  117.          r = _r;
  118.      }
  119.  
  120.      inline void scan()
  121.      {
  122.          p.scan();
  123.          scanf("%lf", &r);
  124.      }
  125.  
  126.  }circle[N];
  127.  
  128.  struct Triangle
  129.  {
  130.      Point a, b, c;
  131.      inline Triangle() {}
  132.      inline Triangle(Point _a, Point _b, Point _c)
  133.      {
  134.          a = _a;
  135.          b = _b;
  136.          c = _c;
  137.      }
  138.  
  139.      inline void scan()
  140.      {
  141.          a.scan(); b.scan(); c.scan();
  142.      }
  143.  
  144.  }triangle[N];
  145.  
  146.  int vis[N];
  147.  int n;
  148.  Point S, T;
  149.  
  150.  double G[N][N];
  151.  
  152.  inline double work11(int i, int j)
  153.  {
  154.      if (line[i].segcrossseg(line[j]) > ) return 0.0;
  155.      double ans = INF * 1.0;
  156.      ans = min(ans, line[i].dispointtoseg(line[j].s));
  157.      ans = min(ans, line[i].dispointtoseg(line[j].e));
  158.      ans = min(ans, line[j].dispointtoseg(line[i].s));
  159.      ans = min(ans, line[j].dispointtoseg(line[i].e));
  160.      return ans;
  161.  }
  162.  
  163.  inline double work12(int i, int j)
  164.  {
  165.      return max(0.0, line[i].dispointtoseg(circle[j].p) - circle[j].r);
  166.  }
  167.  
  168.  inline double work13(int i, int j)
  169.  {
  170.      Point a = triangle[j].a, b = triangle[j].b, c = triangle[j].c;
  171.      if (line[i].segcrossseg(Line(a, b)) > ) return 0.0;
  172.      if (line[i].segcrossseg(Line(a, c)) > ) return 0.0;
  173.      if (line[i].segcrossseg(Line(b, c)) > ) return 0.0;
  174.      double ans = INF * 1.0;
  175.      ans = min(ans, line[i].dispointtoseg(a));
  176.      ans = min(ans, line[i].dispointtoseg(b));
  177.      ans = min(ans, line[i].dispointtoseg(c));
  178.  
  179.      Point s = line[i].s, e = line[i].e;
  180.  
  181.      ans = min(ans, Line(a, b).dispointtoseg(s));
  182.      ans = min(ans, Line(a, b).dispointtoseg(e));
  183.  
  184.      ans = min(ans, Line(a, c).dispointtoseg(s));
  185.      ans = min(ans, Line(a, c).dispointtoseg(e));
  186.  
  187.      ans = min(ans, Line(b, c).dispointtoseg(s));
  188.      ans = min(ans, Line(b, c).dispointtoseg(e));
  189.  
  190.      return ans;
  191.  }
  192.  
  193.  inline double work22(int i, int j)
  194.  {
  195.      Point c1 = circle[i].p, c2 = circle[j].p;
  196.      double r1 = circle[i].r, r2 = circle[j].r;
  197.      return max(0.0, c1.distance(c2) - r1 - r2);
  198.  }
  199.  
  200.  inline double work23(int i, int j)
  201.  {
  202.      Point p = circle[j].p; double r = circle[j].r;
  203.      Point a = triangle[i].a, b = triangle[i].b, c = triangle[i].c;
  204.      double ans = INF * 1.0;
  205.      ans = min(ans, max(0.0, Line(a, b).dispointtoseg(p) - r));
  206.      ans = min(ans, max(0.0, Line(a, c).dispointtoseg(p) - r));
  207.      ans = min(ans, max(0.0, Line(b, c).dispointtoseg(p) - r));
  208.      return ans;
  209.  }
  210.  
  211.  inline double work33(int i, int j)
  212.  {
  213.      Point a = triangle[i].a, b = triangle[i].b, c = triangle[i].c;
  214.      Point aa = triangle[j].a, bb = triangle[j].b, cc = triangle[j].c;
  215.  
  216.      if (Line(a, b).segcrossseg(Line(aa, bb)) > ) return 0.0;
  217.      if (Line(a, b).segcrossseg(Line(aa, cc)) > ) return 0.0;
  218.      if (Line(a, b).segcrossseg(Line(bb, cc)) > ) return 0.0;
  219.  
  220.      if (Line(a, c).segcrossseg(Line(aa, bb)) > ) return 0.0;
  221.      if (Line(a, c).segcrossseg(Line(aa, cc)) > ) return 0.0;
  222.      if (Line(a, c).segcrossseg(Line(bb, cc)) > ) return 0.0;
  223.  
  224.      if (Line(b, c).segcrossseg(Line(aa, bb)) > ) return 0.0;
  225.      if (Line(b, c).segcrossseg(Line(aa, cc)) > ) return 0.0;
  226.      if (Line(b, c).segcrossseg(Line(bb, cc)) > ) return 0.0;
  227.  
  228.      double ans = INF * 1.0;
  229.  
  230.      ans = min(ans, Line(a, b).dispointtoseg(aa));
  231.      ans = min(ans, Line(a, b).dispointtoseg(bb));
  232.      ans = min(ans, Line(a, b).dispointtoseg(cc));
  233.  
  234.      ans = min(ans, Line(a, c).dispointtoseg(aa));
  235.      ans = min(ans, Line(a, c).dispointtoseg(bb));
  236.      ans = min(ans, Line(a, c).dispointtoseg(cc));
  237.  
  238.      ans = min(ans, Line(b, c).dispointtoseg(aa));
  239.      ans = min(ans, Line(b, c).dispointtoseg(bb));
  240.      ans = min(ans, Line(b, c).dispointtoseg(cc));
  241.  
  242.      ans = min(ans, Line(aa, bb).dispointtoseg(a));
  243.      ans = min(ans, Line(aa, bb).dispointtoseg(b));
  244.      ans = min(ans, Line(aa, bb).dispointtoseg(c));
  245.  
  246.      ans = min(ans, Line(aa, cc).dispointtoseg(a));
  247.      ans = min(ans, Line(aa, cc).dispointtoseg(b));
  248.      ans = min(ans, Line(aa, cc).dispointtoseg(c));
  249.  
  250.      ans = min(ans, Line(bb, cc).dispointtoseg(a));
  251.      ans = min(ans, Line(bb, cc).dispointtoseg(b));
  252.      ans = min(ans, Line(bb, cc).dispointtoseg(c));
  253.  
  254.      return ans;
  255.  }
  256.  
  257.  inline double work01(int vis, int i)
  258.  {
  259.      Point a = vis ? T : S;
  260.      return (line[i].dispointtoseg(a));
  261.  }
  262.  
  263.  inline double work02(int vis, int i)
  264.  {
  265.      Point a = vis ? T : S;
  266.      Point p = circle[i].p; double r = circle[i].r;
  267.      return max(0.0, a.distance(p) - r);
  268.  }
  269.  
  270.  struct Polygon
  271.  {
  272.      int n;
  273.      Point p[];
  274.      Line l[];
  275.      inline Polygon() {}
  276.      inline Polygon(Triangle r)
  277.      {
  278.          n = ;
  279.          p[] = r.a, p[] = r.b, p[] = r.c;
  280.          l[] = Line(p[], p[]);
  281.          l[] = Line(p[], p[]);
  282.          l[] = Line(p[], p[]);
  283.      }
  284.  
  285.      inline int relationpoint(Point q)
  286.      {
  287.          for (int i = ; i < n; ++i)
  288.              if (p[i] == q) return ;
  289.  
  290.          for (int i = ; i < n; ++i)
  291.              if (l[i].pointonseg(q)) return ;
  292.  
  293.          int cnt = ;
  294.          for (int i = ; i < n; ++i)
  295.          {
  296.              int j = (i + ) % n;
  297.              int k = sgn((q - p[j]) ^ (p[i] - p[j]));
  298.              int u = sgn(p[i].y - q.y);
  299.              int v = sgn(p[j].y - q.y);
  300.              if (k >  && u <  && v >= ) cnt++;
  301.              if (k <  && v <  && u >= ) cnt--;
  302.          }
  303.          return cnt != ;
  304.      }
  305.  };
  306.  
  307.  inline double work03(int vis, int i)
  308.  {
  309.      Point p = vis ? T : S;
  310.      Polygon tmp = Polygon(triangle[i]);
  311.      if (tmp.relationpoint(p) > ) return 0.0;
  312.  
  313.      double ans = INF * 1.0;
  314.  
  315.      ans = min(ans, tmp.l[].dispointtoseg(p));
  316.      ans = min(ans, tmp.l[].dispointtoseg(p));
  317.      ans = min(ans, tmp.l[].dispointtoseg(p));
  318.  
  319.      return ans;
  320.  }
  321.  
  322.  bool used[N];
  323.  double lowcost[N];
  324.  
  325.  inline void Dijkstra()
  326.  {
  327.      for (int i = ; i <= n + ; ++i)
  328.      {
  329.          lowcost[i] = INF * 1.0;
  330.          used[i] = false;
  331.      }
  332.      lowcost[] = ;
  333.      for (int j = ; j <= n + ; ++j)
  334.      {
  335.          int k = -;
  336.          double Min = INF * 1.0;
  337.          for (int i = ; i <= n + ; ++i)
  338.          {
  339.              if (!used[i] && lowcost[i] < Min)
  340.              {
  341.                  Min = lowcost[i];
  342.                  k = i;
  343.              }
  344.          }
  345.  
  346.          if (k == -) break;
  347.          used[k] = true;
  348.  
  349.          for (int i = ; i <= n + ; ++i)
  350.          {
  351.              if (!used[i] && lowcost[k] + G[k][i] < lowcost[i])
  352.              {
  353.                  lowcost[i] = lowcost[k] + G[k][i];
  354.              }
  355.          }
  356.      }
  357.  }
  358.  
  359.  int main()
  360.  {
  361.      #ifdef LOCAL
  362.      freopen("Test.in", "r", stdin);
  363.      #endif
  364.      while (scanf("%lf%lf%lf%lf", &S.x, &S.y, &T.x, &T.y) != EOF)
  365.      {
  366.          scanf("%d", &n);
  367.          for (int i = ; i <= n; ++i)
  368.          {
  369.              scanf("%d", vis + i);
  370.              if (vis[i] == )
  371.                  line[i].scan();
  372.              else if (vis[i] == )
  373.                  circle[i].scan();
  374.              else
  375.                  triangle[i].scan();
  376.          }
  377.          for (int i = ; i <= n; ++i)
  378.          {
  379.              for (int j = i + ; j <= n; ++j)
  380.              {
  381.                  if (vis[i] == )
  382.                  {
  383.                      if (vis[j] == )
  384.                          G[i][j] = G[j][i] = work11(i, j);
  385.                      else if (vis[j] == )
  386.                          G[i][j] = G[j][i] = work12(i, j);
  387.                      else if (vis[j] == )
  388.                          G[i][j] = G[j][i] = work13(i, j);
  389.                  }
  390.                  else if (vis[i] == )
  391.                  {
  392.                      if (vis[j] == )
  393.                          G[i][j] = G[j][i] = work12(j, i);
  394.                      else if (vis[j] == )
  395.                          G[i][j] = G[j][i] = work22(i, j);
  396.                      else if (vis[j] == )
  397.                          G[i][j] = G[j][i] = work23(i, j);
  398.                  }
  399.                  else if (vis[i] == )
  400.                  {
  401.                      if (vis[j] == )
  402.                          G[i][j] = G[j][i] = work13(j, i);
  403.                      else if (vis[j] == )
  404.                          G[i][j] = G[j][i] = work23(j, i);
  405.                      else if (vis[j] == )
  406.                          G[i][j] = G[j][i] = work33(i, j);
  407.                  }
  408.              }
  409.          }
  410.  
  411.          for (int i = ; i <= n; ++i)
  412.          {
  413.              if (vis[i] == )
  414.              {
  415.                  G[][i] = G[i][] = work01(, i);
  416.                  G[n + ][i] = G[i][n + ] = work01(, i);
  417.              }
  418.              else if (vis[i] == )
  419.              {
  420.                  G[][i] = G[i][] = work02(, i);
  421.                  G[n + ][i] = G[i][n + ] = work02(, i);
  422.              }
  423.              else if (vis[i] == )
  424.              {
  425.                  G[][i] = G[i][] = work03(, i);
  426.                  G[n + ][i] = G[i][n + ] = work03(, i);
  427.              }
  428.          }
  429.  
  430.          G[][n + ] = G[n + ][] = S.distance(T);
  431.  
  432.          //for (int i = 0; i <= n + 1; ++i)
  433.          //    for (int j = 0; j <= n + 1; ++j)
  434.          //        printf("%.2f%c", G[i][j], " \n"[j == n + 1]);
  435.  
  436.          Dijkstra();
  437.          printf("%d\n", (int)floor(lowcost[n + ]));
  438.      }
  439.      return ;
  440.  }

F：Poker

水。

  1.  #include <bits/stdc++.h>
  2.  
  3.  using namespace std;
  4.  
  5.  #define N 100010
  6.  
  7.  int n;
  8.  int arr[N];
  9.  int brr[N];
  10.  int a[N];
  11.  
  12.  inline void Init()
  13.  {
  14.      memset(a, , sizeof a);
  15.  }
  16.  
  17.  inline int lowbit(int x)
  18.  {
  19.      return x & (-x);
  20.  }
  21.  
  22.  inline void update(int x, int val)
  23.  {
  24.      for (int i = x; i <= n; i += lowbit(i))
  25.          a[i] += val;
  26.  }
  27.  
  28.  inline int sum(int x)
  29.  {
  30.      int ans = ;
  31.      for (int i = x; i > ; i -= lowbit(i))
  32.          ans += a[i];
  33.      return ans;
  34.  }
  35.  
  36.  inline bool check(int mid, int emp)
  37.  {
  38.      int tot = sum(mid);
  39.      return tot <= emp;
  40.  }
  41.  
  42.  int main()
  43.  {
  44.      while (scanf("%d", &n) != EOF)
  45.      {
  46.          Init();
  47.          for (int i = ; i <= n; ++i) update(i, );
  48.          for(int i = ; i <= n; ++i)
  49.          {
  50.              scanf("%d",&arr[i]);
  51.          }
  52.          for (int i = ; i <= n; ++i)
  53.          {
  54.              int index = (int)floor(sqrt(n - i + ));
  55.              int l = , r = n, id;
  56.              while (r - l >= )
  57.              {
  58.                  int mid = (l + r) >> ;
  59.                  int tot = sum(mid);
  60.                  if (tot == index)
  61.                      id = mid;
  62.                  if (tot >= index)
  63.                      r = mid - ;
  64.                  else
  65.                      l = mid + ;
  66.              }
  67.              brr[id] = arr[i];
  68.              update(id, -);
  69.          }
  70.          for (int i = ; i <= n; ++i) printf("%d%c", brr[i], " \n"[i == n]);
  71.      }
  72.      return ;
  73.  }
  1.  #include<bits/stdc++.h>
  2.  
  3.  using namespace std;
  4.  
  5.  #define N 100010
  6.  
  7.  int n;
  8.  int arr[N];
  9.  int brr[N];
  10.  
  11.  int main()
  12.  {
  13.      while(~scanf("%d",&n))
  14.      {
  15.          for(int i = ; i <= n; ++i)
  16.          {
  17.              scanf("%d",&arr[i]);
  18.          }
  19.          vector<int>vec;
  20.          for(int i = n; i >= ;--i)
  21.          {
  22.              int tmp = floor(sqrt(n - i + ));
  23.              vec.insert(vec.begin() + tmp - , arr[i]);
  24.          }
  25.          for(int i = ; i < n; ++i)
  26.          {
  27.              printf("%d%c",vec[i]," \n"[i == n - ]);
  28.          }
  29.      }
  30.      return ;
  31.  }

BUCT20180814邀请赛 Solution的更多相关文章

  1. CCPC2018-湖南全国邀请赛 Solution

    A - Easy $h$-index 后缀扫一下 #include <bits/stdc++.h> using namespace std; #define ll long long #d ...

  2. HZNU_TI1050 训练实录

    菜鸡队训练实录 比赛记录:[名称:奖项 / 排名] 2018: ZJPSC                       Bronze      / 86 CCPC Jilin              ...

  3. 2014 ACM/ICPC 北京邀请赛 部分 题解

    题目链接:http://acm.bnu.edu.cn/bnuoj/problem.php?search=2014+ACM-ICPC+Beijing+Invitational+Programming+C ...

  4. Minieye杯第十五届华中科技大学程序设计邀请赛现场同步赛 I Matrix Again

    Minieye杯第十五届华中科技大学程序设计邀请赛现场同步赛 I Matrix Again https://ac.nowcoder.com/acm/contest/700/I 时间限制:C/C++ 1 ...

  5. CSAPC08台湾邀请赛_T1_skyline

    题目链接:CSAPC08台湾邀请赛_T1_skyline 题目描述 一座山的山稜线由许多片段的45度斜坡构成,每一个片段不是上坡就是下坡. / /​ * / ​/ * /  // ​/ // / 在我 ...

  6. Enterprise Solution 3.1 企业应用开发框架 .NET ERP/CRM/MIS 开发框架，C/S架构，SQL Server + ORM(LLBL Gen Pro) + Infragistics WinForms

    行业:基于数据库的制造行业管理软件,包含ERP.MRP.CRM.MIS.MES等企业管理软件 数据库平台:SQL Server 2005或以上 系统架构:C/S 开发技术 序号 领域 技术 1 数据库 ...

  7. Enterprise Solution 开源项目资源汇总 Visual Studio Online 源代码托管 企业管理软件开发框架

    Enterprise Solution 是一套管理软件开发框架,在这个框架基础上开发出一套企业资源计划系统Enterprise Edition. 现将Enterprise Solution开发过程中遇 ...

  8. Windows 10 部署Enterprise Solution 5.5

    Windows 10正式版发布以后,新操作系统带来了许多的变化.现在新购买的电脑安装的系统应该是Windows 10.与当初用户不习惯Windows 7,购买新电脑后第一个想做的事情就是重装成XP,估 ...

  9. Enterprise Solution 企业资源计划管理软件 C/S架构，支持64位系统，企业全面应用集成，制造业信息化

    Enterprise Solution是一套完整的企业资源计划系统,功能符合众多制造业客户要求.系统以.NET Framework技术作为开发架构,完善的功能可有效地帮助企业进行运营策划,减低成本,如 ...

随机推荐

  1. 解决Bootstrap布局注册表单input标签前增加必填项*提示与input框不在同一行问题

    注册表单部分代码如下: <form id="registForm" class="form-horizontal" action="${page ...

  2. Linux netstat 命令

    1. netstat命令用于显示系统的网络信息,包括网络连接 .路由表 .接口状态2. 一般我们使用 netstat 来查看本机开启了哪些端口,查看有哪些客户端连接 常见用法如下: [root@loc ...

  3. VMware克隆虚拟机后网络不能正常使用的解决方法

    1.问题情况 在vmware中克隆一个虚拟机后,新的虚拟机网络无法使用,并用原操作系统中的网卡eth0在克隆出来的新系统中,网卡号变成了eth1,并且IP地址也丢失了,网络不可正常使用. 2.环境情况 ...

  4. m2014-architecture-imgserver->利用Squid反向代理搭建CDN缓存服务器加快Web访问速度

    案例:Web服务器:域名www.abc.com IP:192.168.21.129 电信单线路接入访问用户:电信宽带用户.移动宽带用户出现问题:电信用户打开www.abc.com正常,移动用户打开ww ...

  5. C++11新特性之五——可变参数模板

    有些时候,我们定义一个函数,可能这个函数需要支持可变长参数,也就是说调用者可以传入任意个数的参数.比如C函数printf(). 我们可以这么调用. printf(); 那么这个函数是怎么实现的呢?其实 ...

  6. 当div没有设置宽度，使用width的fit-content和margin:auto实现元素的水平居中

    当我们做水平居中的时候,会有许多方法,margin:0 auto,或者test-align:center,以及flex布局.当元素的width不固定的时候,我们如何实现水平居中呢,代码如下: < ...

  7. php学习九：存取器&魔术方法

    当声明属性的时候用到了private,那么的话只能本类中才能访问此属性,其他地方无法使用,这个时候需要给外界提供一些方法来使外界访问 方法一:存取器: 可以提供一个public的方法来使外界对类里面的 ...

  8. 如何在office2010中的EXCEL表格使用求和公式

    EXCEL做表格非常方便,有时我们需要对表格中的很多数字进行求和计算,如果用计算器算会非常麻烦,别担心,用求和公式计算,非常简单的 工具/原料   电脑一台 offic2010软件一套 方法/步骤   ...

  9. 移动前端开发viewport

    1.viewport的概念 能在移动设备上正常显示那些传统的为桌面浏览器设计的网站宽度 2.css中的1px并不等于移动设备的1px 在iphone3上,一个css像素确实是等于一个屏幕物理像素的.后 ...

  10. android异常：Can not perform this action after onSaveInstanc

    extends:http://zhiweiofli.iteye.com/blog/1539467 本人某个android项目开发阶段一直运行良好,直到上线前夕,在某款跑着android 4.03系统的 ...