斯坦纳树

斯坦纳树是一类比较特殊的DP吧，主要针对点集连通问题，通常dp[i][s]表示以i为根的，连通状态为s的一棵树的最小权值，有两种转移方式，

其中state[i]表示点i的二进制标号，通常无关的点state值为0，

dp[i][s] = min{dp[i][s], dp[i][j] + dp[i][k]},这里是针对state[i]非0

dp[i][s] = min{dp[j][s] + dist(i, j), dp[i][s]},这里针对state[i]为0的点的转移方程。

更详细的分析在这里：http://endlesscount.blog.163.com/blog/static/821197872012525113427573/

UVALive 5717
Peach Blossom Spring

//Template updates date: 20140316
#include <iostream>
#include <sstream>
#include <cstdio>
#include <climits>
#include <ctime>
#include <cctype>
#include <cstring>
#include <cstdlib>
#include <string>
#include <stack>
#include <set>
#include <map>
#include <cmath>
#include <vector>
#include <queue>
#include <algorithm>
#define  esp 1e-6
#define  pi acos(-1.0)
#define  inf 0x0f0f0f0f
#define  pb push_back
#define  lson l, m, rt<<1
#define  rson m+1, r, rt<<1|1
#define  lowbit(x) (x&(-x))
#define  mp(a, b) make_pair((a), (b))
#define  bit(k) (1<<(k))
#define  in  freopen("solve_in.txt", "r", stdin);
#define  out freopen("solve_out.txt", "w", stdout);

#define  bug puts("********))))))");
#define  inout in out

#define  SET(a, v) memset(a, (v), sizeof(a))
#define  SORT(a)   sort((a).begin(), (a).end())
#define  REV(a)    reverse((a).begin(), (a).end())
#define  READ(a, n) {REP(i, n) cin>>(a)[i];}
#define  REP(i, n) for(int i = 0; i < (n); i++)
#define  Rep(i, base, n) for(int i = base; i < n; i++)
#define  REPS(s, i) for(int i = 0; s[i]; i++)
#define  pf(x) ((x)*(x))
#define  mod(n) ((n))
#define  Log(a, b) (log((double)b)/log((double)a))
#define Srand() srand((int)time(0))
#define random(number) (rand()%number)
#define random_range(a, b) (int)(((double)rand()/RAND_MAX)*(b-a) + a)

using namespace std;
typedef long long  LL;
typedef unsigned long long ULL;
typedef vector<int> VI;
typedef pair<int,int> PII;
typedef vector<PII> VII;
typedef vector<PII, int> VIII;
typedef VI:: iterator IT;
typedef map<string, int> Mps;
typedef map<int, int> Mpi;
typedef map<int, PII> Mpii;
typedef map<PII, int> Mpiii;
const int maxn = (1<<10);
const int maxm = 50 + 10;
int dp[maxm][maxn], ans[maxn], s[maxm];
struct EDGE {
    int to, w;
    EDGE *next;
    EDGE() {}
    EDGE(int to, int w, EDGE *next):to(to), w(w), next(next) {}
}*head[maxm], E[2000 + 10], *now;
int n, m, kk, L;
int IN[maxm][maxn];
queue<int> q;
void add(int u, int v, int w) {
    now->to = v;
    now->w = w;
    now->next = head[u];
    head[u] = now;
    now++;
}
void pre() {
    now = E;
    L = (1<<(2*kk));
    SET(head, 0);
    for(int i = 0; i < m; i++) {
        int u, v, w;
        scanf("%d%d%d", &u, &v,&w);
        add(u, v, w);
        add(v, u, w);
    }
    memset(s, 0, sizeof(s));
    for(int i = 0; i < L; i++)
        for(int j = 1; j <= n; j++)
            dp[j][i] = inf;
    for(int i = 1; i <= kk; i++) {
        s[i] = 1<<(i-1);
        dp[i][s[i]] = 0;
        s[n-i+1] = 1<<(kk+i-1);
        dp[n-i+1][s[n-i+1]] = 0;
    }

}
bool check(int x) {
    int ans = 0;
    for(int i = 0; i < 2*kk; x >>= 1, i++)
        ans += (x&1)*(i < kk ? 1 : -1);
    return ans == 0;
}
bool go(int x, int y, int w) {
    if(dp[x][y] > w)
        return dp[x][y] = w, true;
    return false;
}
void spfa() {
    while(!q.empty()) {
        int x = q.front()/10000;
        int y = q.front()%10000;
        IN[x][y] = 0;
        q.pop();
        for(EDGE *next = head[x]; next; next = next->next) {
            if(go(next->to, y|s[next->to], dp[x][y] + next->w) &&  !s[next->to] && !IN[next->to][y])
                IN[next->to][y] = 1, q.push(next->to*10000 + y);
        }
    }
}
int main() {
    
    int T;
    for(int t = scanf("%d" ,&T); t <= T; t++) {
        scanf("%d%d%d", &n, &m, &kk);
        pre();
        memset(IN, 0, sizeof(IN));
        for(int i = 0; i < L; i++) {
            for(int j = 1; j <= n; j++) {
                for(int st = i; st; st = (st-1)&i)
                    dp[j][i] = min(dp[j][i], dp[j][st|s[j]] + dp[j][(i-st)|s[j]]);
                if(dp[j][i] < inf)
                    IN[j][i] = 1, q.push(j*10000 + i);
            }
            spfa();
        }
        for(int i = 0; i < L; i++) {
            ans[i] = inf;
            for(int j = 1; j <= n; j++) {
                ans[i] = min(ans[i], dp[j][i]);
            }
        }
        for(int i = 1; i < L; i++)
            if(check(i))
                for(int j = i; j ; j = (j-1)&i)
                    if(check(j))
                        ans[i] = min(ans[i], ans[j] + ans[i-j]);
        if(ans[L-1] < inf)
            cout<<ans[L-1]<<endl;
        else cout<<"No solution"<<endl;
    }
    return 0;
}

ZOJ 3613
Wormhole Transport

题意：有n个行星上有工厂，m个行星上有资源，每个资源行星只能给一个工厂提供资源，给定行星间的连接关系，

最多能有多少个工厂能够运行，而且花费的费用最少。

与上面的题目变化在于最后DP的时候check里面改成工厂数目不少于资源行星数目就行了。

 

//Template updates date: 20140316
#include <iostream>
#include <sstream>
#include <cstdio>
#include <climits>
#include <ctime>
#include <cctype>
#include <cstring>
#include <cstdlib>
#include <string>
#include <stack>
#include <set>
#include <map>
#include <cmath>
#include <vector>
#include <queue>
#include <algorithm>
#define  esp 1e-6
#define  inf 0x0f0f0f0f
#define  pi acos(-1.0)
#define  pb push_back
#define  lson l, m, rt<<1
#define  rson m+1, r, rt<<1|1
#define  lowbit(x) (x&(-x))
#define  mp(a, b) make_pair((a), (b))
#define  bit(k) (1<<(k))
#define  in  freopen("solve_in.txt", "r", stdin);
#define  out freopen("solve_out.txt", "w", stdout);

#define  bug puts("********))))))");
#define  inout in out

#define  SET(a, v) memset(a, (v), sizeof(a))
#define  SORT(a)   sort((a).begin(), (a).end())
#define  REV(a)    reverse((a).begin(), (a).end())
#define  READ(a, n) {REP(i, n) cin>>(a)[i];}
#define  REP(i, n) for(int i = 0; i < (n); i++)
#define  Rep(i, base, n) for(int i = base; i < n; i++)
#define  REPS(s, i) for(int i = 0; s[i]; i++)
#define  pf(x) ((x)*(x))
#define  mod(n) ((n))
#define  Log(a, b) (log((double)b)/log((double)a))
#define Srand() srand((int)time(0))
#define random(number) (rand()%number)
#define random_range(a, b) (int)(((double)rand()/RAND_MAX)*(b-a) + a)

using namespace std;
typedef long long  LL;
typedef unsigned long long ULL;
typedef vector<int> VI;
typedef pair<int,int> PII;
typedef vector<PII> VII;
typedef vector<PII, int> VIII;
typedef VI:: iterator IT;
typedef map<string, int> Mps;
typedef map<int, int> Mpi;
typedef map<int, PII> Mpii;
typedef map<PII, int> Mpiii;

const int maxn = 222;
const int maxm = 5555;
const int LI = 1<<10;

int dp[maxn][LI], d[LI], s[maxn], num[maxn], vis[maxn], inq[maxn][LI];
int n, m;
VI Store;
queue<int> q;
struct EDGE {
    int v, w;
    EDGE *nxt;
    EDGE() {}
    EDGE(int v, int w, EDGE *nxt):v(v), w(w), nxt(nxt) {}
} *head[maxn], E[maxm*2], *now;
void pre() {
    SET(head, 0);
    SET(dp, 0x0f);
    SET(d, 0x0f);
    SET(s, 0);
    SET(inq, 0);
    Store.clear();
    now = E;
}
void addedge(int u, int v, int w) {
    now->v = v;
    now->w = w;
    now->nxt = head[u];
    head[u] = now++;
}
void read() {
    for(int i = 1; i <= n; i++) {
        int u, v;
        scanf("%d%d", &u, &v);
        if(u || v)
            Store.pb(i);
        num[i] = u;
        vis[i] = v;
    }
    for(int i = scanf("%d", &m); i <= m; i++) {
        int u, v, w;
        scanf("%d%d%d", &u, &v, &w);
        addedge(u, v, w);
        addedge(v, u, w);
    }
}
bool check(int x, int &b) {
    int a;
    a = b = 0;
    for(int i = 0; x; i++, x >>= 1)
        if(x&1) {
            a += num[Store[i]];
            b += vis[Store[i]];
        }
    return a >= b;
}
bool update(int x, int y, int w) {
    if(dp[x][y] > w)
        return dp[x][y] = w, true;
    return false;
}
void spfa() {
    while(!q.empty()) {
        int u = q.front();
        q.pop();
        int x = u/10000;
        int y = u%10000;
        inq[x][y] = 0;
        for(EDGE *p = head[x]; p; p = p->nxt) {
            if(update(p->v, y|s[p->v], dp[x][y] + p->w) && s[p->v] == 0 && !inq[p->v][y])
                inq[p->v][y] = 1, q.push(p->v*10000 + y);
        }
    }
}
void solve() {
    REP(i, Store.size()) {
        s[Store[i]] = 1<<i;
        dp[Store[i]][s[Store[i]]] = 0;
    }
    int L = 1<<Store.size();
    REP(state, L) {
        Rep(i, 1, n+1) {
            for(int st = state; st; st = (st-1)&state)
                dp[i][state] = min(dp[i][state], dp[i][st|s[i]] + dp[i][(state-st)|s[i]]);
            if(dp[i][state] < inf)
                inq[i][state] = 1, q.push(i*10000 + state);
        }
        spfa();
    }
    d[0] = 0;
    int tmp, maxans, mincost;
    maxans = 0, mincost = 0;
    REP(i, L) Rep(j, 1, n+1)
    d[i] = min(d[i], dp[j][i]);
    Rep(i, 1, L) if(check(i, tmp))
        for(int j = i; j; j = (j-1)&i)
            if(check(j, tmp) && check(i-j, tmp))
                d[i] = min(d[i], d[j] + d[i-j]);
    REP(i, L) if(check(i, tmp) && (tmp > maxans || (tmp == maxans && d[i] < mincost)))
        maxans = tmp, mincost = d[i];
    printf("%d %d
", maxans, mincost);
}
int main() {
    
    while(scanf("%d", &n) == 1) {
        pre();
        read();
        solve();
    }
    return 0;
}

不过一开始把题意看成每个资源行星可以给一个行星上所有工厂提供资源，这样一写发现还是可以写出来的，哈哈，倒是自己重新发明了一道题目。

思路是，需要枚举是哪些行星上工厂可以运行，然后算出相应工厂数目，以及这样的情况下，花费最少，由于最多4个行星上有工厂，所以这样暴力是可以的。

既然写了上一下这样的题意的代码，不能保证没有bug啊。

//Template updates date: 20140316
#include <iostream>
#include <sstream>
#include <cstdio>
#include <climits>
#include <ctime>
#include <cctype>
#include <cstring>
#include <cstdlib>
#include <string>
#include <stack>
#include <set>
#include <map>
#include <cmath>
#include <vector>
#include <queue>
#include <algorithm>
#define  esp 1e-6
#define  pi acos(-1.0)
#define  pb push_back
#define  lson l, m, rt<<1
#define  rson m+1, r, rt<<1|1
#define  lowbit(x) (x&(-x))
#define  mp(a, b) make_pair((a), (b))
#define  bit(k) (1<<(k))
#define  in  freopen("solve_in.txt", "r", stdin);
#define  out freopen("solve_out.txt", "w", stdout);

#define  bug puts("********))))))");
#define  inout in out

#define  SET(a, v) memset(a, (v), sizeof(a))
#define  SORT(a)   sort((a).begin(), (a).end())
#define  REV(a)    reverse((a).begin(), (a).end())
#define  READ(a, n) {REP(i, n) cin>>(a)[i];}
#define  REP(i, n) for(int i = 0; i < (n); i++)
#define  Rep(i, base, n) for(int i = base; i < n; i++)
#define  REPS(s, i) for(int i = 0; s[i]; i++)
#define  pf(x) ((x)*(x))
#define  mod(n) ((n))
#define  Log(a, b) (log((double)b)/log((double)a))
#define Srand() srand((int)time(0))
#define random(number) (rand()%number)
#define random_range(a, b) (int)(((double)rand()/RAND_MAX)*(b-a) + a)

using namespace std;
typedef long long  LL;
typedef unsigned long long ULL;
typedef vector<int> VI;
typedef pair<int,int> PII;
typedef vector<PII> VII;
typedef vector<PII, int> VIII;
typedef VI:: iterator IT;
typedef map<string, int> Mps;
typedef map<int, int> Mpi;
typedef map<int, PII> Mpii;
typedef map<PII, int> Mpiii;

const int maxn = 222;
const int maxm = 5555;
const int LI = 1<<10;
int s[maxn], inq[maxn][LI];
LL dp[maxn][LI], d[LI], cost[maxn];
LL inf;

int n, m;
LL maxans, mincost, L, temp;
VI planetA, planetB;
int cntA, cntB, Minx;
queue<int> q;

struct EDGE {
    int v;
    LL w;
    EDGE *nxt;
    EDGE() {}
    EDGE(int v, LL w, EDGE *nxt):v(v), w(w), nxt(nxt) {}
} *head[maxn], E[maxm*2], *now;

void addedge(int u, int v, int w) {
    now->v = v;
    now->w = w;
    now->nxt = head[u];
    head[u] = now++;
}
int maze[5][5][10]= {{}, {{},{1}},{{},{1,2},{3}},{{},{1,2,4},{3,6,5},{7}},
    {{},{1,2,4,8},{3,5,9,6,10,12},{7,11,13,14},{15}}
};
void pre() {
    now = E;
    SET(head, 0);
    SET(s, 0);
    SET(cost, 0);
    SET(&inf, 0x0f);
    maxans = 0;
    mincost = 0;
    temp = 0;
    planetA.clear();
    planetB.clear();
    planetA.pb(-1);
    planetB.pb(-1);
    cntA = cntB = 0;
}
void read() {
    Rep(i, 1, n+1) {
        int u, v;
        scanf("%d%d", &u, &v);
        if(u&&v) {
            temp += u;
        } else {
            if(u)
                planetA.pb(i), cntA++, cost[i] = u;
            if(v)planetB.pb(i), cntB++;
        }
    }
    for(int i = scanf("%d", &m); i <= m; i++) {
        int u, v, w;
        scanf("%d%d%d", &u, &v, &w);
        addedge(u, v, (LL)w);
        addedge(v, u, (LL)w);
    }
}
LL encode(int m, int l, int j) {
    SET(dp, 0x0f),SET(d, 0x0f);
    LL ans = 0;
    SET(s, 0);
    int cnt1 = 0, cnt2 = 0;
    for(int i = 1; i <= cntA; i++)
        if(maze[cntA][m][l]&(1<<(i-1))) {
            ans += cost[planetA[i]];
            s[planetA[i]] = (1<<(cnt1++));
            dp[planetA[i]][s[planetA[i]]] = 0;
        }
    for(int i = 1; i <= cntB; i++)
        if(maze[cntB][m][j]&(1<<(i-1))) {
            s[planetB[i]] = (1<<(cnt2++));
            if(s[planetB[i]] < (1<<(m)))
                s[planetB[i]] += ((1<<m)-1);
            dp[planetB[i]][s[planetB[i]]] = 0;
        }
    return ans;
}
bool update(int x, int y, LL w) {
    if(dp[x][y] > w)
        return dp[x][y] = w, true;
    return false;
}
void spfa() {
    while(!q.empty()) {
        int u = q.front();
        q.pop();
        int x = u/20000;
        int y = u%20000;
        inq[x][y] = 0;
        for(EDGE *p = head[x]; p; p = p->nxt) {
            if(update(p->v, y|s[p->v], dp[x][y]+p->w) && (y|s[p->v] == y) && !inq[p->v][y])
                inq[p->v][y] = 1, q.push(p->v*20000 + y);
        }
    }
}
bool check(int x) {
    int ans = 0;
    for(int i = 0; x; x >>= 1, i++)
        ans += (i < Minx ? 1 : -1)*(x&1);
    return ans == 0;
}
void solve() {
    Minx = min(cntA,cntB);
    while(Minx) {
        L = (1<<(2*Minx));
        for(int i = 0; maze[cntA][Minx][i]; i++)
            for(int j = 0; maze[cntB][Minx][j]; j++) {
                LL tmp = encode(Minx, i, j);
                SET(inq, 0);
                for(int state = 0; state < L; state++) {
                    for(int x = 1; x <= n; x++) {
                        for(int st = state; st; st = (st-1)&state)
                            dp[x][state] = min(dp[x][state], dp[x][st|s[x]] + dp[x][s[x]|(state-st)]);
                        if(dp[x][state] < inf)
                            inq[x][state] = 1, q.push(x*20000 + state);
                    }
                    spfa();
                }
                for(int i = 0; i < L; i++)
                    for(int j = 1; j <= n; j++)
                        d[i] = min(d[i], dp[j][i]);
                d[0] = 0;
                for(int i = 1; i < L; i++)
                    if(check(i))
                        for(int j = i; j; j = (j-1)&i)
                            if(check(j))
                                d[i] = min(d[i], d[j] + d[i-j]);

                if(d[L-1] < inf && (tmp > maxans || (tmp == maxans && d[L-1] < mincost)))
                    maxans = tmp, mincost = d[L-1];
            }
        Minx--;
    }
    maxans += temp;
    printf("%lld %lld
", maxans, mincost);
}
int main() {
    
    while(scanf("%d", &n) != EOF) {
        pre();
        read();
        solve();
    }
    return 0;
}

HYSBZ 2595
        游览计划

给定n*m矩阵，一些格子为景点，要求选择一些格子使得景点之间两两连通，非景点的格子上必须安排相应数目志愿者。

这个题目只不过变成了点带权值，所以进行第一种状态转移时，应该注意减去重复计算的权值，然后最后发现记录路径的时候不会，

看了别人代码发现还是太年轻，直接把中间过渡状态记录最后一步步回溯，记录相应格子就是了。

//Template updates date: 20140316
#include <iostream>
#include <sstream>
#include <cstdio>
#include <climits>
#include <ctime>
#include <cctype>
#include <cstring>
#include <cstdlib>
#include <string>
#include <stack>
#include <set>
#include <map>
#include <cmath>
#include <vector>
#include <queue>
#include <algorithm>
#define  esp 1e-6
#define  inf 0x0f0f0f0f
#define  pi acos(-1.0)
#define  pb push_back
#define  lson l, m, rt<<1
#define  rson m+1, r, rt<<1|1
#define  lowbit(x) (x&(-x))
#define  mp(a, b) make_pair((a), (b))
#define  bit(k) (1<<(k))
#define  in  freopen("solve_in.txt", "r", stdin);
#define  out freopen("solve_out.txt", "w", stdout);

#define  bug puts("********))))))");
#define  inout in out

#define  SET(a, v) memset(a, (v), sizeof(a))
#define  SORT(a)   sort((a).begin(), (a).end())
#define  REV(a)    reverse((a).begin(), (a).end())
#define  READ(a, n) {REP(i, n) cin>>(a)[i];}
#define  REP(i, n) for(int i = 0; i < (n); i++)
#define  Rep(i, base, n) for(int i = base; i < n; i++)
#define  REPS(s, i) for(int i = 0; s[i]; i++)
#define  pf(x) ((x)*(x))
#define  mod(n) ((n))
#define  Log(a, b) (log((double)b)/log((double)a))
#define Srand() srand((int)time(0))
#define random(number) (rand()%number)
#define random_range(a, b) (int)(((double)rand()/RAND_MAX)*(b-a) + a)

using namespace std;
typedef long long  LL;
typedef unsigned long long ULL;
typedef vector<int> VI;
typedef pair<int,int> PII;
typedef vector<PII> VII;
typedef vector<PII, int> VIII;
typedef VI:: iterator IT;
typedef map<string, int> Mps;
typedef map<int, int> Mpi;
typedef map<int, PII> Mpii;
typedef map<PII, int> Mpiii;

const int maxn = 11;
const int LI = 1<<11;

int maze[maxn][maxn], dp[maxn*maxn][LI], inq[maxn*maxn][LI], s[maxn*maxn], vis[maxn][maxn];
int n, m, L ,id;
int pre[maxn*maxn][LI];
char ans[maxn][maxn];
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, 1, 0, -1};
queue<int> q;
VI po;

bool check(int x,int y) {
    return x >= 0 && x < n && y >= 0 && y < m;
}
bool update(int x, int y, int w) {
    if(dp[x][y] > w) return dp[x][y] = w, true;
    return false;
}
void ID(int x, int y) {
    s[x*m+y] = 1<<id;
    dp[x*m+y][s[x*m+y]] = 0;
    po.pb(x*m+y);
    id++;
}
void preprocess() {
    po.clear();
    SET(inq, 0);
    SET(vis, 0);
    SET(s, 0);
    SET(pre, -1);
    SET(dp, 0x0f);
    id = 0;
}
void spfa() {

    while(!q.empty()) {
        int u = q.front();
        q.pop();
        int x = u/2000;
        int y = u%2000;
        inq[x][y] = 0;
        int xx = x/m;
        int yy = x%m;

        REP(k, 4) {
            int nx = xx + dx[k];
            int ny = yy + dy[k];
            if(!check(nx, ny))
                continue;
            int v = nx*m + ny;
            if(update(v, y|s[v], dp[x][y] + maze[nx][ny]) ) {
                pre[v][y|s[v]] = u;
                if(!s[v] && !inq[v][y])
                    inq[v][y] = 1, q.push(v*2000 + y);
            }
        }
    }
}
void solve() {
    L = 1<<id;
    REP(state, L) {
        REP(i, n) REP(j, m) {
            int u = i*m+j;
            for(int st = state; st; st = (st-1)&state){
                if(s[u] && !(s[u] & state))
                    continue;
                if(dp[u][state] > dp[u][st|s[u]] + dp[u][s[u]|(state-st)]-maze[i][j]) {
                    dp[u][state] = dp[u][st|s[u]] + dp[u][s[u]|(state-st)] - maze[i][j];
                    pre[u][state] = u*2000 + (st|s[u]);
                }
            }
            if(dp[u][state] < inf)
                inq[u][state] = 1, q.push(u*2000 + state);
        }
        spfa();
    }
}
void BackTrace(int x, int y) {
    int xx = x/m;
    int yy = x%m;
    vis[xx][yy] = 1;
    int u = pre[x][y], nx, ny;
    if(u == -1)
        return;
    nx = u/2000;
    ny = u%2000;
    BackTrace(nx, ny);
    if(nx == x)
        BackTrace(nx, (y-ny)|s[x]);
}
void output() {
    if(id == 0 || dp[po[0]][L-1] == 0) {
        cout<<0<<endl;
        REP(i, n) {
            REP(j, m)
            putchar(ans[i][j]);
            puts("");
        }
    } else {
        int tmp1 = dp[po[0]][L-1];
        cout<<tmp1<<endl;
        BackTrace(po[0], L-1);
        REP(i, n) {
            REP(j, m) {
                if(!maze[i][j])
                    putchar('x');
                else if(vis[i][j])
                    putchar('o');
                else putchar('_');
            }
            puts("");
        }
    }
}
int main() {

    scanf("%d%d", &n, &m);{
        preprocess();
        REP(i, n) REP(j, m) {
            scanf("%d", &maze[i][j]);
            if(!maze[i][j])
                ID(i, j), ans[i][j] = 'x';
            else ans[i][j] = '_';
        }
        solve();
        output();
    }
    return 0;
}

HDU - 3311

Dig The Wells

给定n个和尚居住地方和其他m个地方，n+m个地方都可以挖井，花费cost[i]，以及这n+m个地方中各种连接路径及花费，选择相应的路径，及在某些地方挖井，所有的和尚都能有水井 到达。

分析：每个连通图分量里面最多只有一口水井。

法一：可以先当做普通斯坦纳树处理dp[i][s]表示，i为根，s为连通状况的最少花费，然后dp的时候加上在i点挖井的花费。

代码：

//Template updates date: 20140316
#include <iostream>
#include <sstream>
#include <cstdio>
#include <climits>
#include <ctime>
#include <cctype>
#include <cstring>
#include <cstdlib>
#include <string>
#include <stack>
#include <set>
#include <map>
#include <cmath>
#include <vector>
#include <queue>
#include <algorithm>
#define  esp 1e-6
#define  inf 0x3f3f3f3f
#define  pi acos(-1.0)
#define  pb push_back
#define  lson l, m, rt<<1
#define  rson m+1, r, rt<<1|1
#define  lowbit(x) (x&(-x))
#define  mp(a, b) make_pair((a), (b))
#define  bit(k) (1<<(k))
#define  in  freopen("solve_in.txt", "r", stdin);
#define  out freopen("solve_out.txt", "w", stdout);

#define  bug puts("********))))))");
#define  inout in out

#define  SET(a, v) memset(a, (v), sizeof(a))
#define  SORT(a)   sort((a).begin(), (a).end())
#define  REV(a)    reverse((a).begin(), (a).end())
#define  READ(a, n) {REP(i, n) cin>>(a)[i];}
#define  REP(i, n) for(int i = 0; i < (n); i++)
#define  Rep(i, base, n) for(int i = base; i < n; i++)
#define  REPS(s, i) for(int i = 0; s[i]; i++)
#define  pf(x) ((x)*(x))
#define  mod(n) ((n))
#define  Log(a, b) (log((double)b)/log((double)a))
#define Srand() srand((int)time(0))
#define random(number) (rand()%number)
#define random_range(a, b) (int)(((double)rand()/RAND_MAX)*(b-a) + a)

using namespace std;
typedef long long  LL;
typedef unsigned long long ULL;
typedef vector<int> VI;
typedef pair<int,int> PII;
typedef vector<PII> VII;
typedef vector<PII, int> VIII;
typedef VI:: iterator IT;
typedef map<string, int> Mps;
typedef map<int, int> Mpi;
typedef map<int, PII> Mpii;
typedef map<PII, int> Mpiii;

const int maxn = 1100;
const int maxm = 5000*2 + 1000;
const int LI = (1<<10);

int dp[maxn][LI], d[LI], inq[maxn][LI], s[maxn], cost[maxn];
int n, m, p;
int L;
queue<int> q;

struct EDGE {
    int v, w;
    EDGE *nxt;
    EDGE() {}
    EDGE(int v, int w, EDGE *nxt):v(v),w(w), nxt(nxt) {}
} *head[maxn], E[maxm], *cur;

void addedge(int u, int v, int w) {
    cur->v = v;
    cur->w = w;
    cur->nxt = head[u];
    head[u] = cur++;

}
void preprocess() {
    SET(head, 0);
    cur = E;
    SET(s, 0);
    SET(inq, 0);
    SET(dp, 0x3f);
    SET(d, 0x3f);
    L = 1<<n;
}
bool update(int x, int y, int w) {
    if(dp[x][y] > w) return dp[x][y] = w, true;
    return false;
}
void spfa() {
    while(!q.empty()) {
        int u = q.front();
        q.pop();
        int x = u/10000;
        int y = u%10000;
        inq[x][y] = 0;
        for(EDGE *p = head[x]; p; p = p->nxt) {
            if(update(p->v, y|s[p->v], dp[x][y] + p->w) && (y|s[p->v]) == y && !inq[p->v][y])
                inq[p->v][y] = 1, q.push(p->v*10000 + y);
        }
    }
}
void solve() {
    REP(i, n+m) scanf("%d", &cost[1+i]);
    REP(i, n)
    s[i+1] = 1<<i, dp[1+i][s[i+1]] = 0;
    REP(i, p) {
        int u, v, w;
        scanf("%d%d%d", &u, &v, &w);
        addedge(u, v, w);
        addedge(v, u, w);
    }
    Rep(state,1, L) {
        Rep(i, 1, n+m+1) {
//            if(s[i] && !(s[i] & state))
//                continue;
            for(int st = state&(state-1); st; st = (st-1)&state) {
                dp[i][state] = min(dp[i][state], dp[i][st|s[i]] + dp[i][(state-st)|s[i]]);
            }
            if(dp[i][state] < inf)
                inq[i][state] = 1, q.push(i*10000 + state);
        }
        spfa();
    }
    Rep(i, 1, L)
    Rep(j, 1, n+m+1)
    d[i] = min(d[i], dp[j][i] + cost[j]);
    Rep(st, 1, L)
    for(int ss = (st-1)&st; ss; ss = (ss-1)&st)
        d[st] = min(d[st], d[ss] + d[st-ss]);
    printf("%d
", d[L-1]);
}

int main() {

    while(scanf("%d%d%d", &n, &m, &p) == 3) {
        preprocess();
        solve();
    }
    return 0;
}

法二：用dp[i][s]表示以i为根且在i点挖井，连通状态为s的最小花费，不过转移时应该注意重复计算的cost[i]，两种情况下的转移都要自习考虑

代码：

//Template updates date: 20140316
#include <iostream>
#include <sstream>
#include <cstdio>
#include <climits>
#include <ctime>
#include <cctype>
#include <cstring>
#include <cstdlib>
#include <string>
#include <stack>
#include <set>
#include <map>
#include <cmath>
#include <vector>
#include <queue>
#include <algorithm>
#define  esp 1e-6
#define  inf 0x0f0f0f0f
#define  pi acos(-1.0)
#define  pb push_back
#define  lson l, m, rt<<1
#define  rson m+1, r, rt<<1|1
#define  lowbit(x) (x&(-x))
#define  mp(a, b) make_pair((a), (b))
#define  bit(k) (1<<(k))
#define  in  freopen("solve_in.txt", "r", stdin);
#define  out freopen("solve_out.txt", "w", stdout);

#define  bug puts("********))))))");
#define  inout in out

#define  SET(a, v) memset(a, (v), sizeof(a))
#define  SORT(a)   sort((a).begin(), (a).end())
#define  REV(a)    reverse((a).begin(), (a).end())
#define  READ(a, n) {REP(i, n) cin>>(a)[i];}
#define  REP(i, n) for(int i = 0; i < (n); i++)
#define  Rep(i, base, n) for(int i = base; i < n; i++)
#define  REPS(s, i) for(int i = 0; s[i]; i++)
#define  pf(x) ((x)*(x))
#define  mod(n) ((n))
#define  Log(a, b) (log((double)b)/log((double)a))
#define Srand() srand((int)time(0))
#define random(number) (rand()%number)
#define random_range(a, b) (int)(((double)rand()/RAND_MAX)*(b-a) + a)

using namespace std;
typedef long long  LL;
typedef unsigned long long ULL;
typedef vector<int> VI;
typedef pair<int,int> PII;
typedef vector<PII> VII;
typedef vector<PII, int> VIII;
typedef VI:: iterator IT;
typedef map<string, int> Mps;
typedef map<int, int> Mpi;
typedef map<int, PII> Mpii;
typedef map<PII, int> Mpiii;
const int maxn = 1100;
const int maxm = 5000*2 + 1000;
const int LI = (1<<10);

int dp[maxn][LI], d[LI], inq[maxn][LI], s[maxn], cost[maxn];
int n, m, p;
int L;
queue<int> q;

struct EDGE {
    int v, w;
    EDGE *nxt;
    EDGE() {}
    EDGE(int v, int w, EDGE *nxt):v(v),w(w), nxt(nxt) {}
} *head[maxn], E[maxm], *cur;

void addedge(int u, int v, int w) {
    u--, v--;
    cur->v = v;
    cur->w = w;
    cur->nxt = head[u];
    head[u] = cur++;

}
void preprocess() {
    SET(head, 0);
    cur = E;
    SET(s, 0);
    SET(inq, 0);
    SET(dp, 0x0f);
    SET(d, 0x0f);
    L = 1<<n;
}
bool update(int x, int y, int w) {
    if(dp[x][y] >= w) return dp[x][y] = w, true;
    return false;
}
void spfa() {
    while(!q.empty()) {
        int u = q.front();
        q.pop();
        int x = u/1000;
        int y = u%1000;
        inq[x][y] = 0;
        for(EDGE *p = head[x]; p; p = p->nxt) {
            if(update(p->v, y|s[p->v], dp[x][y] + p->w + cost[p->v]-cost[x]) && !s[p->v] && !inq[p->v][y])
                inq[p->v][y] = 1, q.push(p->v*1000 + y);
        }
    }
}
void solve() {
    REP(i, n+m) scanf("%d", &cost[i]);
    REP(i, n)
    s[i] = 1<<i, dp[i][s[i]] = cost[i];
    REP(i, p) {
        int u, v, w;
        scanf("%d%d%d", &u, &v, &w);
        addedge(u, v, w);
        addedge(v, u, w);
    }
    REP(state, L) {
        REP(i, n+m) {
            if(s[i] && !(s[i] & state))
                continue;
            for(int st = state; st; st = (st-1)&state) {
                dp[i][state] = min(dp[i][state], dp[i][st|s[i]] + dp[i][(state-st)|s[i]] - cost[i]);
            }
            if(dp[i][state] < inf)
                inq[i][state] = 1, q.push(i*1000 + state);
        }
        spfa();
    }
    d[0] = 0;
    REP(i, L)
    REP(j, n+m)
    d[i] = min(d[i], dp[j][i]);
    Rep(st, 1, L)
    for(int ss = (st-1)&st; ss; ss = (ss-1)&st)
        d[st] = min(d[st], d[ss] + d[st-ss]);
    cout<<d[L-1]<<endl;
}

int main() {
    
    while(scanf("%d%d%d", &n, &m, &p) == 3) {
        preprocess();
        solve();
    }
    return 0;
}

看了别人发现其实还有一种方法就是虚拟一个点，然后连一条cost[i]的边到n+m个点，最后对0,1,2...n这n+1个点求斯坦纳树，可是好像怎么写都不对，

先挖坑。。。