POJ 3123 Ticket to Ride

题目链接：

http://poj.org/problem?id=3123

题意：

在n个城市间要建立四条铁路线，给定每条线路的起点和终点。

如果某两个城市之间可以建造铁路，那么建造这条铁路将有一定的花费。

求建立四条的最小总费用。

算法：

这道题还是斯坦纳树，以四条线路的起点和终点为关键点。

关键点中显然可能有重复的，不过不影响解题。

注意，最终要求的地图可能是由多颗斯坦纳树构成的，

但是必须保证同一条铁路的起点和终点在同一棵斯坦纳树上。

因此把所有包含某一条线路的起点和终点的状态找出来进行状压背包。

这道题我是让第一条铁路的起点代表第一位，终点代表第五位，以此类推。

这样最后枚举状态的时候比较方便。

代码：

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <sstream>
#include <cstdlib>
#include <cstring>
#include <string>
#include <climits>
#include <cmath>
#include <queue>
#include <vector>
#include <stack>
#include <set>
#include <map>
#define INF 0x3f3f3f3f
#define EPS 1e-8
using namespace std;

const int MAXN = 30;
map <string, int> hash;
queue <int> q;
bool inq[MAXN];
int hash1[MAXN];
int dp[1 << 8][MAXN];
int dis[MAXN][MAXN];
int num[MAXN];
int ans[1 << 4];

int main()
{
    int n, m;
    while (cin >> n >> m, n || m)
    {
        memset(dp, -1, sizeof(dp));
        memset(dis, -1, sizeof(dis));
        memset(ans, -1, sizeof(ans));
        memset(hash1, -1, sizeof(hash1));
        hash.clear();
        for (int i = 0; i < n; i ++)
        {
            string s;
            cin >> s;
            hash[s] = i;
            dis[i][i] = 0;
            dp[0][i] = 0;
        }
        while (m --)
        {
            string a, b;
            int c;
            cin >> a >> b >> c;
            int x = hash[a];
            int y = hash[b];
            dis[x][y] = dis[y][x] = dis[x][y] == -1 ? c : min(dis[x][y], c);
        }
        for (int i = 0; i < 8; i ++)
        {
            string s;
            cin >> s;
            hash1[hash[s]] = ((i & 1) << 2) | (i >> 1);
            dp[1 << hash1[hash[s]]][hash[s]] = 0;
            dp[0][hash[s]] = -1;
            num[hash1[hash[s]]] = hash[s];
        }
        for (int mask = 0; mask < 1 << 8; mask ++)
        {
            for(int i = 0; i < n; i ++)
            {
                if((hash1[i] != -1) && ! (mask >> hash1[i] & 1))
                {
                    continue;
                }
                for (int mask1 = (mask - 1) & mask; mask1; mask1 = (mask1 - 1) & mask)
                {
                    int mask2 = mask ^ mask1 | ((hash1[i] != -1) ? 1 << hash1[i] : 0);
                    if (dp[mask1][i] != -1 && dp[mask2][i] != -1)
                    {
                        dp[mask][i] = dp[mask][i] == -1 ? dp[mask2][i] + dp[mask1][i] : min(dp[mask][i], dp[mask2][i] + dp[mask1][i]);
                    }
                }
            }
            while(! q.empty())
            {
                q.pop();
            }
            for(int i = 0; i < n; i ++)
            {
                if(dp[mask][i] != -1)
                {
                    q.push(i);
                    inq[i] = true;
                }
                else
                {
                    inq[i] = false;
                }
            }
            while(! q.empty())
            {
                int u = q. front();
                q.pop();
                inq[u] = false;
                for (int v = 0; v < n; v ++)
                {
                    if(dis[u][v] != -1)
                    {
                        if(dp[mask][v] == - 1 || dp[mask][v] > dp[mask][u] + dis[u][v])
                        {
                            dp[mask][v] = dp[mask][u] + dis[u][v];
                            if(! inq[v])
                            {
                                q.push(v);
                                inq[v] = true;
                            }
                        }
                    }
                }
            }
        }
        for (int mask = 0; mask < 1 << 4; mask ++)
        {
            for (int i = 0; i < 4; i ++)
            {
                if (mask >> i & 1)
                {
                    ans[mask] = dp[mask << 4 | mask][num[i]];
                    break;
                }
            }
            for (int mask1 = (mask - 1) & mask; mask1; mask1 = (mask1 - 1) & mask)
            {
                int mask2 = mask ^ mask1;
                if (ans[mask1] != -1 && ans[mask2] != -1)
                {
                    ans[mask] = ans[mask] == -1 ? (ans[mask1] + ans[mask2]) : min(ans[mask], ans[mask1] + ans[mask2]);
                }
            }
        }
        printf("%d\n", ans[(1 << 4) - 1]);
    }
    return 0;
}