信息学奥赛一本通 1985：【19CSPJ普及组】加工零件 | 洛谷 P5663 [CSP-J2019] 加工零件

【题目链接】

ybt 1985：【19CSPJ普及组】加工零件
洛谷 P5663 [CSP-J2019] 加工零件

【题目考点】

1. 图论
2. SPFA算法

【解题思路】

1. 问题分析

每个工人是一个顶点，传送带是边，构成一个图。轩轩是1号工人，即为1号顶点。被派工单的工人记为顶点a。

引理1：顶点v接到生产L阶段零件的任务。在顶点v的度不为0的前提下，如果L是偶数，那么顶点v需要提供原材料。

• 证明：记顶点v的某一邻接点为u，v要生产L阶段的零件，那么u就要生产第L-1阶段的零件。u生产L-1阶段的零件又要求v生产L-2阶段的零件。依此类推，如果L是个偶数，u最终需要生产第1阶段的零件，v最终需要生产第0阶段的零件，即提供原材料。

引理2：顶点v接到生产L阶段的零件的任务，假设顶点v到1号顶点存在一条长度为n的路径，如果L >= n，且L - n是偶数，那么1号顶点需要为该任务提供原材料。

• 证明：在这一路径上，与v相邻的顶点v1需要生产L-1阶段的零件，路径上与v1相邻的顶点需要生产L-2阶段的零件，一直传导到1号顶点，1号顶点需要生产L-n阶段的零件。根据引理1，如果L-n是偶数，那么1号顶点需要为该任务提供原材料。

定义1：顶点u到顶点v的奇数最短路径

顶点u到顶点v的长度为奇数的路径中，最短的路径。

定义2：顶点u到顶点v的偶数最短路径

顶点u到顶点v的长度为偶数的路径中，最短的路径。

2. 解题算法：

1. 求图上每一顶点到1号顶点的奇数最短路径的长度lodd与偶数最短路径的长度leven。

实现算法：SPFA算法

1. 每个顶点v关联两个值：奇数最短路径长度v.lodd，偶数最短路径长度v.leven，初始值为无穷大。
2. 1号顶点入队，1号顶点的偶数最短路径长度leven设为0。
3. v相邻的点u的奇数最短路径长度，应该是min(v的偶数最短路径长度加1，u的奇数最短路径长度)。
   v相邻的点u的偶数最短路径长度，应该是min(v的奇数最短路径长度加1，u的偶数最短路径长度)。
   某顶点v出队后，遍历其所有相邻的顶点，设某相邻点为u，则如果u.lodd > v.leven + 1 或 u.leven > v.lodd + 1，那么改变u的对应的最短路径长度，并将u入队。如果不满足这两个条件，则不入队。
4. 循环运行直到队空。此时与1号顶点连通的顶点的奇数最短路径和偶数最短路径就都设置完成了。

2. 查询结果

输入数据，v号顶点需要制造L阶段零件。

1. 如果L是奇数，判断L >= v.lodd，如果为真，那么说明1号顶点需要生产L - v.lodd阶段的零件，L - v.lodd是偶数，因此1号顶点需要提供原材料。如果为假，则不需要提供原材料。
2. 如果L是偶数，判断L >= v.leven，如果为真，那么说明1号顶点需要生产L - v.leven阶段的零件，L - v.leven是偶数，因此1号顶点需要提供原材料。如果为假，则不需要提供原材料。

【题解代码】

解法1：使用邻接表 （vector边表）

#include<bits/stdc++.h>
using namespace std;
#define N 100005
#define MAXINT 0x3f3f3f3f //表示无穷大，大于L的最大值10^9
//邻接表
int lodd[N], leven[N]; 
vector<int> edge[N];//边表 
bool vis[N];
//求每一点到1号顶点的奇数最短路径长度和偶数最短路径长度
void initPathLength()
{
	memset(lodd, 0x3f, sizeof(lodd));
	memset(leven, 0x3f, sizeof(leven));
    int u, v;
    leven[1] = 0;//自己到自己的最短偶数路径长度为0
    queue<int> que;//队列保存顶点编号
    que.push(1);
    vis[1] = true;
    while(que.empty() == false)
    {
        u = que.front();//出队的顶点u 
        que.pop();
        vis[u] = false;
        for(int i = 0; i < edge[u].size(); ++i)//遍历u的邻接顶点 
        {
            v = edge[u][i];//v是u的邻接顶点
            if(lodd[v] > leven[u] + 1 || leven[v] > lodd[u] + 1)
            {
                if(lodd[v] > leven[u] + 1)
                    lodd[v] = leven[u] + 1;
                if(leven[v] > lodd[u] + 1)
                    leven[v] = lodd[u] + 1;
                if(vis[v] == false)
                {
                	vis[v] = true;
                	que.push(v);
                }
            }
        }
    }
}

int main()
{
    int n, m, q, u, v, a, l;
    scanf("%d %d %d", &n, &m, &q);
    for(int i = 0; i < m; ++i)
    {
        scanf("%d %d", &u, &v);//无向图添加边 
        edge[u].push_back(v);
        edge[v].push_back(u);
    }
    initPathLength();
    for(int i = 0; i < q; ++i)
    {
        scanf("%d %d", &a, &l);
        if(l % 2 == 1 && l >= lodd[a] //如果l是奇数且大于等于a的奇数最短路径 
            || l % 2 == 0 && l >= leven[a]) //或如果l是偶数且大于等于a的偶数最短路径 
            printf("Yes\n");
        else
            printf("No\n");
    }
    return 0;
}

解法2：使用邻接表 （静态边链表）

#include<bits/stdc++.h>
using namespace std;
#define N 100005
#define MAXINT 1000000005 //表示无穷大，大于L的最大值10^9
//邻接表
typedef struct Ver//顶点
{
    int next;//下一个边结点的地址
    int lodd, leven;//奇数最短路径长度，偶数最短路径长度
    Ver()
    {
        next = 0;
        lodd = leven = MAXINT;//初始值为无穷大
    }
}Ver;
typedef struct Edg//边
{
    int verNum;//顶点编号
    int next;//下一个边结点的地址
}Edg;
Ver ver[N];//顶点数组
Edg edg[2*N];//边结点的结点池。边最多有10^5个，构造邻接表，每个边生成两个边结点，所以数组要开2N
int ep = 1;//edg数组待分配地址
//添加边，在边链表上用头插法
void addEdge(int u, int v)
{
    int lh, edgP;//lh:边链表的头 edgP:新的边结点
    lh = ver[u].next;//在结点u后面的边链表中添加边结点v
    edgP = ep++;//分配新的边结点
    edg[edgP].verNum = v;
    ver[u].next = edgP;
    edg[edgP].next = lh;

    lh = ver[v].next;//在结点v后面的边链表中添加边结点u
    edgP = ep++;//分配新的边结点
    edg[edgP].verNum = u;
    ver[v].next = edgP;
    edg[edgP].next = lh;
}
//求每一点到1号顶点的奇数最短路径长度和偶数最短路径长度
void initPathLength()
{
    int u, v;
    ver[1].leven = 0;//自己到自己的最短偶数路径长度为0
    queue<int> que;//队列保存顶点编号
    que.push(1);
    while(que.empty() == false)
    {
        v = que.front();//出队的顶点v的地址
        que.pop();
        for(int p = ver[v].next; p != 0; p = edg[p].next)//遍历边链表，即遍历v周围的顶点u
        {
            u = edg[p].verNum;//u是v的邻接点的地址
            if(ver[u].lodd > ver[v].leven + 1 || ver[u].leven > ver[v].lodd + 1)
            {
                if(ver[u].lodd > ver[v].leven + 1)
                    ver[u].lodd = ver[v].leven + 1;
                if(ver[u].leven > ver[v].lodd + 1)
                    ver[u].leven = ver[v].lodd + 1;
                que.push(u);
            }
        }
    }
}

int main()
{
    int n, m, q, u, v, a, l;
    scanf("%d %d %d", &n, &m, &q);
    for(int i = 0; i < m; ++i)
    {
        scanf("%d %d", &u, &v);
        addEdge(u, v);
    }
    initPathLength();
    for(int i = 0; i < q; ++i)
    {
        scanf("%d %d", &a, &l);
        if(l % 2 == 0)//如果l是偶数
        {
            if(l >= ver[a].leven)
                printf("Yes\n");
            else
                printf("No\n");
        }
        else//如果l是奇数
        {
            if(l >= ver[a].lodd)
                printf("Yes\n");
            else
                printf("No\n");
        }
    }
    return 0;
}