[POJ 3411]Paid Roads[BFS][状压]

题目链接： [POJ 3411]Paid Roads[BFS][状压]

题意分析：

求从点1到达点N的最少花费。点和边可重复经过。V1->V2的费用分为两种：1.如果通过了某点C，那么可以考虑花费P通过；2.否则只能考虑花费R通过。

解题思路：

考虑常规搜索，单单考虑标记节点的话，有些重复的点就不经过了。再考虑标记边，边就不能重复了，两者都不行。根本上说是缺失了可以比较的状态，导致无法肯定什么时候应该访问，什么时候不继续访问。

考虑多增加一维状态，为当前已经访问的节点，即有：dp[i][j]代表：到第i个点为止，已经走的点集为j，的最少花费。

然后分两种情况转移即可。

个人感受：

头一次以vis[i][j]作为i->j的标记，发现这样无法解决重边，而且边不能被访问多次，一直不知道该怎么办，队友说了状压后还是不明就里。。。。不过学习了

具体代码如下：

#include<algorithm>
#include<cctype>
#include<cmath>
#include<cstdio>
#include<cstring>
#include<iomanip>
#include<iostream>
#include<map>
#include<queue>
#include<set>
#include<sstream>
#include<stack>
#include<string>
#define pii pair<int, int>
#define pr(x) cout << #x << " = " << (x) << '\n';
using namespace std;

const int INF = 0x3f3f3f3f;
const int MAXN = 21;

int ans = INF, n;
bool vis[MAXN][1500];
int dp[MAXN][1500];

struct P {
    int to, w, c, p;
    P(int _to, int _w, int _c, int _p):to(_to),w(_w),c(_c),p(_p){};
};
vector<P> G[MAXN];

int main()
{
    int m, a, b, c, p, r;
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= m; ++i) {
        scanf("%d%d%d%d%d", &a, &b, &c, &p, &r);
        G[a].push_back(P(b, r, c, p));
    }

    memset(dp, 0x3f, sizeof dp);
    memset(vis, 0, sizeof vis);
    dp[1][1] = 0;
    vis[1][1] = 1;
    queue<pii> q;
    q.push(pii(1, 1));
    while (q.size()) {
        pii cur = q.front(); q.pop();
        int u = cur.first, sta = cur.second;
        vis[u][sta] = 0;
        for (int i = 0; i < G[u].size(); ++i) {
            int v = G[u][i].to;
            int nxs = sta | (1 << (v - 1));
            if ((sta & (1 << (G[u][i].c - 1))) && dp[v][nxs] > dp[u][sta] + G[u][i].p) {
                dp[v][nxs] = dp[u][sta] + G[u][i].p;
                if (!vis[v][nxs]) {
                    q.push(pii(v, nxs));
                    vis[v][nxs] = 1;
                }
            }
            if (dp[v][nxs] > dp[u][sta] + G[u][i].w) {
                dp[v][nxs] = dp[u][sta] + G[u][i].w;
                if (!vis[v][nxs]) {
                    q.push(pii(v, nxs));
                    vis[v][nxs] = 1;
                }
            }
        }
    }

    for (int i = 1; i < (1 << n); ++i) ans = min(ans, dp[n][i]);
    if (ans == INF) printf("impossible\n");
    else printf("%d\n", ans);
    return 0;
}