pku1556The Doors

題目：pku1556

方法：直線相交判斷+dijkstra算法

思路：把每個門的兩點看成圖中的一個點，構造一個以兩點距離爲權值的圖（如果不可直達，記爲INF），

再用dijkstra算法求出兩個端點點的最短路。

注意：不要用memset初始化g,d;用memset初始化爲非0值時，其值並非我們想象的，儘管那值很穩定。

如定義一個數組long a[20];memset(a,1,sizeof(a));用一個循環語句將各元素輸出，其值都一樣。

但並不是1，而是16843009。

代碼：

//0 <= n <= 30  

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

//Dijkstra算法模板開始
//==============================================
#define MAX 105
#define INF 0x11111111
#define TRUE 1
#define FALSE 0

typedef struct{
    //double info;
}VertexType;

typedef struct{
    double val;
    //double info;
}ArcType,ArcMatrix[MAX][MAX];

typedef struct{
    int vexnum;
    VertexType vexs[MAX];
    ArcMatrix arcs;
}MGraph;

typedef double ShortPathTable[MAX];

void ShortestPath_DIJ(MGraph &G,int v0, ShortPathTable &D)
{
    // 用Dijkstra算法求有向網G的v0頂點到其餘頂點v的最短路徑P[v]
    // 及其帶權長度D[v]。
    // 若P[v][w]爲TRUE，則w是從v0到v當前求得最短路徑上的頂點。
    // final[v]爲TRUE當且僅當v∈S,即已經求得從v0到v的最短路徑。
    int i=0, v,w;
	double min;
    bool final[MAX];
    for (v=0; v<G.vexnum; ++v)
    {
        final[v] = FALSE; 
        D[v] = G.arcs[v0][v].val;
    }
    D[v0] = 0; final[v0] = TRUE;        // 初始化，v0頂點屬於S集
    //--- 開始主循環，每次求得v0到某個v頂點的最短路徑，並加v到S集 ---
    for (i=1; i<G.vexnum; ++i)           // 其餘G.vexnum-1個頂點
    {
        min = INF;                  // 當前所知離v0頂點的最近距離
        for (w=0; w<G.vexnum; ++w)
            if (!final[w])                             // w頂點在V-S中
                if (D[w]<min) { v = w; min = D[w]; } // w頂點離v0頂點更近
        final[v] = TRUE;                       // 離v0頂點最近的v加入S集
        for (w=0; w<G.vexnum; ++w)             // 更新當前最短路徑及距離
            if (!final[w] && (min+G.arcs[v][w].val<D[w])) { 
                // 修改D[w]和P[w], w∈V-S
                D[w] = min + G.arcs[v][w].val;
            }//if
    }//for
} // ShortestPath_DIJ
MGraph g;
ShortPathTable d;
//=========================================================

//判斷線段相交、距離、差積的計算
//========================================================
struct point
{   double x,y;  }; 
struct line
{   point s, e;  };
double max(double a,double b)
{	return a>b?a:b;		}
double min(double a,double b)
{	return a<b?a:b;		}

//計算距離
double dist(point p1,point p2)
{   double x1=p1.x-p2.x,y1=p1.y-p2.y;
    return sqrt(x1*x1+y1*y1);  
}
//計算叉積
double multi(point p0,point p1,point p2)
{   return (p1.x-p0.x)*(p2.y-p0.y)-(p2.x-p0.x)*(p1.y-p0.y);}
//判斷線段相交  差積有等於號時爲非規範相交，無等號爲規範相交
bool is_cross(point s1,point e1,point s2,point e2)
{
   return max(s1.x,e1.x)>=min(s2.x,e2.x)&&
          max(s2.x,e2.x)>=min(s1.x,e1.x)&&
          max(s1.y,e1.y)>=min(s2.y,e2.y)&&
          max(s2.y,e2.y)>=min(s1.y,e1.y)&&
          multi(s2,e1,s1)*multi(e1,e2,s1)>0&&
          multi(s1,e2,s2)*multi(e2,e1,s2)>0;
}
//============================================================

//0 < x < 10
//思路：把每個門的兩點看成圖中的一個點，構造一個以兩點距離爲權值的圖（如果不可直達，記爲INF），
//再用dijkstra算法求出兩個端點點的最短路。
int main()
{
    int n;
	int i,j,k,s,t;
	double x,y1,y2,y3,y4,temp;
	line segment[60];
	point p[MAX];
	while(cin>>n)
	{
		if(n==-1)break;
		p[0].x=0;p[0].y=5;j=1;k=0;
		for(i=0;i<n;i++)
		{
			cin>>x>>y1>>y2>>y3>>y4;
			p[j].x=x;p[j].y=y1;j++;
			p[j].x=x;p[j].y=y2;j++;
			p[j].x=x;p[j].y=y3;j++;
			p[j].x=x;p[j].y=y4;j++;
			segment[k].s.x=x;segment[k].s.y=0;segment[k].e.x=x;segment[k].e.y=y1;k++;
			segment[k].s.x=x;segment[k].s.y=y2;segment[k].e.x=x;segment[k].e.y=y3;k++;
			segment[k].s.x=x;segment[k].s.y=y4;segment[k].e.x=x;segment[k].e.y=10;k++;
		}
		p[j].x=10;p[j].y=5;
		g.vexnum = j+1;
        //memset(g.arcs,INF,sizeof(g.arcs));
        //memset(d,INF,sizeof(d)); 
		for(i=0;i<=j;i++)
			for(s=0;s<=j;s++)
				g.arcs[i][s].val=INF;
		for(i=0;i<=j+1;i++)d[i]=INF;
		for(i=0;i<j;i++)
			for(s=i+1;s<=j;s++)
			{
				for(t=0;t<k;t++)
					 if(is_cross(p[i],p[s],segment[t].s,segment[t].e)&&p[i].x!=p[s].x)break;
				if(t==k)
				{
					temp=dist(p[i],p[s]);
					g.arcs[i][s].val=temp;
					g.arcs[s][i].val=temp;
				}
			}
		ShortestPath_DIJ(g,0,d);
        printf("%.2lf\n",d[j]);
	}  
    return 0;
}