洛谷 P2149 [SDOI2009]Elaxia的路线

最新推荐文章于 2022-11-17 13:50:55 发布

weixin_30614109

最新推荐文章于 2022-11-17 13:50:55 发布

阅读量79

点赞数

原文链接：http://www.cnblogs.com/BigYellowDog/p/11486934.html

版权

洛谷 P2149 [SDOI2009]Elaxia的路线

Description

最近，Elaxia和w**的关系特别好，他们很想整天在一起，但是大学的学习太紧张了，他们必须合理地安排两个人在一起的时间。

Elaxia和w**每天都要奔波于宿舍和实验室之间，他们希望在节约时间的前提下，一起走的时间尽可能的长。

现在已知的是Elaxia和w**所在的宿舍和实验室的编号以及学校的地图：地图上有N个路口，M条路，经过每条路都需要一定的时间。具体地说，就是要求无向图中，两对点间最短路的最长公共路径。

Input

第一行：两个整数N和M（含义如题目描述）。

第二行：四个整数x1、y1、x2、y2（1 ≤ x1 ≤ N，1 ≤ y1 ≤ N，1 ≤ x2 ≤ N，1 ≤ y2 ≤ N），分别表示Elaxia的宿舍和实验室及w**的宿舍和实验室的标号（两对点分别 x1,y1和x2,y2）。

接下来M行：每行三个整数，u、v、l（1 ≤ u ≤ N，1 ≤ v ≤ N，1 ≤ l ≤ 10000），表 u和v之间有一条路，经过这条路所需要的时间为l。

Output

一行，一个整数，表示每天两人在一起的时间（即最长公共路径的长度）

Sample Input

Sample Output

Data Size

对于30%的数据，N ≤ 100；

对于60%的数据，N ≤ 1000；

对于100%的数据，N ≤ 1500，输入数据保证没有重边和自环。

题解：

最短路。
这道题嗑了我一个星期... ...
首先我的第一思路是求出同时包含两组最短路的边，相加这些边权即可。然后pts37。原因是有可能有多条最短路径。一个Hack数据的图↓

o_%E6%97%A0%E6%A0%87%E9%A2%98.png

OK然后根据这个图加上问了一些大佬，发现可以用分类讨论来解决这个问题。
首先找出第一组最短路的路径。然后再找第二组最短路的路径。
第二次最短路要找两次。第一次找与第一组的边同向的边，第二次找与第一组的边反向的边。
为什么这样分类可以包含全部情况？因为要不就全部与第一组的边同向，要不就全部与第一组的边反向。如果出现了既有同向又有反向的情况，这种情况是不存在的。因为如果一旦第二组有一条边与第一组同向，那么它之后的路必定是同向的。（反向同理）
最后很坑的就是搜索里边要记忆化。

#include <iostream>
#include <cstdio>
#include <queue>
#include <cstring>
#define N 1505
#define M 2250005
using namespace std;

struct Node
{
    int val, pos;
    friend bool operator < (Node x, Node y) {
        return x.val > y.val;
    }
};
struct E {int next, to, dis, tag1, tag2;} e[M * 2], edge[M * 2];
int n, m, x1, y1, x2, y2, num = 1, num_edge = 1, cnt, ans;
int h[N], dis[N], head[N], seq[N], in[N], dp[N], rem[N];
bool vis[N];

int read()
{
    int x = 0; char c = getchar();
    while(c < '0' || c > '9') c = getchar();
    while(c >= '0' && c <= '9') {x = x * 10 + c - '0'; c = getchar();}
    return x;
}

void add(int u, int v, int w)
{
    e[++num].next = h[u];
    e[num].to = v;
    e[num].dis = w;
    h[u] = num;
}

void add_edge(int u, int v, int w)
{
    edge[++num_edge].next = head[u];
    edge[num_edge].to = v;
    edge[num_edge].dis = w;
    head[u] = num_edge;
}

void dijkstra(int str)
{
    priority_queue<Node> que;
    memset(vis, 0, sizeof(vis));
    memset(dis, 0x3f, sizeof(dis));
    que.push((Node){0, str}), dis[str] = 0;
    while(que.size())
    {
        int now = que.top().pos;
        que.pop();
        if(vis[now]) continue;
        vis[now] = 1;
        for(int i = h[now]; i != 0; i = e[i].next)
            if(dis[now] + e[i].dis < dis[e[i].to])
            {
                dis[e[i].to] = dis[now] + e[i].dis;
                que.push((Node){dis[e[i].to], e[i].to});
            }
    }
}

void dfs(int x, int end, int op, int tim)
{
    if(x == end) return;
    if(rem[x]) return;
    rem[x] = 1;
    for(int i = h[x]; i != 0; i = e[i].next)
    {
        if(dis[e[i].to] + e[i].dis == dis[x])
        {
            if(!op) e[i ^ 1].tag1 = 1;
            else
            {
                if(e[i].tag1 && tim == 1)
                {
                    add_edge(x, e[i].to, e[i].dis);
                    if(!vis[x]) vis[x] = 1, seq[++cnt] = x;
                    if(!vis[e[i].to]) vis[e[i].to] = 1, seq[++cnt] = e[i].to;
                    in[e[i].to]++;
                }
                else if(e[i ^ 1].tag1 && tim == 2)
                {
                    add_edge(e[i].to, x, e[i].dis);
                    if(!vis[x]) vis[x] = 1, seq[++cnt] = x;
                    if(!vis[e[i].to]) vis[e[i].to] = 1, seq[++cnt] = e[i].to;
                    in[x]++;
                }
            }
            dfs(e[i].to, end, op, tim);
        }
    }
}

int main()
{
    freopen("P2149.in", "r", stdin);
    freopen("P2149.out", "w", stdout);

    cin >> n >> m;
    cin >> x1 >> y1 >> x2 >> y2;
    for(int i = 1; i <= m; i++)
    {
        int u = read(), v = read(), w = read();
        add(u, v, w), add(v, u, w);
    }

    queue<int> que;
    dijkstra(x1);
    dfs(y1, x1, 0, 1);
    dijkstra(x2);
    memset(vis, 0, sizeof(vis));
    memset(rem, 0, sizeof(rem));
    dfs(y2, x2, 1, 1);
    for(int i = 1; i <= cnt; i++)
        if(!in[seq[i]]) que.push(seq[i]);
    while(que.size())
    {
        int now = que.front(); que.pop();
        for(int i = head[now]; i != 0; i = edge[i].next)
        {
            in[edge[i].to]--;
            if(!in[edge[i].to]) que.push(edge[i].to);
            dp[edge[i].to] = max(dp[edge[i].to], dp[now] + edge[i].dis);
            ans = max(ans, dp[edge[i].to]);
        }
    }

    for(int i = 1; i <= num; i++) e[i].tag2 = 0;
    memset(rem, 0, sizeof(rem));
    memset(vis, 0, sizeof(vis));
    memset(head, 0, sizeof(head));
    memset(in, 0, sizeof(in));
    num_edge = 1, cnt = 0;
    dfs(y2, x2, 1, 2);
    for(int i = 1; i <= cnt; i++)
        if(!in[seq[i]]) que.push(seq[i]);
    while(que.size())
    {
        int now = que.front(); que.pop();
        for(int i = head[now]; i != 0; i = edge[i].next)
        {
            in[edge[i].to]--;
            if(!in[edge[i].to]) que.push(edge[i].to);
            dp[edge[i].to] = max(dp[edge[i].to], dp[now] + edge[i].dis);
            ans = max(ans, dp[edge[i].to]);
        }
    }

    cout << ans;
    return 0;
}

转载于:https://www.cnblogs.com/BigYellowDog/p/11486934.html