【PAT】1003 Emergency

解题思路：

//dijkstra最短路+堆优化(6ms)
//与模板题有所不同的是相同是要计算最短路的条数，那么相同时也要计算，且更新多条最短路中能聚集的人数
//让我没想到的是，似乎pat的数据给的很小，直接暴力dfs也可以轻松通过

//pat的题目可以尝试直接暴力，数据很弱 

 dijstra解法（没有必要）

这里只要求两点间的最短路，直接dfs即可

struct edge
{
    int v, w, next;
    edge(){}
    edge(int _v, int _w, int _next)
    {
        v = _v;
        w = _w;
        next = _next;
    };
}e[mode * 50];

//struct node
//{
//    int pos, dis;
//    bool operator<(const node &lhs) const
//    {
//        return dis > lhs.dis;
//    }
//};

int head[mode], siz = 0;
void insert(int u, int v, int w)
{
    e[siz] = edge(v, w, head[u]);
    head[u] = siz++;

    e[siz] = edge(u, w, head[v]);
    head[v] = siz++;
}
int num[mode];

//priority_queue<node> q;
//bool vis[mode];
//int cnt, len[mode], res[mode];
//void dijkstra(int s, const int &t)
//{
//    q.push((node){s, 0});
//    res[s] = num[s];
//    vis[s] = true;
//    while(!q.empty())
//    {
//        int u = q.top().pos;
//        int dis = q.top().dis;
//        q.pop();
//        for(int i = head[u]; ~i; i= e[i].next)
//        {
//            int v = e[i].v, w = e[i].w;
//            if(!vis[v] && dis + w < len[v])
//            {
//                vis[v] = true;
//                len[v] = dis + w;
//                q.push((node){v, len[v]});
//                res[v] = max(res[v], res[u] + num[v]);
//            }
            访问过则只剩下相同的可能，没有更大的可能
//            else if(len[v] && dis + w == len[v])
//            {
//                if(v == t)
//                {
                    最短路条数
//                    cnt++;
//                }
                再加一次队列去更新能聚集的最大人数
//                q.push((node){v, len[v]});
//                res[v] = max(res[v], res[u] + num[v]);
//            }
//        }
//    }
//}

//暴力dfs解法：

//只要在长度大于之前的其他路的长度，那么就剪掉返回，不需要dijkstra
//果然，暴力dfs的也通过了,时间(6ms)，甚至不剪枝也没有影响

代码：

int lu = 0, ans = 0, len[mode], vis[mode];
void dfs(int u, int ren, int dis, const int &t)
{
    if(dis > len[u])
    {
        return;
    }
    if(dis < len[u])
    {
        if(u == t)
        {
            lu = 0;
            ans = 0;
        }
        len[u] = dis;
    }
    if(u == t)
    {
        ans = max(ans, ren);
        lu++;
        return;
    }
    for(int i = head[u]; ~i; i= e[i].next)
    {
        int v = e[i].v, w = e[i].w;
        if(!vis[v])
        {
            vis[v] = true;
//            cout << ren + num[v] << endl;
            dfs(v, ren + num[v], dis + w, t);
            vis[v] = false;
        }
    }
}

main函数： 

 

int main()
{
//    初始化建边数组 和 记录最短路长度的数组
    memset(head, -1, sizeof(head));
    memset(len, 0x3f, sizeof(len));
    int n, m, s, t;
    read(n); read(m); read(s); read(t);
//    记录各个城市的人数
    for(int i = 0; i < n; i++)
    {
        read(num[i]);
    }
//    建图
    for(int u, v, w, i = 0; i < m; i++)
    {
        read(u); read(v); read(w);
        insert(u, v, w);
    }
//    dijkstra(s, t);
    vis[s] = true;
//    len[s] = 0;
    dfs(s, num[s], 0, t);
    printf("%d %d", lu, ans);
    return 0;
}