shortest path

单源最短路径

　　单终点最短路径问题

　　单对顶点最短路径问题

　　每队顶点的最短路径

最短路径有最优子结构

即使存在负权值的边只要没有从源点可达的负权值回路就存在最短路径。

1.Bellman-Ford可以检查并报告出这种回路的存在

负权回路：回路中权值相加为负值就为负权回路

正权回路：不存在最短路径

0权回路：可以去掉，然后变成一个无环图

图G=(V,E)包含最多V个不同顶点，|V|-1条边

2.dag有向无环图

先进行拓扑排序，然后松弛

可以

pert-chart分析中确定关键路径，－－要完成工作的最长时间  把正无穷－》负无穷，然后>改成<

单源最短路径采用的是临接表

每队顶点的最短距离采用的是临接矩阵

floyd算法思想：

void floyd() {
      for(int i=1; i<=n ; i++){
        for(int j=1; j<= n; j++){
          if(map[i][j]==Inf){
               path[i][j] = -1;//表示  i -> j 不通 
          }else{
               path[i][j] = i;// 表示 i -> j 前驱为 i
          }
        }
      }
      for(int k=1; k<=n; k++) {
        for(int i=1; i<=n; i++) {
          for(int j=1; j<=n; j++) {
            if(!(dist[i][k]==Inf||dist[k][j]==Inf)&&dist[i][j] > dist[i][k] + dist[k][j]) {
              dist[i][j] = dist[i][k] + dist[k][j];
              path[i][k] = i;
              path[i][j] = path[k][j];
            }
          }
        }
      }
    }
    void printPath(int from, int to) {
        /*
         * 这是倒序输出，若想正序可放入栈中，然后输出。
         * 
         * 这样的输出为什么正确呢？个人认为用到了最优子结构性质，
         * 即最短路径的子路径仍然是最短路径
         */
        while(path[from][to]!=from) {
            System.out.print(path[from][to] +"");
            to = path[from][to];
        }
    }

Bellman_Ford

void floyd() {
      for(int i=1; i<=n ; i++){
        for(int j=1; j<= n; j++){
          if(map[i][j]==Inf){
               path[i][j] = -1;//表示  i -> j 不通 
          }else{
               path[i][j] = i;// 表示 i -> j 前驱为 i
          }
        }
      }
      for(int k=1; k<=n; k++) {
        for(int i=1; i<=n; i++) {
          for(int j=1; j<=n; j++) {
            if(!(dist[i][k]==Inf||dist[k][j]==Inf)&&dist[i][j] > dist[i][k] + dist[k][j]) {
              dist[i][j] = dist[i][k] + dist[k][j];
              path[i][k] = i;
              path[i][j] = path[k][j];
            }
          }
        }
      }
    }
    void printPath(int from, int to) {
        /*
         * 这是倒序输出，若想正序可放入栈中，然后输出。
         * 
         * 这样的输出为什么正确呢？个人认为用到了最优子结构性质，
         * 即最短路径的子路径仍然是最短路径
         */
        while(path[from][to]!=from) {
            System.out.print(path[from][to] +"");
            to = path[from][to];
        }
    }

Dijkstra

const int  MAXINT = 32767;
const int MAXNUM = 10;
int dist[MAXNUM];
int prev[MAXNUM];

int A[MAXUNM][MAXNUM];

void Dijkstra(int v0)
{
  　　bool S[MAXNUM];                                  // 判断是否已存入该点到S集合中
      int n=MAXNUM;
  　　for(int i=1; i<=n; ++i)
 　　 {
      　　dist[i] = A[v0][i];
      　　S[i] = false;                                // 初始都未用过该点
      　　if(dist[i] == MAXINT)    
            　　prev[i] = -1;
 　　     else 
            　　prev[i] = v0;
   　　}
   　 dist[v0] = 0;
   　 S[v0] = true; 　　
 　　 for(int i=2; i<=n; i++)
 　　 {
       　　int mindist = MAXINT;
       　　int u = v0; 　　                            // 找出当前未使用的点j的dist[j]最小值
      　　 for(int j=1; j<=n; ++j)
      　　    if((!S[j]) && dist[j]<mindist)
      　　    {
         　　       u = j;                             // u保存当前邻接点中距离最小的点的号码 
         　 　      mindist = dist[j];
       　　   }
       　　S[u] = true; 
       　　for(int j=1; j<=n; j++)
       　　    if((!S[j]) && A[u][j]<MAXINT)
       　　    {
           　    　if(dist[u] + A[u][j] < dist[j])     //在通过新加入的u点路径找到离v0点更短的路径  
           　    　{
                   　　dist[j] = dist[u] + A[u][j];    //更新dist 
                   　　prev[j] = u;                    //记录前驱顶点 
            　　    }
        　    　}
   　　}
}

 Kruskal   hhhhhh   无向联通图的最小生成树，节点：n  边 n*(n-1)/2

hhhhh  kruskal算法详解。

uva,117

给出街道的名字，第一个字母和最后一个字母代表节点，

此无向图为欧拉回路，当所有节点的度都为偶数的时候，直接走一次就能过一次回路，所以把所有的长度加和就可以了

如果存在奇数度的点只可能是一个起点一个终点，把所有的距离加和然后加一次从起点到终点的最短路径就可以了。floyd算法，

#include <algorithm>
#include <iostream>
#include <string>
using namespace std;
//主函数
int main(void) {
    //aMat为连通路口的邻接矩阵，aIdHash为路口字母与其编号的对应表
    //nNodeCnt为路口数量，nRout为最小路径长度
    int aMat[26][26], aIdHash[26], nNodeCnt = 0, nRout = 0, nInf = 0xFFFFFF;
    fill(&aMat[0][0], &aMat[26][0], nInf);
    fill(&aIdHash[0], &aIdHash[26], nInf);
    //循环处理每一行输入，结束时将nRout清0
    for (string strName; cin >> strName;) {
        //如果街名为结束符，则按前一阶段的输入数据进行运算
        if (strName == "deadend") {
            //aOdd数组用于记录奇顶点，pOdd是aOdd的指针形式
            int aOdd[2] = {0, 0}, *pOdd = &aOdd[0];
            for (int i = 0; i < nNodeCnt && pOdd != &aOdd[2]; ++i) {
                //统计每一个顶点的相邻顶点数(连通路口数)
                for (int j = 0; j < nNodeCnt; *pOdd += (aMat[i][j++] != nInf));
                //如果发现奇顶点，加入奇顶点数组
                if (*pOdd % 2 != 0) {
                    *(pOdd++) = i;
                }
            }
            //如果存在两个奇顶点，则开始Floyd算法，找最短路径
            if (pOdd != aOdd) {
                for (int k = 0, nSum; k < nNodeCnt; ++k) {
                    for (int i = 0; i < nNodeCnt; ++i) {
                        //为加快运算减少代码，设置临时变量p = aMat[i]
                        for (int j = 0, *p = &aMat[i][0]; j < nNodeCnt; ++j) {
                            nSum = p[k] + aMat[k][j];
                            p[j] = nSum < p[j] ? nSum : p[j];
                        }
                    }
                }
                nRout += aMat[aOdd[0]][aOdd[1]];
            }
            //输出最小路径长度
            cout << nRout << endl;
            //初始化数据，以便进行下一轮计算
            fill(&aMat[0][0], &aMat[nNodeCnt][0], nInf);
            fill(&aIdHash[0], &aIdHash[26], nInf);
            nRout = nNodeCnt = 0;
            continue;
        }
        //街道名称的首尾字母
        int nF = *strName.begin() - 'a', nL = *(strName.end() - 1) - 'a';
        //验证路口字母是否已经存在，否则添加路口
        nF = (aIdHash[nF] = aIdHash[nF] == nInf ? nNodeCnt++ : aIdHash[nF]);
        nL = (aIdHash[nL] = aIdHash[nL] == nInf ? nNodeCnt++ : aIdHash[nL]);
        //在邻接距阵中添加路口节点
        aMat[nF][nL] = aMat[nL][nF] = strName.length();
        //统计路径长度
        nRout += strName.length();
    }
    return 0;
}

uva,534

青蛙从一块石头跳到另外一块石头，文最小生成树里面的最大距离

Kruskal

#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>

using namespace std;
const int N=202;

struct Point{
    int x,y;
    void read()
    {
        scanf("%d%d",&x,&y);
    }
}p[N];

double dis(Point a,Point b)
{
    int dx=a.x-b.x;
    int dy=a.y-b.y;
    
    return sqrt(dx*dx+dy*dy);
}


struct Edge
{
    int u;
    int v;
    double d;
    
    Edge(){}
    Edge(int u,int v)
    {
        this->u=u;
        this->v=v;
        d=dis(p[u],p[v]);
    }
    bool operator<(const Edge& c)const
    {
        return d<c.d;
    }
}E[N*N];

int n,parent[N];

int find(int x)
{
    return x==parent[x] ? x:parent[x]=find(parent[x]);
}


int main()
{
    int cas=1;
    while(~scanf("%d",&n),n)
    {
        int en=0;
        
        for(int i=0;i<n;i++)
        {
            parent[i]=i;
            p[i].read();
            for(int j=0;j<i;j++)
            {
                E[en++]=Edge(i,j);
            }
        }
        
        sort(E,E+en);
        for(int i=0;i<en;i++)
        {
            int pa=find(E[i].u);
            int pb=find(E[i].v);
            
            if(pa!=pb)
                parent[pa]=pb;
            
            if(find(0)==find(1))
            {
                printf("Scenario #%d
Frog Distance = %.3lf

",cas++,E[i].d);
                break;
            }
        }
    }
    return 0;
}

 Dijkstra

#include <cstdio>
#include <cmath>

using namespace std;

double min(double a,double b)
{
    return (a<b)?a:b;
}

double dis(double ax,double ay,double bx,double by)
{
    return sqrt((ax-bx)*(ax-bx)+(ay-by)*(ay-by));
}

int main()
{
    int n;
    int sets=1;
    
    while(~scanf("%d",&n),n)
    {
        int i;
        double stone[205][5]={0};
        
        for(i=0;i<n;i++)
            scanf("%lf%lf",&stone[i][0],&stone[i][1]);
        
        int now=0;
        
        double dijkstra[205][5]={0};
        for(i=0;i<205;i++)
            dijkstra[i][0]=2147483647;
        dijkstra[0][1]=1;
        
        double maxdistance=0;
        
        int temp=1;
        while(now!=1)
        {
            temp=1;
            for(i=0;i<n;i++)
                    if(dijkstra[i][1]==0)
                    {
                        dijkstra[i][0]=min(dis(stone[now][0],stone[now][1],stone[i][0],stone[i][1]),dijkstra[i][0]);
                        if(dijkstra[i][0]<dijkstra[temp][0])
                            temp=i;
                    }
            now=temp;
            maxdistance=(dijkstra[now][0]>maxdistance?dijkstra[now][0]:maxdistance);
            dijkstra[now][1]=1;
        }
        printf("Scenario #%d
",sets++);
        printf("Frog Distance = %.3lf

",maxdistance);
    }
    return 0;
}

 uva,10000

换一下思路，给每个问题的权值为－1求最小的绝对值最大注意最后换行。

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <cstring>
using namespace std;

const int maxn=105;
int map[maxn][maxn];
int path[maxn][maxn];
int n;


void floyd()
{
    
    for(int k=1;k<=n;k++)
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
            {
                map[i][j]=min(map[i][j],map[i][k]+map[k][j]);
            }
    
}

int main()
{
    int start;
    int from,to;
    int cas=1;
    while(~scanf("%d",&n),n)
    {
        memset(map,0x3F,sizeof(map));
        for(int i=1;i<=n;i++)
            map[i][i]=0;
        scanf("%d",&start);
        while(true)
        {
            scanf("%d%d",&from,&to);
            if(!from && !to)
                break;
            map[from][to]=-1;
        }
        floyd();
        
        int max=0;
        int index=0;
        for(int i=1;i<=n;i++)
        {
            if(map[start][i]<max)
            {
                max=map[start][i];
                index=i;
            }
        }
        max=abs(max);
        printf("Case %d: The longest path from %d has length %d, finishing at %d.

",cas++,start,max,index);
    }
    return 0;
}

 uva,10099

给一个强联通图，每条线路上有一个门限值，求运一拨人，最少运几次，

思想：用kruskal的思想求出最大生产树，然后求出树里面最小值的边，最后求解。

注意“”“”“”“”“  导游要剔除。  即每次运的人要减一。。。。难怪一开始看不懂

#include <iostream>
#include <cstdio>
#include <algorithm>

using namespace std;

const int maxn=105;

struct Edge
{
    int u,v;
    int weight;
    bool operator<(const Edge& a)const
    {
        return weight>a.weight;
    }
}E[maxn*maxn];


int parent[maxn];
int find(int x)
{
    return x==parent[x]?x:parent[x]=find(parent[x]);
}

int main()
{
    int N,R;
    int S,D,T;
    int cas=1;
    while(scanf("%d%d",&N,&R) && N+R)
    {
        for(int i=1;i<=N;i++)
            parent[i]=i;   //一开始赋值赋错了，tle了几次。
        for(int i=0;i<R;i++)
        {
            scanf("%d%d%d",&E[i].u,&E[i].v,&E[i].weight);
        }
        
        scanf("%d%d%d",&S,&D,&T);
        sort(E,E+R);
        int re=0;
        for(int i=0;i<R;i++)
        {
            int pa=find(E[i].u);
            int pb=find(E[i].v);
            
            if(pa!=pb)
                parent[pa]=pb;
            if(find(S)==find(D))
            {
                re=E[i].weight;
                break;
            }
        }
        re--;
        int flag=0;
        if(T%re==0)
            flag=1;
        int t=T/re;
        if(!flag)
            t++;
        
        printf("Scenario #%d
Minimum Number of Trips = %d

",cas++,t);
    }
    return 0;
}