轻量级的巧妙解法

EOJ 1076 染气球

---

一共有 N 只气球，小强将 N 只气球从左到右依次编号为 1、2、3……N，每次给 2 个整数 a，b （a<=b），小强便骑上他的“小飞鸽 ” 牌电动车从气球 a 开始到气球 b 依次给每个气球涂一次颜色。但是 N 次以后小强已经忘记了第 I 个气球已经涂过几次颜色了，你能帮他算出每个气球被涂过几次颜色吗？
N <= 100000

dalao解法线段树，这里用了一种类似dp的解法，实际上是运用了差分数组前缀和。把从a刷到b的操作等价为++dp[a],–dp[b+1]，最后求前缀和就可以得到答案。
可能需要多理解一会儿……不过并不难。

#include<bits/stdc++.h>
using namespace std;

int dp[100005];

int main()
{
    int n, a, b;
    while (~scanf("%d", &n) && n) {
        memset(dp, 0, sizeof(dp));
        for (int i = 0; i < n; ++i) {
            scanf("%d%d", &a, &b);
            ++dp[a];
            --dp[b+1];
        }
        for (int i = 1; i <= n; ++i) {
            dp[i] += dp[i-1];
            printf("%d%c", dp[i], i == n ? '\n' : ' ');
        }
    }
    return 0;
}

EOJ 3469/COCI 2016-2017 Contest#6 Savrsen

---

A number is perfect if it is equal to the sum of its divisors, the ones that are smaller than it. For example, number 28 is perfect because 28=1+2+4+7+14.
Motivated by this definition, we introduce the metric of imperfection of number N, denoted with f(N), as the absolute difference between N and the sum of its divisors less than N. It follows that perfect numbers’ imperfection score is 0, and the rest of natural numbers have a higher imperfection score. For example:
f(6)=|6−1−2−3|=0,
f(11)=|11−1|=10,
f(24)=|24−1−2−3−4−6−8−12|=|−12|=12.
Write a programme that, for positive integers A and B, calculates the sum of imperfections of all numbers between A and B: f(A)+f(A+1)+…+f(B).

难点在于求因子。普通方法一个个找因子时间复杂度太高，因此正难则反，采用类似埃氏筛法的方法：对于从1~B的数，我们看它可能是谁的因子并且存入表c中，最后计算结果。
这个方法的时间复杂度看起来也不低，不过实际上，通过计算不难发现：对每个因子d我们循环了B/d次，所以总复杂度约为B/1+B/2+B/3+…+B/B，也就是B*(1+1/2+1/3+…+1/B)，而这个式子约等于BlnB。也就是说，时间复杂度是O(BlogB)。

#include <cstdio>
#include <cmath>
using namespace std;

const int maxn = 1e7 + 1;
int c[maxn];

int main() {
    int a, b, i, j;
    scanf("%d%d", &a, &b);
    for (i = 1; i < b+1; ++i)
        for (j = 2*i; j < b+1; j += i)
            c[j] += i;
    long long ans = 0;
    for (i = a; i <= b; ++i) ans += abs(c[i] - i);
    printf("%lld\n", ans);
    return 0;
}

EOJ 49 素数和排序

---

设 f(x,y) 表示 [x,y] 区间中所有素数的和。
给你 n 组 x,y，把它们按 f(x,y) 从小到大排序，若 f(x,y) 相等，则按 x 从小到大排序，若 f(x,y) 和 x 都相等，则按 y 从大到小排序。
1 ≤ n ≤ 10^5, max{yi} − min{xi} ≤ 10^6,1 ≤ xi ≤ yi ≤ 10^12 (1≤i≤n).

不能开10^12的数组，但注意到max{yi} − min{xi} ≤ 10^6这一条件，考虑平移到[min{xi}, max{yi}]区间内，然后再用埃氏筛或欧拉筛，这样就能得到范围内的质数。最后预处理前缀和求解。

#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5+5;
const int maxm = 1e6+5;

typedef long long ll;
typedef struct fff{ll l, r, sum;} F;

F f[maxn];
ll ans[maxm];

int cmp(F a, F b) {
    if (a.sum != b.sum) return a.sum < b.sum;
    else if (a.l != b.l) return a.l < b.l;
    return a.r > b.r;
}

int main() {
    int n;
    cin >> n;
    ll l = 1e12, r = 0;
    for(int i = 0; i < n; ++i) {
        scanf("%lld%lld", &f[i].l, &f[i].r);
        l = min(f[i].l, l);
        r = max(f[i].r, r);
    }
    ll trans = l-1;
    for(ll i = l; i <= r; ++i)
        ans[i-trans] = i;
    if(l == 1) ans[1] = 0;
    for(int i = 2; i < maxm; ++i) {
        ll p = l - l%i;
        if(p < l) p += i;
        if(p == i) p += i;
        while(p <= r) {
            ans[p-trans] = 0;
            p += i;
        }
    }
    for(ll i = 1; i <= r-l+1; ++i) ans[i] += ans[i-1];
    for(int i = 0; i < n; ++i)
        f[i].sum = ans[f[i].r-trans] - ans[f[i].l-trans-1];
    sort(f, f + n, cmp);
    for(int i = 0; i < n; ++i)
        printf("f(%lld,%lld)=%lld\n", f[i].l, f[i].r, f[i].sum);
    return 0;
}

EOJ 2918 Kth-Number

---

Given an array a[1…n] of different integer numbers, what would be the k-th number in a[i…j] segment, if this segment was sorted?
1 <= n <= 10^5

似乎又是线段树/划分树的题，不过还是可以暴力+优化过。记录好原数组中数的位置，然后排好序。根据k在范围中的相对位置选择从后往前/从前往后找。
评测结果：线段树做法不到0.1s，本做法不到0.55s，应该还算可以接受……

#include <bits/stdc++.h>
using namespace std;

struct nn{int val, prevpos;}num[100005];

int cmp(nn a, nn b)
{
    return a.val < b.val;
}

int main()
{
    int n, m, i, l, r, k;
    while (~scanf("%d%d", &n, &m)) {
        for(i = 1; i <= n; ++i) {
            scanf("%d", &num[i].val);
            num[i].prevpos = i;
        }
        sort(num+1, num+1+n, cmp);
        while (m--) {
            scanf("%d%d%d", &l, &r, &k);
            int len = r-l+1, mid = len >> 1;
            if (k > mid) {
                k = len-k+1;
                for(i = n; i >= 1; --i)
                    if(num[i].prevpos >= l && num[i].prevpos <= r)
                        if(!(--k)) break;
                printf("%d\n", num[i].val);
            }else {
                for(i = 1; i <= n; ++i)
                    if(num[i].prevpos >= l && num[i].prevpos <= r)
                        if(!(--k)) break;
                printf("%d\n", num[i].val);
            }
        }
    }
}

EOJ 3462（EOJ Monthly 2018.1） 最小OR路径

---

给定一个有 n 个点和 m 条边的无向图，其中每一条边 ei 都有一个权值记为 wi。
对于给出的两个点 a 和 b，求一条 a 到 b 的路径，使得路径上的边权的 OR（位或）和最小，输出这个值。(也就是说，如果将路径看做边的集合 {e1,e2,…,ek}，那么这条路径的代价为 w1 OR w2 OR … OR wk，现在求一条路径使得其代价最小，输出这个代价。) 如果不存在这样的路径，输出 −1。
2 ≤ n ≤ 10^4, 0 ≤ m ≤ 10^6, 0 ≤ ci ≤ 2^62−1
1 ≤ ui,vi,a,b ≤ n, a≠b
可能有重边和自环。

假设答案二进制位全为1，然后从高到低，如果不影响连通性就置0，最后得到的就是最优方案。（看起来很暴力啊）
判断连通性可以dfs，不过我觉得并查集好写一点……

#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
ll x[1000005], y[1000005], w[1000005], f[10005];
int n, m, s, e;

ll find(ll u)
{
    return u == f[u] ? u : (f[u] = find(f[u]));
}

ll check(ll mask)
{
    for(int i = 1; i <= n; ++i) f[i] = i;
    for(int i = 1; i <= m; ++i)
        if(!(w[i] & mask))
            f[find(x[i])] = find(y[i]);
    return find(s) == find(e);
}

int main()
{
    cin >> n >> m;
    for(int i = 1; i <= m; ++i)
        scanf("%lld%lld%lld", &x[i], &y[i], &w[i]);
    cin >> s >> e;
    if(!check(0)) puts("-1");
    else {
        ll ans = 0, mask = 0;
        for(int i = 61; i >= 0; --i) {
            mask += 1LL<<i;
            if(!check(mask))
                ans += 1LL<<i, mask -= 1LL<<i;
        }
        cout << ans << endl;
    }
    return 0;
}