Codeforces Round#310 div2

C题：这题说的是套娃，如果做题的时候知道是套娃，那就好理解多了

规则1：套娃A可以放到套娃B里面，当且仅当套娃B没有放在其他套娃里面

规则2：套娃A放在套娃B里面，且套娃B没有放在其他套娃里面，那么可以把A从B中拿出来

问我们最少要操作多少次，才能将套娃全部套起来，拆开和组装都算是一次操作

思路：找到序号为1的套娃的哪一组，然后统计该组有多少个套娃是连在1后面，且每次序号都是加1的，那么这些个套娃是不用拆开的。那么剩下的套娃都是要拆开的

 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <algorithm>
 #include <iostream>
 #include <queue>
 #include <stack>
 #include <vector>
 #include <map>
 #include <set>
 #include <string>
 #include <math.h>
 using namespace std;
 #pragma warning(disable:4996)
 typedef long long LL;
 const int INF = <<;
 /*

 */
 int a[ + ];
 int main()
 {

     int n, k, m;
     int ans;
     int cnt;
     while (scanf("%d%d", &n, &k) != EOF)
     {
         ans  = cnt = ;
         for (int i = ; i < k; ++i)
         {
             scanf("%d", &m);
             bool flag = false;
             for (int j = ; j < m; ++j)
             {
                 scanf("%d", &a[j]);
                 if (a[j] == )
                 {
                     flag = true;
                 }
             }

             if (flag)
             {
                 cnt = ;
                 for (int j = ; j < m; ++j)
                 {
                     if (a[j] -  == a[j - ])
                         cnt++;
                     else
                         break;
                 }
                 ans += m - cnt;
                 flag = false;
             }
             else
                 ans += m - ;
         }
         ans += n - cnt;
         printf("%d\n", ans);
     }
     return ;
 }

D题：当时的想法是把岛屿按距离下一个的岛屿的距离，从小到大排序， 并且将桥的长度也从小到大排序，然后进行贪心， 但是问题是

可能贪心的时候，选择了当前的桥A，但是桥B也时候自己（桥A排在桥B前面）， 但是呢，到下一个岛屿的时候，桥B对它来说，太长了。

例子：三个岛屿，两座桥，按上面那样子贪心是不行的。

1 10

11 16

20 23

10 15

上面的贪心策略，没有考虑到的信息是岛屿自身的长度。仅考虑了岛屿与岛屿之间的距离

我们规定上界是：两个岛屿之间能建立的最长的桥， 下界是：最短的桥

我们可以将岛屿按照上界进行排序，然后选择桥的时候，找到第一个大于等于下界的桥即可。这样就不会发生上面所说的那种情况（因为上界是递增的）

还有一点就是STL的lower_bound()函数极端情况下，时间复杂度是O(n)，会超时

可以将桥的长度存到set中，然后用set自带的lower_bound()函数， 时间复杂度是O(logn)

 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <algorithm>
 #include <iostream>
 #include <queue>
 #include <stack>
 #include <vector>
 #include <map>
 #include <set>
 #include <string>
 #include <math.h>
 using namespace std;
 #pragma warning(disable:4996)
 typedef long long LL;
 const int INF =  << ;
 /*

 */
 const int N =  + ;
 struct Island
 {
     LL l, r, upper, lower, id;
     bool operator<(const Island&rhs)const
     {
         return upper < rhs.upper;
     }
 }island[N];
 set<pair<LL, int> > b;
 int ans[N];
 int main()
 {
     int n, m;
     LL a;
     scanf("%d%d", &n, &m);
     for (int i = ; i < n; ++i)
     {
         scanf("%I64d%I64d", &island[i].l, &island[i].r);
     }
     for (int i = ; i < n - ; ++i)
     {
         island[i].id = i;
         island[i].lower = island[i + ].l - island[i].r;
         island[i].upper = island[i + ].r - island[i].l;
     }
     sort(island, island + n - );
     for (int i = ; i < m; ++i)
     {
         scanf("%I64d", &a);
         b.insert(make_pair(a, i));
     }
     for (int i = ; i < n - ; ++i)
     {
         set<pair<LL, int> >::iterator iter = b.lower_bound(make_pair(island[i].lower, ));
         if (iter == b.end())
         {
             puts("No");
             return ;
         }
         else
         {
             if (iter->first <= island[i].upper)
             {
                 ans[island[i].id] = iter->second + ;
                 b.erase(iter);
             }
             else
             {
                 puts("No");
                 return ;
             }
         }
     }
     puts("Yes");
     printf("%d", ans[]);
     for (int i = ; i < n - ; ++i)
         printf(" %d", ans[i]);
     puts("");
     return ;
 }

E题：

对于向上走的点，那么只有比自己大的x能影响到自己

对于向左走的点，那么只有比自己小的x能影响到自己

用set就行了。

 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <algorithm>
 #include <iostream>
 #include <queue>
 #include <stack>
 #include <vector>
 #include <map>
 #include <set>
 #include <string>
 #include <math.h>
 using namespace std;
 #pragma warning(disable:4996)
 typedef long long LL;
 const int INF = <<;
 /*
 6 5
 3 4 U
 6 1 L
 5 2 U
 4 3 U
 2 5 U

 如果向上走，那么只有比自己大的x[i]向左走能影响到自己
 如果向左走，那么只有比自己小的x[i]向上走能影响到自己
 */
 const int N =  + ;
 set<pair<int,int> > s;
 set<pair<int, int> >::iterator it;
 int x[N], y[N];
 int main()
 {
     int n, q;
     char d[];
     scanf("%d%d", &n, &q);
     s.insert(make_pair(, q+));
     s.insert(make_pair(n + , q+));
     x[] = y[] = ;
     for (int i = ; i <= q; ++i)
     {
         scanf("%d%d%s", &x[i], &y[i], d);
         if (d[] == 'U')
         {
             it = s.lower_bound(make_pair(x[i], -));
         }
         else
         {
             it = s.upper_bound(make_pair(x[i], q+));
             //it-- , 找到比自己小的x
             it--;
         }
         if (it->first == x[i])
         {
             printf("0\n");
             continue;
         }
         s.insert(make_pair(x[i], i));
         if (d[] == 'U')
         {
             printf("%d\n", y[i] - y[it->second]);
             //影响是可以传递的
             y[i] = y[it->second];
         }
         else
         {
             printf("%d\n", x[i] - x[it->second]);
             x[i] = x[it->second];
         }
     }
     return ;
 }

目标：①div2做4题   ②一次AC，手速快，题意看清