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();
}
}