In Touch（思维+dij+优先队列）

最新推荐文章于 2020-04-20 19:32:19 发布

原创最新推荐文章于 2020-04-20 19:32:19 发布 · 344 阅读

0 ·

CC 4.0 BY-SA版权

图论同时被 2 个专栏收录

40 篇文章

订阅专栏

思维

37 篇文章

订阅专栏

该问题要求找到从第1个点到第n个点的最小花费路径，其中每个点能到达一定范围内的其他点，并且有各自的费用。由于数据规模大，直接建图不合适。解决方案是结合Dijkstra算法和并查集，用优先队列维护最小距离，已更新的点不再更新，更新过的点归并。也可以使用线段树来解决。

In Touch

Time Limit: 8000/4000 MS (Java/Others) Memory Limit: 131072/131072 K (Java/Others)
Total Submission(s): 3217 Accepted Submission(s): 827

Problem Description

There are n soda living in a straight line. soda are numbered by 1,2,…,n from left to right. The distance between two adjacent soda is 1 meter. Every soda has a teleporter. The teleporter of i-th soda can teleport to the soda whose distance between i-th soda is no less than li and no larger than ri. The cost to use i-th soda's teleporter is ci.

The 1-st soda is their leader and he wants to know the minimum cost needed to reach i-th soda (1≤i≤n).

Input

There are multiple test cases. The first line of input contains an integer T, indicating the number of test cases. For each test case:

The first line contains an integer n (1≤n≤2×105), the number of soda.
The second line contains n integers l1,l2,…,ln. The third line contains n integers r1,r2,…,rn. The fourth line contains n integers c1,c2,…,cn. (0≤li≤ri≤n,1≤ci≤109)

Output

For each case, output n integers where i-th integer denotes the minimum cost needed to reach i-th soda. If 1-st soda cannot reach i-the soda, you should just output -1.

Sample Input

1 5 2 0 0 0 1 3 1 1 0 5 1 1 1 1 1

Sample Output

0 2 1 1 -1

Hint

If you need a larger stack size, please use #pragma comment(linker, "/STACK:102400000,102400000") and submit your solution using C++.

Author

zimpha@zju

Source

2015 Multi-University Training Contest 6

Recommend

wange2014 | We have carefully selected several similar problems for you: 6343 6342 6341 6340 6339

题意：题意是从给出n个点，第一行是l[i],第二行是r[i]，意思是i点可以到达距i点的距离在【l，r】以内的所有点，第三行是c[i]，意思是到达i点需要花费c。问从第一个点到1—n的点，分别求一下最短路径。

由数据范围如此庞大可以知道，直接建图不是好方法。

然后我们就去利用dij算法，和并查集，那么dist[i]表示从1到 i 的花费再加上点 i 的花费，这样每个点就只会被更新一次，更新后在以后就不会再次被更新了，这里用到并查集把已经更新的点得father指向还没被更新的点。简单地说，就是从第一个点开始更新，更新过的点缩成一个点，因为在Dijkstra里每次取出的都是最小的distance，（用优先队列维护）所以更新过的点后面肯定不需要再次更新。更新一个点后加入堆中，因为通过这个点可能更新别的点。

ps：这道题自己还没敲，但是觉得思想很好，应该记住并且灵活运用！！

参考博客：

https://blog.youkuaiyun.com/u014422052/article/details/47376273

也可以用线段树做：

https://blog.youkuaiyun.com/hnust_derker/article/details/79343341

代码：

#include<bits/stdc++.h>
typedef __int64 ll;
using namespace std;

const ll INF = 1LL << 60;   //要大点
#define mod 1000000009
const int maxn = 200010;
const int MAXN = 2005;
const int MAXM = 200010;
const int N = 1005;

typedef pair<ll,int>Pir;
ll L[maxn],R[maxn],C[maxn],dist[maxn];
int n,father[maxn];

void init()
{
    for (int i=0;i<=n+5;i++)
    {
        father[i]=i;
        dist[i]=INF;
    }
}

int find_father(int x)
{
    if (x!=father[x])
        father[x]=find_father(father[x]);
    return father[x];
}

void solve()
{
    dist[1]=C[1];
    priority_queue<Pir,vector<Pir>,greater<Pir> >Q;
    Q.push(make_pair(dist[1],1));
    while (!Q.empty())
    {
        Pir st=Q.top(); Q.pop();
        int u=st.second;
      ///  cout<<u<<"&&&"<<endl;
        for (int i=-1;i<=1;i+=2)
        {
            int l=u+i*L[u];
            int r=u+i*R[u];
            if (l>r) swap(l,r);
            l=max(1,l);
            l=min(l,n+1);
            if (l>r) continue;
            for (int v=l;;v++)
            {
                v=find_father(v);
                if (v<=0||v>n||v>r) break;
                if (dist[v]>dist[u]+C[v])
                {
                    dist[v]=dist[u]+C[v];
                    Q.push(make_pair(dist[v],v));
                }
                father[find_father(v)]=find_father(v+1);
            }
        }
    }
    printf("0");
    for (int i=2;i<=n;i++)
    {
        if (dist[i]>=INF)
            printf(" -1");
        else
            printf(" %I64d",dist[i]-C[i]);
    }
    printf("\n");
}

int main()
{
    int i,j,t;
    scanf("%d",&t);
    while (t--)
    {
        scanf("%d",&n);
        for (i=1;i<=n;i++)
            scanf("%I64d",&L[i]);
        for (i=1;i<=n;i++)
            scanf("%I64d",&R[i]);
        for (i=1;i<=n;i++)
            scanf("%I64d",&C[i]);
        init();
        solve();
    }
    return 0;
}