最短路问题专题

最新推荐文章于 2022-10-22 23:54:12 发布
最新推荐文章于 2022-10-22 23:54:12 发布
阅读量774 收藏
点赞数
分类专栏： # 系列 最短路
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nike0good/article/details/51038988
版权

Dijkstra

UVA 11374 Airport Express

n点m边的无向图，额外给k条边，走这k条边需要票（你只有一张），求s->t最短路，
n≤500,m≤1000,k≤1000

先求从源汇点出发的最短路，枚举k条边，
ans=min(f1(a)+w(a,b)+f2(b)) 

#include<bits/stdc++.h>
using namespace std;
#define For(i,n) for(int i=1;i<=n;i++)
#define Fork(i,k,n) for(int i=k;i<=n;i++)
#define Rep(i,n) for(int i=0;i<n;i++)
#define ForD(i,n) for(int i=n;i;i--)
#define ForkD(i,k,n) for(int i=n;i>=k;i--)
#define RepD(i,n) for(int i=n;i>=0;i--)
#define Forp(x) for(int p=Pre[x];p;p=Next[p])
#define Forpiter(x) for(int &p=iter[x];p;p=Next[p])  
#define Lson (o<<1)
#define Rson ((o<<1)+1)
#define MEM(a) memset(a,0,sizeof(a));
#define MEMI(a) memset(a,127,sizeof(a));
#define MEMi(a) memset(a,128,sizeof(a));
#define INF (2139062143)
#define F (100000007)
#define pb push_back
#define mp make_pair 
#define fi first
#define se second
#define vi vector<int> 
#define pi pair<int,int>
#define SI(a) ((a).size())
#define Pr(kcase,ans) printf("Case %d: %lld\n",kcase,ans);
#define PRi(a,n) For(i,n-1) cout<<a[i]<<' '; cout<<a[n]<<endl;
#define PRi2D(a,n,m) For(i,n) { \
                        For(j,m-1) cout<<a[i][j]<<' ';\
                        cout<<a[i][m]<<endl; \
                        } 
typedef long long ll;
typedef unsigned long long ull;
ll mul(ll a,ll b){return (a*b)%F;}
ll add(ll a,ll b){return (a+b)%F;}
ll sub(ll a,ll b){return (a-b+llabs(a-b)/F*F+F)%F;}
void upd(ll &a,ll b){a=(a%F+b%F)%F;}
int read()
{
    int x=0,f=1; char ch=getchar();
    while(!isdigit(ch)) {if (ch=='-') f=-1; ch=getchar();}
    while(isdigit(ch)) { x=x*10+ch-'0'; ch=getchar();}
    return x*f;
} 
struct Edge{
    int from,to,dist;
};
struct HeapNode {
    int d,u;
    bool operator< (const HeapNode& rhs) const {
        return d > rhs.d;
    }
}; 
#define MAXN (1000)
struct Dijkstra {
    int n,m;
    vector<Edge> edges;
    vector<int> G[MAXN];
    bool done[MAXN];
    int d[MAXN];
    int p[MAXN]; //最短路中上一条边
    int pnode[MAXN];
    void addedge(int u,int v,int w){
        edges.pb((Edge){u,v,w});
        G[u].pb(m++);
    }
    void addedge2(int u,int v,int w) {
        addedge(u,v,w);addedge(v,u,w);
    }
    void init(int _n){
        n=_n; m = 0;
        Rep(i,n) G[i].clear();
        edges.clear(); 
    } 
    void dijkstra(int s) {
        priority_queue<HeapNode> Q;
        Rep(i,n) d[i]=INF,pnode[i]=-1;
        d[s]=0;
        MEM(done)
        Q.push((HeapNode){0,s});
        while(!Q.empty()) {
            HeapNode x=Q.top(); Q.pop();
            int u=x.u;
            if (done[u]) continue;
            done[u]=1;
            int mm=G[u].size();
            Rep(i,mm) {
                Edge e = edges[G[u][i]];
                if (d[e.to]>d[u]+e.dist) {
                    d[e.to]=d[u]+e.dist;
                    p[e.to]=G[u][i];
                    pnode[e.to]=u;
                    Q.push((HeapNode){d[e.to],e.to});
                }
            }
        }
    } 
}S1;
int d1[MAXN],d2[MAXN],P1[MAXN],P2[MAXN];
int main()
{
//  freopen("uva11374.in","r",stdin);
//  freopen(".out","w",stdout);
    int n,S,T;
    bool flag=0;
    while(cin>>n>>S>>T) {
        if (flag) puts(""); flag=1; 
        S1.init(n);
        S--,T--;
        int m=read();
        For(i,m) {
            int x,y,z;
            cin>>x>>y>>z;
            S1.addedge2(x-1,y-1,z);
        }       
        S1.dijkstra(S);
        memcpy(d1,S1.d,sizeof(int)*n);
        memcpy(P1,S1.pnode,sizeof(int)*n);
        S1.dijkstra(T);
        memcpy(d2,S1.d,sizeof(int)*n);
        memcpy(P2,S1.pnode,sizeof(int)*n);
        int ans=d1[T],p=0,p2=0;

        m=read();
        For(i,m) {
            int x,y,z;
            cin>>x>>y>>z;
            x--,y--;
            if (d1[x]>d1[y]) swap(x,y);
            ll cost=(ll)d1[x]+d2[y]+z;
            if (cost < ans) {
                ans=cost; p = x+1; p2=y+1;
            }
        }

        vi v;
        if (!p) {
            v.pb(T);
            for(int u=P1[T];u!=-1;u=P1[u]) v.pb(u);
        }else {
            v.pb(p2-1);
            for(int u=P2[p2-1];u!=-1;u=P2[u]) v.pb(u);
            reverse(v.begin(),v.end());
            v.pb(p-1);
            for(int u=P1[p-1];u!=-1;u=P1[u]) v.pb(u);
        }
        int vs=SI(v);
        ForD(i,vs-1) cout<<v[i]+1<<' '; cout<<v[0]+1<<endl;     


        if (p) cout<<p<<endl; else puts("Ticket Not Used");
        cout<<ans<<endl;
    }



    return 0;
}

UVA 10917 Walk Through the Forest

gbn最近打算穿过一个森林，但是他比较傲娇，于是他决定只走一些特殊的道路，他打算只沿着满足如下条件的（A,B）道路走：存在一条从B出发回家的路，比所有从A出发回家的路径都短。你的任务是计算一共有多少条不同的回家路径。其中起点的编号为1，终点的编号为2.

预处理出最短路，转DAG，dp

#include<bits/stdc++.h>
using namespace std;
#define For(i,n) for(int i=1;i<=n;i++)
#define Fork(i,k,n) for(int i=k;i<=n;i++)
#define Rep(i,n) for(int i=0;i<n;i++)
#define ForD(i,n) for(int i=n;i;i--)
#define ForkD(i,k,n) for(int i=n;i>=k;i--)
#define RepD(i,n) for(int i=n;i>=0;i--)
#define Forp(x) for(int p=Pre[x];p;p=Next[p])
#define Forpiter(x) for(int &p=iter[x];p;p=Next[p])  
#define Lson (o<<1)
#define Rson ((o<<1)+1)
#define MEM(a) memset(a,0,sizeof(a));
#define MEMI(a) memset(a,127,sizeof(a));
#define MEMi(a) memset(a,128,sizeof(a));
#define INF (2139062143)
#define F (100000007)
#define pb push_back
#define mp make_pair 
#define fi first
#define se second
#define vi vector<int> 
#define pi pair<int,int>
#define SI(a) ((a).size())
#define Pr(kcase,ans) printf("Case %d: %lld\n",kcase,ans);
#define PRi(a,n) For(i,n-1) cout<<a[i]<<' '; cout<<a[n]<<endl;
#define PRi2D(a,n,m) For(i,n) { \
                        For(j,m-1) cout<<a[i][j]<<' ';\
                        cout<<a[i][m]<<endl; \
                        } 
typedef long long ll;
typedef unsigned long long ull;
ll mul(ll a,ll b){return (a*b)%F;}
ll add(ll a,ll b){return (a+b)%F;}
ll sub(ll a,ll b){return (a-b+llabs(a-b)/F*F+F)%F;}
void upd(ll &a,ll b){a=(a%F+b%F)%F;}
int read()
{
    int x=0,f=1; char ch=getchar();
    while(!isdigit(ch)) {if (ch=='-') f=-1; ch=getchar();}
    while(isdigit(ch)) { x=x*10+ch-'0'; ch=getchar();}
    return x*f;
} 
struct Edge{
    int from,to,dist;
};
struct HeapNode {
    int d,u;
    bool operator< (const HeapNode& rhs) const {
        return d > rhs.d;
    }
}; 
#define MAXN (1010)
struct Dijkstra {
    int n,m;
    vector<Edge> edges;
    vector<int> G[MAXN];
    bool done[MAXN];
    int d[MAXN];
    int p[MAXN]; //最短路中上一条边
    int pnode[MAXN];
    void addedge(int u,int v,int w){
        edges.pb((Edge){u,v,w});
        G[u].pb(m++);
    }
    void addedge2(int u,int v,int w) {
        addedge(u,v,w);addedge(v,u,w);
    }
    void init(int _n){
        n=_n; m = 0;
        Rep(i,n) G[i].clear();
        edges.clear(); 
    } 
    void dijkstra(int s) {
        priority_queue<HeapNode> Q;
        Rep(i,n) d[i]=INF,pnode[i]=-1;
        d[s]=0;
        MEM(done)
        Q.push((HeapNode){0,s});
        while(!Q.empty()) {
            HeapNode x=Q.top(); Q.pop();
            int u=x.u;
            if (done[u]) continue;
            done[u]=1;
            int mm=G[u].size();
            Rep(i,mm) {
                Edge e = edges[G[u][i]];
                if (d[e.to]>d[u]+e.dist) {
                    d[e.to]=d[u]+e.dist;
                    p[e.to]=G[u][i];
                    pnode[e.to]=u;
                    Q.push((HeapNode){d[e.to],e.to});
                }
            }
        }
    } 
}S1;
int n,m;
vi G[MAXN];
int indegree[MAXN];
namespace topsort{
    int b[MAXN];
    int q[MAXN*4];
    int topsort()    
    {   
        MEM(b) b[0]=1;
        int head_=1,tail=0;
        Rep(i,n)  
            if (indegree[i]==0)     
            {    
                q[++tail]=i;   
            }    

        while (head_<=tail)    
        {    
            int now=q[head_];    
            int m=SI(G[now]); 
            Rep(i,m) {
                int v=G[now][i];
                indegree[v]--;    b[v]+=b[now]; 
                if (indegree[v]==0)    
                {    
                    q[++tail]=v;   
                }                                       
            }
            head_++;    
        }         
        return b[1];
    }    

}
int main()
{
//  freopen("uva10917.in","r",stdin);
//  freopen(".out","w",stdout);

    while(cin>>n &&n) {
        m=read();
        S1.init(n);
        Rep(i,m) {
            int a=read()-1,b=read()-1;
            S1.addedge2(a,b,read()); 
        } 
        S1.dijkstra(1);


        Rep(i,n) indegree[i]=0,G[i].clear(); 
        Rep(k,m) {
            int i=S1.edges[k*2].from,j=S1.edges[k*2].to;
            if (S1.d[i]>S1.d[j]) G[i].pb(j),indegree[j]++;
            else if (S1.d[i]<S1.d[j]) G[j].pb(i),indegree[i]++; 
        } 
        cout<<topsort::topsort()<<endl;
    }
    return 0;
}

LA 4080 Warfare

给一张n点m边的无向带边权图，你需要删一条边，
使 ∑i∑jdis(i,j) 最小

枚举起点，枚举删的边，跑dijkstra，复杂度 O(nm2logn)
对于某个起点i，删的边只有在最短路树上才会改变 ∑jdis(i,j) ，所以复杂度降到 O(n2mlogn) 

#include<bits/stdc++.h>
using namespace std;
#define For(i,n) for(int i=1;i<=n;i++)
#define Fork(i,k,n) for(int i=k;i<=n;i++)
#define Rep(i,n) for(int i=0;i<n;i++)
#define ForD(i,n) for(int i=n;i;i--)
#define ForkD(i,k,n) for(int i=n;i>=k;i--)
#define RepD(i,n) for(int i=n;i>=0;i--)
#define Forp(x) for(int p=Pre[x];p;p=Next[p])
#define Forpiter(x) for(int &p=iter[x];p;p=Next[p])  
#define Lson (o<<1)
#define Rson ((o<<1)+1)
#define MEM(a) memset(a,0,sizeof(a));
#define MEMI(a) memset(a,127,sizeof(a));
#define MEMi(a) memset(a,128,sizeof(a));
#define INF (0x3f3f3f3f3f3f3f3f)
#define F (100000007)
#define pb push_back
#define mp make_pair 
#define fi first
#define se second
#define vi vector<int> 
#define pi pair<int,int>
#define SI(a) ((a).size())
#define Pr(kcase,ans) printf("Case %d: %lld\n",kcase,ans);
#define PRi(a,n) For(i,n-1) cout<<a[i]<<' '; cout<<a[n]<<endl;
#define PRi2D(a,n,m) For(i,n) { \
                        For(j,m-1) cout<<a[i][j]<<' ';\
                        cout<<a[i][m]<<endl; \
                        } 
typedef long long ll;
typedef unsigned long long ull;
ll mul(ll a,ll b){return (a*b)%F;}
ll add(ll a,ll b){return (a+b)%F;}
ll sub(ll a,ll b){return (a-b+llabs(a-b)/F*F+F)%F;}
void upd(ll &a,ll b){a=(a%F+b%F)%F;}
int read()
{
    int x=0,f=1; char ch=getchar();
    while(!isdigit(ch)) {if (ch=='-') f=-1; ch=getchar();}
    while(isdigit(ch)) { x=x*10+ch-'0'; ch=getchar();}
    return x*f;
}
int n,m,L;

struct Edge{
    int from,to,dist;
};
struct HeapNode {
    int d,u;
    bool operator< (const HeapNode& rhs) const {
        return d > rhs.d;
    }
}; 
#define MAXN (100+10)
#define MAXM (2000+10)
struct Dijkstra {
    int n,m;
    vector<Edge> edges;
    vector<int> G[MAXN];
    bool done[MAXN];
    ll d[MAXN];
    int p[MAXN]; //最短路中上一条边
    int pnode[MAXN];
    void addedge(int u,int v,int w){
        edges.pb((Edge){u,v,w});
        G[u].pb(m++);
    }
    void addedge2(int u,int v,int w) {
        addedge(u,v,w);addedge(v,u,w);
    }
    void init(int _n){
        n=_n; m = 0;
        Rep(i,n) G[i].clear();
        edges.clear(); 
    }  
    ll dijkstra(int s,int E = -1 ) {
        priority_queue<HeapNode> Q;
        Rep(i,n) d[i]=INF,pnode[i]=-1,p[i]=-1;
        d[s]=0;
        MEM(done)
        Q.push((HeapNode){0,s});
        while(!Q.empty()) {
            HeapNode x=Q.top(); Q.pop();
            int u=x.u;
            if (done[u]) continue;
            done[u]=1;
            int mm=G[u].size();
            Rep(i,mm) {
                if (E!=-1&&E/2==G[u][i]/2) continue;
                Edge e = edges[G[u][i]];
                if (d[e.to]>d[u]+e.dist) {
                    d[e.to]=d[u]+e.dist;
                    p[e.to]=G[u][i];
                    pnode[e.to]=u;
                    Q.push((HeapNode){d[e.to],e.to});
                }
            }
        }
        ll ans=0;
        Rep(i,n) ans+=(INF == d[i] ) ? L : d[i] ;
        return ans;

    } 
    ll T[MAXM]; // the cost if delete ith edge
    int p2[MAXN]; //最短路中上一条边

    void calc(int s){ //only consider started at Point s
        ll c=dijkstra(s);
        Rep(i,m+1) T[i]+=c; 
        memcpy(p2,p,sizeof(int)*n);
        Rep(i,n) if (p2[i]!=-1) {
            T[p2[i]|1]+= dijkstra(s,p2[i])-c;
        } 
    }
    void solve(){
        MEM(T)
        Rep(i,n) calc(i);
        ll ans=T[0];
        Rep(i,m) ans=max(ans,T[i]);
        cout<<T[m]<<' '<<ans<<endl;     
    }
}S1;
int main()
{
//  freopen("uva1416.in","r",stdin);
//  freopen(".out","w",stdout);
    while(cin>>n>>m>>L) {
        S1.init(n);
        Rep(i,m) {
            int a=read()-1,b=read()-1;
            S1.addedge2(a,b,read());
        }
        S1.solve();
    }   
    return 0;
}

UVA 10537 The Toll! Revisited

从s到t，每次经过一个村庄要缴纳1个单位的货物，经过一个城镇时，每20个货物就要缴纳一个（不足向上取整），求字典序最小的最少花费路径。

从终点向起点走Dijkstra。

#include<bits/stdc++.h>
using namespace std;
#define For(i,n) for(int i=1;i<=n;i++)
#define Fork(i,k,n) for(int i=k;i<=n;i++)
#define Rep(i,n) for(int i=0;i<n;i++)
#define ForD(i,n) for(int i=n;i;i--)
#define ForkD(i,k,n) for(int i=n;i>=k;i--)
#define RepD(i,n) for(int i=n;i>=0;i--)
#define Forp(x) for(int p=Pre[x];p;p=Next[p])
#define Forpiter(x) for(int &p=iter[x];p;p=Next[p])  
#define Lson (o<<1)
#define Rson ((o<<1)+1)
#define MEM(a) memset(a,0,sizeof(a));
#define MEMI(a) memset(a,127,sizeof(a));
#define MEMi(a) memset(a,128,sizeof(a));
#define INF (0x3f3f3f3f3f3f3f3f)
#define F (100000007)
#define pb push_back
#define mp make_pair 
#define fi first
#define se second
#define vi vector<int> 
#define pi pair<int,int>
#define SI(a) ((a).size())
#define Pr(kcase,ans) printf("Case %d: %lld\n",kcase,ans);
#define PRi(a,n) For(i,n-1) cout<<a[i]<<' '; cout<<a[n]<<endl;
#define PRi2D(a,n,m) For(i,n) { \
                        For(j,m-1) cout<<a[i][j]<<' ';\
                        cout<<a[i][m]<<endl; \
                        } 
typedef long long ll;
typedef unsigned long long ull;
ll mul(ll a,ll b){return (a*b)%F;}
ll add(ll a,ll b){return (a+b)%F;}
ll sub(ll a,ll b){return (a-b+llabs(a-b)/F*F+F)%F;}
void upd(ll &a,ll b){a=(a%F+b%F)%F;}
int read()
{
    int x=0,f=1; char ch=getchar();
    while(!isdigit(ch)) {if (ch=='-') f=-1; ch=getchar();}
    while(isdigit(ch)) { x=x*10+ch-'0'; ch=getchar();}
    return x*f;
} 
int n,h[1000];
char h2[1000];
void prework(){
    Fork(i,'a','z') h[i]=i-'a',h2[i-'a']=i;
    Fork(i,'A','Z') h[i]=i-'A'+26,h2[i-'A'+26]=i;
} 
struct Edge{
    int from,to,dist;
};
struct HeapNode {
    int d,u;
    bool operator< (const HeapNode& rhs) const {
        return d > rhs.d;
    }
}; 
#define MAXN (100)
struct Dijkstra {
    int n,m;
    vector<Edge> edges;
    vector<int> G[MAXN];
    bool done[MAXN];
    ll d[MAXN];
    int p[MAXN]; //最短路中上一条边
    int pnode[MAXN];
    void addedge(int u,int v,int w){
        edges.pb((Edge){u,v,w});
        G[u].pb(m++);
    }
    void addedge2(int u,int v,int w) {
        addedge(u,v,w);addedge(v,u,w);
    }
    void init(int _n){
        n=_n; m = 0;
        Rep(i,n) G[i].clear();
        edges.clear(); 
    } 
    void dijkstra(int s,ll w) {
        priority_queue<HeapNode> Q;
        Rep(i,n) d[i]=INF,pnode[i]=-1;
        d[s]=w;
        MEM(done)
        Q.push((HeapNode){0,s});
        while(!Q.empty()) {
            HeapNode x=Q.top(); Q.pop();
            int u=x.u;
            if (done[u]) continue;
            done[u]=1;
            int mm=G[u].size();
            Rep(i,mm) {
                Edge e = edges[G[u][i]];
                if (e.from<26) e.dist=1;
                else {
                    e.dist=d[u]/19;
                    while((d[u]+e.dist)-ceil(((double)d[u]+e.dist)/20)<d[u]) ++e.dist;
                }
                if (d[e.to]>d[u]+e.dist|| (d[e.to]==d[u]+e.dist&&h2[pnode[e.to]]>h2[u]) ) {
                    d[e.to]=d[u]+e.dist;
                    p[e.to]=G[u][i];
                    pnode[e.to]=u;
                    Q.push((HeapNode){d[e.to],e.to});
                }
            }
        }
    } 
}S1;
int main()
{
//  freopen("uva10537.in","r",stdin);
//  freopen(".out","w",stdout);
    prework();
    int kcase=1;
    while(cin>>n && n!=-1) {
         S1.init(26*2);
         For(i,n) {
            char a[2],b[2];
            cin>>a>>b;
            S1.addedge2(h[a[0]],h[b[0]],0);
         }
         ll w;
         char st[2],ed[2];
         cin>>w>>st>>ed;
         printf("Case %d:\n",kcase++);
         S1.dijkstra(h[ed[0]],w);
         printf("%lld\n",S1.d[h[st[0]]]);
         int u;
         for(u=h[st[0]];S1.pnode[u]!=-1;u=S1.pnode[u]) printf("%c-",h2[u]); 
         cout<<h2[u]<<endl; 
    } 
    return 0;
}

Bellman-Ford

UVA 11090 Going in Cycle!!

给定一个n点m边带正权有向图，求平均权值最小的回路，无解输’No cycle found’

二分求解，注意无解当且仅当图中无环

#include<bits/stdc++.h>
using namespace std;
#define For(i,n) for(int i=1;i<=n;i++)
#define Fork(i,k,n) for(int i=k;i<=n;i++)
#define Rep(i,n) for(int i=0;i<n;i++)
#define ForD(i,n) for(int i=n;i;i--)
#define ForkD(i,k,n) for(int i=n;i>=k;i--)
#define RepD(i,n) for(int i=n;i>=0;i--)
#define Forp(x) for(int p=Pre[x];p;p=Next[p])
#define Forpiter(x) for(int &p=iter[x];p;p=Next[p])  
#define Lson (o<<1)
#define Rson ((o<<1)+1)
#define MEM(a) memset(a,0,sizeof(a));
#define MEMI(a) memset(a,127,sizeof(a));
#define MEMi(a) memset(a,128,sizeof(a));
#define INF (2139062143)
#define F (100000007)
#define pb push_back
#define mp make_pair 
#define fi first
#define se second
#define vi vector<int> 
#define pi pair<int,int>
#define SI(a) ((a).size())
#define Pr(kcase,ans) printf("Case %d: %lld\n",kcase,ans);
#define PRi(a,n) For(i,n-1) cout<<a[i]<<' '; cout<<a[n]<<endl;
#define PRi2D(a,n,m) For(i,n) { \
                        For(j,m-1) cout<<a[i][j]<<' ';\
                        cout<<a[i][m]<<endl; \
                        } 
typedef long long ll;
typedef unsigned long long ull;
ll mul(ll a,ll b){return (a*b)%F;}
ll add(ll a,ll b){return (a+b)%F;}
ll sub(ll a,ll b){return (a-b+llabs(a-b)/F*F+F)%F;}
void upd(ll &a,ll b){a=(a%F+b%F)%F;}
int read()
{
    int x=0,f=1; char ch=getchar();
    while(!isdigit(ch)) {if (ch=='-') f=-1; ch=getchar();}
    while(isdigit(ch)) { x=x*10+ch-'0'; ch=getchar();}
    return x*f;
} 
int n,m;
struct Edge{
    int from,to;
    double dist;
};
#define MAXN (1000)
struct BellmanFord {
    int n,m;
    vector<Edge> edges;
    vi G[MAXN];
    bool inq[MAXN];
    double d[MAXN];
    int cnt[MAXN],p[MAXN];
    void addedge(int u,int v,int w){
        edges.pb((Edge){u,v,w});
        G[u].pb(m++);
    }
    void addedge2(int u,int v,int w) {
        addedge(u,v,w);addedge(v,u,w);
    }
    void init(int _n){
        n=_n; m = 0;
        Rep(i,n) G[i].clear();
        edges.clear(); 
    } 
    bool negativeCycle() {
        queue<int> Q;
        MEM(inq) MEM(cnt)
        Rep(i,n) d[i]=0,inq[i]=1,Q.push(i);
        while(!Q.empty()) {
            int u = Q.front(); Q.pop();
            inq[u] = 0;
            int mm=G[u].size();
            Rep(i,mm) {
                Edge e = edges[G[u][i]];
                if (d[e.to]>d[u]+e.dist ) {
                    d[e.to]=d[u]+e.dist;
                    p[e.to]=G[u][i];

                    if (!inq[e.to]) {
                        Q.push(e.to);
                        inq[e.to]=1;
                        if (++cnt[e.to]>n) return 1;
                    }
                }
            } 
        } 
        return 0;
    }

    bool check(double x) {
        Rep(i,m) edges[i].dist -=x;
        bool ret = negativeCycle();
        Rep(i,m) edges[i].dist +=x;
        return ret;
    }

}S1;

int main()
{
//  freopen("uva11090.in","r",stdin);
//  freopen(".out","w",stdout);

    int T=read();
    For(kcase,T) {
        cin>>n>>m;
        S1.init(n);
        For(i,m) {
            int a=read()-1,b=read()-1;
            S1.addedge(a,b,read());
        }
        double L = 0 , R = 10000000;
        printf("Case #%d: ",kcase);
        if (!S1.check(R+1)) {
            puts("No cycle found."); 
            continue;
        } 
        while(R-L>1e-3) {
            double m= (L+R)/2;
            if (S1.check(m)) R=m; else L=m; 
        } 
        printf("%.2lf\n",R);

    } 

    return 0;
}

UVA 11478 Halum

已知带权有向图，每次可以选一个结点v和整数d，把终点为v的边的权值减d,起点为v的边的权值加d，求让所有边权的最小值非负且尽量大。

设节点v上的d为sum_v
则， wa,b−x<=db−da 

#include<bits/stdc++.h>
using namespace std;
#define For(i,n) for(int i=1;i<=n;i++)
#define Fork(i,k,n) for(int i=k;i<=n;i++)
#define Rep(i,n) for(int i=0;i<n;i++)
#define ForD(i,n) for(int i=n;i;i--)
#define ForkD(i,k,n) for(int i=n;i>=k;i--)
#define RepD(i,n) for(int i=n;i>=0;i--)
#define Forp(x) for(int p=Pre[x];p;p=Next[p])
#define Forpiter(x) for(int &p=iter[x];p;p=Next[p])  
#define Lson (o<<1)
#define Rson ((o<<1)+1)
#define MEM(a) memset(a,0,sizeof(a));
#define MEMI(a) memset(a,127,sizeof(a));
#define MEMi(a) memset(a,128,sizeof(a));
#define INF (2139062143)
#define F (100000007)
#define pb push_back
#define mp make_pair 
#define fi first
#define se second
#define vi vector<int> 
#define pi pair<int,int>
#define SI(a) ((a).size())
#define Pr(kcase,ans) printf("Case %d: %lld\n",kcase,ans);
#define PRi(a,n) For(i,n-1) cout<<a[i]<<' '; cout<<a[n]<<endl;
#define PRi2D(a,n,m) For(i,n) { \
                        For(j,m-1) cout<<a[i][j]<<' ';\
                        cout<<a[i][m]<<endl; \
                        } 
typedef long long ll;
typedef unsigned long long ull;
ll mul(ll a,ll b){return (a*b)%F;}
ll add(ll a,ll b){return (a+b)%F;}
ll sub(ll a,ll b){return (a-b+llabs(a-b)/F*F+F)%F;}
void upd(ll &a,ll b){a=(a%F+b%F)%F;}
int read()
{
    int x=0,f=1; char ch=getchar();
    while(!isdigit(ch)) {if (ch=='-') f=-1; ch=getchar();}
    while(isdigit(ch)) { x=x*10+ch-'0'; ch=getchar();}
    return x*f;
} 
int n,m;
struct Edge{
    int from,to;
    double dist;
};
#define MAXN (520)
struct BellmanFord {
    int n,m;
    vector<Edge> edges;
    vi G[MAXN];
    bool inq[MAXN];
    double d[MAXN];
    int cnt[MAXN],p[MAXN];
    void addedge(int u,int v,int w){
        edges.pb((Edge){u,v,w});
        G[u].pb(m++);
    }
    void addedge2(int u,int v,int w) {
        addedge(u,v,w);addedge(v,u,w);
    }
    void init(int _n){
        n=_n; m = 0;
        Rep(i,n) G[i].clear();
        edges.clear(); 
    } 
    bool negativeCycle() {
        queue<int> Q;
        MEM(inq) MEM(cnt)
        Rep(i,n) d[i]=0,inq[i]=1,Q.push(i);
        while(!Q.empty()) {
            int u = Q.front(); Q.pop();
            inq[u] = 0;
            int mm=G[u].size();
            Rep(i,mm) {
                Edge e = edges[G[u][i]];
                if (d[e.to]>d[u]+e.dist ) {
                    d[e.to]=d[u]+e.dist;
                    p[e.to]=G[u][i];

                    if (!inq[e.to]) {
                        Q.push(e.to);
                        inq[e.to]=1;
                        if (++cnt[e.to]>n) return 1;
                    }
                }
            } 
        } 
        return 0;
    }
    bool check(double x) {
        Rep(i,m) edges[i].dist -=x;
        bool ret = negativeCycle();
        Rep(i,m) edges[i].dist +=x;
        return !ret;
    }

}S1;

int main()
{
//  freopen("uva11478.in","r",stdin);
//  freopen(".out","w",stdout);

    while(cin>>n>>m) {
        S1.init(n);
        For(i,m) {
            int a=read()-1,b=read()-1;
            S1.addedge(a,b,read());
        }
        int L = 0 , R = 10001,ans = 0;
        if (S1.check(R+1)) {
            puts("Infinite"); 
            continue;
        } else if (!S1.check(1)) {
            puts("No Solution");
            continue;
        }
        while(L<=R) {
            int m= (L+R)/2;
            if (S1.check(m)) L=m+1,ans=m; else R=m-1; 
        } 
        printf("%d\n",ans);
    }


    return 0;
}

建模

UVA 1078 Steam Roller

给一个R条横线与C条竖线组成的网格，线段带权表示通过时间，权为0的线段不能通过，求(r1,c1)->(r2,c2)的最短路。
对于任意一条边，如果在进入这条边之前或离开这条边之后立即拐弯，通过时间翻倍，起点终点所在的时间翻倍，“时间加倍规则不叠加”。

拆点，(r,c,dir)表示(r,c)点有向dir趋势时的最短路，其中dir为4方向与静止。

#include<bits/stdc++.h>
using namespace std;
#define For(i,n) for(int i=1;i<=n;i++)
#define Fork(i,k,n) for(int i=k;i<=n;i++)
#define Rep(i,n) for(int i=0;i<n;i++)
#define ForD(i,n) for(int i=n;i;i--)
#define ForkD(i,k,n) for(int i=n;i>=k;i--)
#define RepD(i,n) for(int i=n;i>=0;i--)
#define Forp(x) for(int p=Pre[x];p;p=Next[p])
#define Forpiter(x) for(int &p=iter[x];p;p=Next[p])  
#define Lson (o<<1)
#define Rson ((o<<1)+1)
#define MEM(a) memset(a,0,sizeof(a));
#define MEMI(a) memset(a,127,sizeof(a));
#define MEMi(a) memset(a,128,sizeof(a));
#define INF (2139062143)
#define F (100000007)
#define pb push_back
#define mp make_pair 
#define fi first
#define se second
#define vi vector<int> 
#define pi pair<int,int>
#define SI(a) ((a).size())
#define Pr(kcase,ans) printf("Case %d: %lld\n",kcase,ans);
#define PRi(a,n) For(i,n-1) cout<<a[i]<<' '; cout<<a[n]<<endl;
#define PRi2D(a,n,m) For(i,n) { \
                        For(j,m-1) cout<<a[i][j]<<' ';\
                        cout<<a[i][m]<<endl; \
                        } 
typedef long long ll;
typedef unsigned long long ull;
ll mul(ll a,ll b){return (a*b)%F;}
ll add(ll a,ll b){return (a+b)%F;}
ll sub(ll a,ll b){return (a-b+llabs(a-b)/F*F+F)%F;}
void upd(ll &a,ll b){a=(a%F+b%F)%F;}
int read()
{
    int x=0,f=1; char ch=getchar();
    while(!isdigit(ch)) {if (ch=='-') f=-1; ch=getchar();}
    while(isdigit(ch)) { x=x*10+ch-'0'; ch=getchar();}
    return x*f;
} 
#define MAXN (60000)
#define MAXR (100+10)
int n,m;
struct Edge{
    int from,to,dist;
};
struct HeapNode {
    int d,u;
    bool operator< (const HeapNode& rhs) const {
        return d > rhs.d;
    }
}; 
struct Dijkstra {
    int n,m;
    vector<Edge> edges;
    vector<int> G[MAXN];
    bool done[MAXN];
    int d[MAXN];
    int p[MAXN]; //最短路中上一条边
    int pnode[MAXN];
    void addedge(int u,int v,int w){
        edges.pb((Edge){u,v,w});
        G[u].pb(m++);
    }
    void addedge2(int u,int v,int w) {
        addedge(u,v,w);addedge(v,u,w);
    }
    void init(int _n){
        n=_n; m = 0;
        Rep(i,n) G[i].clear();
        edges.clear(); 
    } 
    void dijkstra(int s) {
        priority_queue<HeapNode> Q;
        Rep(i,n) d[i]=INF,pnode[i]=-1;
        d[s]=0;
        MEM(done)
        Q.push((HeapNode){0,s});
        while(!Q.empty()) {
            HeapNode x=Q.top(); Q.pop();
            int u=x.u;
            if (done[u]) continue;
            done[u]=1;
            int mm=G[u].size();
            Rep(i,mm) {
                Edge e = edges[G[u][i]];
                if (d[e.to]>d[u]+e.dist) {
                    d[e.to]=d[u]+e.dist;
                    p[e.to]=G[u][i];
                    pnode[e.to]=u;
                    Q.push((HeapNode){d[e.to],e.to});
                }
            }
        }
    } 
}S1;
int R,C,r1,c1,r2,c2;
int grid[MAXR][MAXR][5];
const int LEFT=0,RIGHT=1,DOWN=2,UP=3,STAY=4;
int di[4][2]={{0,-1},{0,1},{1,0},{-1,0}};

int id[MAXR][MAXR][5],siz=0;
int ID(int i,int j,int k) {
    int &x = id[i][j][k];
    if (!x) x=++siz;
    return x;
}
bool cango(int i,int j,int dir) {
    if (i<0||i>=R||j<0||j>=C) return 0;
    return grid[i][j][dir] >0;
}
int main()
{
//  freopen("uva1078.in","r",stdin);
//  freopen(".out","w",stdout);
    int kcase=1;
    while(cin>>R>>C>>r1>>c1>>r2>>c2&&R ) {
        r1--,c1--,r2--,c2--; 
        MEM(grid)
        Rep(i,R) {
            Rep(j,C-1) {
                grid[i][j][RIGHT]=grid[i][j+1][LEFT]=read();
            }
            if (i!=R-1)
                Rep(j,C) {
                    grid[i][j][DOWN]=grid[i+1][j][UP]=read();
                }
        }
        S1.init(5*R*C+1);
        MEM(id)
        siz=0;

        Rep(i,R) Rep(j,C) {
            Rep(dir,4) {
                if (cango(i,j,dir^1)) {
                    S1.addedge(ID(i,j,dir),ID(i,j,4),grid[i][j][dir^1]);
                    if (cango(i,j,dir)) {
                        S1.addedge(ID(i,j,dir),ID(i+di[dir][0],j+di[dir][1],dir),grid[i][j][dir]);
                    }
                }
                if (grid[i][j][dir]) {
                    S1.addedge(ID(i,j,4),ID(i+di[dir][0],j+di[dir][1],4),2*grid[i][j][dir]);
                    S1.addedge(ID(i,j,4),ID(i+di[dir][0],j+di[dir][1],dir),2*grid[i][j][dir]);
                }
            }
        }
        S1.dijkstra(ID(r1,c1,4));
        ll ans=S1.d[ID(r2,c2,4)];
        printf("Case %d: ",kcase++);
        if (ans==INF) puts("Impossible"); else printf("%lld\n",ans);
    }
    return 0;
}

UVA 1048 - Low Cost Air Travel

航空公司出售 NT≤20 张联票，要求从头坐，但可在中途任一站下飞机。
你有 NI≤20 份行程单，每份行程单上有若干城市，你在第一个城市，且希望按顺序游览城市，问最小花费，及该情况下的方案（保证唯一）。
每张票或行程单上的城市数 ≤10
对每份行程单
把“目前所在城市，已经经过行程单上几个城市”作为节点建图

#include<bits/stdc++.h>
using namespace std;
#define For(i,n) for(int i=1;i<=n;i++)
#define Fork(i,k,n) for(int i=k;i<=n;i++)
#define Rep(i,n) for(int i=0;i<n;i++)
#define ForD(i,n) for(int i=n;i;i--)
#define ForkD(i,k,n) for(int i=n;i>=k;i--)
#define RepD(i,n) for(int i=n;i>=0;i--)
#define Forp(x) for(int p=Pre[x];p;p=Next[p])
#define Forpiter(x) for(int &p=iter[x];p;p=Next[p])  
#define Lson (o<<1)
#define Rson ((o<<1)+1)
#define MEM(a) memset(a,0,sizeof(a));
#define MEMI(a) memset(a,127,sizeof(a));
#define MEMi(a) memset(a,128,sizeof(a));
#define INF (2139062143)
#define F (100000007)
#define pb push_back
#define mp make_pair 
#define fi first
#define se second
#define vi vector<int> 
#define pi pair<int,int>
#define SI(a) ((a).size())
#define Pr(kcase,ans) printf("Case %d: %lld\n",kcase,ans);
#define PRi(a,n) For(i,n-1) cout<<a[i]<<' '; cout<<a[n]<<endl;
#define PRi2D(a,n,m) For(i,n) { \
                        For(j,m-1) cout<<a[i][j]<<' ';\
                        cout<<a[i][m]<<endl; \
                        } 
typedef long long ll;
typedef unsigned long long ull;
ll mul(ll a,ll b){return (a*b)%F;}
ll add(ll a,ll b){return (a+b)%F;}
ll sub(ll a,ll b){return (a-b+llabs(a-b)/F*F+F)%F;}
void upd(ll &a,ll b){a=(a%F+b%F)%F;}
int read()
{
    int x=0,f=1; char ch=getchar();
    while(!isdigit(ch)) {if (ch=='-') f=-1; ch=getchar();}
    while(isdigit(ch)) { x=x*10+ch-'0'; ch=getchar();}
    return x*f;
} 
int NT,NI,Q;
#define MAXC (400+10)
#define MAXL (20+10) 
int id[MAXC][MAXL],siz=0;
int ID(int x,int y) {
    int &p =id[x][y];
    if (!p) {
        id[x][y]=siz++;
    }
    return p;
}
vector<int> idx;
int find(int x) { return lower_bound(idx.begin(), idx.end(), x) - idx.begin(); }  
vector<int> ticket[MAXL],trip[MAXL];
int w[MAXL],l[MAXL],l2[MAXL];

struct Edge{
    int from,to,dist;
};
struct HeapNode {
    int d,u;
    bool operator< (const HeapNode& rhs) const {
        return d > rhs.d;
    }
}; 
#define MAXN (40000+10)
struct Dijkstra {
    int n,m;
    vector<Edge> edges;
    vector<int> G[MAXN],Rid;
    bool done[MAXN];
    int d[MAXN];
    int p[MAXN]; //最短路中上一条边
    int pnode[MAXN];
    void addedge(int u,int v,int w,int rid){
        edges.pb((Edge){u,v,w});
        Rid.pb(rid);
        G[u].pb(m++);
    }
    void init(int _n){
        n=_n; m = 0;
        Rep(i,n) G[i].clear();
        edges.clear(); Rid.clear();
    } 
    void dijkstra(int s) {
        priority_queue<HeapNode> Q;
        Rep(i,n) d[i]=INF,p[i]=pnode[i]=-1;
        d[s]=0;
        MEM(done)
        Q.push((HeapNode){0,s});
        while(!Q.empty()) {
            HeapNode x=Q.top(); Q.pop();
            int u=x.u;
            if (done[u]) continue;
            done[u]=1;
            int mm=G[u].size();
            Rep(i,mm) {
                Edge e = edges[G[u][i]];
                if (d[e.to]>d[u]+e.dist) {
                    d[e.to]=d[u]+e.dist;
                    p[e.to]=G[u][i];
                    pnode[e.to]=u;
                    Q.push((HeapNode){d[e.to],e.to});
                }
            }
        }
    } 
    void putedge(int e) {
        int u;
        vi ans;
        for(u=e;p[u]!=-1;u=pnode[u]) ans.pb(Rid[p[u]]);
        int mm=ans.size();
        RepD(i,mm-1) printf(" %d",ans[i]); 
        cout<<endl;
    }
}S1;
int main()
{
//  freopen("uva1048.in","r",stdin);
//  freopen(".out","w",stdout);

    int kcase=1;
    while(cin>>NT && NT ) {
        MEM(id)
        siz=0;  
        idx.clear();
        For(i,NT) {
            w[i]=read();
            l[i]=read();
            ticket[i].clear();
            For(j,l[i]) {
                int p=read();
                ticket[i].pb(p);
                idx.pb(p);
            }
        }
        NI=read();
        For(i,NI) {
            l2[i]=read();
            trip[i].clear();
            For(j,l2[i]) {
                int p=read();
                trip[i].pb(p);
                idx.pb(p);
            }
        }
        sort(idx.begin(),idx.end());
        int m=unique(idx.begin(),idx.end())-idx.begin();
        For(i,NT) Rep(j,l[i]) ticket[i][j]=find(ticket[i][j]);
        For(i,NI) Rep(j,l2[i]) trip[i][j]=find(trip[i][j]);

        For(k,NI) { //枚举行程 
            S1.init(m*13);
            int sz = l2[k]; //行程城市数 
            For(i,NT) { //枚举票 
                int s = ticket[i][0];
                Rep(pos1,sz) { //枚举当前城市
                    int pos2=pos1; 
                    For(j,l[i]-1) {
                        int e = ticket[i][j];
                        if (e==trip[k][pos2]) pos2++;
                        S1.addedge(ID(s,pos1),ID(e,pos2),w[i],i);
                        if (pos2==sz) break;            
                    }
                }
            }   
            S1.dijkstra(ID(trip[k][0],1));

            int ans=S1.d[ID(trip[k][sz-1],sz)];
            printf("Case %d, Trip %d: Cost = %d\n  Tickets used:",kcase,k,ans);
            S1.putedge(ID(trip[k][sz-1],sz));

        }
        ++kcase;
    }

    return 0;
}

LA 3661 Animal Run

同BZOJ 1001
解法略

UVA 10603 Fill

UVA 10269 Adventure of Super Mario

#include<bits/stdc++.h>
using namespace std;
#define For(i,n) for(int i=1;i<=n;i++)
#define Fork(i,k,n) for(int i=k;i<=n;i++)
#define Rep(i,n) for(int i=0;i<n;i++)
#define ForD(i,n) for(int i=n;i;i--)
#define ForkD(i,k,n) for(int i=n;i>=k;i--)
#define RepD(i,n) for(int i=n;i>=0;i--)
#define Forp(x) for(int p=Pre[x];p;p=Next[p])
#define Forpiter(x) for(int &p=iter[x];p;p=Next[p])  
#define Lson (o<<1)
#define Rson ((o<<1)+1)
#define MEM(a) memset(a,0,sizeof(a));
#define MEMI(a) memset(a,127,sizeof(a));
#define MEMi(a) memset(a,128,sizeof(a));
#define INF (2139062143)
#define F (100000007)
#define pb push_back
#define mp make_pair 
#define fi first
#define se second
#define vi vector<int> 
#define pi pair<int,int>
#define SI(a) ((a).size())
#define Pr(kcase,ans) printf("Case %d: %lld\n",kcase,ans);
#define PRi(a,n) For(i,n-1) cout<<a[i]<<' '; cout<<a[n]<<endl;
#define PRi2D(a,n,m) For(i,n) { \
                        For(j,m-1) cout<<a[i][j]<<' ';\
                        cout<<a[i][m]<<endl; \
                        } 
typedef long long ll;
typedef unsigned long long ull;
ll mul(ll a,ll b){return (a*b)%F;}
ll add(ll a,ll b){return (a+b)%F;}
ll sub(ll a,ll b){return (a-b+llabs(a-b)/F*F+F)%F;}
void upd(ll &a,ll b){a=(a%F+b%F)%F;}
int read()
{
    int x=0,f=1; char ch=getchar();
    while(!isdigit(ch)) {if (ch=='-') f=-1; ch=getchar();}
    while(isdigit(ch)) { x=x*10+ch-'0'; ch=getchar();}
    return x*f;
} 
int n,m;
int A,B,L,C;
struct Edge{
    int from,to,dist;
};
struct HeapNode {
    int d,c,u;
    bool operator< (const HeapNode& rhs) const {
        return d > rhs.d;
    }
}; 
#define MAXN (100+10)
#define MAXC (10+10)
int f[MAXN][MAXN];
void floyd() {
    Rep(k,A)
        Rep(i,n) Rep(j,n) 
            f[i][j]=min((ll)f[i][j],(ll)f[i][k]+f[k][j]);
}
struct Dijkstra {
    int n,m,w[MAXN];
    vector<Edge> edges;
    vector<int> G[MAXN];
    bool done[MAXC][MAXN];
    int d[MAXC][MAXN];
    void addedge(int u,int v,int w){
        edges.pb((Edge){u,v,w});
        G[u].pb(m++);
    }
    void addedge2(int u,int v,int w) {
        addedge(u,v,w);addedge(v,u,w);
    }
    void init(int _n){
        n=_n; m = 0;
        Rep(i,n) G[i].clear();
        edges.clear(); 
    } 
    void dijkstra(int s,int e) {
        priority_queue<HeapNode> Q;
        MEMI(d)
        d[0][s]=0;
        MEM(done)
        Q.push((HeapNode){0,0,s});
        while(!Q.empty()) {
            HeapNode x=Q.top(); Q.pop();
            int u=x.u,c=x.c;
            if (done[c][u]) continue;
            done[c][u]=1;
            int mm=G[u].size();
            Rep(i,mm) {
                Edge e = edges[G[u][i]];
                if (d[c][e.to]>d[c][u]+e.dist) {
                    d[c][e.to]=d[c][u]+e.dist;
                    Q.push((HeapNode){d[c][e.to],c,e.to});
                }
            }
            if (c<C) {
                Rep(i,n) if (f[u][i]<=L) {
                    if (d[c+1][i]>d[c][u]) {
                        d[c+1][i]=d[c][u];
                        Q.push((HeapNode){d[c+1][i],c+1,i});
                    }
                }

            }
        }
        cout<<d[C][e]<<endl;
    } 
}S1;
int main()
{
//  freopen("uva10269.in","r",stdin);
//  freopen(".out","w",stdout);
    int T=read();
    while(T--) {
        cin>>A>>B>>m>>L>>C;
        n=A+B;
        S1.init(n);
        MEMI(f)
        For(i,m) {
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c); --a;--b;
            S1.addedge2(a,b,c);
            f[a][b]=f[b][a]=min(f[a][b],c);
        }
        Rep(i,n) f[i][i]=0;
        floyd();
        S1.dijkstra(n-1,0);

    }

    return 0;
}

UVA 11367 Full Tank?

#include<bits/stdc++.h>
using namespace std;
#define For(i,n) for(int i=1;i<=n;i++)
#define Fork(i,k,n) for(int i=k;i<=n;i++)
#define Rep(i,n) for(int i=0;i<n;i++)
#define ForD(i,n) for(int i=n;i;i--)
#define ForkD(i,k,n) for(int i=n;i>=k;i--)
#define RepD(i,n) for(int i=n;i>=0;i--)
#define Forp(x) for(int p=Pre[x];p;p=Next[p])
#define Forpiter(x) for(int &p=iter[x];p;p=Next[p])  
#define Lson (o<<1)
#define Rson ((o<<1)+1)
#define MEM(a) memset(a,0,sizeof(a));
#define MEMI(a) memset(a,127,sizeof(a));
#define MEMi(a) memset(a,128,sizeof(a));
#define INF (2139062143)
#define F (100000007)
#define pb push_back
#define mp make_pair 
#define fi first
#define se second
#define vi vector<int> 
#define pi pair<int,int>
#define SI(a) ((a).size())
#define Pr(kcase,ans) printf("Case %d: %lld\n",kcase,ans);
#define PRi(a,n) For(i,n-1) cout<<a[i]<<' '; cout<<a[n]<<endl;
#define PRi2D(a,n,m) For(i,n) { \
                        For(j,m-1) cout<<a[i][j]<<' ';\
                        cout<<a[i][m]<<endl; \
                        } 
typedef long long ll;
typedef unsigned long long ull;
ll mul(ll a,ll b){return (a*b)%F;}
ll add(ll a,ll b){return (a+b)%F;}
ll sub(ll a,ll b){return (a-b+llabs(a-b)/F*F+F)%F;}
void upd(ll &a,ll b){a=(a%F+b%F)%F;}
int read()
{
    int x=0,f=1; char ch=getchar();
    while(!isdigit(ch)) {if (ch=='-') f=-1; ch=getchar();}
    while(isdigit(ch)) { x=x*10+ch-'0'; ch=getchar();}
    return x*f;
} 
int n,m;

struct Edge{
    int from,to,dist;
};
struct HeapNode {
    int d,c,u;
    bool operator< (const HeapNode& rhs) const {
        return d > rhs.d;
    }
}; 
#define MAXN (1010)
#define MAXC (100+10)
struct Dijkstra {
    int n,m,w[MAXN];
    vector<Edge> edges;
    vector<int> G[MAXN];
    bool done[MAXC][MAXN];
    int d[MAXC][MAXN];
    void addedge(int u,int v,int w){
        edges.pb((Edge){u,v,w});
        G[u].pb(m++);
    }
    void addedge2(int u,int v,int w) {
        addedge(u,v,w);addedge(v,u,w);
    }
    void init(int _n){
        n=_n; m = 0;
        Rep(i,n) G[i].clear();
        edges.clear(); 
    } 
    void dijkstra(int s,int C,int e) {
        priority_queue<HeapNode> Q;
        MEMI(d)
        d[0][s]=0;
        MEM(done)
        Q.push((HeapNode){0,0,s});
        while(!Q.empty()) {
            HeapNode x=Q.top(); Q.pop();
            int u=x.u,c=x.c;
            if (done[c][u]) continue;
            done[c][u]=1;
            int mm=G[u].size();
            Rep(i,mm) {
                Edge e = edges[G[u][i]];
                if (c<e.dist) continue;
                if (d[c-e.dist][e.to]>d[c][u]) {
                    d[c-e.dist][e.to]=d[c][u];
                    Q.push((HeapNode){d[c-e.dist][e.to],c-e.dist,e.to});
                }
            }
            if (c<C) {
                if (d[c+1][u]>d[c][u]+w[u]) {
                    d[c+1][u]=d[c][u]+w[u];
                    Q.push((HeapNode){d[c+1][u],c+1,u});
                }

            }
        }
        if (INF == d[0][e]) {
            puts("impossible");
        } else {
            cout<<d[0][e]<<endl;
        }
    } 
}S1;
int main()
{
//  freopen("uva11367.in","r",stdin);
//  freopen(".out","w",stdout);

    while(cin>>n>>m) {
        S1.init(n);
        Rep(i,n) S1.w[i]=read();
        For(i,m) {
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);
            S1.addedge2(a,b,c);
        }
        int q=read();
        while(q--) {
            int c,s,e;
            scanf("%d%d%d",&c,&s,&e);
            S1.dijkstra(s,c,e);

        }
    }

    return 0;
}

UVA 11280 Flying to Fredericton


#include<bits/stdc++.h>
using namespace std;
#define For(i,n) for(int i=1;i<=n;i++)
#define Fork(i,k,n) for(int i=k;i<=n;i++)
#define Rep(i,n) for(int i=0;i<n;i++)
#define ForD(i,n) for(int i=n;i;i--)
#define ForkD(i,k,n) for(int i=n;i>=k;i--)
#define RepD(i,n) for(int i=n;i>=0;i--)
#define Forp(x) for(int p=Pre[x];p;p=Next[p])
#define Forpiter(x) for(int &p=iter[x];p;p=Next[p])  
#define Lson (o<<1)
#define Rson ((o<<1)+1)
#define MEM(a) memset(a,0,sizeof(a));
#define MEMI(a) memset(a,127,sizeof(a));
#define MEMi(a) memset(a,128,sizeof(a));
#define INF (2139062143)
#define F (100000007)
#define pb push_back
#define mp make_pair 
#define fi first
#define se second
#define vi vector<int> 
#define pi pair<int,int>
#define SI(a) ((a).size())
#define Pr(kcase,ans) printf("Case %d: %lld\n",kcase,ans);
#define PRi(a,n) For(i,n-1) cout<<a[i]<<' '; cout<<a[n]<<endl;
#define PRi2D(a,n,m) For(i,n) { \
                        For(j,m-1) cout<<a[i][j]<<' ';\
                        cout<<a[i][m]<<endl; \
                        } 
typedef long long ll;
typedef unsigned long long ull;
ll mul(ll a,ll b){return (a*b)%F;}
ll add(ll a,ll b){return (a+b)%F;}
ll sub(ll a,ll b){return (a-b+llabs(a-b)/F*F+F)%F;}
void upd(ll &a,ll b){a=(a%F+b%F)%F;}
int read()
{
    int x=0,f=1; char ch=getchar();
    while(!isdigit(ch)) {if (ch=='-') f=-1; ch=getchar();}
    while(isdigit(ch)) { x=x*10+ch-'0'; ch=getchar();}
    return x*f;
} 
int n,m,s,e;
struct Edge{
    int from,to;
    double dist;
};
#define MAXN (1000+10)
#define MAXC (MAXN)
struct BellmanFord {
    int n,m;
    vector<Edge> edges;
    vi G[MAXN];
    bool inq[MAXC][MAXN];
    int d[MAXC][MAXN];
    int cnt[MAXN],p[MAXN];
    void addedge(int u,int v,int w){
        edges.pb((Edge){u,v,w});
        G[u].pb(m++);
    }
    void addedge2(int u,int v,int w) {
        addedge(u,v,w);addedge(v,u,w);
    }
    void init(int _n){
        n=_n; m = 0;
        Rep(i,n) G[i].clear();
        edges.clear(); 
    } 
    void BF() {
        int C=n;
        queue<int> Q;
        queue<int> Q2;
        MEM(inq) MEM(cnt)
        inq[0][s]=1; Q.push(s); Q2.push(0);
        MEMI(d)

        Rep(i,n) d[0][s]=0;
        while(!Q.empty()) {
            int u = Q.front(); Q.pop();
            int c = Q2 .front(); Q2.pop();
            inq[c][u] = 0;
            int mm=G[u].size();
            if (c<C)
                Rep(i,mm) {
                    Edge e = edges[G[u][i]];
                    if (d[c+1][e.to]>d[c][u]+e.dist ) {
                        d[c+1][e.to]=d[c][u]+e.dist;
                        p[e.to]=G[u][i];

                        if (!inq[c+1][e.to]) {
                            Q.push(e.to);
                            Q2.push(c+1);
                            inq[c+1][e.to]=1;
                        }
                    }
                } 
        } 
        For(i,C) d[i][e]=min(d[i][e],d[i-1][e]);

    }

}S1;
vector<string> idx;
int find(string x) { return lower_bound(idx.begin(), idx.end(), x) - idx.begin(); }  
int main()
{
//  freopen("uva11280.in","r",stdin);
//  freopen(".out","w",stdout);

    int T=read();
    For(kcase,T) {
        if (kcase>1) puts("");
        printf("Scenario #%d\n",kcase);
        n=read();
        S1.init(n);
        idx.clear();
        For(i,n) {
            string s;
            cin>>s;
            idx.pb(s);
        }
        sort(idx.begin(),idx.end());
        m=read();
        For(i,m) {
            string s1,s2;
            int c;
            cin>>s1>>s2>>c;
            S1.addedge(find(s1),find(s2),c);
        }
        int q=read();
        s=find("Calgary"),e=find("Fredericton");
        S1.BF();
        while(q--) {
            int t=read();
            ++t;
            t=max(t,0);
            t=min(t,-1+n);
            if (S1.d[t][e] == INF ) {
                puts("No satisfactory flights");
            }
            else printf("Total cost of flight(s) is $%d\n",(int)S1.d[t][e]);
        }
    }


    return 0;
}
nike0good
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
acm最短路与网络流
08-06
最短路问题与网络流是图论中的两个重要概念，它们在计算机科学，尤其是算法设计和运筹学中有着广泛的应用。最短路问题主要关注如何在带权重的图中找到两个节点之间的最短路径，而网络流问题则研究如何在有向图中最大...
17.3电阻的测量flash专题培训课件.ppt
最新发布
11-11
实验中可能会遇到各种问题，例如电流表和电压表指针偏转角度小可能是量程过大或电源电压低，指针反向偏转则可能是因为正负极接反，电流表超量程可能是因为量程选择过小或短路，电表示数不变可能是因为滑动变阻器未...
【图论】最短路总结+例题
weixin_43819578的博客
08-30 3124
板子 迪杰斯特拉普通板子 void dli(){ memset(d,0x3f,sizeof(d));//memset可能会错，最好用循环赋值 memset(v,0,sizeof(v)); d[1]=0;//起点的距离是0 for(int i=1;i<n;i++){ int x=0; for(int j=1;j<=n;j++){ if(!v[j]&&...
【图论】最短路问题大合集，五种算法刷爆最短路问题。
m0_70875482的博客
10-22 757
思路：迭代n次，每次找到距离离起点最近的点，起点置为0，并且用距离最近的点更新其他点。题目：给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环，所有边权均为正值。请你求出 1 号点到 n 号点的最短距离，如果无法从 1 号点走到 n 号点，则输出 −1。输入格式：第一行包含整数 n 和 m。接下来 m 行每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。输出格式：输出一个整数，表示 1 号点到 n 号点的最短距离。
最短路基础与习题
weixin_43870697的博客
07-23 952
目录 前言 Floyd算法 Dijkstra算法 详解 模板 Spfa算法 详解 模板 例题 A.POJ-2387 Til the Cows Come Home B.POJ-2253 Frogger C.POJ-1797 Heavy Transportation D：POJ-3268 Silver Cow Party E:POJ-1860 Currency Exc...
图论之最短路问题（acwing模板篇）
lihua777的博客
02-14 793
acwing(6)
最短路问题
sky的博客
04-09 3539
转载自：https://mp.weixin.qq.com/s/4G77pVgfHuPHjGDmfc27ZA 1.什么是最短路问题 最短路问题（shortest-path problem）是图论中的经典问题之一，可用来解决管路铺设、线路安装、厂区布局和设备更新等实际问题。 基本内容是：假设网络中的每条边都有一个权重（常用长度、成本、时间等表示），最短路问题的目标是找出给定两点（通常是源节点和汇节点）之间总权重之和最小的路径。 如上图所示，以1为起点，7为终点，则...
专题资料（2021-2022年）初三中考物理总复习第二部分专题训练专题一选择题电学课件.ppt
10-08
16. **电路故障判断**：两电表示数变大，可能是灯L短路，导致总电阻减小，电流增大，电表读数增加。选项A正确。 17. **气敏电阻与指示灯电路**：有害尾气浓度增大，气敏电阻的阻值变化，导致电压表读数的变化，因为...
专题资料（2021-2022年）安全灯谜.doc
10-08
2. **电工用语**：如“捷径”代表“短路”，“离婚”象征“绝缘”，揭示了电工操作中的安全规则，避免短路和确保绝缘的重要性。 3. **安全意识**：“违章操作”提示我们应遵守规程，避免不按规范行事导致事故。 4....
专题资料（2021-2022年）安全检查表1.doc
10-08
这份"专题资料（2021-2022年）安全检查表1.doc"详细列出了多个关键的安全隐患，旨在提醒相关人员对这些潜在风险进行整改和预防。下面将对检查表中的各项内容进行深入解析： 1. **消防设施**：消防设施是任何场所...
图论：最短路问题
qq_51704853的博客
07-21 643
图论中的最短路问题
UVA 10917 Walk Through the Forest（Dijkstra+DAG动态规划）
adr5970的博客
04-23 61
题意：gbn近期打算穿过一个森林。可是他比較傲娇，于是他决定仅仅走一些特殊的道路。他打算仅仅沿着满足例如以下条件的（A,B）道路走：存在一条从B出发回家的路，比全部从A出发回家的路径都短。你的任务是计算一共同拥有多少条不同的回家路径。当中起点的编号为1，终点的编号为2. 思路：首先从终点Dijkstra一次。求出每一个点u回家的最短路长度。那么相当于创建了一个新图。当d[B]&...
UVA 10917 Walk Through the Forest（最短路+dp）
沉溺的专栏
03-01 641
题目：http://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=1858 题目大意：n个节点，公司是1号，家是2号。他从公司走回家，走的时候他有个规则，那就是：一条a到b，如果b到家的存在一条路都比从a到家的任何一条路要短，那么这条路可以走，否则就不能走。问你从 2
最短路问题（——模板习题与总结）
aisebu7819的博客
07-25 436
　　摘要：本文主要讲解在竞赛中如何求解图中存在环的最短路问题。其中涉及的算法有Floyd算法，Dijkstra算法，使用邻接表和优先队列优化的Dijkstra算法，Bellman-Ford算法，简要总结各算法的基本思想和实现以及使用注意事项。 　　最短路问题主要分为单源最短路问题和多源最短路问题。给出顶点数和边数，以及边的权值，让我们计算从某个顶点到某个顶点的最短路径，单源最短路就是求...
最短路习题（一）
微凉的博客
04-13 905
1.骑车比赛 测试输入： 5 6 1 2 2 2 3 3 2 5 5 3 4 2 3 5 1 4 5 1 测试输出： 6 裸题，dijkstra 代码如下： package _最短路习题; import java.util.Arrays; import java.util.Scanner; public class _汽车比赛 { static int n, m...
道路与航线——图论综合性最短路问题，综合性太强把他单独拎出来了
ZZU_LGY
10-23 214
道路与航线–dfs+topsort+dijkstra+建图方式 算法流程 1.先输入所有双向道路，然后DFS出所有连通块，计算两个数组:id[]存储每个点属于哪个连通块;vector<int> block[]存储每个连通块里有哪些点: 2.输入所有航线，同时统计出每个连通块的入度。 3.按照拓扑序依次处理每个连通块，先将所有入度为0的连通块的编号加入队列 中。 4.每次从队头取出一个连通块的编号bid 5.将该block[bid]中的所有点加入堆中，然后对堆中所有点跑dijkstra算法。 6.
【最短路+最小费用】hdu 3790 最短路径问题
Hacker_vision
08-30 3057
Source : hdu 3790 最短路径问题 http://acm.hdu.edu.cn/showproblem.php?pid=3790 Problem Description 给你n个点，m条无向边，每条边都有长度d和花费p，给你起点s终点t，要求输出起点到终点的最短距离及其花费，如果最短距离有多条路线，则输出花费最少的。 Input 输入n,m，点的编号是1~n,然后是m行
（转）SPFA算法详解
尧 棣
09-09 1146
适用范围：给定的图存在负权边，这时类似Dijkstra等算法便没有了用武之地，而Bellman-Ford算法的复杂度又过高，SPFA算法便派上用场了。 我们约定有向加权图G不存在负权回路，即最短路径一定存在。当然，我们可以在执行该算法前做一次拓扑排序，以判断是否存在负权回路，但这不是我们讨论的重点。 算法思想：我们用数组d记录每个结点的最短路径估计值，用邻接表来存储图G。我们采取的方法是
MATLAB编程实现最短路问题的数学建模
最短路问题在数学建模与实验中是一个核心议题，它主要涉及图论中的理论与实际应用。图论是一门研究网络结构和关系的学科，其中最基本的概念包括图的概念及其不同表示形式。 首先，图被定义为一个有序三元组G=(V,E,...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值