Codeforces Round#413 Problem A - C

Problem#A Carrot Cakes

vjudge链接[here]

（偷个懒,cf链接就不给了）

　　题目大意是说，烤面包，给出一段时间内可以考的面包数，建第二个炉子的时间，需要达到的面包数，问建炉子是否合理。

　　玄学 & 智商题，可能是因为我智商不够，所以在我决定休息的时候被hank掉了。。。（纠正一个错误，是fst掉的）

　　输NO的情况大概是当炉子建好后，考完第一波的时间，任务已经或刚好完成。

Code

 /**
  * Codeforces
  * Problem#799A
  * Accepted
  * Time:15ms
  * Memory:8k
  */
 #include<iostream>
 #include<fstream>
 #include<sstream>
 #include<algorithm>
 #include<cstdio>
 #include<cstring>
 #include<cstdlib>
 #include<cctype>
 #include<cmath>
 #include<ctime>
 #include<map>
 #include<stack>
 #include<set>
 #include<queue>
 #include<vector>
 using namespace std;
 typedef bool boolean;
 #define inf 0xfffffff
 #define smin(a, b) (a) = min((a), (b))
 #define smax(a, b) (a) = max((a), (b))
 template<typename T>
 inline boolean readInteger(T& u) {
     char x;
     ;
     );
     )    {
         ungetc(x, stdin);
         return false;
     }
     if(x == '-') {
         aFlag = -;
         x = getchar();
     }
      + x - ');
     u *= aFlag;
     ungetc(x, stdin);
     return true;
 }

 int n, t, k, d;

 inline void work() {
     readInteger(n);
     readInteger(t);
     readInteger(k);
     readInteger(d);
     ;
     if(turns * k > n)
         puts("NO");
     else if(turns * k == n && (d == t || turns * t <= d + t))
         puts("NO");
     else
         puts("YES");
 }

 int main() {
     work();
     ;
 }

Problem#A

---

Problem#B T-shirt buying

vjudge链接[here]

　　题目大意是说，每件衣服有两面，每面有个颜色，有些人要来买，他只买存在一面有他喜欢的颜色且价格最低的一个，输出每个人付的钱，没有买到输出-1。

　　用个set，依题意乱搞就好了。(每场比赛貌似都是b题稳AC)

Code

 /**
  * Codeforces
  * Problem#799B
  * Accepted
  * Time:296ms
  * Memory:14964k
  */
 #include<iostream>
 #include<fstream>
 #include<sstream>
 #include<algorithm>
 #include<cstdio>
 #include<cstring>
 #include<cstdlib>
 #include<cctype>
 #include<cmath>
 #include<ctime>
 #include<map>
 #include<stack>
 #include<set>
 #include<queue>
 #include<vector>
 using namespace std;
 typedef bool boolean;
 #define inf 0xfffffff
 #define smin(a, b) (a) = min((a), (b))
 #define smax(a, b) (a) = max((a), (b))
 template<typename T>
 inline boolean readInteger(T& u) {
     char x;
     ;
     );
     )    {
         ungetc(x, stdin);
         return false;
     }
     if(x == '-') {
         aFlag = -;
         x = getchar();
     }
      + x - ');
     u *= aFlag;
     ungetc(x, stdin);
     return true;
 }

 typedef class Tshirt {
     public:
         int p;
         int id;

         Tshirt() {        }
         Tshirt(int p, int id):p(p), id(id) {    }

         boolean operator < (Tshirt b) const {
             if(p != b.p) return p < b.p;
             return id < b.id;
         }
 }Tshirt;

 int n, m;
 int* prices;
 int *color1, *color2;

 multiset<Tshirt> ps[];

 inline void init() {
     readInteger(n);
     prices = )];
     color1 = )];
     color2 = )];
     ; i <= n; i++)
         readInteger(prices[i]);
     ; i <= n; i++) {
         readInteger(color1[i]);
         ps[color1[i] - ].insert(Tshirt(prices[i], i));
     }
     ; i <= n; i++) {
         readInteger(color2[i]);
         if(color1[i] != color2[i])
             ps[color2[i] - ].insert(Tshirt(prices[i], i));
     }
 }

 inline void solve() {
     int c;
     readInteger(m);
     while(m--) {
         readInteger(c);
         c--;
         ) {
             printf("-1 ");
         } else {
             multiset<Tshirt>::iterator t = ps[c].begin();
             printf("%d ", t->p);
             ) {
                 ps[color1[t->id] - ].erase(ps[color1[t->id] - ].find(Tshirt(t->p, t->id)));
             } ) {
                 ps[color2[t->id] - ].erase(ps[color2[t->id] - ].find(*t));
             }
             ps[c].erase(t);
         }
     }
 }

 int main() {
     init();
     solve();
     ;
 }

Problem#B

---

Problem#C Fountains

vjudge链接[here]

　　C题思路不是很难，很好想，结果写炸了。。。

　　第一种情况，买两个不同购买方式的物品，贪心就好了。

　　第二种情况，买两个购买方式相同的物品，先按价格从小到大拍一道序，然后记录一个能延伸到的一个最远的物品r,每次i++时要用while循环去更新r，接着剩下的事交给线段树查最大值就好了。两种购买方式的物品都做一下就好了。

　　当然，写炸的缘故

　　1.自己坑自己。。sort的cmpare函数改了后没有改for循环的顺序(第一种情况比较懒，开始就写了就不想改了)

　　2.少特判当某种购买方式的物品不存在的情况，然后建树就挂了，MLE。

Code

 /**
  * Codeforces
  * Problem#799C
  * Accepted
  * Time:62ms
  * Memory:6300k
  */
 #include<iostream>
 #include<fstream>
 #include<sstream>
 #include<algorithm>
 #include<cstdio>
 #include<cstring>
 #include<cstdlib>
 #include<cctype>
 #include<cmath>
 #include<ctime>
 #include<map>
 #include<stack>
 #include<set>
 #include<queue>
 #include<vector>
 using namespace std;
 typedef bool boolean;
 #define inf 0xfffffff
 #define smin(a, b) (a) = min((a), (b))
 #define smax(a, b) (a) = max((a), (b))
 template<typename T>
 inline boolean readInteger(T& u) {
     char x;
     ;
     );
     )    {
         ungetc(x, stdin);
         return false;
     }
     if(x == '-') {
         aFlag = -;
         x = getchar();
     }
      + x - ');
     u *= aFlag;
     ungetc(x, stdin);
     return true;
 }

 typedef class MyPair {
     public:
         int c;
         int p;

         MyPair(, ):c(c), p(p) {    }
 }MyPair;

 typedef class SegTreeNode {
     public:
         int val;
         SegTreeNode* l, *r;

         SegTreeNode():val(), l(NULL), r(NULL) {        }

         inline void pushUp() {
             val = max(l->val, r->val);
         }
 }SegTreeNode;

 typedef class SegTree {
     public:
         SegTreeNode* root;

         SegTree() {        }
         SegTree(int n, MyPair*& lis) {
             build(root, , n, lis);
         }

         void build(SegTreeNode*& node, int l, int r, MyPair*& lis) {
             node = new SegTreeNode();
             if(l == r) {
                 node->val = lis[l].c;
                 return;
             }
             ;
             build(node->l, l, mid, lis);
             build(node->r, mid + , r, lis);
             node->pushUp();
         }

         int query(SegTreeNode*& node, int l, int r, int ql, int qr) {
             ;
             if(l == ql && r == qr) {
                 return node->val;
             }
             ;
             if(qr <= mid)    return query(node->l, l, mid, ql, qr);
             , r, ql, qr);
             int a = query(node->l, l, mid, ql, mid);
             , r, mid + , qr);
             return max(a, b);
         }

         void clear(SegTreeNode*& node) {
             if(node->l)    clear(node->l);
             if(node->r)    clear(node->r);
             delete node;
         }
 }SegTree;

 int n;
 int C, D;
 MyPair *cs, *ds;
 , cnd = ;
 , bd = -;
 SegTree stc, stdd;

 inline void init() {
     readInteger(n);
     readInteger(C);
     readInteger(D);
     cs = )];
     ds = )];
     int a, b;
     char x;
     ; i <= n; i++) {
         readInteger(a);
         readInteger(b);
         getchar(); x = getchar();
         if(x == 'C' && b <= C)
             cs[++cnc] = MyPair(a, b);
         else if(x == 'D' && b <= D)
             ds[++cnd] = MyPair(a, b);
     }
 }

 boolean cmp1(const MyPair& a, const MyPair& b) {
     if(a.c != b.c) return a.c > b.c;
     return a.p < b.p;
 }

 boolean cmp2(const MyPair& a, const MyPair& b) {
     if(a.p != b.p) return a.p < b.p;
     return a.c > b.c;
 }

 ;

 inline void solve() {
     )
         sort(cs + , cs + cnc + , cmp1);
     )
         sort(ds + , ds + cnd + , cmp1);
     ; i <= cnc; i++)
         if(cs[i].p <= C) {
             bc = cs[i].c;
             break;
         }
     ; i <= cnd; i++)
         if(ds[i].p <= D) {
             bd = ds[i].c;
             break;
         }
      && bd != -)
         res = bc + bd;

     )
         sort(cs + , cs + cnc + , cmp2);
     )
         sort(ds + , ds + cnd + , cmp2);
     int r = cnc;
     if(cnc) {
         stc = SegTree(cnc, cs);
         ; i <= r; i++) {
             , a1 = ;
             while(cs[i].p + cs[r].p > C)    r--;
             if(i > r)   break;
             )
                 a0 = stc.query(stc.root, , cnc, , i - );
             if(i < cnc)
                 a1 = stc.query(stc.root, , cnc, i + , r);
              && a1 == )    continue;
             smax(res, max(a0, a1) + cs[i].c);
         }
     }

     r = cnd;
     if(cnd) {
     stdd = SegTree(cnd, ds);
         ; i <= r; i++) {
             , a1 = ;
             while(ds[i].p + ds[r].p > D)    r--;
             if(i > r)    break;
             )
                 a0 = stdd.query(stdd.root, , cnd, , i - );
             if(i < cnd)
                 a1 = stdd.query(stdd.root, , cnd, i + , r);
              && a1 == )    continue;
             smax(res, max(a0, a1) + ds[i].c);
         }
     }
     printf("%d", res);
 }

 int main() {
     init();
     solve();
     ;
 }

Problem#C