poj3411

---

题目描述：

经过一条路有代价，但是多少取决于之前是否经过一个点，求1到n最小花费。

题解：

首先到达某一个点,还需要状压一个以前走过什么点.其次,因为要走回头,因此更新的时候不能普通的扫sta,然后走,因为不知道重复的到底有没有必要走,不好.所以用松弛的spfa,把sta和v当做一个统一放到队列里面,然后spfa的dp,直到队列为空.

重点：

图论会走回头路,因此用spfa上的dp

代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <ctype.h>
#include <limits.h>
#include <cstdlib>
#include <algorithm>
#include <vector>
#include <queue>
#include <map>
#include <stack>
#include <set>
#include <bitset>
#define CLR(a) memset(a, 0, sizeof(a))
#define REP(i, a, b) for(int i = a;i < b;i++)
#define REP_D(i, a, b) for(int i = a;i <= b;i++)
typedef long long ll;

using namespace std;

struct q_element
{
    int sta, last;
};
struct next_list
{
    int c, to, shao, duo;
    next_list(int to, int c, int shao, int duo)
    {
        this->to = to;
        this->c = c;
        this->shao = shao;
        this->duo = duo;
    }
};
vector<next_list> G[20];
const int max_key = (1<<10) + 100;
const int INF = INT_MAX/2 - 1;
int n, m;
int key;
int dp[max_key][20], in_q[max_key][20];

void get_dp()
{
    REP_D(i, 0, key)
    {
        REP(j, 0, n)
        {
            dp[i][j] = INF;
        }
    }
    dp[1][0] = 0;
    CLR(in_q);
    in_q[1][0] = 1;
    queue<q_element> my_q;
    q_element temp;
    temp.last = 0;
    temp.sta = 1;
    my_q.push(temp);
    while(!my_q.empty())
    {
        int s = my_q.front().sta;
        int lll = my_q.front().last;
        my_q.pop();
        in_q[s][lll] = 0;
        REP(i, 0, G[lll].size())
        {
            int v_c = G[lll][i].c, v_to = G[lll][i].to, v_shao = G[lll][i].shao, v_duo = G[lll][i].duo;
            if(((1<<v_c)&s) == 0)
            {
                if(dp[s|(1<<v_to)][v_to] > dp[s][lll] + v_duo)
                {
                    dp[s|(1<<v_to)][v_to] = dp[s][lll] + v_duo;
                    if(!in_q[s|(1<<v_to)][v_to])
                       {
                           temp.last = v_to;
                           temp.sta = (s|(1<<v_to));
                           my_q.push(temp);
                           in_q[s|(1<<v_to)][v_to] = 1;
                       }
                }
            }
            else
            {
                if(dp[s|(1<<v_to)][v_to] > dp[s][lll] + v_shao)
                {
                    dp[s|(1<<v_to)][v_to] = dp[s][lll] + v_shao;
                    if(!in_q[s|(1<<v_to)][v_to])
                       {
                           temp.last = v_to;
                           temp.sta = (s|(1<<v_to));
                           my_q.push(temp);
                           in_q[s|(1<<v_to)][v_to] = 1;
                       }
                }
            }
        }
    }
}

void solve()
{
    key = (1<<n) - 1;
    REP(i, 0, n)
    {
        G[i].clear();
    }
    REP(i, 0, m)
    {
        int a, b,  c,  p, r;
        scanf("%d%d%d%d%d", &a, &b, &c, &p, &r);
        G[a - 1].push_back(next_list(b - 1, c - 1, p, r));
    }
    get_dp();
    int ans = INF;
    REP_D(i, 0, key)
    {
        if((1&i) && ((1<<n - 1) &i))
            ans = min(ans, dp[i][n - 1]);
    }
    if(ans != INF)
        printf("%d\n", ans);
    else
        printf("impossible\n");
}
int main()
{
    //freopen("4Din.txt", "r", stdin);
    //freopen("4Dout.txt", "w", stdout);
    while(scanf("%d%d", &n, &m) != EOF)
    {
        solve();
    }
    return 0;
}