[JZOJ5041]游戏

题目描述

有一天小A和小B在一棵有N个节点的树上玩游戏,初始时1号节点上有一枚硬币。游戏以如下方式进行:
●每一轮,小A选取一个节点,并在该节点上画一个叉
●紧接着,小B将硬币移动到一个相邻的、没有被画叉的节点
●小B在硬币原来所在的节点上画一个叉
以上三步不停重复,直到小B无法再移动硬币。而在游戏过程中,小A全程被戴上眼罩,因此小A无法准确地知道每一个时刻硬币在哪一个节点上。他只知道树的形态以及初始时硬币在哪一个节点上。
两盘游戏以后,小A对这个游戏失去了兴趣。他想尽快结束游戏,现在他想知道是否存在一种操作的方式,使得不管小B如何操作,游戏都会在K步以内结束(小B移动硬币次数小于K步)。

模型转化

每个深度上选择一个点。
使每一个深度为k的结点到根路径上都存在被选择的点。
判断可行。

结论

k>20一定行。
考虑证明,可以感性一点。
一个点两个分叉它容易被一石二鸟,不是很优秀。
所以一堆直链看起来最棒。
可以得出根号条直链最棒。
那么感性证明这个结论。

状压

k<=20还不上状压?

#include<cstdio>
#include<algorithm>
#define fo(i,a,b) for(i=a;i<=b;i++)
using namespace std;
const int maxn=400+10,maxm=200000+10;
bool f[maxn][maxm],g[maxn][maxm];
int id[(1<<20)+10],t1[maxm],t2[maxm],js[25];
int h[maxn],go[(1<<20)+10],next[(1<<20)+10],d[maxn],L[maxn],dfn[maxn],nfd[maxn],size[maxn];
bool bz[maxn];
int i,j,k,l,t,n,m,s,tot,top,cnt;
bool czy;
void add(int x,int y){
    go[++tot]=y;
    next[tot]=h[x];
    h[x]=tot;
}
void dfs(int x,int y){
    d[x]=d[y]+1;
    if (d[x]>m) return;
    if (d[x]==m) bz[x]=1;
    int t=h[x];
    while (t){
        if (go[t]!=y){
            dfs(go[t],x);
            bz[x]|=bz[go[t]];
        }
        t=next[t];
    }
}
void dg(int x,int y){
    if (!bz[x]||d[x]>m) return;
    dfn[x]=++top;
    nfd[top]=x;
    size[x]=1;
    if (d[x]==m){
        cnt++;
        L[x]=cnt;
        return;
    }
    L[x]=1000000;
    int t=h[x];
    while (t){
        if (go[t]!=y&&bz[go[t]]){
            dg(go[t],x);
            L[x]=min(L[x],L[go[t]]);
            size[x]+=size[go[t]];
        }
        t=next[t];
    }
}
int lowbit(int x){
    return x&-x;
}
int count(int x){
    int t=0;
    while (x){
        t++;
        x-=lowbit(x);
    }
    return t;
}
void dp(int s){
    int i;
    fo(i,1,top)
        if (f[i][id[s]]){
            if (L[nfd[i+1]]==L[nfd[i]]) f[i+1][id[s]]=1;
            if (i!=1&&(s&(1<<(d[nfd[i]]-1)))==0) g[i+size[nfd[i]]][id[s|(1<<(d[nfd[i]]-1))]]=1;
        }
    if (f[top+1][id[s]]) czy=1;
}
int main(){
    freopen("game.in","r",stdin);freopen("game.out","w",stdout);
    scanf("%d%d",&n,&m);
    if (m>=20){
        printf("DA\n");
        return 0;
    }
    fo(i,1,n-1){
        scanf("%d%d",&j,&k);
        add(j,k);add(k,j);
    }
    d[0]=-1;
    dfs(1,0);
    dg(1,0);
    tot=0;
    fo(i,0,m) h[i]=0;
    fo(i,0,(1<<m)-1){
        t=count(i);
        id[i]=++js[t];
        add(t,i);
    }
    f[1][id[0]]=1;
    fo(i,0,m){
        fo(j,1,n)
            fo(k,1,js[i+1])
                g[j][k]=0;
        t=h[i];
        while (t){
            s=go[t];
            t1[id[s]]=s;
            t=next[t];
        }
        t=h[i+1];
        while (t){
            s=go[t];
            t2[id[s]]=s;
            t=next[t];
        }
        t=h[i];
        while (t){
            s=go[t];
            dp(s);
            t=next[t];
        }
        fo(j,1,n)
            fo(k,1,js[i+1])
                f[j][k]=g[j][k];
    }
    if (czy) printf("DA\n");else printf("NE\n");
}
### 解题思路 题目要求解决的是一个与图相关的最小覆盖问题,通常在特定条件下可以通过状态压缩动态规划(State Compression Dynamic Programming, SCDP)来高效求解。由于状态压缩的适用条件是状态维度较小(例如K≤10),因此可以利用二进制表示状态集合,从而优化计算过程。 #### 1. 状态表示 - 使用一个整数 `mask` 表示当前选择的点集,其中第 `i` 位为 `1` 表示第 `i` 个节点被选中。 - 定义 `dp[mask]` 表示在选中 `mask` 所代表的点集后,能够覆盖的节点集合。 - 可以通过预处理每个点的邻域信息(包括自身和所有直接连接的点),快速更新状态。 #### 2. 预处理邻域 对于每个节点 `u`,预先计算其邻域范围 `neighbor[u]`,即从该节点出发一步能到达的所有节点集合。这样,在后续的状态转移过程中,可以直接使用这些信息进行合并操作。 #### 3. 状态转移 - 初始化:对每个单独节点 `u`,设置初始状态 `dp[1 << u] = neighbor[u]`。 - 转移规则:对于任意两个状态 `mask1` 和 `mask2`,如果它们没有交集,则可以通过合并这两个状态得到新的状态 `mask = mask1 | mask2`,并更新对应的覆盖范围为 `dp[mask1] ∪ dp[mask2]`。 - 在所有状态生成之后,检查是否某个状态的覆盖范围等于全集(即覆盖了所有节点)。如果是,则记录此时使用的最少节点数量。 #### 4. 最优解提取 遍历所有可能的状态,找出能够覆盖整个图的最小节点数目。 --- ### 时间复杂度分析 - 状态总数为 $ O(2^K) $,其中 `K` 是关键点的数量。 - 每次状态转移需要枚举所有可能的子集组合,复杂度为 $ O(2^K \cdot K^2) $。 - 整体时间复杂度控制在可接受范围内,适用于 `K ≤ 10~20` 的情况。 --- ### 代码实现(状态压缩 DP) ```cpp #include <bits/stdc++.h> using namespace std; const int MAXN = 25; int neighbor[MAXN]; // 每个节点的邻域 int dp[1 << 20]; // dp[mask] 表示选中的点集合为 mask 时所能覆盖的点集合 int min_nodes; // 最小覆盖点数 void solve(int n, vector<vector<int>>& graph) { // 预处理每个节点的邻域 for (int i = 0; i < n; ++i) { neighbor[i] = (1 << i); // 包括自己 for (int j : graph[i]) { neighbor[i] |= (1 << j); } } // 初始化 dp 数组 memset(dp, 0x3f, sizeof(dp)); for (int i = 0; i < n; ++i) { dp[1 << i] = neighbor[i]; } // 状态转移 for (int mask = 1; mask < (1 << n); ++mask) { if (__builtin_popcount(mask) >= min_nodes) continue; // 剪枝 for (int sub = mask & (mask - 1); sub; sub = (sub - 1) & mask) { int comp = mask ^ sub; if (comp == 0) continue; int new_mask = mask; int covered = dp[sub] | dp[comp]; if (covered == (1 << n) - 1) { min_nodes = min(min_nodes, __builtin_popcount(new_mask)); } dp[new_mask] = min(dp[new_mask], covered); } } } int main() { int n, m; cin >> n >> m; vector<vector<int>> graph(n); for (int i = 0; i < m; ++i) { int u, v; cin >> u >> v; graph[u].push_back(v); graph[v].push_back(u); // 无向图 } min_nodes = n; solve(n, graph); cout << "Minimum nodes required: " << min_nodes << endl; return 0; } ``` --- ### 优化策略 - **剪枝**:当当前状态所用节点数已经超过已知最优解时,跳过后续计算。 - **提前终止**:一旦发现某个状态覆盖了全部节点,并且节点数达到理论下限,即可提前结束程序。 - **空间优化**:可以仅保存当前轮次的状态,减少内存占用。 --- ### 总结 本题通过状态压缩动态规划的方法,将原本指数级复杂度的问题压缩到可接受范围内。结合位运算技巧和预处理机制,能够高效地完成状态转移和覆盖判断操作。 ---
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值