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[], b[], cha[], dep = , vis[][], temp[];
bool flag = false;

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

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

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

    return ;
}

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[], a[], cnt, d[][], f[ << ];
pair <int, int>p[];
queue <int> q;

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

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

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

    return ;
}