ARC 085 NRE

　　在01序列上操作，给出一个初始序列以及目标序列和若干个区间赋值操作，问选择其中若干个操作对初始序列进行赋值，能使的初始序列与目标序列的差异最小值。

　　

　　发现没有办法找到可行的贪心策略，想到dp,设dp[i]为当前的区间覆盖到的最远的点为i所能与目标序列（１－ｉ）匹配上的最多个数，发现一些情况无法转移，但发现我们按照左端点排序后枚举转移就十分方便了，注意区间右端点相等时不要直接赋值，以及一些转移时要考虑两个区间之间的０是可以直接加入贡献的，具体就见代码。

　　

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

#define rep(i, s, t) for(int i = (s), i##E = (t); i <= i##E; ++i)
#define dec(i, s, t) for(int i = (s), i##E = (t); i >= i##E; --i)

const int N = 2e5 + 10, inf = 0x3f3f3f3f;

int n, m, C1[N], C0[N], f[N];

struct Order
{
    int l, r;
    bool operator < (const Order& rhs)const
    {
        return l == rhs.l? r < rhs.r : l < rhs.l;
    }
}Q[N];

namespace Segment_tree
{
#define lc h << 1
#define rc lc | 1
#define M ((L + R) >> 1)
    const int T = N << 2;
    int fax[T][2];

    void modify(int h, int L, int R, int u, int val, bool opt)
    {
        if(L == R) fax[h][opt] = val;
        else{
            if(u <= M) modify(lc, L, M, u, val, opt);
            else modify(rc, M + 1, R, u, val, opt);

            fax[h][opt] = max(fax[lc][opt], fax[rc][opt]);
        }
    }

    int query(int h, int L, int R, int u, int v, bool opt)
    {
        if(u <= L && R <= v) return fax[h][opt];
        else{
            int ret = -inf;
            if(u <= M) ret = query(lc, L, M, u, v, opt);
            if(v > M) ret = max(ret, query(rc, M + 1, R, u, v, opt));
            return ret;
        }
    }
}
using namespace Segment_tree;

int main()
{
    freopen("hamming.in", "r", stdin);
    freopen("hamming.out", "w", stdout);

    scanf("%d", &n);
    rep(i, 1, n){
        int x; scanf("%d", &x);
        C1[i] = C1[i-1] + bool(x != 0);
        C0[i] = i - C1[i];
    }
    scanf("%d", &m);
    rep(i, 1, m) scanf("%d%d", &Q[i].l, &Q[i].r);
    sort(Q + 1, Q + m + 1);

    memset(fax, -inf, sizeof fax);

    f[0] = 0;
    modify(1, 0, n, 0, 0, 0);
    modify(1, 0, n, 0, 0, 1);

    rep(i, 1, m){
        int l = Q[i].l, r = Q[i].r;

        int tmp = query(1, 0, n, 0, l - 1, 0);
        f[r] = max(f[r], tmp + C1[r] - C1[l-1] + C0[l-1]);

        if(l != r){
            int tmp = query(1, 0, n, l, r - 1, 1);
            f[r] = max(f[r], tmp + C1[r]);
        }

        modify(1, 0, n, r, f[r] - C0[r], 0);
        modify(1, 0, n, r, f[r] - C1[r], 1);
    }

    int answer = 0;
    rep(i, 1, n) answer = max(answer, f[i] + C0[n] - C0[i]);
    printf("%d
", n - answer);
    return 0;
}