noip刷题记录 20170818

天天爱跑步

lca + 树上差分

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

const int N = 3e5 + , M = 3e5 + ;
int n, m, ans[N], offset;
int ecnt, adj[N], go[M << ], nxt[M << ];
int w[N], dep[N], cnt[N << ], fa[N][];
struct node{
    int val, delta;
    node(){}
    node(int a, int b):val(a), delta(b){}
};
vector<node> tag[N];

inline void addEdge(int u, int v){
    nxt[++ecnt] = adj[u], adj[u] = ecnt, go[ecnt] = v;
    nxt[++ecnt] = adj[v], adj[v] = ecnt, go[ecnt] = u;
}

inline int getLca(int u, int v){
    if(dep[u] < dep[v]) swap(u, v);
    int delta = dep[u] - dep[v];
    for(int i = ; i >= ; i--)
        if(( << i) & delta) u = fa[u][i];
    if(u == v) return u;
    for(int i = ; i >= ; i--)
        if(fa[u][i] != fa[v][i])
            u = fa[u][i], v = fa[v][i];
    return fa[u][];
}

inline void dfs(int u, int f){
    fa[u][] = f;
    for(int i = ; i <= ; i++)
        fa[u][i] = fa[fa[u][i - ]][i - ];
    for(int e = adj[u], v; e; e = nxt[e]){
        v = go[e];
        if(v != f){
            dep[v] = dep[u] + ;
            dfs(v, u);
        }
    }
}

inline void solve(int u){
    int cur = cnt[dep[u] + w[u]] + cnt[w[u] - dep[u] + offset];
    for(int i = ; i < tag[u].size(); i++)
        cnt[tag[u][i].val] += tag[u][i].delta;
    for(int e = adj[u], v; e; e = nxt[e]){
        if((v = go[e]) == fa[u][]) continue;
        solve(v);
    }
    ans[u] = cnt[dep[u] + w[u]] + cnt[w[u] - dep[u] + offset] - cur;
}

inline int read(){
    int i = , f = ; char ch = getchar();
    for(; (ch < '' || ch > '') && ch != '-'; ch = getchar());
    if(ch == '-') f = -, ch = getchar();
    for(; ch >= '' && ch <= ''; ch = getchar())
        i = (i << ) + (i << ) + (ch - '');
    return i * f;
}

inline void wr(int x){
    if(x < ) putchar('-'), x = -x;
    if(x > ) wr(x / );
    putchar(x %  + '');
}

int main(){
    n = read(), m = read(), offset =  * n + ;
    for(int i = ; i < n; i++){
        int x = read(), y = read();
        addEdge(x, y);
    }
    dfs(, );
    for(int i = ; i <= n; i++) w[i] = read();
    for(int i = ; i <= m; i++){
        int s = read(), t = read(), lca = getLca(s, t);
        tag[s].push_back(node(dep[s], ));
        tag[t].push_back(node(dep[s] -  * dep[lca] + offset, ));
        tag[fa[lca][]].push_back(node(dep[s], -));
        tag[lca].push_back(node(dep[s] -  * dep[lca] + offset, -));
    }
    solve();
    for(int i = ; i <= n; i++) wr(ans[i]), putchar(' ');
    return ;
}

借教室

二分法

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<string>
#include<algorithm>
#include<vector>
using namespace std;

const int N = 1e6 + ;
int n, m, a[N], f[N], s[N], t[N], d[N], ans;

inline int read(){
    int i = , f = ; char ch = getchar();
    for(; (ch < '' || ch > '') && ch != '-'; ch = getchar());
    if(ch == '-') f = -, ch = getchar();
    for(; ch >= '' && ch <= ''; ch = getchar())
        i = (i << ) + (i << ) + (ch - '');
    return i * f;
}

inline void wr(int x){
    if(x < ) putchar('-'), x = -x;
    if(x > ) wr(x / );
    putchar(x %  + '');
}

inline bool check(int mid){
    int sum = ;
    memset(f, , sizeof f);
    for(int i = ; i <= mid; i++)
        f[s[i]] += d[i], f[t[i] + ] -= d[i];
    for(int i = ; i <= n; i++){
        sum += f[i];
        if(sum > a[i]) return false;
    }
    return true;
}

int main(){
    n = read(), m = read();
    for(int i = ; i <= n; i++) a[i] = read();
    for(int i = ; i <= m; i++) d[i] = read(), s[i] = read(), t[i] = read();
    int l = , r = m;
    while(l <= r){
        int mid = l + r >> ;
        if(check(mid)) l = mid + ;
        else ans = mid, r = mid - ;
    }
    if(ans == ) putchar('');
    else{
        wr(-), putchar('\n');
        wr(ans);
    }
    return ;
}

线段树

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<string>
#include<cmath>
#include<algorithm>
using namespace std;

const int N = 1e6 + , oo = 0x3f3f3f3f;
int n, m, minn[N * ], a[N], tag[N * ];

inline int read(){
    int i = , f = ; char ch = getchar();
    for(; (ch < '' || ch > '') && ch != '-'; ch = getchar());
    if(ch == '-') f = -, ch = getchar();
    for(; ch >= '' && ch <= ''; ch = getchar())
        i = (i << ) + (i << ) + (ch - '');
    return i * f;
}

inline void wr(int x){
    if(x < ) putchar('-'), x = -x;
    if(x > ) wr(x / );
    putchar(x %  + '');
}

inline void build(int k, int l, int r){
    if(l == r){
        minn[k] = a[l];
        return;
    }
    int mid = l + r >> , lc = k << , rc = k <<  | ;
    build(lc, l, mid);
    build(rc, mid + , r);
    minn[k] = min(minn[lc], minn[rc]);
}

inline void minuss(int k, int v){
    minn[k] -= v;
    tag[k] += v;
}

inline void pushDown(int k){
    if(tag[k]){
        if(minn[k << ] != -) minuss(k << , tag[k]);
        if(minn[k <<  | ] != -) minuss(k <<  | , tag[k]);
        tag[k] = ;
    }
}

inline void modify(int k, int l, int r, int x, int y, int v){
    if(x <= l && r <= y){
        minuss(k, v);
        return;
    }
    pushDown(k);
    int mid = l + r >> , lc = k << , rc = k <<  | , ret = oo;
    if(x <= mid) modify(lc, l, mid, x, y, v);
    if(y > mid) modify(rc, mid + , r, x, y, v);
    minn[k] = min(minn[lc], minn[rc]);
}

inline int query(int k, int l, int r, int x, int y){
    if(x <= l && r <= y) return minn[k];
    pushDown(k);
    int mid = l + r >> , lc = k << , rc = k <<  | , ret = oo;
    if(x <= mid) ret = min(ret, query(lc, l, mid, x, y));
    if(y > mid) ret = min(ret, query(rc, mid + , r, x, y));
    return ret;
}

int main(){
    n = read(), m = read();
    for(int i = ; i <= n; i++) a[i] = read();
    memset(minn, -, sizeof tag);
    build(, , n);
    for(int i = ; i <= m; i++){
        int d = read(), s = read(), t = read();
        if(s > t) swap(s, t);
//        cout<<s<<" "<<t<<" "<<query(1, 1, n, s, t)<<"!!!"<<endl;
        if(query(, , n, s, t) < d){
            wr(-), putchar('\n'), wr(i);
            return ;
        }
        modify(, , n, s, t, d);
    }
    wr();
    return ;
}

积木大赛

简单分析

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<string>
#include<algorithm>
#include<cmath>
using namespace std;

const int N = 1e5 + ;
int n, ans, last;

int main(){
    cin >> n;
    for(int i = ; i <= n; i++){
        int tmp; cin >> tmp;
        if(tmp - last > ) ans += tmp - last;
        last = tmp;
    }
    cout << ans;
    return ;
}

Vigenère密码

简单分析 + 模拟

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<string>
#include<algorithm>
#include<cmath>
using namespace std;

int klen, slen, key[];
char k[], s[], t[];

int main(){
    cin >> k >> s;
    klen = strlen(k), slen = strlen(s);
    for(int i = ; i < klen; i++){
        if('a' <= k[i] && k[i] <= 'z')
            key[i] = k[i] - 'a';
        else key[i] = k[i] - 'A';
    }
    for(int i = ; i < slen; i++){
        if('a' <= s[i] && s[i] <= 'z'){
            t[i] = s[i] - key[i % (klen)];
            while(t[i] < 'a') t[i] += ;
        }
        else if('A' <= s[i] && s[i] <= 'Z'){
            t[i] = s[i] - key[i % (klen)];
            while(t[i] < 'A') t[i] += ;
        }
        else continue;
        putchar(t[i]);
    }
    return ;
}

花匠

动态规划 + 树状数组优化

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<string>
#include<algorithm>
#include<cmath>
using namespace std;

const int N = 1e5 + , H = 1e6 + ;
int n, h[N], f[N], g[N], maxh, maxxF[H], maxxG[H], ans;

inline int read(){
    int i = , f = ; char ch = getchar();
    for(; (ch < '' || ch > '') && ch != '-'; ch = getchar());
    if(ch == '-') f = -, ch = getchar();
    for(; ch >= '' && ch <= ''; ch = getchar())
        i = (i << ) + (i << ) + (ch - '');
    return i * f;
}

inline void wr(int x){
    if(x < ) putchar('-'), x = -x;
    if(x > ) wr(x / );
    putchar(x %  + '');
}

inline void uptF(int x, int v){
    for(int i = x; i <= maxh; i += (i&(-i)))
        maxxF[i] = max(maxxF[i], v);
}

inline void uptG(int x, int v){
    for(int i = x; i <= maxh; i += (i&(-i)))
        maxxG[i] = max(maxxG[i], v);
}

inline int queryF(int x){
    int ret = ;
    for(int i = x; i > ; i-=(i&-i))
        ret = max(maxxF[i], ret);
    return ret;
}

inline int queryG(int x){
    int ret = ;
    for(int i = x; i > ; i-=(i&-i))
        ret = max(ret, maxxG[i]);
    return ret;
}

int main(){
    n = read();
    for(int i = ; i <= n; i++) h[i] = read() + , maxh = max(maxh, h[i]);
    maxh += ;
    for(int i = ; i <= n; i++){
        f[i] = max(queryG(h[i] - ) + , f[i]);
        g[i] = max(queryF(maxh - h[i] - ) + , g[i]);
        uptF(maxh - h[i], f[i]);
        uptG(h[i], g[i]);
        ans = max(ans, max(f[i], g[i]));
    }
    wr(ans);
    return ;
}