noip模拟赛 星空

分析：非常神的一道题.迭代加深搜索+rand可以骗得20分.状压n的话只有24分，必须对问题进行一个转化.

在爆搜的过程中，可以利用差分来快速地对一个区间进行修改，把一般的差分改成异或型的差分：

b[i] = a[i] ^ a[i + 1],每次翻转操作实际上就是在b[l-1]取反，b[r]上取反.那么先对原序列建一个差分数组，实际上的操作就是在对这个差分数组进行操作：每次可以选两个数取反，问多少次能够把这个数组中的所有元素全部变成1.这是一个很神奇的转化.

每次取反的两个数长度都是固定的.两种情况：1.将1,0取反. 2.将0,0取反.其实第一种操作完全是不必要考虑的，因为这种情况下就是把0挪到了另一个位置罢了.对于第二种操作，可以理解为把这两个0给“消”去.那么题目就变成了最少用多少次操作能够把所有的0给消掉.每一次操作都会把0移动固定的位置，只有当两个0的位置重叠，这两个0才会被消掉。

问题还可以接着转化：有n个物品，每次取出还没有被消掉的两个物品，将它们消掉，问最小的代价.k非常小，这就是典型的状压dp了，和noip2016愤怒的小鸟差不多，只不过那道题可以消掉多个.先对每个0求到其他能到达的位置的最短路(最小代价)，f[i]表示i这个状态的最小代价，如果i上的第j位为1，说明第j个0已经被消掉了，状态转移方程很明显，每次找两个没消掉的消就好了，具体见代码.

20分暴力：

#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

int n, k, m, a[40010], b[40010], cha[40010], dep = 1, vis[70][40010], temp[40010];
bool flag = false;

bool check()
{
    memcpy(temp, cha, sizeof(cha));
    for (int i = 1; i <= n; i++)
    {
        temp[i] += temp[i - 1];
        if ((temp[i] + a[i]) % 2 != 1)
            return false;
    }
    return true;
}

void dfs(int d)
{
    if (d == dep + 1)
    {
        if (check())
            flag = 1;
        return;
    }
    for (int i = 1; i <= m; i++)
        for (int j = 1; j + b[i] - 1 <= n; j++)
            if (!vis[i][j])
            {
                cha[j]++;
                cha[j + b[i]]--;
                vis[i][j] = 1;
                dfs(d + 1);
                cha[j]--;
                cha[j + b[i]]++;
                vis[i][j] = 0;
            }
}

int main()
{
    scanf("%d%d%d", &n, &k, &m);
    for (int i = 1; i <= n; i++)
        a[i] = 1;
    for (int i = 1; i <= k; i++)
    {
        int t;
        scanf("%d", &t);
        a[t] = 0;
    }
    for (int i = 1; i <= m; i++)
        scanf("%d", &b[i]);
    if (n <= 16)
    {
        for (;; dep++)
        {
            dfs(1);
            if (flag)
            {
                printf("%d\n", dep);
                break;
            }
        }
    }
    else
    {
        srand(time(0));
        cout << rand() % 4 << endl;
    }

    return 0;
}

std:

#include <cmath>
#include <queue>
#include <vector>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;
const int inf = 0x7ffffff;

typedef long long ll;

int n, k, m, b[70], a[40010], cnt, d[20][40010], f[1 << 19];
pair <int, int>p[20];
queue <int> q;

void bfs(pair <int, int> s)
{
    for (int i = 0; i < 40010; i++)
        d[s.first][i] = inf;
    q.push(s.second);
    d[s.first][s.second] = 0;
    while (!q.empty())
    {
        int x = q.front();
        q.pop();
        for (int i = 1; i <= m; i++)
        {
            if (x - b[i] >= 0 && d[s.first][x - b[i]] > d[s.first][x] + 1)
            {
                d[s.first][x - b[i]] = d[s.first][x] + 1;
                q.push(x - b[i]);
            }
            if (x + b[i] <= n && d[s.first][x + b[i]] > d[s.first][x] + 1)
            {
                d[s.first][x + b[i]] = d[s.first][x] + 1;
                q.push(x + b[i]);
            }
        }
    }
}

int solve(int statuu)
{
    if (f[statuu] != -1)
        return f[statuu];
    if (statuu == 0)
        return 0;
    int &ret = f[statuu];
    ret = inf;
    for (int i = 0; i < 2 * k; i++)
        if (statuu & (1 << i))
            for (int j = 0; j < 2 * k; j++)
                if (statuu & (1 << j) && j != i)
            ret = min(ret, solve(statuu ^ (1 << j) ^ (1 << i)) + d[j][p[i].second]);
    return ret;
}

int main()
{
    scanf("%d%d%d", &n, &k, &m);
    for (int i = 1; i <= k; i++)
    {
        int t;
        scanf("%d", &t);
        a[t] = 1;
    }
    for (int i = 1; i <= m; i++)
        scanf("%d", &b[i]);
    for (int i = 0; i <= n; i++)
        if (a[i] != a[i + 1]) //实质上就是差分
        {
        p[cnt] = make_pair(cnt, i);
        cnt++;
        }
    for (int i = 0; i < cnt; i++)
        bfs(p[i]);
    memset(f, -1, sizeof(f));
    printf("%d\n", solve((1 << cnt) - 1));

    return 0;
}