Shortest Path（hdu5636）

Shortest Path

 

 Accepts: 40

 

 Submissions: 610

 Time Limit: 4000/2000 MS (Java/Others)

 

 Memory Limit: 131072/131072 K (Java/Others)

问题描述

有一条长度为nn的链. 节点ii和i+1i+1之间有长度为11的边. 现在又新加了3条边, 每条边长度都是1. 给出mm个询问, 每次询问两点之间的最短路.

输入描述

输入包含多组数据. 第一行有一个整数TT, 表示测试数据的组数. 对于每组数据:

第一行包含2个整数nn和mm (1 le n,m le 10^5)(1≤n,m≤10​5​​)表示节点的数目和询问数目. 接下来一行包含66个有空格分开的整数a_1, b_1, a_2, b_2, a_3, b_3a​1​​,b​1​​,a​2​​,b​2​​,a​3​​,b​3​​ (1 le a_1,a_2,a_3,b_1,b_2,b_3 le n)(1≤a​1​​,a​2​​,a​3​​,b​1​​,b​2​​,b​3​​≤n), 表示新加的三条边为(a_1,b_1)(a​1​​,b​1​​), (a_2,b_2)(a​2​​,b​2​​), (a_3,b_3)(a​3​​,b​3​​). 接下来mm行, 每行包含两个整数s_is​i​​和t_it​i​​ (1 le s_i, t_i le n)(1≤s​i​​,t​i​​≤n), 表示一组询问.

所有数据中mm的和不超过10^610​6​​.

输出描述

对于每组数据, 输出一个整数S=(displaystylesum_{i=1}^{m} i cdot z_i) 	ext{ mod } (10^9 + 7)S=(​i=1​∑​m​​i⋅z​i​​) mod (10​9​​+7), 其中z_iz​i​​表示第ii组询问的答案.

输入样例

1
10 2
2 4 5 7 8 10
1 5
3 1

输出样例

7
思路：因为在每加入这些边之前我们知道任意两点最短距离是abs（a-b）；
那么我们每次要询问两个点之间的最短路，所以我们可以把新加的边和询问的边中两个点拿出来离散化下
然后建图加边，然后直接最短路即可，复杂度为O(m*8*8)。

#include<stdio.h>
#include<algorithm>
#include<iostream>
#include<stdlib.h>
#include<string.h>
#include<map>
using namespace std;
typedef long long LL;
int flag[10];
const  LL N=1e9+7;
int cmp(const void*p,const void*q);
typedef struct pp
{
    LL x;
    int id;
}ss;
ss aa[10];
LL d[10];LL ma[10][10];
LL num[10];LL bum[10];
void dij(int n,int ans);
int main(void)
{
    LL i,j,k,p,q;
    scanf("%lld",&k);
    while(k--)
    {
        scanf("%lld %lld",&p,&q);
        for(i=0;i<6;i++)
        {
            scanf("%lld",&num[i]);
        }LL sum=0;LL a=0;
        while(q--)
        {   a++;
            scanf("%lld %lld",&num[6],&num[7]);
            LL ans=1;
            for(i=0;i<8;i++)
            {
                aa[i].x=num[i];
                aa[i].id=i;
            }qsort(aa,8,sizeof(ss),cmp);
            bum[aa[0].id]=1;
            for(i=1;i<8;i++)
            {
                if(aa[i].x!=aa[i-1].x)
                    ans++;
                bum[aa[i].id]=ans;
            }
           for(i=0;i<10;i++)
            {
                for(j=0;j<10;j++)
                {
                    ma[i][j]=N;
                }
            }
            ma[bum[0]][bum[1]]=ma[bum[1]][bum[0]]=1;
            ma[bum[2]][bum[3]]=ma[bum[3]][bum[2]]=1;
            ma[bum[4]][bum[5]]=ma[bum[5]][bum[4]]=1;
            for(i=0;i<8;i++)
            {
                for(j=0;j<8;j++)
                {
                    LL x=bum[i];
                    LL y=bum[j];
                    ma[x][y]=min(ma[x][y],abs(num[i]-num[j]));
                }
            }
            dij(bum[6],ans);sum=(sum%N+d[bum[7]]*a%N)%N;
        }printf("%lld
",sum);
    }return 0;
}

void dij(int n,int ans)
{
    fill(d,d+10,N);
    memset(flag,0,sizeof(flag));
    d[n]=0;int i,j;
    while(true)
    {
        int l=-1;
        for(i=1;i<=ans;i++)
        {
            if((l==-1||d[l]>d[i])&&!flag[i])
            {
                l=i;
            }
        }if(l==-1)
        break;
        flag[l]=1;
        for(i=1;i<=ans;i++)
        {
            d[i]=min(ma[l][i]+d[l],d[i]);
        }
    }
}
int cmp(const void*p,const void*q)
{
    ss*n=(ss*)p;
    ss*m=(ss*)q;
    return n->x>m->x?1:-1;
}