作物杂交 作物杂交是作物栽培中重要的一步。已知有 N 种作物 (编号 1 至 N )，第 i 种作物从播种到成熟的时间为 Ti 。作物之间两两可以进行杂交，杂交时间取两种中时间

作物杂交

题目描述

作物杂交是作物栽培中重要的一步。已知有 N 种作物 (编号 1 至 N )，第 i 种作物从播种到成熟的时间为 T_i。作物之间两两可以进行杂交，杂交时间取两种中时间较长的一方。如作物 A 种植时间为 5 天，作物 B 种植时间为 7 天，则 AB 杂交花费的时间为 7 天。作物杂交会产生固定的作物，新产生的作物仍然属于 N 种作物中的一种。

初始时，拥有其中 M 种作物的作物 (数量无限，可以支持多次杂交)。同时可以进行多个杂交过程。求问对于给定的目标作物，最少需要多少天能够得到。

如存在 4 种作物 ABCD，各自的成熟时间为 5 天、7 天、3 天、8 天。初始拥有 AB 两种作物的作物，目标作物为 D，已知杂交情况为 A × B → C，A × C → D。则最短的杂交过程为：

第 1 天到第 7 天 (作物 B 的时间)，A × B → C。

第 8 天到第 12 天 (作物 A 的时间)，A × C → D。

花费 12 天得到作物 D 的作物。

输入描述

输入的第 1 行包含 4 个整数 N, M, K, T，N 表示作物种类总数 (编号 1 至 N)，M 表示初始拥有的作物作物类型数量，K 表示可以杂交的方案数，T 表示目标作物的编号。

第 2 行包含 N 个整数，其中第 i 个整数表示第 i 种作物的种植时间 T_i(1≤T_i≤100)
第 3 行包含 M 个整数，分别表示已拥有的作物类型 K_j (1 ≤ K_j ≤ M)，K_j两两不同。

第 4 至 K + 3 行，每行包含 3 个整数 A, B,C，表示第 A 类作物和第 B 类作物杂交可以获得第 C 类作物的作物。

其中，1 ≤ N ≤ 2000, 2 ≤ M ≤ N, 1 ≤ K ≤ 10⁵, 1 ≤ T ≤ N, 保证目标作物一定可以通过杂交得到。

输出描述

输出一个整数，表示得到目标作物的最短杂交时间。

输入输出样例

示例

输入
6 2 4 6 5 3 4 6 4 9 1 2 1 2 3 1 3 4 2 3 5 4 5 6

输出
16

样例说明
第 1 天至第 5 天，将编号 1 与编号 2 的作物杂交，得到编号 3 的作物作物。 第 6 天至第 10 天，将编号 1 与编号 3 的作物杂交，得到编号 4 的作物作物。 第 6 天至第 9 天，将编号 2 与编号 3 的作物杂交，得到编号 5 的作物作物。 第 11 天至第 16 天，将编号 4 与编号 5 的作物杂交，得到编号 6 的作物作物。 总共花费 16 天。

运行限制

最大运行时间：2s
最大运行内存: 256M

代码

#include<iostream>
#include<string>
#include<map>
#include<math.h>
#include<vector>
using namespace std;
int    N, M, K, T;
int arr[2005] = {
    
     0 };//种植时间
int les[2005];//对应位置的作物最短的获得时间
const int INF = 0x3f3f3f3f;
map<int, vector<pair<int, int>>>m;//int与vector<pair<int, int>>一一对应的map数据类型
void DFS(int x) {
    
    //深度优先
    if (les[x] != -1)return;//判断是否已经对该作物进行过搜索
    les[x] = 0;
    int minv = INF;
    for (int i = 0; i < m[x].size(); i++)
    {
    
    
        int l, r;
        l = m[x][i].first;//获取可以得到x作物的其中一种作物
        r = m[x][i].second;//获取可以得到x作物的另一种作物
        DFS(l), DFS(r);//分别对两个作物进行深度优先搜索
        minv = min(minv, max(les[l], les[r]) + max(arr[l], arr[r]));//比较minv与当前种类的杂交路线的时长的大小
    }
    if (minv != INF)les[x] += minv;//如果当前的作物可以通过杂交获取
}
int main()
{
    
    
    int x, y, z;
    cin >> N >> M >> K >> T;
    for (int i = 1; i <= N; i++)
    {
    
    
        cin >> arr[i];
    }
    for (int i = 1; i <= M; i++)
    {
    
    
        cin >> x;
    }
    for (int i = 0; i < K; i++)
    {
    
    
        cin >> x >> y >> z;
        m[z].push_back({
    
     x,y });
    }
    fill(les + 1, les + N + 1, -1);
    DFS(T);
    cout << les[T] << endl;
    return 0;
}

思路

采用map存储对应作物的所有直接杂交路线，然后从目标作物开始倒推进行深度优先搜索，使用一维数组les维护每个作物的最短获得时间，类似于动态规划，最后输出目标作物的最短时间。