思路：要找到到达N,M点的最短距离，当有门时需要用对应的钥匙开门，那么我们用dis[i][j]表示在编号i位置时此时持有钥匙的状态是j的最短距离。根据钥匙的编号id我们初始化Key的状态为Key=1<<id-1 ,我们可以发现当该位置有钥匙时，我们的状态就要发生改变state=state(原)|key然后看是否需要更新dis可得转移方程dis[i][state]=dis[i][state(原)|key],然后就是上下左右移动，在移动时我们需要判断有门的情况，当有门时，我们要判断在该位置上我们此时持有钥匙的状态中是否有该位置的要钥匙。若该位置为W,我们就看1>>w-1&1是0的话表示没有门钥匙。题目建图比较坑，首先我们根据吧每个点的位置x,y换成编号，然后再输入墙和门的位置时，如果是墙不用管，如果是门就建立边并吧门的编号当权值，为了后面判断这个位置有没有门，我们吧输入的门和墙的位置的编号全部加入set中，在后面我们对整个图就行加边，如果此时没有用过这个编号说明他们之间有边，没个编号通常都有上下左右4个边所以用dir数组。

代码：

#pragma GCC optimize(2)
#include<bits/stdc++.h>
 
using namespace std;
typedef long long ll;
#define SIS std::ios::sync_with_stdio(false)
#define space putchar(' ')
#define enter putchar('\n')
#define lson root<<1
#define rson root<<1|1
typedef pair<int,int> PII;
typedef pair<int,PII> PIII;
const int mod=1e9+7;
const int N=2e5+5;
const int inf=0x7f7f7f7f;

int gcd(int a,int b)
{
    
    
    return b==0?a:gcd(b,a%b);
}
 
ll lcm(ll a,ll b)
{
    
    
    return a*(b/gcd(a,b));
}
 
template <class T>
void read(T &x)
{
    
    
    char c;
    bool op = 0;
    while(c = getchar(), c < '0' || c > '9')
        if(c == '-')
            op = 1;
    x = c - '0';
    while(c = getchar(), c >= '0' && c <= '9')
        x = x * 10 + c - '0';
    if(op)
        x = -x;
}
template <class T>
void write(T x)
{
    
    
    if(x < 0)
        x = -x, putchar('-');
    if(x >= 10)
         write(x / 10);
    putchar('0' + x % 10);
}
ll qsm(int a,int b,int p)
{
    
    
    ll res=1%p;
    while(b)
    {
    
    
        if(b&1)
            res=res*a%p;
        a=1ll*a*a%p;
        b>>=1;
    }
    return res;
}
struct node
{
    
    
    int to,nex,w;
}edge[400];
const int P=1<<10;
int head[400],dis[400][P],vis[400][P];
int g[400][400],key[400];
int tot;
int n,m,s,k;
set<PII> edges;
void add(int u,int v,int w)
{
    
    
    edge[tot].w=w;
    edge[tot].to=v;
    edge[tot].nex=head[u];
    head[u]=tot++;
}
int dir[4][2]={
    
    {
    
    1,0},{
    
    -1,0},{
    
    0,1},{
    
    0,-1}};

void build()
{
    
    
    for(int i=1;i<=n;i++)
     for(int j=1;j<=m;j++)
      for(int u=0;u<4;u++)
      {
    
    
          int x=i+dir[u][0],y=j+dir[u][1];
          if(!x||x>n||!y||y>m)continue;
          int a=g[i][j],b=g[x][y];
          if(edges.count({
    
    a,b})==0){
    
    
              add(a,b,0);
              add(b,a,0);
          }
      }
   
}

int bfs()
{
    
    
    memset(dis,inf,sizeof dis);
    memset(vis,0,sizeof vis);
    dis[1][0]=0;
    deque<PII> q;
    q.push_back({
    
    1,0});
    while(q.size())
    {
    
    
        
        PII now=q.front();q.pop_front();
        int u=now.first,sta=now.second;
        //cout<<u<<endl;
        if(vis[u][sta])continue;
        vis[u][sta]=1;
        if(u==n*m) return dis[u][sta];
        
        if(key[u])
        {
    
    
            int state=sta|key[u];
            if(dis[u][state]>dis[u][sta])
            {
    
    
                dis[u][state]=dis[u][sta];
                q.push_front({
    
    u,state});
            }
        }
       // cout<<"2--"<<u<<endl;
        for(int i=head[u];~i;i=edge[i].nex)
        {
    
    
            int v=edge[i].to,w=edge[i].w;
            if(w && !(sta >> w - 1 & 1) ) continue;
            if(dis[v][sta]>dis[u][sta]+1)
            {
    
    
                dis[v][sta]=dis[u][sta]+1;
                q.push_back({
    
    v,sta});
            }
        }

    }
    return -1;

}




int main()
{
    
    
   cin>>n>>m>>s>>k;
   memset(head,-1,sizeof head);
   
   for(int i=1,t=1;i<=n;i++)
       for(int j=1;j<=m;j++)
           g[i][j]=t++;

   while(k--)
   {
    
    
       int x1,x2,y1,y2,op;
       cin>>x1>>y1>>x2>>y2>>op;
       int a=g[x1][y1],b=g[x2][y2];
       edges.insert({
    
    a,b});edges.insert({
    
    b,a});
       if(op){
    
    
           add(a,b,op);add(b,a,op);
       }

   }
    build();

   int rz;
   cin>>rz;
   while(rz--)
   {
    
    
       int x,y,c;
       cin>>x>>y>>c;
       key[g[x][y]]|=1<<c-1;
      

   }
  
   cout<<bfs()<<endl;


   return 0;

}