add a few including gcj 2013 first round

Author: oeddyo

cf/113/E2.cpp

@@ -0,0 +1,89 @@
+#include <iostream>
+#include <vector>
+#include <cstring>
+#include <cstdio>
+
+using namespace std;
+
+typedef long long int ll;
+
+long long int dp[4][4];
+long long int bf[4][4];
+int N;
+
+long long int MOD = 1000000007;
+
+void multi(ll a[][4], ll b[][4], ll res[][4]){
+    for(int i=0; i<4; i++){
+        for(int j=0; j<4; j++){
+            ll tmp = 0;
+            for(int k=0; k<4; k++){
+                tmp += a[i][k]*b[k][j];
+            }
+            res[i][j] = tmp%MOD;
+        }
+    }
+}
+
+
+void print(ll a[][4]){
+    for(int i=0; i<4; i++){
+        for(int j=0; j<4; j++){
+            cout<<a[i][j]<<" ";
+        }
+        cout<<endl;
+    }
+}
+
+void mypow(ll input[][4], ll output[][4], int n){
+    ll tmp[4][4];
+    ll tmp2[4][4];
+    memset(tmp, 0 , sizeof(tmp));
+    memset(tmp2, 0, sizeof(tmp2));
+    //cout<<"input is "<<endl;
+    //print(input);
+    if(n==1){
+        for(int i=0; i<4; i++){
+            for(int j=0; j<4; j++){
+                output[i][j] = input[i][j];
+            }
+        }
+        return ;
+    }else if(n%2==1 && n>1){
+        mypow(input, tmp, n/2);
+        multi(tmp, tmp, tmp2);
+        multi(input, tmp2, output);
+    }else if(n%2==0 && n>0){
+        mypow(input, tmp,  n/2);
+        multi(tmp, tmp, output); 
+    }
+}
+
+
+void work(){
+    ll ans[4][4];
+    memset(ans,0,sizeof(ans));
+    mypow(dp, ans, N);
+    //print(ans);
+    
+    cout<<ans[3][3]<<endl;
+
+}
+
+
+
+int main(){
+    cin>>N;
+    for(int i=0; i<4; i++){
+        for(int j=0;j<4; j++){
+            if(i==j)continue;
+            dp[i][j] = 1;
+        }
+    }
+    work();
+    
+    
+    
+    return 0;
+}
+

cf/113/a.out

@@ -0,0 +1,43 @@
+#include <iostream>
+#include <set>
+#include <vector>
+
+using namespace std;
+
+const int MAXN = 5000;
+const int INF = 99999999;
+int dp[MAXN];
+int N;
+
+
+int main(){
+    cin>>N;
+
+    set<int> d;
+    for(int i=0; i<3; i++){
+        int t;
+        cin>>t;
+        d.insert(t);
+    } 
+
+    for(int i=0; i<MAXN; i++)dp[i] = -INF;
+    dp[0] = 0;
+
+    for(int i=0; i<=N; i++){
+        if(dp[i]!=-INF){
+            vector<int> tmp(d.begin(), d.end());
+            for(int j=0; j<tmp.size(); j++){
+
+                for(int j=0; j<tmp.size(); j++){
+                    if(i+tmp[j]<=N){
+                        dp[i+tmp[j]] = max( dp[i]+1, dp[i+tmp[j]]);
+                    }
+                }
+            }
+        }
+
+    }
+        cout<<dp[N]<<endl;
+    return 0;
+}
+

cf/119/A.cpp

@@ -0,0 +1,52 @@
+#include <iostream>
+#include <queue>
+#include <vector>
+
+using namespace std;
+
+
+int N, M;
+const int MAXN = 10001;
+int data[MAXN];
+
+
+int main(){
+    cin>>N>>M;
+
+    priority_queue<int> max_Q;
+    priority_queue<int, vector<int> , greater<int> > min_Q;
+
+    for(int i=0; i<M; i++){
+        int t;
+        cin>>t;
+        max_Q.push(t);
+        min_Q.push(t);
+    }
+    int cnt = N;
+    int max_ans = 0;
+    int min_ans = 0;
+    while(cnt--){
+        int cur = max_Q.top();
+        max_Q.pop();
+        max_ans += cur;
+        cur -= 1;
+        if(cur>0){
+            max_Q.push(cur);
+        }
+    }
+    
+    cnt = N;
+    while(cnt--){
+        int cur = min_Q.top();
+        min_Q.pop();
+        min_ans += cur;
+        cur -= 1;
+        if(cur>0){
+            min_Q.push(cur);
+        }
+    }
+    cout<<max_ans<<" "<<min_ans<<endl;
+
+    return 0;
+}
+

cf/119/a.out

@@ -0,0 +1,69 @@
+#include <iostream>
+#include <string>
+#include <cstring>
+
+using namespace std;
+
+string S;
+
+bool dp[1<<26];
+int cnt[26];
+const int INF = 99999999;
+
+int get_ans(int state){
+    if(dp[state]!=INF){
+        return dp[state];
+    }
+    int num = __builtin_popcount(state);
+    if(num== 0 || num == 1){
+        return 1;
+    }
+    int ok = 0;
+    for(int i=0; i<26; i++){
+        if( ((state>>i)&1)==1 ){
+            int ns = (~(1<<i))&state;
+            int ans = get_ans(ns);
+            if(ans==0){
+                ok = 1;
+            }
+        }
+    }
+    dp[state] = ok;
+    return ok;
+}
+
+
+void work(){
+    memset(cnt,0,sizeof(cnt));
+    for(int i=0; i<S.size(); i++){
+        cnt[ S[i]-'a' ] += 1;
+    }
+    int start = 0;
+    for(int i=0; i<26; i++){
+        if(cnt[i]%2==1){
+            start |= (1<<i);
+        }
+    }
+    for(int i=0; i<(1<<26); i++){
+        dp[i] = INF;
+    }
+    int ans = get_ans(start);
+    if(ans==1){
+        cout<<"First"<<endl;
+    }
+    else{
+        cout<<"Second"<<endl;
+    }
+
+
+}
+
+
+
+int main(){
+    cin>>S;
+    work();
+
+    return 0;
+}
+

cf/134/B.cpp

@@ -0,0 +1,120 @@
+#include <iostream>
+#include <cstring>
+#include <queue>
+#include <algorithm>
+#include <cstdio>
+using namespace std;
+
+
+const int MAXN = 200001;
+
+int trees[MAXN*8];
+int mark[MAXN*8];
+int data[MAXN];
+
+int N, Q;
+
+void pushUp(int idx){
+    trees[idx] = trees[idx<<1] + trees[idx<<1|1]; 
+}
+
+void pushDown(int idx){
+    if(mark[idx]){
+        //cout<<"now at "<<idx<<" and i'm pushing down"<<endl;
+        mark[idx<<1] = mark[idx<<1|1] = mark[idx];
+        trees[idx<<1] += trees[idx];
+        trees[idx<<1|1] += trees[idx];
+        
+        trees[idx] = 0;
+        
+        mark[idx] = 0;
+    }
+}
+
+void insert(int L, int R, int l, int r, int idx){
+    //cout<<"try to insert "<<L<<" "<<R<<" "<<l<<" "<<r<<endl;
+    if(L<=l && R>=r){
+        //cout<<"insert!"<<endl;
+        trees[idx] += 1;
+        //ncout<<" idx = "<<idx<<" cur = "<<trees[idx]<<endl;
+        mark[idx] = 1;
+        return ;
+    }
+    pushDown(idx);
+    int m = (l+r)>>1;
+    if(L<=m){
+        insert(L, R, l, m, idx<<1);
+    }
+    if(R>m){
+        insert(L, R, m+1, r, idx<<1|1);
+    }
+    //pushUp(idx);
+}
+
+int query(int L, int R, int l, int r, int idx){
+    if(L<=l && R>=r){
+        return trees[idx];
+    }
+    pushDown(idx);
+    int m = (l+r)>>1;
+    if(L<=m){
+        return query(L, R, l, m, idx<<1);
+    }
+    if(R>m){
+        return query(L, R, m+1, r, idx<<1|1);
+    }
+}
+
+
+void build(int l, int r, int idx){
+    if(l==r){
+        trees[idx] = 0;
+        return ;
+    }
+    int m = (l+r)>>1;
+    build(l, m, 2*idx);
+    build(m+1, r, 2*idx + 1);
+    pushUp(idx);
+}
+
+
+
+
+int main(){
+    memset(trees,0,sizeof(trees));
+    memset(mark, 0, sizeof(mark));
+    scanf("%d %d", &N,&Q);
+    
+    
+    //build(1, N, 1);
+    for(int i=0; i<N; i++){
+        scanf("%d",&data[i]);
+    }
+
+    
+    int left, right;
+    for(int i=0; i<Q; i++){
+        //cout<<"inserting -> "<<i<<" tree[1] = "<<trees[1]<<endl;
+        scanf("%d %d", &left, &right);
+        insert(left, right, 1, N, 1);
+    }
+    long long int qts[MAXN];
+    //cout<<"query 1 1 "<<query(1,1,1,N,1)<<endl;
+    for(int i=0; i<N; i++){
+        qts[i] = query(i+1, i+1, 1, N, 1);
+        //cout<<"querying "<<i+1<<" res = "<<qts[i]<<endl;
+    }
+    sort(qts, qts+N, std::greater<int>());
+    sort(data, data+N , std::greater<int>());
+    long long int ans = 0;
+    for(int i=0; i<N; i++){
+        ans += (qts[i])*data[i];
+        //cout<<"qts["<<i<<"] = "<<qts[i]<<" and data["<<i<<"] = "<<data[i]<<endl;
+    }
+
+
+    cout<<ans<<endl;
+
+    return 0;
+}
+