HDU5870 Alice's Adventure in Wonderland

　　 大概做法是这样的

考虑最朴素的做法，预处理出1到所有点的最短路数组dis1和方案数数组cnt1，和预处理出n到所有点的最短路数组dis2和方案数数组出cnt2,然后暴力枚举点对(A,B),如果A和B之间没有连边，那么就可以考虑添加一条正权边，满足这个条件就能添加dis1[A]+dis2[B]+1<=dis1[n],且cnt1[A]*cnt2[B]>=X,由于是要使方案增加，所以将边权设为dis1[n]-(dis1[A]+dis2[B])是最好的，因为可以继承原有的最短路方案数。那么由于（A,B）和(B,A)只算一次，那么第一维枚举到A第二维枚举到B，和第一维枚举到B第二维枚举到A会不会算同一种呢，可以证明这种情况并不会出现重复技计数。

那么考虑优化，枚举点A，点B需满足dis1[A]+dis2[B]+1<=dis1[n]，那么可以将dis2进行排序，然后二分出临界范围，然后查询出这个范围内cnt2[B]>=X/cnt[A]的数目，离线的话做法估计挺多的，我代码里用了主席树，最后还需要去掉范围内已经连边的点和自身。时间复杂度O（nlogn）

　　代码

 #include<cstdio>
 #include<vector>
 #include<set>
 #include<queue>
 #include<algorithm>
 #define mp make_pair
 #define pb push_back
 #define fi first
 #define sc second
 using namespace std;
 const int N = ;
 const int M = ;
 const int inf = ;
 typedef pair<int,int> P;
 priority_queue<P,vector<P>,greater<P> > Q;
 int n,m,i,a,b,c,dis[N],cnt[N],dis1[N],cnt1[N],dis2[N],cnt2[N],X;
 int id[N],ID[N],Id[N];
 vector<P> e[N];
 void gao(int x)
 {
     int i;
     for (i=;i<=n;i++)
     dis[i]=inf,cnt[i]=;
     dis[x]=;
     cnt[x]=;
     Q.push(mp(,x));
     while (!Q.empty())
     {
         P tmp=Q.top();
         Q.pop();
         x=tmp.sc;
         if (dis[x]!=tmp.fi) continue;
         for (i=;i<e[x].size();i++)
         if (dis[x]+e[x][i].sc<dis[e[x][i].fi])
         {
             dis[e[x][i].fi]=dis[x]+e[x][i].sc;
             cnt[e[x][i].fi]=cnt[x];
             Q.push(mp(dis[e[x][i].fi],e[x][i].fi));
         }
         else
         if (dis[x]+e[x][i].sc==dis[e[x][i].fi])
         {
             cnt[e[x][i].fi]+=cnt[x];
             if (cnt[e[x][i].fi]>X) cnt[e[x][i].fi]=X;
         }
     }
 }

 int ls[M],rs[M],s[M],tot,root[N];
 void build(int &x,int a,int b)
 {
     x=++tot;
     ls[x]=rs[x]=s[x]=;
     if (b-a>)
     {
         int m=(a+b)>>;
         build(ls[x],a,m);
         build(rs[x],m,b);
     }
 }
 void insert(int y,int &x,int a,int b,int l,int r)
 {
     x=++tot;
     ls[x]=ls[y];rs[x]=rs[y];s[x]=s[y]+;
     if ((a<=l)&&(r<=b))
     return;
     int m=(l+r)>>;
     if (a<m) insert(ls[y],ls[x],a,b,l,m);
     if (m<b) insert(rs[y],rs[x],a,b,m,r);
 }
 int query(int x,int a,int b,int l,int r)
 {
     if ((a<=l)&&(r<=b))
     return s[x];
     int m=(l+r)>>,ans=;
     if (a<m) ans+=query(ls[x],a,b,l,m);
     if (m<b) ans+=query(rs[x],a,b,m,r);
     return ans;
 }
 bool cmp(int a,int b)
 {
     return dis2[a]<dis2[b];
 }
 bool CMP(int a,int b)
 {
     return cnt2[a]>cnt2[b];
 }
 int main()
 {
     while (~scanf("%d%d",&n,&m))
     {
     if (n+m==) return ;
     for (i=;i<=n;i++) e[i].clear();
     scanf("%d",&X);
     for (i=;i<=m;i++)
     {
         scanf("%d%d%d",&a,&b,&c);
         e[a].pb(mp(b,c));
         e[b].pb(mp(a,c));
     }
     gao();
     for (i=;i<=n;i++)
     dis1[i]=dis[i],cnt1[i]=cnt[i];
     gao(n);
     for (i=;i<=n;i++)
     dis2[i]=dis[i],cnt2[i]=cnt[i];

     tot=;
     build(root[],,n);
     for (i=;i<=n;i++)
     id[i]=i;
     sort(id+,id++n,cmp);
     for (i=;i<=n;i++)
     ID[id[i]]=i;

     for (i=;i<=n;i++)
     Id[i]=i;
     sort(Id+,Id++n,CMP);
     for (i=;i<=n;i++)
         insert(root[i-],root[i],ID[Id[i]]-,ID[Id[i]],,n);
     long long ans=;
     for (i=;i<=n;i++)
     {
         int l=,r=n;
         while (l<=r)
         {
             m=(l+r)>>;
             if (dis2[id[m]]+dis1[i]+<=dis1[n]) l=m+;else r=m-;
         }
         int j=r;

         l=;r=n;
         while (l<=r)
         {
             m=(l+r)>>;
             if (1LL*cnt1[i]*cnt2[Id[m]]>=X) l=m+;else r=m-;
         }

         if (j) ans=ans+query(root[r],,j,,n);

         for (int k=;k<e[i].size();k++)
         if (dis2[e[i][k].fi]++dis1[i]<=dis1[n])
         if (1LL*cnt1[i]*cnt2[e[i][k].fi]>=X) ans--;

         if (dis1[i]+dis2[i]+<=dis1[N])
         if (1LL*cnt1[i]*cnt2[i]>=X) ans--;

     }
     printf("%lld\n",ans);
     }
 }