Codeforces Round #605 (Div. 3) E - Nearest Opposite Parity

题意：

一个序列

i 可以移动到 i+  与 i-

若是奇数，则终点为是偶数

若是偶数，则终点为是奇数

每个点最少需要多少步到达终点，到达不了输出-1

题解：

思路的话，首先了解一下 这个思路：

每个点 建立最多 两条边 [i,i+]  [i,i-]  不一定可以建成功 要判断一下 下标要在 [1,n]中

之后，每个点都跑一遍最短路，跑完最短路之后

for循环遍历所有点的最小值，若当前点是偶数我就遍历所有为奇数的点取最短路的最小值。

若为偶数，同理。

然后对上面思路进行优化：

上述算法时间浪费在了遍历上面，所以要尽可能减少遍历时间。

假设我现在的点为偶数点.

将所有的奇数点连到一个超级源点上，从超级源点反向跑一遍最短路，那么每个偶数点的权值一定是 到所有奇数点里面最小的权值。

同理：

把所有偶数点的权值，连到奇数点的超级源点上，反向最短路之后，跑一边偶数点的权值即为答案。

核心思想：反向建图+超级源点

AC:

#pragma GCC optimize(2)
#include<bits/stdc++.h>
typedef long long ll;
const int maxn=2e6+5;
using namespace std;
const ll INF=1e13+5;
const ll mod=1e9+7;
ll n,m,p;
ll a[maxn];
ll dis[maxn];
int vis[maxn];
struct node{
    int e,next;
    int w;
}edge[maxn];
ll cnt=0;
int head[maxn];
ll res[maxn];
void addedge(int u,int v,int w)
{
    edge[cnt]=node{v,head[u],w};
    head[u]=cnt++;
}
void spfa(int x)
{
    queue<int>q;
    for(int i=1;i<=n+2;i++) dis[i]=INF,vis[i]=0;
    q.push(x);
    dis[x]=0;
    vis[x]=1;
    while(!q.empty())
    {
        int u=q.front();q.pop();vis[u]=0;
        for(int i=head[u];~i;i=edge[i].next)
        {
            int e=edge[i].e;
            if(dis[e]>dis[u]+edge[i].w)
            {
                dis[e]=dis[u]+edge[i].w;
                if(!vis[e])
                {
                    vis[e]=1;
                    q.push(e);
                }
            }
        }
    }
}
int main()
{
    memset(head,-1,sizeof(head));
    scanf("%lld",&n);
    for(int i=1;i<=n;i++) scanf("%lld",&a[i]);
    for(int i=1;i<=n;i++)
    {
        if(i+a[i]<=n) addedge(i+a[i],i,1);
        if(i-a[i]>=1) addedge(i-a[i],i,1);
    }
    for(int i=1;i<=n;i++)
    {
        if(a[i]%2==0) addedge(n+1,i,0);
        else addedge(n+2,i,0);
    }
    spfa(n+1);
    for(int i=1;i<=n;i++)
        if(a[i]%2==1) res[i]=dis[i];
    spfa(n+2);
    for(int i=1;i<=n;i++)
        if(a[i]%2==0) res[i]=dis[i];
    for(int i=1;i<=n;i++)
        printf("%lld ",res[i]==INF?-1ll:res[i]);
    return 0;
}