AtCoder ABC 128(C ~ E)

C Switches(枚举 + 位运算)

Description:

​ 有n盏灯和m组设定，要求输出同时符合m组设定的灯开关的方案数

​ 设定：s_i中亮灯的数量%2 == p_i

Solution:

​ 因为跟开关灯有关也就是01有关 再加上N只有10 于是我们就用01串枚举一下灯的状态

​ 用位运算来check是否合法

Code:

int n, m;
int p[15];
 
signed main()
{
    ios;
    cin >> n >> m;
    vector<int> s[15];
    rep(i, 0, m)
    {
        int x, xx; cin >> x;
        rep(j, 0, x)
            cin >> xx, s[i].pb(xx);
    }
    
    rep(i, 0, m)
        cin >> p[i];
    
    int res = 0;
    for(int k = 0; k < (1 << n); k ++)
    {
        bool ok = 1;
        rep(i, 0, m)
        {
            int cnt = 0;
            for(auto x : s[i])
            {
                if(k & (1 << (x - 1)))
                    cnt ++;
            }
            if(cnt % 2 != p[i])
            {
                ok = false;
                break;
            }
        }
        if(ok)
            res ++;
    }
 
    cout << res << endl;
}

D equeue(暴力 贪心)

Description:

​ 给出长度为n的序列 可以在头部或者尾部进行k次四种操作

​ 1 从头部拿出一个 2 把从头部拿的任意一个放回去

​ 3 从尾部拿出一个 4 把从尾部拿的任意一个放回去

Solution:

​ N = 50，k = 100 于是优先考虑暴力的模拟

​ 枚举一下从头部拿1到x个 自然从尾部只能1到k-x个

​ 如果是负数就放回 记录答案取最大值

​ 这样做的时间复杂度为O(100^3*lg100) 可行

Code:

int n, k;
vector<int> b;
 
signed main()
{
    ios;
    cin >> n >> k;
    vector<int> a(n);
    rep(i, 0, n)
        cin >> a[i];
    
    int res = 0;
    for(int i = 0; i <= min(n, k); i ++)
    {
        for(int j = 0; j <= min(n, k); j ++)
        {
            if(i + j > min(n, k))
                break;
            b.clear();
            for(int l = 0; l < i; l ++)
                b.pb(a[l]);
            for(int l = 0; l < j; l ++)
                b.pb(a[n - 1 - l]);
            
            sort(b.begin(), b.end());
            int tot = 0;
            for(auto x : b)
                tot += x;
            res = max(res, tot);
            
            int cnt = k - i - j, idx = 0;
            while(cnt -- && idx < b.size())
            {
                if(b[idx] < 0)
                    tot -= b[idx ++];
                else break;
            }
            res = max(res, tot);
        }
    }
    cout << res << '\n';
}

E Roadwork(STL + 二分)

Description:

​ 有n个在时间[l, r]内生效的路障位于x_i 请问一个人在0坐标d时刻出发 输出每个人最长的行走距离

Solution:

​ 如果枚举人 那就是N*Q 必超时 我们可以将问题转化一下

​ 我们不考虑人， 我们来考虑障碍物可以挡住哪些人

​ 障碍物按坐标小到大排序 并将生效时间-坐标位置，就等价于0坐标时候障碍物出现的时间

​ 将人插入set 然后枚举障碍物的 [l, r] 进行二分，每次将落在区间内的人答案记录并删去

​ 每个人只会被删去一次 复杂度是O(nlgQ + QlgQ + Q)

Code:

const int N = 200005;
int n, m;
struct node {
    int s, t, x;
    bool operator < (const node &a) const {
        return x < a.x;
    }
}p[N];
int res[N], a[N];
map<int, int> pos;

signed main()
{
    memset(res, -1, sizeof res);
    scanf("%d%d", &n, &m);
    rep(i, 1, n + 1)
    {
        scanf("%d%d%d", &p[i].s, &p[i].t, &p[i].x);
        p[i].s -= p[i].x;
        p[i].t -= p[i].x;
        p[i].s = max(p[i].s, 0);
        p[i].t = max(p[i].t, 0);
    }
    sort(p + 1, p + n + 1);
    rep(i, 1, m + 1)
        scanf("%d", &a[i]), pos[a[i]] = i;
    
    set<int> s;
    rep(i, 1, m + 1)    s.insert(a[i]);  

    rep(i, 1, n + 1)
    {
        auto l = s.lower_bound(p[i].s);
        auto r = s.lower_bound(p[i].t);
        vector<int> q;
        for(auto j = l; j != r; j ++)
        {
            res[pos[*j]] = p[i].x;
            q.pb(*j);
        }
        for(auto j : q) s.erase(j);
    }
    rep(i, 1, m + 1)
        printf("%d\n", res[i]);
}