【最短路问题】（单源，多源）

•单源最短路径

       No.1 dijkstra算法

             算法核心：（1）两个集合 s,t 分别保存已经更新过的和未更新的数据，用一个vis[]数组来实现；

                                （2）用dis[i]数组保存当前 i 点到源点的最短路径长度，每次在dis中找到一个最小的值dis[i],每次由dis[i] 更新与 i 相连的dis值；

                                                   p.s：dis[x]=0,x为源点；

                                   *(3)* 堆优化：每次找dis最小值时会花费大量时间，于是可以动用c++stl里的结构 大根堆（优先队列）实现优化

             时间复杂度：进行堆优化后的程序为 O(m*logn)

堆优化后code：         q为大根堆。

void dijkstra(){
    memset(d,0x3f,sizeof(d));
    memset(v,0,sizeof(v));
    d[1]=0;
    q.push(make_pair(0,1));
    while(q.size()){
        int x=q.top().second;
        q,pop();
        if(v[x]) continue;
        v[x]=1;
        for(int i=head[x];i;i=next[i]){
            int y=ver[i],z=edge[i];
            if(d[y]>d[x]+z){
                d[y]=d[x]+z;
                q.push(make_pair(-d[y],y));
            }
        }        
    } 
}

         No.2 Bellman-Ford & SPFA(shortest path fast algorithm)

                   bellman-ford算法核心：

                                          扫描所有的边（x,y,z） 若dis[y] > dis[x] + z 则更新 dis[y]=dis[x]+z;

                  spfa:对bellman算法进行队列优化

                               建立一个队列 q ，起点含1，然后每次取出队头 x  ，对x的每条出边进行 dis 更新 与 vis更新 （是否入过队）：如果未入过队，将其入队与更新 vis；

                    时间复杂度：O(km) 或 O(nm)

code            

void spfa(){
    memset(d,0x3f,sizeof(d));
    memset(v,0,sizeof(v));
    d[1]=0,v[1]=1;
    q.push(1);
    while(q.size()){
        int x=q.front();
        q.pop();
        v[x]=0;
        for(int i=head[x];i;i=next[i]){
            int y=ver[i],z=edge[i];
            if(d[y]>d[x]+z){
                d[y]=d[x]+z;
                if(!v[y]) q.push(y),v[y]=1;
            }
        }
    }
}

•多源最短路径                  

         Floyd算法

                      算法核心：动态规划（dp）

                                    （1）设 f[i , j , k] 为经过不超过k的节点从i->j的最短路径长度，得状态转移方程 f[i,j,k]=min(f[i,j,k-1],f[i,k,k-1]+f[k,j,k-1]);

                                    （2） 由此开三层for循环进行更新 f ，时间复杂度为O(n³)  空间复杂度 也为 O(n³),但进行观察可以得知 f 的值 只与 k  、k-1 有关，所以可将第三维变成动态结构或者根本就不需要第三维 k ；

                                    （3） 理解f[i,j] 无k ：  三层循环中 第一层必为 k ，因为考虑到dp的无后效性 ，将k看做中间节点，每次f[i,j]可与f[i,k]+f[k,j]比较：f[i,j]=min(f[i,j],f[i,k]+f[k,j])（状态转移方程）

核心code

for(int k=1;k<=n;k++)
   for(int i=1;i<=n;i++)
      for(int j=1;j<=n;j++)
         f[i][j]=min(f[i][j],f[i][k]+f[k][j]);

                  应用：关系的传递性，可以存图时定义单向关系为1，否则为0，然后利用floyd算法进行关系的传递；

f[i][j] |= f[i][k] & f[k][j];

例题e.g.

No.1 单源最短路问题(模板题）

题目描述

输入一个无向网络，输出其中2个顶点之间的最短路径长度

输入

输入文件第一行为n和m，表示有n个顶点和m条带权边，其中顶点编号是从1到n，接下来有m行，每行三个整数，分别表示两个顶点编号和对应边的权值，再接下来有一行，两个整数表示要求的最短路径的两个顶点编号

输出

输出文件就一行，即两个顶点间的最短路径长度（权值和）

输入样例

4 5
1 2 2
1 3 1
2 3 2
2 4 1
3 4 6
1 4

输出样例

3

code

#include<iostream>
#include<cmath>
#include<cstring>
using namespace std;
int e[1001][1001],dis[1001],vis[1001];
int main() {
    int n,m;
    cin>>n>>m;
    memset(e,127,sizeof(e));
    const int q=e[0][0];
    for(int i=1; i<=m; i++) {
        int x,y,v;
        cin>>x>>y>>v;
        e[x][y]=e[y][x]=v;
    }
    int x,y;
    cin>>x>>y;
    for(int i=1; i<=n; i++)
        e[i][i]=0,dis[i]=e[x][i];
    int ji=0;
    while(ji<=n) {
        int minn=q,k;
        for(int i=1; i<=n; i++) {
            if(!vis[i]&&dis[i]<minn) {
                minn=dis[i];
                k=i;
            }
        }
        vis[k]=1;
        ji++;
        for(int i=1; i<=n; i++) {
            if(e[k][i]!=q&&i!=k) {
                dis[i]=min(dis[i],e[k][i]+dis[k]);
            }
        }
    }
//    for(int i=1;i<=n;i++) cout<<dis[i]<<" ";
    cout<<dis[y];
    return 0;
}/*6 9
1 2 1
1 3 12
2 3 9
2 4 3
3 5 5
4 3 4
4 5 13
4 6 15
5 6 4*

 No.2 最优贸易

描述

C国有 n 个大城市和 m 条道路，每条道路连接这 n 个城市中的某两个城市。任意两个城市之间最多只有一条道路直接相连。这 m 条道路中有一部分为单向通行的道路，一部分为双向通行的道路，双向通行的道路在统计条数时也计为1条。
C国幅员辽阔，各地的资源分布情况各不相同，这就导致了同一种商品在不同城市的价格不一定相同。但是，同一种商品在同一个城市的买入价和卖出价始终是相同的。
商人阿龙来到C国旅游。当他得知“同一种商品在不同城市的价格可能会不同”这一信息之后，便决定在旅游的同时，利用商品在不同城市中的差价赚一点旅费。设C国 n 个城市的标号从 1~n，阿龙决定从1号城市出发，并最终在 n 号城市结束自己的旅行。在旅游的过程中，任何城市可以被重复经过多次，但不要求经过所有 n 个城市。
阿龙通过这样的贸易方式赚取旅费：他会选择一个经过的城市买入他最喜欢的商品——水晶球，并在之后经过的另一个城市卖出这个水晶球，用赚取的差价当做旅费。因为阿龙主要是来C国旅游，他决定这个贸易只进行最多一次，当然，在赚不到差价的情况下他就无需进行贸易。
现在给出 n 个城市的水晶球价格，m 条道路的信息（每条道路所连接的两个城市的编号以及该条道路的通行情况）。请你告诉阿龙，他最多能赚取多少旅费。

输入格式

   第一行包含 2 个正整数n 和m，中间用一个空格隔开，分别表示城市的数目和道路的
数目。
   第二行 n 个正整数，每两个整数之间用一个空格隔开，按标号顺序分别表示这n 个城
市的商品价格。
   接下来 m 行，每行有3 个正整数，x，y，z，每两个整数之间用一个空格隔开。如果z=1，表示这条道路是城市x 到城市y 之间的单向道路；如果z=2，表示这条道路为城市x 和城市y 之间的双向道路。

输出格式

一个整数，表示答案。

样例输入

5 5
4 3 5 6 1
1 2 1
1 4 1
2 3 2
3 5 1
4 5 2

样例输出

5

数据范围与约定

• 输入数据保证 1 号城市可以到达n 号城市。
  对于 10%的数据，1≤n≤6。
  对于 30%的数据，1≤n≤100。
  对于 50%的数据，不存在一条旅游路线，可以从一个城市出发，再回到这个城市。
  对于 100%的数据，1≤n≤100000，1≤m≤500000，1≤x，y≤n，1≤z≤2，1≤各城市
  水晶球价格≤100。

来源

CCF NOIP2009

思路

           将最短路中 用 d[x] + z更新d[y] 变成 min(d[x],price[y]) 更新 d[y]

            用d[x] 表示从 1->x 的所有路径中，能够经过的权值最小的权值。

            这时候不难发现，我们还应该求出从x->n 的最大权值 ，这时候我们就应该存一个反图，用 f 数组来保存从x->n 的最大权值

code

#include <iostream>
#include <vector>
#include <queue>
#include <cstring>

using namespace std;

int a[100001],tb[100001],ta[100001];

vector<int> g[100001],gf[100001];

int main()
{
    int n,m;
    cin>>n>>m;
    for(int i=1;i<=n;++i)
    {
        cin>>a[i];
    }
    for(int i=1;i<=m;i++)
    {
        int x,y,z;
        cin>>x>>y>>z;
        g[x].push_back(y);
        gf[y].push_back(x);
        if(z==2)
        {
            g[y].push_back(x);
            gf[x].push_back(y);
        }
    }
    queue<int> q;
    q.push(1);
    memset(ta,127,sizeof(ta));
    ta[1]=2147483647;
    while(!q.empty())
    {
        int t=q.front();
        q.pop();
        ta[t]=min(ta[t],a[t]);
        int l=g[t].size();
        for(int i=0;i<l;i++)
        {
            if(ta[t]<ta[g[t][i]])
            {
                ta[g[t][i]]=ta[t];
                q.push(g[t][i]);
            }
        }
    }
    q.push(n);
    while(!q.empty())
    {
        int t=q.front();
        q.pop();
        tb[t]=max(tb[t],a[t]);
        int l=gf[t].size();
        for(int i=0;i<l;i++)
        {
            if(tb[t]>tb[gf[t][i]])
            {
                tb[gf[t][i]]=tb[t];
                q.push(gf[t][i]);
            }
        }
    }
    int ans=0;
    for(int i=1;i<=n;i++)
    {
        ans=max(ans,tb[i]-ta[i]);
    }
    cout<<ans;
    return 0;
}

No.3 Sorting It All Out

题目点标题               思路：

                           这是一道利用于floyd的有向闭包传递问题，存图时用 1表示 a>b ，0表示<;

                           floyd传递完成后，若有d[i,j]=d[j,i]=1,则矛盾。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
bool a[30][30];
int b[30],n,m,i,j,k;
char x,y;
int main()
{
    while(~scanf("%d%d
",&n,&m)&&n)
    {
        memset(a,0,sizeof(a));
        for(i=1;i<=n;i++) a[i][i]=1;
        for(i=1;i<=m;i++)
        {
            scanf("%c<%c
",&x,&y);
            x=x-'A'+1,y=y-'A'+1;
            a[x][y]=1;
            for(j=1;j<=n;j++)
                for(k=1;k<=n;k++)
                    if(a[j][x]&&a[y][k]) a[j][k]=1;
            for(j=1;j<n;j++)
                for(k=j+1;k<=n;k++)
                    if(a[j][k]&&a[k][j])
                    {
                        printf("Inconsistency found after %d relations.
",i);
                        j=n; break;
                    }
                    else if(!a[j][k]&&!a[k][j]) x=0;
            if(j==n+1) break;
            if(x&&j==n)
            {
                printf("Sorted sequence determined after %d relations: ",i);
                memset(b,0,sizeof(b));
                for(j=1;j<n;j++)
                    for(k=j+1;k<=n;k++)
                        if(a[j][k]) b[j]++; else b[k]++;
                for(j=n-1;j>=0;j--)
                    for(k=1;k<=n;k++)
                        if(b[k]==j) {putchar(k+'A'-1); break;}
                puts(".");
                break;
            }
        }
        if(i>m) puts("Sorted sequence cannot be determined.");
        for(i++;i<=m;i++) scanf("%c<%c
",&x,&y);
    }
    return 0;
}

No.4 贫富差距

题目描述

一个国家有N个公民，标记为0,1,2，...，N-1，每个公民有一个存款额。已知每个公民有一些朋友，同时国家有一条规定朋友间的存款额之差不能大于d。也就是说，a和b是朋友的话，a有x元的存款，b有y元，那么|x-y|<=d。给定d值与N个人的朋友关系，求这个国家最富有的人和最贫穷的人的存款相差最大的可能值是多少？即求贫富差距的最大值的下界。若这个值为无穷大，输出-1.
输入

多组测试数据，第一行一个整数T，表示测试数据数量，1<=T<=5
每组测试数据有相同的结构构成。
每组数据的第一行两个整数N，d，表示人数与朋友间存款差的最大值，其中2<=N<=50,0<=d<=1000.
接下来有一个N*N的数组A，若A[i][j]='Y'表示i与j两个人是朋友，否则A[i][j]='N'表示不是朋友。其中A[i][i]='N'，且保证
A[i][j]=A[j][i].
输出

每组数据一行输出，即这个国家的贫富差距最大值的下界，如果这个值为无穷大输出-1.
输入样例

    3
    3 10
    NYN
    YNY
    NYN
    2 1
    NN
    NN
    6 1000
    NNYNNN
    NNYNNN
    YYNYNN
    NNYNYY
    NNNYNN
    NNNYNN

输出样例

    20
    -1
    3000

思路

      floyd求多源最短路，然后将最小值拿出来*d即为answer；

code

#include <stdio.h>
#include <string.h>
const int inf = 99999999;
int map[55][55], n;
void Floyd()
{
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            for (int k = 0; k < n; k++)
                if (map[j][k] > map[j][i] + map[i][k])
                    map[j][k] = map[j][i] + map[i][k];
}
int main()
{
    int d, t, ans;
    char str[55][55];
    scanf("%d", &t);
    while (t--)
    {
        ans = -inf;
        scanf("%d%d", &n, &d);
        for (int i = 0; i < n; i++)
            scanf("%s", str[i]);
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < n; j++)
            {
                if (str[i][j] == 'Y')
                    map[i][j] = 1;
                else
                {
                    if (i != j)
                        map[i][j] = inf;
                    else map[i][j] = 0;
                }
            }
        }
        Floyd();
        for (int i = 0; i < n; i++)
            for (int j = 0; j < n; j++)
                if (ans < map[i][j])
                    ans = map[i][j];
        if (ans < inf)
            printf("%d
", ans * d);
        else printf("-1
");
    }
    return 0;
}