从廊桥分配学习优先队列

题目地址：P7913 [CSP-S 2021] 廊桥分配 - 洛谷

• 首先考虑最朴素的做法，即枚举廊桥对国内和国际的分配，此过程时间复杂度O（n），接着问题就变成了有 i 个廊桥，有m架飞机，分别要在[ai,bi]时间段内使用一个廊桥，问最多有多少架飞机可以使用廊桥。因为有“先到先得”原则，实际上只需要先将飞机到达时间从小到大排序，再按顺序枚举每一架飞机，并看其前面的飞机都有没有使用廊桥，记录总使用数，以此判断当前飞机能否使用廊桥，最后总使用数即为答案，这个枚举的过程时间复杂度为O（n²），总复杂度为O（n³），代码如下：

  #include <bits/stdc++.h>
  using namespace std;
  const int N = 1e5 + 7;
  struct node
  {
      int a, b;
  } f1[N], f2[N];
  int n, m1, m2, MAX = -1, v1[N], v2[N]; // v数组用于记录飞机是否能用廊桥
  bool cmp(node x, node y)
  {
      return x.a < y.a;
  }
  int main()
  {
      scanf("%d %d %d", &n, &m1, &m2);
      for (int i = 1; i <= m1; i++)
          scanf("%d %d", &f1[i].a, &f1[i].b);
      for (int i = 1; i <= m2; i++)
          scanf("%d %d", &f2[i].a, &f2[i].b);
      sort(f1 + 1, f1 + m1 + 1, cmp);
      sort(f2 + 1, f2 + m2 + 1, cmp);
      for (int k = 0; k <= n; k++)
      {
          int sum1 = k, sum2 = n - k;
          int ans1 = 0, ans2 = 0;
          memset(v1, 0, sizeof(v1));
          memset(v2, 0, sizeof(v2));
          for (int i = 1; i <= m1; i++)
          {
              int flag = 1;
              for (int j = 1; j <= i - 1; j++)
                  if (f1[j].b > f1[i].a && v1[j])
                      flag++;
              if (flag <= sum1)
              {
                  v1[i] = 1;
                  ans1++;
              }
          }
          for (int i = 1; i <= m2; i++)
          {
              int flag = 1;
              for (int j = 1; j <= i - 1; j++)
                  if (f2[j].b > f2[i].a && v2[j])
                      flag++;
              if (flag <= sum2)
              {
                  v2[i] = 1;
                  ans2++;
              }
          }
          MAX = max(MAX, ans1 + ans2);
      }
      printf("%d", MAX);
      return 0;
  }

  只有20pts

• 仔细思考下飞机使用廊桥的过程，我们发现对于任意一架飞机，因为“先到先得”，所以他使用第几个廊桥是固定的，当我们枚举廊桥的分配时，对一架飞机能否使用廊桥会重复判断，比如有i个廊桥时，这架飞机可以使用，那么有i+1个廊桥，这架飞机当然可以使用。所以我们可以考虑记录每架飞机如果使用廊桥是使用第几个，这样就可以通过枚举飞机，来省略对廊桥分配的枚举，时间复杂度降为O（n²），代码如下：

  #include <bits/stdc++.h>
  using namespace std;
  const int N = 1e5 + 7;
  struct node
  {
      int a, b;
  } f1[N], f2[N];
  int n, m1, m2, MAX = -1, v1[N], v2[N]; // 特别注意，这里的v含义不同，他记录的是第i个廊桥目前飞机最晚的离开时间
  int c1[N], c2[N];                      // 表示第i个廊桥有多少飞机使用
  int s1[N], s2[N];                      // 表示前i个廊桥一共能运送多少飞机
  bool cmp(node x, node y)
  {
      return x.a < y.a;
  }
  int main()
  {
      scanf("%d %d %d", &n, &m1, &m2);
      for (int i = 1; i <= m1; i++)
          scanf("%d %d", &f1[i].a, &f1[i].b);
      for (int i = 1; i <= m2; i++)
          scanf("%d %d", &f2[i].a, &f2[i].b);
      sort(f1 + 1, f1 + m1 + 1, cmp);
      sort(f2 + 1, f2 + m2 + 1, cmp);
      int k1 = 1; // 当前用了多少个廊桥
      for (int i = 1; i <= m1; i++)
      {
          for (int j = 1; j <= k1; j++)
          {
              if (v1[j] <= f1[i].a)
              {
                  v1[j] = f1[i].b;
                  c1[j]++;
                  break;
              }
              else if (j == k1)
              {
                  v1[++k1] = f1[i].b;
                  c1[k1] = 1;
                  break;//！！！这里一定要break,因为k1增加了，循环还会进行！！！
              }
          }
      }
      int k2 = 1; // 当前用了多少个廊桥
      for (int i = 1; i <= m2; i++)
      {
          for (int j = 1; j <= k2; j++)
          {
              if (v2[j] <= f2[i].a)
              {
                  v2[j] = f2[i].b;
                  c2[j]++;
                  break;
              }
              else if (j == k2)
              {
                  v2[++k2] = f2[i].b;
                  c2[k2] = 1;
                  break;
              }
          }
      }
      for (int i = 1; i <= n; i++)
      {
          s1[i] = s1[i - 1] + c1[i];
          s2[i] = s2[i - 1] + c2[i];
      }
      for (int i = 0; i <= n; i++)
          MAX = max(MAX, s1[i] + s2[n - i]);
      printf("%d", MAX);
      return 0;
  }

  得分95pts

• 想想看哪里还能优化呢？枚举飞机这一步不可避免，但是我们找这架飞机要使用的廊桥，不就是编号最小的，并且满足廊桥上一架飞机的离开时间早于这架飞机的到达时间吗。看到查询“最小”，并且飞机对于每个廊桥肯定是先进先出的，应该就能想到使用优先队列，因为优先队列的插入和删除时间复杂度都是logn，那总的复杂度就是O（nlogn），用优先队列存取每个廊桥的飞机的离开时间和使用的廊桥，当下一架飞机到达时，弹出所有在他到达前离开的飞机，并将其占用廊桥重新加入可用廊桥，再把它存入队列，从可用廊桥中选一个编号最小的给他用（也就是用了两个优先队列，维护两个数据，其中廊桥编号要复用）。代码如下：

  #include <bits/stdc++.h>
  using namespace std;
  const int N = 1e5 + 7;
  struct node
  {
      int a, b;
  } f1[N], f2[N];
  int n, m1, m2, MAX = -1, c1[N], c2[N];
  priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> q1, q2; // 存离开时间，使用廊桥编号
  priority_queue<int, vector<int>, greater<int>> p1, p2;                 // 存空余廊桥
  int s1[N], s2[N];                                                      // 表示前i个廊桥一共能运送多少飞机
  bool cmp(node x, node y)
  {
      return x.a < y.a;
  }
  int main()
  {
      scanf("%d %d %d", &n, &m1, &m2);
      for (int i = 1; i <= m1; i++)
          scanf("%d %d", &f1[i].a, &f1[i].b);
      for (int i = 1; i <= m2; i++)
          scanf("%d %d", &f2[i].a, &f2[i].b);
      for (int i = 1; i <= n; i++)
      {
          p1.push(i);
          p2.push(i);
      }
      sort(f1 + 1, f1 + m1 + 1, cmp);
      sort(f2 + 1, f2 + m2 + 1, cmp);
      for (int i = 1; i <= m1; i++)
      {
          while (!q1.empty() && q1.top().first <= f1[i].a)
          {
              int t = q1.top().second;
              p1.push(t);
              q1.pop();
          }
          if (!p1.empty())//这里要特别注意,廊桥n不一定大于m1,m2,小心RE
          {
              int t = p1.top();
              p1.pop();
              q1.push(make_pair(f1[i].b, t));
              c1[t]++;
          }
      }
      for (int i = 1; i <= m2; i++)
      {
          while (!q2.empty() && q2.top().first <= f2[i].a)
          {
              int t = q2.top().second;
              p2.push(t);
              q2.pop();
          }
          if (!p2.empty())
          {
              int t = p2.top();
              p2.pop();
              q2.push(make_pair(f2[i].b, t));
              c2[t]++;   
          }
      }
      for (int i = 1; i <= n; i++)
      {
          s1[i] = s1[i - 1] + c1[i];
          s2[i] = s2[i - 1] + c2[i];
      }
      for (int i = 0; i <= n; i++)
          MAX = max(MAX, s1[i] + s2[n - i]);
      printf("%d", MAX);
      return 0;
  }

  得分100pts,成功AC

• 从这道题中我们应该学到什么呢，为什么会想到使用优先队列，即“堆”这个数据结构，而不是线段树之类的呢？听听Chatgpt怎么说的

• 

•  

  总结一下，其实就是优先队列它将原来的数列重构，按照优先级排序成一个二叉树，因此查询全局最值只要o（1）的时间，插入和删除也只要O（logn）的时间 ，而线段树，他并没有重构原来的数列，他针对的是区间的处理，将相邻的几个节点的某个信息记录在一个我们额外增加的节点上（也就是为什么线段树数组要开4N）,因此它有了很多区间处理的功能，但相应的他对元素的增加和删除（这改变了树的节点数量，树需要重构）复杂度大大增加。因此，当我们只关心一个数列中，某种特征最明显的那个数时，往往使用优先队列来维护，当我们关心数列某段的性质时，往往用线段树。
  
  
  ————————————————————————————————戛然而止