HDU 3001 Traveling

Travelling HDU - 3001

Description

    After coding so many days,Mr Acmer wants to have a good rest.So travelling is the best choice!He has decided to visit n cities(he insists on seeing all the cities!And he does not mind which city being his start station because superman can bring him to any city at first but only once.), and of course there are m roads here,following a fee as usual.But Mr Acmer gets bored so easily that he doesn’t want to visit a city more than twice!And he is so mean that he wants to minimize the total fee!He is lazy you see.So he turns to you for help.

Input

    There are several test cases,the first line is two intergers n(1<=n<=10) and m,which means he needs to visit n cities and there are m roads he can choose,then m lines follow,each line will include three intergers a,b and c(1<=a,b<=n),means there is a road between a and b and the cost is of course c.Input to the End Of File.

Output

    Output the minimum fee that he should pay,or -1 if he can’t find such a route.

Sample Input

2 1
1 2 100
3 2
1 2 40
2 3 50
3 3
1 2 3
1 3 4
2 3 10

Sample Output

100
90
7

---

About:

    给你 n 个点， 和 m 条边，经过边会有花费，且每个点可以经过两次，求走完每个点的最小花费。

Solution:

    开始我看快了，我以为每个点只能经过一次，调了好久。
    这道题的每个点可以经过 2 次，于是就会想到 3 进制的状压，于是我们想了一想，嗯，比较简单直接暴力扫就好了。于是我们只需要暴力扫每条边然后更新答案就好了。主要是为了练一练 3 进制的状压，当然尝试了后发现， 你用数组存 3 进制要好很多。毕竟其他的并不好调。
    哦，还有，傻逼的我开始求最终答案时是从数位都为 1， 遍历到数位都为 2 的所有情况，后来才反应过来，这样是错的，因为你不能保证其中的状态满足每位都有， 比如 $(111111)_3 \le (202020)_3 \le (222222)_3$，看来我是真的弱。

Code:

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <string>
#include <algorithm>
#include <iostream>
#include <cmath>
#include <ctime>
#include <map>
#include <vector>
using namespace std;

inline int read() {
    int i = 0, f = 1;
    char ch = getchar();
    while(!isdigit(ch)) {
        if(ch == '-') f = -1; ch = getchar();
    }
    while(isdigit(ch)) {
        i = (i << 3) + (i << 1) + ch - '0'; ch = getchar();
    }
    return i * f;
}

int dp[15][60000], way[15][15], n, m;
int pow1[20], num[60000][15];


inline void init() {
    pow1[0] = 1;
    for(int i = 1; i <= 15; ++i) pow1[i] = pow1[i - 1] * 3;
    for(int i = 0; i < pow1[10]; ++i) {
        int now = i;
        for(int j = 0; j < 10; ++j) {
            num[i][j] = now % 3;
            now /= 3;
        }
    }
}

inline bool check(int k, int i) {
    if(num[k][i] >= 2) return false;
    return true;
}

inline bool exist(int k, int i) {
    if(num[k][i]) return true;
    return false;
}

inline void Input() {
    memset(way, 0x3f3f, sizeof(way));
    memset(dp, 0x3f3f, sizeof(dp));
    for (int i = 1; i <= m; ++i) {
        int x = read(), y = read(), w = read();
        way[x][y] = min(way[x][y], w);
        way[y][x] = min(way[y][x], w);
    }
}

int main() {

    init();

    while(scanf("%d%d", &n, &m) != EOF) {
        Input();
        int ans = 0x3f3f3f3f;
        int MAX = pow1[n] - 1; 
        for(int i = 1; i <= n; ++i) dp[i][pow1[i - 1]] = 0;

        for(int k = 0; k <= MAX; ++k) {
            int flag = 1;
            for(int i = 1; i <= n; ++i) {
                if(!exist(k, i - 1)) { flag = 0; continue; }
                for(int j = 1; j <= n; ++j) {
                    if(i != j && way[i][j] != 0x3f3f3f3f) {
                        if(check(k, j - 1))
                            dp[j][k + pow1[j - 1]] = min(dp[j][k + pow1[j - 1]], dp[i][k] + way[i][j]);
                    }
                }
            }
            if(flag)
                for(int j = 1; j <= n; ++j) 
                    ans = min(ans, dp[j][k]);
        } 
        if(ans == 0x3f3f3f3f) ans = -1;
        printf("%d\n", ans);
    }
}