codeforeces722 Intel Code Challenge Elimination Round (Div.1 + Div.2, combined)

终于补完这场了。

C. Destroying Array
题意：
给一个数组a，长度为n，然后给一个1~n的排列p，依次毁灭 api ，问每次毁灭后数组的最大连续子段和（当然是不能包括毁灭的位置）。
思路：
倒过来看就是每次加一个元素问最大子段和，并查集可解。

//
//  main.cpp
//  722C
//
//  Created by 翅膀 on 16/10/1.
//  Copyright © 2016年 kg20006. All rights reserved.
//

#include 
#include 
#include 
using namespace std;
typedef long long ll;
int n;
ll num[100005];
bool vis[100005];
int op[100005];
ll as[100005];
ll seed[100005];
ll find(ll x){
    return seed[x] <= 0? x : seed[x] = find(seed[x]);
}
void join(int a, int b){
    a = find(a), b = find(b);
    if(a == b) return;
    seed[a] += seed[b], seed[b] = a;
}
int main(int argc, const char * argv[]) {
    scanf("%d", &n);
    for(int i = 1; i <= n; ++i) scanf("%lld", num+i);
    for(int i = 1; i <= n; ++i) scanf("%d", op+i);
    ll ans = 0;
    for(int i = n; i >= 1; --i) {
        as[i] = ans;
        int id = op[i];
        if(vis[id-1] == 0 && vis[id+1] == 0) seed[id] = -num[id];
        else{
            if(vis[id+1]) join(id, id+1);
            if(vis[id-1]) join(id, id-1);
            seed[find(id)] -= num[id];
        }
        vis[id] = 1;
        ans = max(ans, -seed[find(id)]);
    }
    for(int i = 1; i <= n; ++i) printf("%lld\n", as[i]);
    return 0;
}

D.Generating Sets
题意：
给一个集合Y，求一个集合X，集合大小相同，要求二进制下X是Y中某个元素的前缀，必须一一对应，并且X中最大的元素最小。
思路：
先二分最大值，然后贪心，每个元素的前缀取不超过当前二分值的尽量大的，如果有重复的就不断减少一位，看看是不是所以元素都能找到。

//
//  main.cpp
//  722D
//
//  Created by 翅膀 on 16/10/1.
//  Copyright © 2016年 kg20006. All rights reserved.
//

#include 
#include 
#include 
#include 
#include 
using namespace std;
const int N = 50005;
typedef long long ll;
int a[N], n;
bool ok(ll up) {
    set<int>st;
    for(int i = 1; i <= n; ++i) {
        int x = a[i];
        while(x > up) x >>= 1;
        while(x && st.count(x)) x >>= 1;
        if(x == 0) return 0;
        st.insert(x);
    }
    return 1;
}
void print(ll up) {
    set<int>st;
    for(int i = 1; i <= n; ++i) {
        int x = a[i];
        while(x > up) x >>= 1;
        while(st.count(x)) x >>= 1;
        st.insert(x);
        printf("%d ", x);
    }
}
int main(int argc, const char * argv[]) {
    scanf("%d", &n);
    for(int i = 1; i <= n; ++i) {
        scanf("%d", a+i);
    }
    sort(a+1, a+n+1);
    ll l = 1, r = 1000000000, ans;
    while(l <= r) {
        ll mid = (l+r) >> 1;
        if(ok(mid)) r = mid-1, ans = mid;
        else l = mid+1;
    }
    print(ans);
    return 0;
}

E. Research Rover
题意：
从(1,1)通过最短路径走到(n,m)，能量值为s，其中有k个特殊点，每经过一个特殊点能力值就会变成(s+1)/2，问最后能力值的期望值。
思路：
容易发现s减小的速度是很快的，最多20次就会变成1，因此我们算出经过0，1，2…20个特殊点的方案数，剩下的方案能力值都是1了。
首先考虑经过0个特殊点的方案数，就是这个题，是个很经典的容斥了，首先按经过的顺序排序，如果从点a可以走到点b，那a就在b前面，然后就可以算出从（1，1）走到点（x，y）且不经过其他点的方案数，推一下就可以算出从（1，1）走到点（n，m）不经过特殊点的方案数了。
可以发现这个题就是要算恰好经过k个点的方案数，按照上面的思路来就行。

//
//  main.cpp
//  722E
//
//  Created by 翅膀 on 16/10/10.
//  Copyright © 2016年 kg20006. All rights reserved.
//

#include 
#include 
#include 
#include 
#include 
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const int N = 2e5+5;
ll fac[N], invfac[N];
const ll mod = 1e9+7;
ll qpow(ll a, ll k) {
    ll res = 1;
    while(k) {
        if(k&1) res = (res*a)%mod;
        a = (a*a)%mod;
        k >>= 1;
    }
    return res;
}
void init(){
    fac[0] = 1, invfac[0] = 1;
    fac[1] = 1, invfac[1] = 1;
    for(ll x = 2; x < N; ++x){
        fac[x] = (fac[x-1]*x)%mod;
        invfac[x] = qpow(fac[x], mod-2);
    }
}

ll C(int n, int m) {
    if(n < 0 || m < 0 || n < m) return 0;
    else if(n == m) return 1;
    else return fac[n]*invfac[m]%mod*invfac[n-m]%mod;
}
pii p[2005];
inline bool cmp(const pii& a, const pii& b) {
    return a.first+a.second < b.first+b.second;
}
ll cal(pii a, pii b) {
    int x = b.first-a.first, y = b.second-a.second;
    return C(x+y, x);
}
ll dp[2005][25];
int main(int argc, const char * argv[]) {
    init();
    int n, m, k, s;
    scanf("%d%d%d%d", &n, &m, &k, &s);
    for(int i = 1; i <= k; ++i) {
        scanf("%d %d", &p[i].first, &p[i].second);
    }
    p[0] = pii(1, 1);
    p[++k] = pii(n, m);
    sort(p, p+k+1, cmp);
    dp[0][0] = 1, dp[1][0] = cal(p[0], p[1]);
    for(int i = 2; i <= k; ++i) {
        dp[i][0] = cal(p[0], p[i]);
        for(int j = 1; j < i; ++j) {
            dp[i][0] = (dp[i][0]-dp[j][0]*cal(p[j], p[i])%mod+mod)%mod;
        }
    }
    for(int i = 1; i <= 20; ++i) {
        for(int j = 0; j <= k; ++j) {
            dp[j][i] = cal(p[0], p[j]);
            for(int l = 0; l < i; ++l) {
                dp[j][i] = (dp[j][i]-dp[j][l]+mod)%mod;
            }
            for(int l = 1; l < j; ++l) {
                dp[j][i] = (dp[j][i]-dp[l][i]*cal(p[l], p[j])%mod+mod)%mod;
            }
        }
    }
    ll ans = 0, tot = cal(p[0], p[k]);
    for(int i = 0; i <= 20; ++i, s = (s+1)/2) {
        ans = (ans+dp[k][i]*s%mod)%mod;
        tot = (tot-dp[k][i]+mod)%mod;
    }
    ans = (ans+tot)%mod;
    ans = ans*qpow(cal(p[0], p[k]), mod-2)%mod;
    printf("%lld\n", ans);
    return 0;
}

F. Cyclic Cipher
题意：
给n个序列，一个序列内没有重复元素，不同序列内可能有重复元素，每个序列长度<=40，每秒钟每个序列会循环左移一次，要求算出 10100 秒内，[1,m]的答案。
一个数x在某时刻的答案为，把此时所有序列的第一个元素顺序排成一个新序列，这个新序列中最长的连续x的长度。
思路：考虑对m个答案分开求，设当前要求解的数为x，那么我们只用关心所有x的位置，可能的答案一定是连续出现x的序列，假设i，j是答案中的两个序列，长度为li，lj，对应x的位置为pi，pj，显然要让pi和pj同时出现在第一个元素，则有 pi+li∗k==pj+lj∗k ，然后有 pi−pj==lj∗k−li∗k ，两边同时对gcd(li,lj)取模，则有 (pi−pj)=0(modgcd(li,lj)) ，然后可以得到一个结论，两个长度相同的序列，其pi和pj一定相同。因为序列长度<=40，所以长度相同的序列肯定是很多的，一个序列出现的数是很少的，我们就可以考虑two pointer了，过程中要保证这一段出现的x是连续的。

//
//  main.cpp
//  722F
//
//  Created by 翅膀 on 16/10/9.
//  Copyright © 2016年 kg20006. All rights reserved.
//

#include 
#include 
#include 
#include 
#include 
using namespace std;
typedef long long ll;
const int N = 1e5+5;
int n, m;
struct node{
    int r, len, c;
    node(int _a = 0, int _b = 0, int _c = 0) {
        r = _a, len = _b, c = _c;
    }
};
vectorl[N];
int pos[50];
int cnt[50];
int gcd[50][50];
int _gcd(int a, int b){ return b? _gcd(b, a%b) : a; }
// (xi+a*li) == (xj+b*lj)
// xi-xj == b*lj-a*li
// (xi-xj)%gcd(lj,li) == 0
bool add(node a) {
    if(cnt[a.len] && pos[a.len] != a.c) return 0;
    for(int i = 1; i <= 40; ++i) {
        if(cnt[i] && (pos[i]-a.c)%gcd[i][a.len] != 0) return 0;
    }
    pos[a.len] = a.c;
    cnt[a.len]++;
    return 1;
}
void del(node a) {
    cnt[a.len]--;
}
int solve(vector& x) {
    int res = 0;
    memset(pos, 0, sizeof(pos));
    memset(cnt, 0, sizeof(cnt));
    int l = 0, r = 0;
    while(l < x.size()) {
        while(r < x.size()) {
            if(x[r].r-x[l].r != r-l) break;
            if(!add(x[r])) break;
            ++r;
        }
        res = max(res, r-l);
        if(x[r].r - x[l].r != r-l) {
            l = r;
            memset(pos, 0, sizeof(pos));
            memset(cnt, 0, sizeof(cnt));
        }
        else del(x[l++]);
    }
    return res;
}
int main(int argc, const char * argv[]) {
    for(int i = 1; i < 50; ++i) {
        for(int j = 1; j < 50; ++j) {
            gcd[i][j] = _gcd(i, j);
        }
    }
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= n; ++i) {
        int k;
        scanf("%d", &k);
        for(int x, j = 1; j <= k; ++j) {
            scanf("%d", &x);
            l[x].emplace_back(node(i, k, j));
        }
    }
    for(int i = 1; i <= m; ++i) {
        printf("%d\n", solve(l[i]));
    }
    return 0;
}