POI2014 Tourism

Tourism

POI2014

题意

1.一个n个点，m条边的无向图

2.在第i个点建立旅游站点的费用为C[i]

3.在这张图中，任意两点间不存在节点数超过10的简单路径

4.一种方案合法，当且仅当每个点要么建立了旅游站点，要么与它有边直接相连的点里至少有一个点建立了旅游站点

5.选一些点建立旅游站点，问费用最少的合法方案需要花费多少

解

1.特别注意"在这张图中，任意两点间不存在节点数超过10的简单路径",因为有这个条件，所以想到了状压

2.树形dp时记录当前点到根的路径上，所有点的状态
分成三类
①既没有建立站点，也没有被覆盖(状态0)
②没有建立站点，但被覆盖(状态1)
③建立了站点，并且被覆盖(状态2)

3.因为每个点要从父亲转移状态时，需要考虑到与他直接连边的点，所以状压表示上面这些状态。

4.当前这个点，与他相连的点中，已经被遍历过的哪些点，深度一定都不相同；还未被遍历过的点，状态会从当前的点转移下去。因此这个转移没有遗漏

5.但是光是从父亲转移到儿子还不够，还要从儿子转移回来，因为儿子被选后会对父亲造成影响

6.从上到下转移就是父亲选不选对当前点的影响
从下到上转移就是儿子选不选对当前点的影响

7.状态转移

※从上到下
设当前父亲的状态为S，当前点为x
①该点不选
遍历该点的返祖点y(连向已经访问过的点)
查询存在只是一个y在S中被选(状态2)
如果存在->S|(x点位置状态为1)
如果不存在->S|(x点位置状态为0)

②该点被选
遍历该点的返祖点y(连向已经访问过的点)
如果y在S中的状态为没被覆盖(状态0)，就把新状态|=(y点位置状态为1)
最后x点的状态为2

※从下到上
设当前x的状态为S，当前点为x

因为每个点都要被选或被覆盖
所以从儿子被选(状态1)或被覆盖(状态2)转移，取min

具体代码

#include<bits/stdc++.h>
using namespace std;
const int M=20005;
bool vis[M];
int n,m,C[M],B[105];
int dp[12][M*3];
int stk[M],top,dep[M];
int head[M],asdf;
struct edge {
    int to,nxt;
} G[M*3];
void add_edge(int a,int b) {
    G[++asdf].to=b;
    G[asdf].nxt=head[a];
    head[a]=asdf;
}
void init() {
    B[0]=1;
    for(int i=1; i<15; i++)B[i]=B[i-1]*3;
}
void dfs(int x) {
    vis[x]=1;
    int d=dep[x];
    for(int i=0; i<B[d+1]; i++)dp[d][i]=1e9;
    if(!d) {
        dp[0][0]=0,dp[0][1]=1e9,dp[0][2]=C[x];
    }
    //祖先->x
    top=0;
    for(int i=head[x]; i; i=G[i].nxt) {
        int y=G[i].to;
        if(vis[y])stk[++top]=dep[y];
    }
    if(d>0) {
        for(int S=0; S<B[d]; S++) {
            int flag=0;
            int T=S+B[d]*2;
            for(int i=1; i<=top; i++) {
                int p=S/B[stk[i]]%3;
                if(p==2)flag=1;
                else if(p==0)T+=B[stk[i]];
            }
            dp[d][S+flag*B[d]]=min(dp[d][S+flag*B[d]],dp[d-1][S]);
            dp[d][T]=min(dp[d][T],dp[d-1][S]+C[x]);
        }
    }
    for(int i=head[x]; i; i=G[i].nxt) {
        int y=G[i].to;
        if(vis[y])continue;
        dep[y]=dep[x]+1;
        dfs(y);
        //儿子->x
        for(int S=0; S<B[d+1]; S++) {
            dp[d][S]=min(dp[d+1][S+B[d+1]],dp[d+1][S+B[d+1]*2]);
        }
    }
    return;
}
int main() {
    int a,b;
    init();
    scanf("%d %d",&n,&m);
    for(int i=1; i<=n; i++) {
        scanf("%d",&C[i]);
    }
    for(int i=1; i<=m; i++) {
        scanf("%d %d",&a,&b);
        add_edge(a,b);
        add_edge(b,a);
    }
    int ans=0;
    for(int i=1; i<=n; i++) {
        if(!vis[i]) {
            dfs(i);
            ans+=min(dp[0][1],dp[0][2]);
        }
    }
    printf("%d\n",ans);
    return 0;
}