【最短路的条数】hdu 6026 Deleting Edges

                                              Deleting Edges

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 131072/131072 K (Java/Others)
Total Submission(s): 2101    Accepted Submission(s): 686

 

Problem Description

Little Q is crazy about graph theory, and now he creates a game about graphs and trees.
There is a bi-directional graph with n nodes, labeled from 0 to n−1. Every edge has its length, which is a positive integer ranged from 1 to 9.
Now, Little Q wants to delete some edges (or delete nothing) in the graph to get a new graph, which satisfies the following requirements:
(1) The new graph is a tree with n−1 edges.
(2) For every vertice v(0<v<n), the distance between 0 and v on the tree is equal to the length of shortest path from 0 to v in the original graph.
Little Q wonders the number of ways to delete edges to get such a satisfied graph. If there exists an edge between two nodes i and j, while in another graph there isn't such edge, then we regard the two graphs different.
Since the answer may be very large, please print the answer modulo 109+7.

 

 

Input

The input contains several test cases, no more than 10 test cases.
In each test case, the first line contains an integer n(1≤n≤50), denoting the number of nodes in the graph.
In the following n lines, every line contains a string with n characters. These strings describes the adjacency matrix of the graph. Suppose the j-th number of the i-th line is c(0≤c≤9), if c is a positive integer, there is an edge between i and j with length of c, if c=0, then there isn't any edge between i and j.
The input data ensure that the i-th number of the i-th line is always 0, and the j-th number of the i-th line is always equal to the i-th number of the j-th line.

 

 

Output

For each test case, print a single line containing a single integer, denoting the answer modulo 109+7.

 

 

Sample Input

2 01 10 4 0123 1012 2101 3210

 

 

Sample Output

1 6

题意：一个图，要求保留n-1条边，同时保留完之后的所有点到0点的最短距离不便。

思路：最终做法是将每个点的最短路个数相乘。

解析：设到u点的最短路有dp[u]条，由于最后要删到n-1条，所以到u点的最短路中可以删掉dp[u]-1条，从dp[u]中选（dp[u]-1）个总共有dp[u]中方案，然后用乘法原理。倒着想也可以，保留的补集就是删除的，所以有多少合法的方案就有多少不合法的方案。

注意：在更新最短路的时候，一定要先判断有路，不然最短路就一直会被0更新

#include<iostream>
#include<algorithm>
#include<queue>
#include<cstring>
#include<string>
using namespace std;
typedef pair<int,int> pii;
typedef long long LL;
const int INF=0x3f3f3f3f;
const int mod=1e9+7;
const int N=55;
int n;
int a[N][N];
int dist[N];
int dp[N];
void dijkstra()
{
    priority_queue<pii>q;
    memset(dist,INF,sizeof(dist));
    dist[0]=0;
    q.push(pii(dist[0],0));
    //vis[0]=1;
    dp[0]=1;
    while(!q.empty())
    {
        pii tmp=q.top();
        q.pop();
        int d=tmp.first,u=tmp.second;
        if(dist[u]<d) continue;
        for(int v=0;v<n;++v)
        {
            if(a[u][v])     //有路是前提
            {
                if(d+a[u][v]<dist[v])
                {
                    dist[v]=d+a[u][v];
                    dp[v]=dp[u];
                    q.push(pii(dist[v],v));
                }
                else if(d+a[u][v]==dist[v])
                    dp[v]+=dp[u];
            }
        }
    }

}
int main()
{
        while(cin>>n)
        {
            //cout<<n<<endl;
            //读题错误导致读入错误
            for(int i=0;i<n;++i)
            {
                string s;
                cin>>s;
                for(int j=0;j<n;++j)
                    a[i][j]=s[j]-'0';
            }

            //cout<<"?"<<endl;
            dijkstra();
            LL ans=1;

            for(int i=0;i<n;++i)
            {
                //cout<<dp[i]<<endl;
                ans=(ans*dp[i])%mod;
            }
            //cout<<"?"<<endl;

            cout<<ans<<endl;

        }




    return 0;

}