图论专题 - 解题报告 - N

想起来我觉得这题算是过题数人少里最好做的了（题解出来以后）。基本上照着题解的思路全写出来就过了。
就是根据状态压缩的转移关系建图，连上自己总共不超过16个人，所以枚举的上限值是start = (1<<16)-1，我们枚举目标是从上限转移到goal = 0。两重循环找到对应的关系看起来复杂度很高，但是因为对应的关系很苛刻，所以其实中途能减去很多情况的。

首先，当前状态需要合法：
根据约束条件：“成员中存在许多CP关系，这些CP在处于
相同段位，并且洁姐姐不在该段位时，他们就会悄悄的跑去双排”
可知，sta为非法条件的充要条件为：
（1） sta的末位为0
（2） 对某一对关系x和y，sta的第x位和第y位同时为1
（3） max - sta为非法状态
其中，（2)提到的某一对关系只要满足就算非法，所以我们需要循环与每对关系比对（不超过15次关系），提前处理出只有该对关系存在时的二进制的代表并用数组cp[ ]存储，只要当前状态与cp或运算后的答案还是等于原答案，就说明是存在这样的情况的，而这些情况我们甚至可以提前预处理出来。
这部分的判断函数就很好写。

void init()
{
    all = (1 << (n +1)) - 1;					
    for (int i = 0; i <= all; i++) ok[i] = 1;					//首先所有情况都是可行的
    for (int i = 0; i <= all; i++)
    {
        for (int j = 1; j <= m; j++)
            if ((i|cp[j]) == i)				//如果枚举情况与cp[]的或运算的答案不变
            {
                ok[i] = 0;				//就说明不可取
                break;
            }
        cnt[i] = gkd(i);
    }
    FOR(i, 0, all) fa[i] = i;				//初始化并查集
    memset(head, -1, sizeof(head));
    memset(dis, 0x3f, sizeof(dis));
}

bool judge(int x)
{
    bool flag = 1;
    if(ok[x] == 0 && !(x & 1))					//若不满足（2），且这时jj也不在场，就是说没了
        flag = 0;
    if(ok[all - x] == 0 && !((all - x) & 1))					//同理判断all-x
        flag = 0;
    return flag;
}

其次，转移条件要合法：
（1）cnt应小于等于座位数
（2）det的末位为1
（3）det一定要被较大数所包含（我是枚举的det，没有枚举最小数），因为被包含，所以转移后的状态一定为当前状态减去det
（4）同理转移后状态也应当合法
最后合法状态间无向连接，代价就是当前带上jj有几个人在打比赛，这也是可以预处理数出来的（存在cnt[ ]内。

该注意的都有了，直接上代码：

#include<bits/stdc++.h>
#define FOR(a, b, c) for(int a=b; a<=c; a++)
#define maxn 2000005
#define maxm 23
#define hrdg 1000000007
#define zh 16711680
#define inf 2147483647
#define llinf 9223372036854775807
#define ll long long
#define pi acos(-1.0)
#define ls p<<1
#define rs p<<1|1
using namespace std;

int n, m, k, u, v, cp[maxm];
int all, cnt[maxn], goal = -1;
bool ok[maxn];
struct Edge {int to, nex; ll dis;} edge[maxn<<1];
int head[maxn << 1], tot;
void add_edge(int u, int v, ll d) {edge[tot] = {v, head[u], d}; head[u] = tot++;}
struct node{
    ll dis; int id;
    bool operator < (const node & rhs) const			//dij内排序规则
    {return dis > rhs.dis;}
};
ll dis[maxn];
bool vis[maxn];
priority_queue<node> q;
int f[maxn];

inline int read(){
    char c=getchar();long long x=0,f=1;
    while(c<'0'||c>'9'){if(c=='-')f=-1;c=getchar();}
    while(c>='0'&&c<='9'){x=x*10+c-'0';c=getchar();}
    return x*f;
}

int fa[maxn];			//并查集
inline int setfind(int x){ return x == fa[x] ? x : fa[x] = setfind(fa[x]);}
inline void setunion(int x,int y){ x = setfind(fa[x]); y = setfind(fa[y]); fa[x] = y;}
inline bool setcheck(int x,int y){ x = setfind(x); y = setfind(y); return x == y;}

int gkd(int x)			//数当前情况有几个1
{
    int ret = 0;
    for (int i = n; i >= 0; i--)
        ret += (x >> i) & 1;
    return ret;
}

void dij(int start)				//最后有个最短路
{
    memset(vis,0,sizeof vis);
    q.push((node){0LL, start});
    dis[start] = 0LL;
    f[start] = 1;
    while (!q.empty())
    {
        node x=q.top();q.pop();
        int now = x.id;
        if (vis[now]) continue;vis[now]=true;
        for (int i=head[now];~i;i=edge[i].nex)
        {
            int to = edge[i].to;
            if(!f[now] && now > to) continue;
            if(f[now] && now < to) continue;
            f[to] = 1 ^ f[now];
            if (dis[to]>dis[now]+edge[i].dis)
            {
                if(to == 0) goal = 0;
                dis[to]=dis[now]+edge[i].dis;
                q.push((node){dis[to],to});
            }
        }
    }
    return ;
}

bool judge(int x)			//判断当前情况是否合法
{
    bool flag = 1;
    if(ok[x] == 0 && !(x & 1))
        flag = 0;
    if(ok[all - x] == 0 && !((all - x) & 1))
        flag = 0;
    return flag;
}

void init()
{
    all = (1 << (n +1)) - 1;
    for (int i = 0; i <= all; i++) ok[i] = 1;
    for (int i = 0; i <= all; i++)
    {
        for (int j = 1; j <= m; j++)			//预处理
            if ((i|cp[j]) == i)
            {
                ok[i] = 0;
                break;
            }
        cnt[i] = gkd(i);
    }
    FOR(i, 0, all) fa[i] = i;
    memset(head, -1, sizeof(head));
    memset(dis, 0x3f, sizeof(dis));			//初始化
}

int main()
{
    n = read(); m = read(); k = read();
    FOR(i, 1, m)
    {
        u = read(); v = read();
        cp[i] = (1 << u) | (1 << v);
    }
    init();
    for (int i = all; i > 0; i--)   				//枚举较大数
    {
        if(!judge(i)) continue;
        for (int det = 1; det <= i; det += 2)							//从1到all，循环找det的合法情况，枚举det				
        {
            if((det|i) != i) continue;
            if(cnt[det] > k) continue;						//筛选非法情况
            if(judge(i - det))
            {
                add_edge(i, i - det, 1LL * cnt[det]);						//建边
                add_edge(i - det, i, 1LL * cnt[det]);
                setunion(i, i - det);
            }
        }
    }
    dij(all);
    if (!setcheck(all, 0) || goal == -1)				//如果并查集没联通就是mole，还有当天没人到达goal，那么dis[ goal ]的值仍旧为1
        return puts("mole"), 0;						//摸了！
    printf("%lld", dis[0]);					//打印，结束
    return 0;
}