HDU4370 O OR 1

http://acm.hdu.edu.cn/showproblem.php?pid=4370

//两种情况:

1.1、n有无自环的闭环

2.跑一遍spfa求d[n]即可

取两种情况最小值

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <queue>
using namespace std;
const int N = 305;
const int M = 90000;
const int INF = 0x3f3f3f3f;
typedef long long ll;
int n, Gra[N][N];
int d[N], vis[N], en;
int head[M];
struct node {  
    int to, dis, next;  
}edge[M];  
void addEdge(int u,int v,int x) {  
    edge[en].to = v;  
    edge[en].next = head[u];  
    edge[en].dis = x;  
    head[u] = en++;  
}  //连接表存储;
void SPFA(int s) {  
    queue<int> Q;   
    for (int i = 0; i <= n; i++) d[i] = INF;//初始化无穷;
    for (int i = head[s]; i != -1; i = edge[i].next) {
        int v = edge[i].to; //到达的点;
        if (v == s) continue;
        d[v] = edge[i].dis;//到达它的距离;
        Q.push(v);//入队;
        vis[v] = 1;//标记;
    }
    while(!Q.empty()) {  
        int u = Q.front();
        Q.pop();  
        vis[u] = 0;  
        for(int i = head[u]; i != -1; i = edge[i].next) {  
            int v = edge[i].to;  
            if(d[u] + edge[i].dis < d[v]) {  
                d[v] = d[u] + edge[i].dis;  
                if(!vis[v]) {  
                    Q.push(v);  
                    vis[v] = 1;  
                }  
            }  
        }  
    }  
} 

void init() {
    en = 0;
    for (int i = 0; i <= n; i++) {
        vis[i] = 0; 
        head[i] = -1;
    }
}

void input() {
    int a;
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            scanf("%d", &a);
            addEdge(i, j, a);
        }   //矩阵;
    }
}
void solve() {
    SPFA(1);    //先从1跑一遍
    int ans = d[n], temp1 = d[1];
    SPFA(n);//再从n点跑一遍,看非自环的闭环;
    int temp2 = d[n];
    printf("%d\n", min(ans, temp1 + temp2));
}

int main() {
    while (scanf("%d", &n) != EOF) {
        init();
        input();
        solve();
    }
    return 0;
}

dir做法:

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 5;
const int INF = 0x3f3f3f3f;
 
struct Edge
{
    int from, to, dist;
    Edge(int u, int v, int w): from(u), to(v), dist(w) {}
};
 
struct Dijkstra
{
    int n, m;
    vector<Edge> edges;
    vector<int> G[MAXN];
    int d[MAXN];
    bool vis[MAXN];
    int pre[MAXN];
 
    void init(int n)
    {
        this->n = n;
        edges.clear();
        for (int i = 0; i <= n; i++) G[i].clear();
    }
 
    void add_edge(int from, int to, int dist)
    {
        edges.push_back(Edge(from, to, dist));
        m = edges.size();
        G[from].push_back(m - 1);
    }
 
    struct HeapNode
    {
        int from, dist;
        bool operator < (const HeapNode& rhs) const
        {
            return rhs.dist < dist;
        }
        HeapNode(int u, int w): from(u), dist(w) {}
    };
 
    void dijkstra(int s)
    {
        for (int i = 0; i <= n; i++) d[i] = INF;
        memset(vis, 0, sizeof(vis));
        bool flag = false;//更新最小环用
        d[s] = 0;
        priority_queue<HeapNode> Q;
        Q.push(HeapNode(s, d[s]));
        while (!Q.empty())
        {
            HeapNode x = Q.top(); Q.pop();
            int u = x.from;
            if (vis[u]) continue;
            vis[u] = true;
            for (int i = 0; i < G[u].size(); i++)
            {
                Edge& e = edges[G[u][i]];
                if (u != s && e.to == s && flag) d[s] = min(d[s], d[e.from] + e.dist);
                if (u != s && e.to == s && !flag) { flag = true; d[s] = d[e.from] + e.dist; }
                if (!vis[e.to] && d[e.to] > d[u] + e.dist)
                {
                    d[e.to] = d[u] + e.dist;
                    pre[e.to] = G[u][i];
                    Q.push(HeapNode(e.to, d[e.to]));
                }
            }
        }
    }
};
Dijkstra solve;
int main()
{
    int n;
    while (~scanf("%d", &n))
    {
        solve.init(n);
        for (int i = 1; i <= n; i++)
        {
            for (int j = 1; j <= n; j++)
            {
                int t; scanf("%d", &t);
                solve.add_edge(i, j, t);
            }
        }
        solve.dijkstra(1);
        int ans = solve.d[n], loop1 = solve.d[1];
        solve.dijkstra(n);
        int loopn = solve.d[n];
        ans = min(ans, loop1 + loopn);//1~n的最短路和（1的最小环花费 + n的最小环花费）
        printf("%d\n", ans);
    }
    return 0;
}
/*
4
1 2 4 10
2 0 1 1
2 2 0 5
6 3 1 2
*/