hdu4085 Peach Blossom Spring

看题表示不会，百度后发现是斯坦纳树，又没见过...

大致是状态DP通过枚举子树或者最短路来状态转移

若两种状态集合没有交集，则可以直接合并   

                    dp[ i ][ j ]=min{ dp[ i ][ j ]，dp[ i ][ k ]+dp[ i ][ l ] }，其中k和l是j的两个互补的子集

若i和i'之间有边相连, 那么可以通过spfa的三角不等式进行状态转移 

                    dp[ i ][ j ]=min{ dp[ i ][ j ]，dp[ i' ][ j ]+w[ i ][ i' ] }

其实还是不很明白      不过有篇写的不错的博客，值得一看                 点击打开链接

//#pragma warning (disable: 4786)
//#pragma comment (linker, "/STACK:16777216")
//HEAD
#include <cstdio>
#include <ctime>
#include <cstdlib>
#include <cstring>
#include <queue>
#include <string>
#include <set>
#include <stack>
#include <map>
#include <cmath>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
//LOOP
#define FF(i, a, b) for(int i = (a); i < (b); ++i)
#define FE(i, a, b) for(int i = (a); i <= (b); ++i)
#define FED(i, b, a) for(int i = (b); i>= (a); --i)
#define REP(i, N) for(int i = 0; i < (N); ++i)
#define CLR(A,value) memset(A,value,sizeof(A))
//STL
#define SZ(V) (int)V.size()
#define PB push_back
//INPUT
#define RI(n) scanf("%d", &n)
#define RII(n, m) scanf("%d%d", &n, &m)
#define RIII(n, m, k) scanf("%d%d%d", &n, &m, &k)
#define RS(s) scanf("%s", s)
//OUTPUT
#define WI(n) printf("%d\n", n)
typedef long long LL;
typedef unsigned long long ULL;
typedef vector <int> VI;
const int INF = 0x3f3f3f3f;
const double eps = 1e-10;
const int maxn = 60;
const int Maxs = (1 << 10) + 10;

int n, m, k, st;
int mask[maxn], dp[Maxs], dis[maxn][Maxs];
bool inq[maxn][Maxs];
struct Edge{
    int u, v, w;
};
vector<Edge> edges;
VI G[maxn];
queue<int> Q;

void add(int u, int v, int w)
{
    edges.PB((Edge){u, v, w});
    edges.PB((Edge){v, u, w});
    int sz = edges.size();
    G[u].PB(sz - 2);
    G[v].PB(sz - 1);
}

void init()
{
    CLR(dp, 0x3f), CLR(dis, 0x3f);
    CLR(mask, 0), CLR(inq, 0);
    RIII(n, m, k);
    edges.clear();
    FE(i, 0, n + 1)   G[i].clear();
    st = 1 << 2 * k;
    REP(i, m)
    {
        int u, v, w;
        RIII(u, v, w);
        add(u, v, w);
    }
}

void spfa()
{
    while (!Q.empty())
    {
        int u = Q.front() / 10000, s0 = Q.front() % 10000;
        inq[u][s0] = 0;
        Q.pop();
        REP(i, SZ(G[u]))
        {
            Edge e = edges[G[u][i]];
            int v = e.v, ns = s0 | mask[e.v];
            if (dis[v][ns] > dis[u][s0] + e.w)
            {
                dis[v][ns] = dis[u][s0] + e.w;
                if (ns == s0 && !inq[v][ns])
                {
                    inq[v][ns] = 1;
                    Q.push(v * 10000 + ns);
                }
            }
        }
    }
}

bool check(int s)
{
    int a = 0;
    REP(i, k)
    {
        if (s & (1 << i))   a++;
        if (s & (1 << (k + i))) a--;
    }
    return a == 0;
}

void solve()
{
    FE(i, 1, k)
    {
        mask[i] = 1 << (i - 1), dis[i][mask[i]] = 0;
        mask[n - i + 1] = 1 << (k + i - 1), dis[n - i + 1][mask[n - i + 1]] = 0;
    }
    REP(s, st)
    {
        FE(i, 1, n)
        {
            for (int s0 = (s - 1) & s ; s0; s0 = (s0 - 1) & s)
                dis[i][s] = min(dis[i][s], dis[i][s0 | mask[i]]+dis[i][(s - s0) | mask[i]]);
            if (dis[i][s] < INF && !inq[i][s])
            {
                inq[i][s] = 1;
                Q.push(i * 10000 + s);
            }
        }
        spfa();
    }
    REP(s, st)
        FE(i, 1, n)
            dp[s] = min(dp[s], dis[i][s]);
    REP(s, st)
        if (check(s))
        {
            for (int s0 = s & (s - 1); s0; s0 = s & (s0 - 1))
                if (check(s0))
                    dp[s] = min(dp[s0] + dp[s - s0], dp[s]);
        }
    if (dp[st - 1] >= INF)
        puts("No solution");
    else
        WI(dp[st - 1]);
}

int main()
{
    int T;
    RI(T);
    while (T--)
    {
        init();
        solve();
    }
}