101 Hack October'14

拖了近一个月的总结。（可能源于最近不太想做事:(）

A题

给出ｎ个长度都为ｎ的字符串，你只可以对每个字符串分别排序，问当每个字符串按升序排序之后，每一列是否也是升序的。

 #include <cmath>
 #include <cstdio>
 #include <vector>
 #include <iostream>
 #include <algorithm>
 using namespace std;

 int main() {
     ios::sync_with_stdio(false);
     int t;
     cin >> t;
     while (t--) {
         int n;
         cin >> n;
         string ch1, ch2;
         cin >> ch1;
         sort(ch1.begin(), ch1.end());
         bool flag = true;
         for (int i = ; i < n; i++) {
             cin >> ch2;
             sort(ch2.begin(), ch2.end());
             for (int j = ; j < n; j++) if (ch1[j] > ch2[j]) flag = false;
             //if (ch1 > ch2) flag = false;
             swap(ch1, ch2);
         }
         if (flag) cout << "YES\n";
         else cout << "NO\n";
     }

     return ;
 }

B题

进制转换

 #include <map>
 #include <cmath>
 #include <cstdio>
 #include <vector>
 #include <iostream>
 #include <algorithm>
 using namespace std;

 int work(int m, int d) {
     int res = , t = ;
     while (d) {
         if (d %  >= m) return -;
         res += (d % ) * t;
         d /= ;
         t *= m;
     }
     return res;
 }

 int main() {
     ios_base::sync_with_stdio(false);
     int n;
     cin >> n;
     map<int, int> mmap;
     for (int i = ; i < n; i++) {
         int m, d;
         cin >> m >> d;
         int x = work(m, d);
         if (x != -) mmap[x]++;
     }
     long long res = ;
     for (map<int, int>::iterator it = mmap.begin(); it != mmap.end(); it++) res += (long long)(it->second) * (it->second - ) / ;
     cout << res << endl;
     return ;
 }

C题

从Ｎ个蜡烛中选出一个子序列使得每种颜色都至少出现一次且序列中蜡烛的高度递增，问存在多少种这样的集合。

因为Ｋ较小，那么建立(1<<K)棵梳妆数组，分别维护以hi为最后一根蜡烛的方法数。

 #include <cmath>
 #include <cstdio>
 #include <vector>
 #include <iostream>
 #include <algorithm>
 using namespace std;

 const int MAX_N = ;
 const int MOD = 1e9 + ;
 typedef long long LL;
 int H[MAX_N], C[MAX_N], dp[<<];
 int c[<<][MAX_N];

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

 int sum(int id, int x) {
     int res = ;
     while (x > ) {
         res += c[id][x];
         if (res >= MOD) res -= MOD;
         x -= lowbit(x);
     }
     return res;
 }

 void add(int id, int x, int v) {
     while (x <= MAX_N - ) {
         c[id][x] += v;
         if (c[id][x] >= MOD) c[id][x] -= MOD;
         x += lowbit(x);
     }
 }

 int main() {
     ios::sync_with_stdio(false);
     int N, K;
     cin >> N >> K;
     for (int i = ; i <= N; i++) {
         cin >> H[i] >> C[i];
         C[i]--;
     }

     for (int i = ; i <= N; i++) {
         for (int j = ; j < (<<K); j++) {
             int x = j | (<<C[i]);
             dp[j] = sum(j, H[i] - );
             //add(x, H[i], s);
         }
         for (int j = ; j < (<<K); j++) add(j | (<<C[i]), H[i], dp[j]);
         add(<<C[i], H[i], );
     }
     cout << sum((<<K) - , MAX_N - ) << endl;

     return ;
 }

D题

线段树优化DP

 /*************************************************************************
     > File Name: Burger_Happiness.cpp
     > Author: Stomach_ache
     > Mail: sudaweitong@gmail.com
     > Created Time: 2014?11?14? ??? 18?12?10?
     > Propose: /Hackerrank/Contest/101 Hack October 14
  ************************************************************************/

 #include <cmath>
 #include <string>
 #include <cstdio>
 #include <vector>
 #include <fstream>
 #include <cstring>
 #include <iostream>
 #include <algorithm>
 using namespace std;
 /*Let's fight!!!*/

 typedef long long LL;
 const LL INF = 1LL << ;
 const int MOD = 1e9 + ;
 const int MAX_N = 1e5 + ;
 #define lson(x) (x<<1)
 #define rson(x) ((x<<1) | 1)
 struct Node {
       int l, r;
     LL lazy;
     LL mmax;
     void set(int ll, int rr) {
           l = ll;
         r = rr;
         mmax = ;
         lazy = ;
     }
 };

 struct SegmentTree {
     Node tr[MAX_N*];

     void build(int rt, int l, int r) {
           tr[rt].set(l, r);
         if (l != r) {
               int mid = (l + r) >> ;
             build(lson(rt), l, mid);
             build(rson(rt), mid + , r);
         }
     }

     void pushdown(int rt) {
         tr[rt].mmax += tr[rt].lazy;
           if (tr[rt].l != tr[rt].r) {
             tr[lson(rt)].lazy += tr[rt].lazy;
             tr[rson(rt)].lazy += tr[rt].lazy;
         }
         tr[rt].lazy = ;
     }

     void pushup(int rt) {
           tr[rt].mmax = max(tr[lson(rt)].mmax, tr[rson(rt)].mmax);
     }

     // add v to [l, r]
     void update(int rt, int l, int r, int v) {
           pushdown(rt);
         if (r < tr[rt].l || l > tr[rt].r) return ;
           if (tr[rt].l >= l && tr[rt].r <= r) {
               tr[rt].lazy = v;
             pushdown(rt);
         } else {
             update(lson(rt), l, r, v);
             update(rson(rt), l, r, v);
             pushup(rt);
         }
     }

     // query maximum value in [l, r]
     LL query(int rt, int l, int r) {
           if (r < tr[rt].l || l > tr[rt].r) return -INF;
           pushdown(rt);
           if (tr[rt].l >= l && tr[rt].r <= r) {
               return tr[rt].mmax;
         }
         return max(query(lson(rt), l, r), query(rson(rt), l, r));
     }
 };

 SegmentTree T1; // stores maximum f(x) + s[x - 1]
 SegmentTree T2; // stores maximum f(x) - s[x]

 int A[MAX_N], B[MAX_N], X[MAX_N];
 LL F[MAX_N];
 int main(void) {
       ios::sync_with_stdio(false);
       int N;
     cin >> N;
     vector<int> arr;
     for (int i = ; i < N; i++) {
         cin >> X[i] >> A[i] >> B[i];
         arr.push_back(X[i]);
     }
     sort (arr.begin(), arr.end());
     arr.erase(unique(arr.begin(), arr.end()), arr.end());
       T1.build(, , N); T2.build(, , N);
     for (int i = ; i < N; i++) {
           X[i] = lower_bound(arr.begin(), arr.end(), X[i]) - arr.begin() + ;
     }

     LL res = ;
     for (int i = ; i < N; i++) {
           LL s = -T2.query(, X[i], X[i]); // s[x], since f[x] = 0
         LL s1 = T1.query(, X[i], X[i]); // s[x - 1]
         // case p < x
         LL res1 = -s + A[i] + T1.query(, , X[i]-);
         // case p > x
         LL res2 = s1 + A[i] + T2.query(, X[i]+, N);
         // case beginning from x
         LL res3 = A[i];
         F[X[i]] = max(max(res1, res2), res3);

         T1.update(, X[i], X[i], F[X[i]]);
         T1.update(, X[i]+, N, B[i]);

         T2.update(, X[i], X[i], F[X[i]]);
         T2.update(, X[i], N, -B[i]);

         res = max(res, F[X[i]]);
     }
     cout << res << endl;

     return ;
 }

E题

目前是没有能力做这个题了。