标签：21 int 题解 T2 t1 t2 lx2y2 x1 dis

meet

大概思路就是 ， 找出相交的路径 ， 判断方向 ， 分类讨论。。

假设已经找出了相交路径 。。。
若方向相同 ， 则找到相交路径上边权的最大值 ， 若最大值>出发时间差 ， 则可行。
原因： 由于方向相同所以在相交路径上这两个点的相对距离是不变的，看最大的边权即可。
这个东西用st表就可以搞定

若方向不同，就看看他们相遇的位置是不是相交路径上各个（不一定是最两头的点）边的端点之一。
因为题中说在边上才算 ， 点不能算到边上。 所以不在点上就一定会在边上相遇。

然后就是怎么找相交路径了。。
大概有这么几种情况。。
分类讨论即可

#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<vector>
#include<cmath>
#include<queue>
#include<set>
#include<map>
using namespace std;
#define int long long
const int N = 1e5+10;
inline int read()
{
    register int x = 0 , f = 0; register char c = getchar();
    while(c < '0' || c > '9') f |= c == '-' , c = getchar();
    while(c >= '0' && c <= '9') x = (x << 3) + (x << 1) + c - '0' , c = getchar();
    return f ? -x : x;
}
int n , Q , cnt;
int head[N] , f[N][20] , st[N][20] , pre[N] , d[N] , dis[N] , Log[N];
struct edge{ int v , nex , c , id; } e[N<<1];
struct node{ 
    int id , l , r;
    node(int id = 0 , int l = 0 , int r = 0) : id(id) , l(l) , r(r) {} 
} A[N] , B[N];
inline void add(int u , int v , int c , int id) { e[++cnt].v = v; e[cnt].nex = head[u]; e[cnt].c = c;  e[cnt].id = id; head[u] = cnt; return ; }

void dfs(int x , int fa)
{
    f[x][0] = fa; d[x] = d[fa] + 1;
    for(int i = 1 ; i < 20 ; ++i) f[x][i] = f[f[x][i-1]][i-1] , st[x][i] = max(st[x][i-1] , st[f[x][i-1]][i-1]);
    for(int i = head[x] , v ; i ; i = e[i].nex)
    {
        v = e[i].v; if(v == fa) continue;
        pre[v] = i; st[v][0] = e[i].c; dis[v] = dis[x] + e[i].c; dfs(v , x);
    }
    return ;
}

int LCA(int x , int y)
{
    if(d[x] < d[y]) swap(x , y);
    for(int i = 19 ; ~i ; --i) if(d[f[x][i]] >= d[y]) x = f[x][i];
    if(x == y) return x;
    for(int i = 19 ; ~i ; --i) if(f[x][i] != f[y][i]) x = f[x][i] , y = f[y][i];
    return f[x][0];
}

void Work(int u , int v , int t , int &tot , node *s)
{
    int p = LCA(u , v);
    while(u != p)
    {
        int i = pre[u];
        s[++tot] = node(e[i].id , t , t + e[i].c);
        t += e[i].c; u = f[u][0];
    }
    int lim = tot , T = 0;
    while(v != p)
    {
        int i = pre[v];
        s[++tot] = node(e[i].id , T , T + e[i].c);
        T += e[i].c; t += e[i].c; v = f[v][0];
    }
    for(int i = lim + 1 ; i <= tot ; ++i) s[i].l = t - s[i].l , s[i].r = t - s[i].r , swap(s[i].l , s[i].r);
    return ;
}

inline bool cmp(const node &A , const node &B) { return A.id < B.id; }

void solve1()
{
    for(int i = 1 ; i <= n ; ++i) d[i] = 0;
    dfs(1 , 0);
    int u1 , v1 , t1 , u2 , v2 , t2 , tot1 , tot2;
    while(Q--)
    {
        u1 = read(); v1 = read(); t1 = read(); tot1 = 0;
        u2 = read(); v2 = read(); t2 = read(); tot2 = 0;
        Work(u1 , v1 , t1 , tot1 , A);
        Work(u2 , v2 , t2 , tot2 , B);
        sort(A + 1 , A + 1 + tot1 , cmp);
        sort(B + 1 , B + 1 + tot2 , cmp);
        int l = 1 , r = 1 , flag = 0;
        while(l <= tot1 && r <= tot2)
        {
            if(A[l].id < B[r].id) l++;
            else if(A[l].id > B[r].id) r++;
            else 
            {
                if((A[l].l <= B[r].l && B[r].l < A[l].r) || (A[l].l < B[r].r && B[r].r <= A[l].r)) { flag = 1; break; }
                l++; r++;
            }
        }
        puts(flag ? "YES" : "NO");
    }
    return ;
}

int Ask_MAX(int x , int y) // 求得x->y之间边权的最大值 
{
    int ans = 0;
    if(d[x] < d[y]) swap(x , y);
    for(int i = 19 ; ~i ; --i) if(d[f[x][i]] >= d[y]) ans = max(ans , st[x][i]) , x = f[x][i];
    if(x == y) return ans;
    for(int i = 19 ; ~i ; --i) if(f[x][i] != f[y][i]) ans = max(ans , max(st[x][i] , st[y][i])) , x = f[x][i] , y = f[y][i];
    return max(ans , max(st[x][0] , st[y][0]));
}

inline int Abs(int x) { return x < 0 ? -x : x; }

#define stop { puts("NO"); return ; }
#define is_ok { puts("YES"); return ; }
void calc0(int x , int y , int t1 , int t2) // 同向 
{
    if(x == y) stop
    int Max = Ask_MAX(x , y);
    puts(Abs(t1 - t2) < Max ? "YES" : "NO");
    return ;
}

int find(int x , int s) // x 往上走 s 到达的点是不是整点 
{
    s = dis[x] - s;
    for(int i = 19 ; ~i ; --i) if(dis[f[x][i]] >= s) x = f[x][i];
    return dis[x] == s;
}

void calc1(int x , int y , int t1 , int t2)
{
    if(x == y) stop
    int p = LCA(x , y) , s = dis[x] + dis[y] - 2 * dis[p] , S = s + t2 - t1; // 这里的S是用来算x要走多少 
    if(S < 0 || S > 2 * s) stop
    if(S & 1) is_ok 
    S >>= 1; int ans = 0; // 这是真正x要走多少 ， 上面那个意会。。 
    if(dis[x] - dis[p] >= S) ans = find(x , S); else ans = find(y , s - S);
    puts(ans ? "NO" : "YES"); return ;
    
}

void solve2()
{
    dfs(1 , 0); int x1 , y1 , x2 , y2 , t1 , t2 , lx1x2 , ly1y2 , lx1y1 , lx2y2 , lx1y2 , ly1x2;
    // 各种LCA 很清楚吧 
    while(Q--)
    {
        x1 = read(); y1 = read(); t1 = read();
        x2 = read(); y2 = read(); t2 = read();
        lx1y1 = LCA(x1 , y1); lx2y2 = LCA(x2 , y2);
        if(d[lx1y1] > d[lx2y2]) // 让x1y1的LCA在上面 
            swap(x1 , x2), swap(y1 , y2), swap(t1 , t2), swap(lx1y1 , lx2y2);
            
        lx1x2 = LCA(x1 , x2); ly1y2 = LCA(y1 , y2); // 这个要写下面， 不然会GG 
        lx1y2 = LCA(x1 , y2); ly1x2 = LCA(y1 , x2); 
        if(lx1y1 == lx2y2) // 图1 
        {
            if(lx1x2 == lx1y1 && ly1y2 == lx1y1) 
                calc1(lx1y2 , ly1x2 , t1 + dis[x1] - dis[lx1y2] , t2 + dis[x2] - dis[ly1x2]); // 图1-1 
            else 
                calc0(lx1x2 , ly1y2 , t1 + dis[x1] - dis[lx1x2] , t2 + dis[x2] - dis[lx1x2]); // 1-2 
            continue;
        }
        int lca = LCA(lx1y1 , lx2y2);
        if(lca != lx1y1) { puts("NO"); continue; } // 两条路径不相交 
        if(LCA(x1 , lx2y2) == lx2y2) // 2
        {
            if(lx1x2 == lx2y2) 
                calc1(lx1y2 , lx2y2 , t1 + dis[x1] - dis[lx1y2] , t2 + dis[x2] - dis[lx2y2]); //2-1
            else
                calc0(lx1x2 , lx2y2 , t1 + dis[x1] - dis[lx1x2] , t2 + dis[x2] - dis[lx1x2]); //2-2
            continue;
        }
        if(LCA(y1 , lx2y2) == lx2y2) // 3
        {
            if(ly1y2 == lx2y2)
                calc1(lx2y2 , ly1x2 , t1 + dis[x1] + dis[lx2y2] - dis[lca] * 2 , t2 + dis[x2] - dis[ly1x2]); // 3-1
            else
                calc0(lx2y2 , ly1y2 , t1 + dis[x1] + dis[lx2y2] - dis[lca] * 2 , t2 + dis[x2] - dis[lx2y2]); // 3-2
            continue;
        }
        puts("NO");
    }
    return ;
}

signed main()
{
    freopen("meet.in" , "r" , stdin);
    freopen("meet.out" , "w" , stdout);
    n = read(); Q = read();
    for(int i = 1 , u , v , c ; i < n ; ++i) u = read() , v = read() , c = read() , d[u]++ , d[v]++ , add(u , v , c , i) , add(v , u , c , i);
    if(n <= 100) solve1(); else solve2();
    fclose(stdin); fclose(stdout);
    return 0;
}
/*
8 6
1 2 3
1 3 1
1 4 2
2 5 5
2 6 1
5 7 2
5 8 4
5 3 2 7 4 2
8 6 1 1 7 6
4 5 1 4 5 10
7 8 3 3 4 5
6 7 6 5 1 2
2 1 10 8 3 3
*/

标签：21,int,题解,T2,t1,t2,lx2y2,x1,dis
来源： https://www.cnblogs.com/R-Q-R-Q/p/12344081.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。