AtCoder ABC 155F Perils in Parallel

题目链接：https://atcoder.jp/contests/abc155/tasks/abc155_f

题目大意

　　有$N$个炸弹排成一列，放置在不同的坐标位置，其中部分激活了，部分没激活，有$M$个操控装置，每个操控装置能同时反转坐标区间$[L, R]$上炸弹的激活状态。问能否把所有炸弹调成未激活状态，没有则输出$-1$，有则输出需要需要操作的装置个数并升序输出装置序号，若答案不唯一，随意输出一个即可。

分析

　　把炸弹先按坐标位置从小到大排个序，然后把每个操控装置能同时反转的坐标区间转化为能同时反转的炸弹数组下标区间(这一步相当重要，数据范围直接降了下来)，还是记为$[L, R]$，不过这里含义已经变了哦。

　　设排序后的第$i$个炸弹为$bomb[i]$。

　　对于操控装置的功能，其实等价于先把区间$[0, L - 1]$上炸弹的激活状态反转，再把区间$[0, R]$上炸弹的激活状态反转。为了统一操作，我们把区间右值往后挪一个，这样作用区间就变成$[L, R)$了。于是，操控装置的功能，就等价于先把区间$[0, L - 1]$上炸弹的激活状态反转，再把区间$[0, R - 1]$上炸弹的激活状态反转。为了对应改动，需要假想第$N + 1$个未激活的炸弹，对应下标为$N$。

　　设$D[i](0)$为使用第$i$个操作装置把区间$[0, L_i - 1]$上炸弹的激活状态反转。

　　设$D[i](1)$为使用第$i$个操作装置把区间$[0, R_i - 1]$上炸弹的激活状态反转。

　　那么，我们我们只需要同时地执行$D[i](0)$和$D[i](1)$操作即可。

　　再来看下$bomb[i - 1]$和$bomb[i]$，无非有激活状态相同和激活状态不同两种可能情况。

　　然后想一下我们的目的，把所有炸弹搞成未激活。

　　所有炸弹未激活等价于两两相邻的炸弹激活状态相同且最后一个炸弹($bomb[N]$)未激活。

　　设$state[i] = bomb[i - 1] oplus bomb[i]$。

　　于是我们只需要同时地执行$D[i](0)$和$D[i](1)$操作，使得$state[i]$全为$0$即可(不存在全激活的可能，因为$bomb[N]$一定是未激活的)。

　　接下来中重头戏，构造图，以炸弹数组下标为顶点，操作区间为边构造DAG，于是问题转化为不重复地选择边，使得$state[i]$全为$0$。

　　当我们$D[i](0)$时，$state[L_i]$必然发生改变；当我们$D[i](1)$时，$state[R_i]$必然发生改变。

　　反之，当我们想要改变$state[X_i]$时，一定是通过$D[i](0)$或$D[i](1)$来实现。

　　也就是说，如果要改变顶点$i$的$state[i]$，则必须选中与此顶点相关的一条边，进而与此边相连的另一个顶点的$state$值也发生改变，不断影响下去直到$state[i]$全为$0$或者无法全为$0$。

　　可以用$DFS$来实现这个过程(具体可以见代码)，如果最后还有节点的$state$值为$1$的话，就表明无法全部设置成未激活。

代码如下

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

/*-------------------Define Start-------------------*/
typedef bool BL;                        // 布尔类型
typedef char SB;                        // 有符号1字节,8位
typedef unsigned char UB;                // 无符号1字节,8位
typedef short SW;                        // 有符号短整型,16位
typedef unsigned short UW;                // 无符号短整型,16位
typedef long SDW;                        // 有符号整型,32位
typedef unsigned long UDW;               // 无符号整型,32位
typedef long long SLL;                    // 有符号长整型,64位
typedef unsigned long long ULL;            // 无符号长整型,64位
typedef char CH;                        // 单个字符
typedef float R32;                        // 单精度浮点数
typedef double R64;                        // 双精度浮点数

#define Rep(i, n) for (register SDW i = 0; i < (n); ++i)
#define For(i, s, t) for (register SDW i = (s); i <= (t); ++i)
#define rFor(i, t, s) for (register SDW i = (t); i >= (s); --i)
#define foreach(i, c) for (__typeof(c.begin()) i = c.begin(); i != c.end(); ++i)
#define ms0(a) memset(a,0,sizeof(a))
#define msI(a) memset(a,0x7f,sizeof(a))
#define LOWBIT(x) ((x)&(-x))

#define MP make_pair
#define PB push_back
#define ft first
#define sd second
#define ALL(x) x.begin(),x.end()

#define pr(x) cout << #x << " = " << x << "  "
#define prln(x) cout << #x << " = " << x << endl

const ULL mod = 1e9 + 7;                //常用模数(可根据题目需要修改)
const ULL inf = 0x7fffffff;                //用来表示无限大
const ULL infLL = 0x7fffffffffffffffLL;    //用来表示无限大

// 重载<<操作符，用来打印vector 
template < typename T >
ostream& operator<< (ostream& out, vector< T > vec) {
    foreach(i, vec) {
        if(i != vec.begin()) {
            out << " ";
        }
        out << *i;
    }
    return out;
}
/*-------------------Define End-------------------*/

const UDW maxN = 1e5 + 7;

struct Bomb{
    SDW pos; // 炸弹的坐标 
    BL st; // 激活状态 
    
    Bomb() {}
    Bomb(SDW pos, BL st) : pos(pos), st(st) {}
    
    BL operator< (const Bomb &x) const {
        return pos < x.pos;
    }
};

struct Vertex{
    vector< SDW > next;
}; 

struct Edge{
    SDW id, from, to;
    
    Edge(SDW id, SDW from, SDW to) : id(id), from(from), to(to) {}
};

SDW N, M; 
Bomb bomb[maxN];
vector< Edge > E;
Vertex V[maxN];
BL vis[maxN];
SDW k;
vector< SDW > c;

void addEdge(Edge x) {
    V[x.from].next.PB(E.size());
    E.PB(x);
}

void input(){
    cin >> N >> M;
    Rep(i, N) {
        cin >> bomb[i].pos >> bomb[i].st;
    }
    sort(bomb, bomb + N); // 把炸弹按坐标排序，设bomb[N]为假想的炸弹 
    
    Rep(i, M) {
        SDW L, R;
        cin >> L >> R;
        // 把坐标覆盖区域[L, R]转化为炸弹下标覆盖区域[u, v)，如此一来顶点有V[0]~V[N]一共N+1个 
        SDW u = lower_bound(bomb, bomb + N, Bomb(L, false)) - bomb;     // u为覆盖区域[L, R]中离L最近的炸弹在bomb数组中的位置 
        SDW v = upper_bound(bomb, bomb + N, Bomb(R, false)) - bomb;     // v为覆盖区域[L, R]中离R最近的炸弹在bomb数组中的位置的后一个位置 
        if(u != v) {
            addEdge(Edge(i << 1, u, v));
            addEdge(Edge(i << 1 | 1, v, u));
        }
    }
}

BL dfs(SDW x) {
    vis[x] = true;
    
    foreach(i, V[x].next) {
        Edge e = E[*i];
        
        // 如果dfs(e.to)为真，则代表边e需要被选一次 
        if(!vis[e.to] && dfs(e.to)) {
            c.PB((e.id >> 1) + 1);
            ++k;
            // 当边e被选时，以下两个值会发生变化 
            bomb[x].st ^= 1;
            bomb[e.to].st ^= 1; // 可以不要这条语句，但是写上，便于理解 
        }
    }
    
    return bomb[x].st;
}

void solve(){
    rFor(i, N, 1) {
        bomb[i].st ^= bomb[i - 1].st;
    } 
    
    For(i, 0, N) {
        if(!vis[i] && dfs(i)) {
            k = -1;
            break;
        }
    }
}

void output(){
    cout << k << endl;
    if(k != -1) {
        sort(ALL(c));
        cout << c << endl;
    }
}

int main() {
    input();
    solve();
    output();
    return 0;
}