比赛-6月Round1

A.饥饿的奶牛

想到线段覆盖问题的贪心解法，比如根据线段长度排序再选（据加藤惠实测能过 20% 数据），比如根据左端点为第一关键字，右端点为第二关键字排序再选……胡乱画图发现都不行。然后考虑 DP，f[i][j] 表示前 i 条线段选 j 条的最大收益，期望从 f[i-1][j-1] 和 f[i][j-1] 转移，发现不满足 DP 性质，因为子问题解不包含于当前问题解集中（最佳方式选 i-1 条后不一定能构造出选 i 条的最佳方案）。然后我想了下搜索……选一条线段之后，它包含的区间所在的线段不能再选，限制好像比较强，但是时间复杂度玄学……

正解： 对线段 [x, y] ，从 x 向 y+1 连一条权值为 y-x+1 的边。对每个点 i 向 i+1 连权值为 0 的边。设置一个源点，向所有点连权值为 0 的边。从源点开始进行最长路算法，答案是 max{ dis[i] }。

类似“何老板看守果园”，不过考试的时候并没有想到那道题。真的没想到 A 题这么难，太坑了OrzOrzOrz。

B.平衡的队列

正解： 以 x 坐标为关键字从小到大排序。讨论每个点，把种族 0 作为种族 -1 处理，这样可以让 1 和 -1 在累加中互相“消除”。设前缀和 sum[i] ，若 sum[x-1] = sum[y]，则 [x, y] 是一段“平衡”的区间。对于所有 sum 值相同的位置，显然希望得到最右的位置 R[v] 和最左的位置 L[v]，用 X 表示一点的 x 坐标，那么这样一组 L R 对答案的贡献是 X[R[v]] - X[L[v]+1] ，在所有合理的方案里取最大值就是最终答案。

C.颜色间距

正解： 对每个颜色，记录任意一个深度最深的节点 x ，max{ length(x, i) } 就是这个颜色的答案，其中 i 是这个颜色中不是 x 的其它点。求 length(a, b) ，可以找到 LCA(a, b) = c ，那么路径长度为 depth(a) + depth(b) - 2 * depth(c)

如果一个节点的子树中有和它相同颜色的节点，那么显然比起这个节点，它的子节点更适合作为一条路径的一端。所以期望一个节点没有相同颜色的节点在它的子树中，找到这个颜色深度最大的节点即可。

D.和谐数

正解： 用树状数组就非常好写。从左往右讨论每个值 A[i] ，L[i] 表示 i 左边更大的数的个数，L[i] = GetSum(INF)-GetSum(A[i]) 然后再 Modify(A[i], 1)。同理得到 R[i]，然后算答案。注意离散化（排序）。

#include <stdio.h>
#include <algorithm>
#include <queue>
#include <vector>

using namespace std;

const int INF = 1e9;
const int _N = 2100;

struct edge {
    int v, w;
    edge(int v = 0, int w = 0):
        v(v), w(w) { }
};

vector<edge> G[_N];
queue<int> Q;
int dis[_N];
bool mk[_N];

void Ins(int t1, int t2, int t3) { G[t1].push_back(edge(t2, t3)); return; }

void SPFA(int beg)
{
    int i;
    for (i = 0; i <= 2011; ++i)
        dis[i] = -INF, mk[i] = false;
    while (!Q.empty()) Q.pop();
    dis[beg] = 0, Q.push(beg), mk[beg] = true;
    while (!Q.empty()) {
        int p = Q.front();
        Q.pop(); mk[p] = false;
        for (i = G[p].size()-1; i >= 0; --i) {
            edge v = G[p][i];
            if (dis[v.v] < dis[p] + v.w) {
                dis[v.v] = dis[p] + v.w;
                if (!mk[v.v]) Q.push(v.v), mk[v.v] = true;
            }
        }
    }
    return;
}

int main()
{
    int N, i;
    scanf("%d", &N);
    for (i = 1; i <= N; ++i) {
        int t1, t2;
        scanf("%d%d", &t1, &t2);
        if (t1 > t2) swap(t1, t2);
        Ins(t1, t2+1, t2+1-t1);
    }
    for (i = 1; i <= 2010; ++i) Ins(i, i+1, 0), Ins(0, i, 0);
    SPFA(0);
    int ans = 0;
    for (i = 1; i <= 2011; ++i) ans = max(ans, dis[i]);
    printf("%d
", ans);
    return 0;
}

#include <stdio.h>
#include <algorithm>
#include <string.h>

using namespace std;

const int _N = 51000;
const int INF = 1e9;

struct data {
    int val, x;
    bool operator < (const data &tmp) const
    {
        return x < tmp.x;
    }
} A[_N];

int L[_N*2], R[_N*2];

int main()
{
    int i, sum, mx_sum, mn_sum, ans, N;
    scanf("%d", &N);
    for (i = 1; i <= N; ++i) {
        scanf("%d%d", &A[i].val, &A[i].x);
        if (!A[i].val) A[i].val = -1;
    }
    sort(A+1, A+1+N);
    
    memset(L, -1, sizeof L), memset(R, -1, sizeof R);
    sum = mx_sum = mn_sum = 0;
    L[sum+_N] = R[sum+_N] = 0;
    
    for (i = 1; i <= N; ++i) {
        mx_sum = max(mx_sum, sum += A[i].val);
        mn_sum = min(mn_sum, sum);
        if (L[sum+_N] == -1) L[sum+_N] = i;
        R[sum+_N] = i;
    }
    ans = 0;
    for (i = mn_sum; i <= mx_sum; ++i)
        if (L[i+_N] != -1 && L[i+_N] < R[i+_N])
            ans = max(ans, A[R[i+_N]].x-A[L[i+_N]+1].x);
    printf("%d
", ans);
    return 0;
}

#include <stdio.h>
#include <algorithm>
#include <vector>
#include <math.h>

using namespace std;

const int _N = 200105;

vector<int> G[_N], P[_N];
int mxd, lg_mxd;
int depth[_N], X[_N], Clr[_N], dad[_N][20];

void DFS(int node, int d)
{
    mxd = max(mxd, depth[node] = d);
    if (!X[Clr[node]] || depth[X[Clr[node]]] < depth[node])
        X[Clr[node]] = node;
    for (int i = G[node].size()-1; i >= 0; --i)
        DFS(G[node][i], d+1);
    return;
}

int LCA(int x, int y)
{
    if (depth[x] < depth[y]) swap(x, y);
    int t = depth[x]-depth[y], i;
    for (i = lg_mxd; i >= 0; --i)
        if ((t>>i) & 1) x = dad[x][i];
    if (x == y) return x;
    for (i = lg_mxd; i >= 0; --i)
        if (dad[x][i] != dad[y][i])
            x = dad[x][i], y = dad[y][i];
    return dad[x][0];
}

int main()
{
    int N, M, i, c, j, root;
    scanf("%d%d", &N, &M);
    for (i = 1; i <= N; ++i) {
        scanf("%d%d", &Clr[i], &dad[i][0]);
        P[Clr[i]].push_back(i);
        if (!dad[i][0]) root = i;
        else G[dad[i][0]].push_back(i);
    }
    DFS(root, 1);
    lg_mxd = log2(mxd+0.5)+1;
    for (j = 1; j <= lg_mxd; ++j)
        for (i = 1; i <= N; ++i)
            dad[i][j] = dad[dad[i][j-1]][j-1];
    for (c = 1; c <= M; ++c) {
        int ans = -1;
        for (i = P[c].size()-1; i >= 0; --i)
            if (P[c][i] != X[c])
                ans = max(ans, depth[X[c]]+depth[P[c][i]]-2-(depth[LCA(X[c], P[c][i])]-1)*2);
        printf("%d
", ans);
    }
    return 0;
}

#include <stdio.h>
#include <algorithm>
#include <string.h>

using namespace std;

const int _N = 101005;

struct data {
    int val, id;
} A[_N];

int cnt;
int B[_N], C[_N], L[_N], R[_N];

bool val_first(data t1, data t2) { return t1.val < t2.val; }

inline int lbt(int v) { return v & (-v); }

int GetSum(int k)
{
    int tmp = 0;
    for (int i = k; i; i ^= lbt(i)) tmp += C[i];
    return tmp;
}

void Modify(int k, int d)
{
    for (int i = k; i <= cnt; i += lbt(i)) C[i] += d;
    return;
}

int main()
{
    int N, i;
    scanf("%d", &N);
    for (i = 1; i <= N; ++i)
        scanf("%d", &A[i].val), A[i].id = i;
    sort(A+1, A+1+N, val_first);
    
    B[A[1].id] = cnt = 1;
    for (i = 2; i <= N; ++i)
        B[A[i].id] = A[i].val == A[i-1].val ? B[A[i-1].id] : (++cnt);
    for (i = 1; i <= N; ++i)
        L[i] = GetSum(cnt)-GetSum(B[i]), Modify(B[i], 1);
    memset(C, 0, sizeof C);
    for (i = N; i >= 1; --i)
        R[i] = GetSum(cnt)-GetSum(B[i]), Modify(B[i], 1);
    int ans = 0;
    for (i = 1; i <= N; ++i)
        if (max(L[i], R[i]) > 2*min(L[i], R[i])) ++ans;
    printf("%d
", ans);
    return 0;
}